# Class: Matrix

Inherits:
Object
• Object
show all
Extended by:
ConversionHelper
Includes:
Enumerable, ExceptionForMatrix, CoercionHelper
Defined in:
lib/matrix.rb

## Overview

The `Matrix` class represents a mathematical matrix. It provides methods for creating matrices, operating on them arithmetically and algebraically, and determining their mathematical properties (trace, rank, inverse, determinant).

## Method Catalogue

To create a matrix:

• Matrix

• Matrix.[](*rows)

• Matrix.rows(rows, copy = true)

• Matrix.columns(columns)

• Matrix.build(row_count, column_count, &block)

• Matrix.diagonal(*values)

• Matrix.scalar(n, value)

• Matrix.identity(n)

• Matrix.unit(n)

• Matrix.I(n)

• Matrix.zero(n)

• Matrix.row_vector(row)

• Matrix.column_vector(column)

To access Matrix elements/columns/rows/submatrices/properties:

• #[](i, j)

• #row_count (row_size)

• #column_count (column_size)

• #row(i)

• #column(j)

• #collect

• #map

• #each

• #each_with_index

• #find_index

• #minor(*param)

Properties of a matrix:

• #diagonal?

• #empty?

• #hermitian?

• #lower_triangular?

• #normal?

• #orthogonal?

• #permutation?

• #real?

• #regular?

• #singular?

• #square?

• #symmetric?

• #unitary?

• #upper_triangular?

• #zero?

Matrix arithmetic:

• #*(m)

• #+(m)

• #-(m)

• #/(m)

• #inverse

• #inv

• #**

Matrix functions:

• #determinant

• #det

• #rank

• #round

• #trace

• #tr

• #transpose

• #t

Matrix decompositions:

• #eigen

• #eigensystem

• #lup

• #lup_decomposition

Complex arithmetic:

• conj

• conjugate

• imag

• imaginary

• real

• rect

• rectangular

Conversion to other data types:

• #coerce(other)

• #row_vectors

• #column_vectors

• #to_a

String representations:

• #to_s

• #inspect

## Defined Under Namespace

Modules: CoercionHelper, ConversionHelper Classes: Scalar

## Constant Summary collapse

SELECTORS =
```{all: true, diagonal: true, off_diagonal: true, lower: true, strict_lower: true, strict_upper: true, upper: true}.freeze
```

## Class Method Summary collapse

• Creates a matrix where each argument is a row.

• Creates a matrix of size `row_count` x `column_count`.

• Creates a single-column matrix where the values of that column are as given in `column`.

• Creates a matrix using `columns` as an array of column vectors.

• Creates a matrix where the diagonal elements are composed of `values`.

• Creates a empty matrix of `row_count` x `column_count`.

• .identity(n) ⇒ Object (also: unit, I)

Creates an `n` by `n` identity matrix.

• Creates a single-row matrix where the values of that row are as given in `row`.

• Creates a matrix where `rows` is an array of arrays, each of which is a row of the matrix.

• Creates an `n` by `n` diagonal matrix where each diagonal element is `value`.

• Creates a zero matrix.

## Instance Method Summary collapse

• Matrix multiplication.

• Matrix exponentiation.

• Matrix subtraction.

• Matrix division (multiplication by the inverse).

• Returns `true` if and only if the two matrices contain equal elements.

• #[](i, j) ⇒ Object (also: #element, #component)

Returns element (`i`,`j`) of the matrix.

• Returns a clone of the matrix, so that the contents of each do not reference identical objects.

• The coerce method provides support for Ruby type coercion.

• #collect(&block) ⇒ Object (also: #map)

Returns a matrix that is the result of iteration of the given block over all elements of the matrix.

• Returns column vector number `j` of the matrix as a Vector (starting at 0 like an array).

• Returns an array of the column vectors of the matrix.

• #conjugate ⇒ Object (also: #conj)

Returns the conjugate of the matrix.

• #determinant ⇒ Object (also: #det)

Returns the determinant of the matrix.

• #determinant_e ⇒ Object (also: #det_e)

deprecated; use Matrix#determinant.

• Returns `true` is this is a diagonal matrix.

• Yields all elements of the matrix, starting with those of the first row, or returns an Enumerator is no block given.

• Same as #each, but the row index and column index in addition to the element.

• #eigensystem ⇒ Object (also: #eigen)

Returns the Eigensystem of the matrix; see `EigenvalueDecomposition`.

• Returns `true` if this is an empty matrix, i.e.

• Returns a hash-code for the matrix.

• Returns `true` is this is an hermitian matrix.

• #imaginary ⇒ Object (also: #imag)

Returns the imaginary part of the matrix.

• #index(*args) ⇒ Object (also: #find_index)

:call-seq: index(value, selector = :all) -> [row, column] index(selector = :all){ block } -> [row, column] index(selector = :all) -> an_enumerator.

• constructor

Matrix.new is private; use Matrix.rows, columns, [], etcâ€¦

• Overrides Object#inspect.

• #inverse ⇒ Object (also: #inv)

Returns the inverse of the matrix.

• Returns `true` is this is a lower triangular matrix.

• #lup ⇒ Object (also: #lup_decomposition)

Returns the LUP decomposition of the matrix; see `LUPDecomposition`.

• Returns a section of the matrix.

• Returns `true` is this is a normal matrix.

• Returns `true` is this is an orthogonal matrix Raises an error if matrix is not square.

• Returns `true` is this is a permutation matrix Raises an error if matrix is not square.

• Returns the rank of the matrix.

• deprecated; use Matrix#rank.

• Returns the real part of the matrix.

• Returns `true` if all entries of the matrix are real.

• #rect ⇒ Object (also: #rectangular)

Returns an array containing matrices corresponding to the real and imaginary parts of the matrix.

• Returns `true` if this is a regular (i.e. non-singular) matrix.

• Returns a matrix with entries rounded to the given precision (see Float#round).

• Returns row vector number `i` of the matrix as a Vector (starting at 0 like an array).

• #row_count ⇒ Object (also: #row_size)

Returns the number of rows.

• Returns an array of the row vectors of the matrix.

• Returns `true` is this is a singular matrix.

• Returns `true` is this is a square matrix.

• Returns `true` is this is a symmetric matrix.

• Returns an array of arrays that describe the rows of the matrix.

• Overrides Object#to_s.

• #trace ⇒ Object (also: #tr)

Returns the trace (sum of diagonal elements) of the matrix.

• #transpose ⇒ Object (also: #t)

Returns the transpose of the matrix.

• Returns `true` is this is a unitary matrix Raises an error if matrix is not square.

• Returns `true` is this is an upper triangular matrix.

• Returns `true` is this is a matrix with only zero elements.

## Constructor Details

### #initialize(rows, column_count = rows[0].size) ⇒ Matrix

Matrix.new is private; use Matrix.rows, columns, [], etcâ€¦ to create.

 ``` 298 299 300 301 302 303 304``` ```# File 'lib/matrix.rb', line 298 def initialize(rows, column_count = rows[0].size) # No checking is done at this point. rows must be an Array of Arrays. # column_count must be the size of the first row, if there is one, # otherwise it *must* be specified and can be any integer >= 0 @rows = rows @column_count = column_count end ```

## Instance Attribute Details

### #column_count ⇒ Object(readonly)Also known as: column_size

Returns the number of columns.

 ``` 338 339 340``` ```# File 'lib/matrix.rb', line 338 def column_count @column_count end ```

## Class Method Details

### .[](*rows) ⇒ Object

Creates a matrix where each argument is a row.

``````Matrix[ [25, 93], [-1, 66] ]
=>  25 93
-1 66
``````
 ``` 140 141 142``` ```# File 'lib/matrix.rb', line 140 def Matrix.[](*rows) rows(rows, false) end ```

### .build(row_count, column_count = row_count) ⇒ Object

Creates a matrix of size `row_count` x `column_count`. It fills the values by calling the given block, passing the current row and column. Returns an enumerator if no block is given.

``````m = Matrix.build(2, 4) {|row, col| col - row }
=> Matrix[[0, 1, 2, 3], [-1, 0, 1, 2]]
m = Matrix.build(3) { rand }
=> a 3x3 matrix with random elements
``````

Raises:

• (ArgumentError)
 ``` 185 186 187 188 189 190 191 192 193 194 195 196``` ```# File 'lib/matrix.rb', line 185 def Matrix.build(row_count, column_count = row_count) row_count = CoercionHelper.coerce_to_int(row_count) column_count = CoercionHelper.coerce_to_int(column_count) raise ArgumentError if row_count < 0 || column_count < 0 return to_enum :build, row_count, column_count unless block_given? rows = Array.new(row_count) do |i| Array.new(column_count) do |j| yield i, j end end new rows, column_count end ```

### .column_vector(column) ⇒ Object

Creates a single-column matrix where the values of that column are as given in `column`.

``````Matrix.column_vector([4,5,6])
=> 4
5
6
``````
 ``` 270 271 272 273``` ```# File 'lib/matrix.rb', line 270 def Matrix.column_vector(column) column = convert_to_array(column) new [column].transpose, 1 end ```

### .columns(columns) ⇒ Object

Creates a matrix using `columns` as an array of column vectors.

``````Matrix.columns([[25, 93], [-1, 66]])
=>  25 -1
93 66
``````
 ``` 170 171 172``` ```# File 'lib/matrix.rb', line 170 def Matrix.columns(columns) rows(columns, false).transpose end ```

### .diagonal(*values) ⇒ Object

Creates a matrix where the diagonal elements are composed of `values`.

``````Matrix.diagonal(9, 5, -3)
=>  9  0  0
0  5  0
0  0 -3
``````
 ``` 205 206 207 208 209 210 211 212 213``` ```# File 'lib/matrix.rb', line 205 def Matrix.diagonal(*values) size = values.size rows = Array.new(size) {|j| row = Array.new(size, 0) row[j] = values[j] row } new rows end ```

### .empty(row_count = 0, column_count = 0) ⇒ Object

Creates a empty matrix of `row_count` x `column_count`. At least one of `row_count` or `column_count` must be 0.

``````m = Matrix.empty(2, 0)
m == Matrix[ [], [] ]
=> true
n = Matrix.empty(0, 3)
n == Matrix.columns([ [], [], [] ])
=> true
m * n
=> Matrix[[0, 0, 0], [0, 0, 0]]
``````

Raises:

• (ArgumentError)
 ``` 288 289 290 291 292 293``` ```# File 'lib/matrix.rb', line 288 def Matrix.empty(row_count = 0, column_count = 0) raise ArgumentError, "One size must be 0" if column_count != 0 && row_count != 0 raise ArgumentError, "Negative size" if column_count < 0 || row_count < 0 new([[]]*row_count, column_count) end ```

### .identity(n) ⇒ ObjectAlso known as: unit, I

Creates an `n` by `n` identity matrix.

``````Matrix.identity(2)
=> 1 0
0 1
``````
 ``` 232 233 234``` ```# File 'lib/matrix.rb', line 232 def Matrix.identity(n) scalar(n, 1) end ```

### .row_vector(row) ⇒ Object

Creates a single-row matrix where the values of that row are as given in `row`.

``````Matrix.row_vector([4,5,6])
=> 4 5 6
``````
 ``` 257 258 259 260``` ```# File 'lib/matrix.rb', line 257 def Matrix.row_vector(row) row = convert_to_array(row) new [row] end ```

### .rows(rows, copy = true) ⇒ Object

Creates a matrix where `rows` is an array of arrays, each of which is a row of the matrix. If the optional argument `copy` is false, use the given arrays as the internal structure of the matrix without copying.

``````Matrix.rows([[25, 93], [-1, 66]])
=>  25 93
-1 66
``````
 ``` 152 153 154 155 156 157 158 159 160 161 162``` ```# File 'lib/matrix.rb', line 152 def Matrix.rows(rows, copy = true) rows = convert_to_array(rows) rows.map! do |row| convert_to_array(row, copy) end size = (rows[0] || []).size rows.each do |row| raise ErrDimensionMismatch, "row size differs (#{row.size} should be #{size})" unless row.size == size end new rows, size end ```

### .scalar(n, value) ⇒ Object

Creates an `n` by `n` diagonal matrix where each diagonal element is `value`.

``````Matrix.scalar(2, 5)
=> 5 0
0 5
``````
 ``` 222 223 224``` ```# File 'lib/matrix.rb', line 222 def Matrix.scalar(n, value) diagonal(*Array.new(n, value)) end ```

### .zero(row_count, column_count = row_count) ⇒ Object

Creates a zero matrix.

``````Matrix.zero(2)
=> 0 0
0 0
``````
 ``` 246 247 248 249``` ```# File 'lib/matrix.rb', line 246 def Matrix.zero(row_count, column_count = row_count) rows = Array.new(row_count){Array.new(column_count, 0)} new rows, column_count end ```

## Instance Method Details

### #*(m) ⇒ Object

Matrix multiplication.

``````Matrix[[2,4], [6,8]] * Matrix.identity(2)
=> 2 4
6 8
``````
 ``` 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831``` ```# File 'lib/matrix.rb', line 806 def *(m) # m is matrix or vector or number case(m) when Numeric rows = @rows.collect {|row| row.collect {|e| e * m } } return new_matrix rows, column_count when Vector m = self.class.column_vector(m) r = self * m return r.column(0) when Matrix Matrix.Raise ErrDimensionMismatch if column_count != m.row_count rows = Array.new(row_count) {|i| Array.new(m.column_count) {|j| (0 ... column_count).inject(0) do |vij, k| vij + self[i, k] * m[k, j] end } } return new_matrix rows, m.column_count else return apply_through_coercion(m, __method__) end end ```

### #**(other) ⇒ Object

Matrix exponentiation. Equivalent to multiplying the matrix by itself N times. Non integer exponents will be handled by diagonalizing the matrix.

``````Matrix[[7,6], [3,9]] ** 2
=> 67 96
48 99
``````
 ``` 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994``` ```# File 'lib/matrix.rb', line 973 def ** (other) case other when Integer x = self if other <= 0 x = self.inverse return self.class.identity(self.column_count) if other == 0 other = -other end z = nil loop do z = z ? z * x : x if other[0] == 1 return z if (other >>= 1).zero? x *= x end when Numeric v, d, v_inv = eigensystem v * self.class.diagonal(*d.each(:diagonal).map{|e| e ** other}) * v_inv else Matrix.Raise ErrOperationNotDefined, "**", self.class, other.class end end ```

### #+(m) ⇒ Object

``````Matrix.scalar(2,5) + Matrix[[1,0], [-4,7]]
=>  6  0
-4 12
``````
 ``` 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858``` ```# File 'lib/matrix.rb', line 839 def +(m) case m when Numeric Matrix.Raise ErrOperationNotDefined, "+", self.class, m.class when Vector m = self.class.column_vector(m) when Matrix else return apply_through_coercion(m, __method__) end Matrix.Raise ErrDimensionMismatch unless row_count == m.row_count and column_count == m.column_count rows = Array.new(row_count) {|i| Array.new(column_count) {|j| self[i, j] + m[i, j] } } new_matrix rows, column_count end ```

### #-(m) ⇒ Object

Matrix subtraction.

``````Matrix[[1,5], [4,2]] - Matrix[[9,3], [-4,1]]
=> -8  2
8  1
``````
 ``` 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885``` ```# File 'lib/matrix.rb', line 866 def -(m) case m when Numeric Matrix.Raise ErrOperationNotDefined, "-", self.class, m.class when Vector m = self.class.column_vector(m) when Matrix else return apply_through_coercion(m, __method__) end Matrix.Raise ErrDimensionMismatch unless row_count == m.row_count and column_count == m.column_count rows = Array.new(row_count) {|i| Array.new(column_count) {|j| self[i, j] - m[i, j] } } new_matrix rows, column_count end ```

### #/(other) ⇒ Object

Matrix division (multiplication by the inverse).

``````Matrix[[7,6], [3,9]] / Matrix[[2,9], [3,1]]
=> -7  1
-3 -6
``````
 ``` 893 894 895 896 897 898 899 900 901 902 903 904 905``` ```# File 'lib/matrix.rb', line 893 def /(other) case other when Numeric rows = @rows.collect {|row| row.collect {|e| e / other } } return new_matrix rows, column_count when Matrix return self * other.inverse else return apply_through_coercion(other, __method__) end end ```

### #==(other) ⇒ Object

Returns `true` if and only if the two matrices contain equal elements.

 ``` 768 769 770 771 772``` ```# File 'lib/matrix.rb', line 768 def ==(other) return false unless Matrix === other && column_count == other.column_count # necessary for empty matrices rows == other.rows end ```

### #[](i, j) ⇒ ObjectAlso known as: element, component

Returns element (`i`,`j`) of the matrix. That is: row `i`, column `j`.

 ``` 314 315 316``` ```# File 'lib/matrix.rb', line 314 def [](i, j) @rows.fetch(i){return nil}[j] end ```

### #clone ⇒ Object

Returns a clone of the matrix, so that the contents of each do not reference identical objects. There should be no good reason to do this since Matrices are immutable.

 ``` 785 786 787``` ```# File 'lib/matrix.rb', line 785 def clone new_matrix @rows.map(&:dup), column_count end ```

### #coerce(other) ⇒ Object

The coerce method provides support for Ruby type coercion. This coercion mechanism is used by Ruby to handle mixed-type numeric operations: it is intended to find a compatible common type between the two operands of the operator. See also Numeric#coerce.

 ``` 1278 1279 1280 1281 1282 1283 1284 1285``` ```# File 'lib/matrix.rb', line 1278 def coerce(other) case other when Numeric return Scalar.new(other), self else raise TypeError, "#{self.class} can't be coerced into #{other.class}" end end ```

### #collect(&block) ⇒ ObjectAlso known as: map

Returns a matrix that is the result of iteration of the given block over all elements of the matrix.

``````Matrix[ [1,2], [3,4] ].collect { |e| e**2 }
=> 1  4
9 16
``````
 ``` 382 383 384 385 386``` ```# File 'lib/matrix.rb', line 382 def collect(&block) # :yield: e return to_enum(:collect) unless block_given? rows = @rows.collect{|row| row.collect(&block)} new_matrix rows, column_count end ```

### #column(j) ⇒ Object

Returns column vector number `j` of the matrix as a Vector (starting at 0 like an array). When a block is given, the elements of that vector are iterated.

 ``` 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373``` ```# File 'lib/matrix.rb', line 359 def column(j) # :yield: e if block_given? return self if j >= column_count || j < -column_count row_count.times do |i| yield @rows[i][j] end self else return nil if j >= column_count || j < -column_count col = Array.new(row_count) {|i| @rows[i][j] } Vector.elements(col, false) end end ```

### #column_vectors ⇒ Object

Returns an array of the column vectors of the matrix. See Vector.

 ``` 1299 1300 1301 1302 1303``` ```# File 'lib/matrix.rb', line 1299 def column_vectors Array.new(column_count) {|i| column(i) } end ```

### #conjugate ⇒ ObjectAlso known as: conj

Returns the conjugate of the matrix.

``````Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]]
=> 1+2i   i  0
1   2  3
Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]].conjugate
=> 1-2i  -i  0
1   2  3
``````
 ``` 1224 1225 1226``` ```# File 'lib/matrix.rb', line 1224 def conjugate collect(&:conjugate) end ```

### #determinant ⇒ ObjectAlso known as: det

Returns the determinant of the matrix.

Beware that using Float values can yield erroneous results because of their lack of precision. Consider using exact types like Rational or BigDecimal instead.

``````Matrix[[7,6], [3,9]].determinant
=> 45
``````
 ``` 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047``` ```# File 'lib/matrix.rb', line 1010 def determinant Matrix.Raise ErrDimensionMismatch unless square? m = @rows case row_count # Up to 4x4, give result using Laplacian expansion by minors. # This will typically be faster, as well as giving good results # in case of Floats when 0 +1 when 1 + m[0][0] when 2 + m[0][0] * m[1][1] - m[0][1] * m[1][0] when 3 m0, m1, m2 = m + m0[0] * m1[1] * m2[2] - m0[0] * m1[2] * m2[1] \ - m0[1] * m1[0] * m2[2] + m0[1] * m1[2] * m2[0] \ + m0[2] * m1[0] * m2[1] - m0[2] * m1[1] * m2[0] when 4 m0, m1, m2, m3 = m + m0[0] * m1[1] * m2[2] * m3[3] - m0[0] * m1[1] * m2[3] * m3[2] \ - m0[0] * m1[2] * m2[1] * m3[3] + m0[0] * m1[2] * m2[3] * m3[1] \ + m0[0] * m1[3] * m2[1] * m3[2] - m0[0] * m1[3] * m2[2] * m3[1] \ - m0[1] * m1[0] * m2[2] * m3[3] + m0[1] * m1[0] * m2[3] * m3[2] \ + m0[1] * m1[2] * m2[0] * m3[3] - m0[1] * m1[2] * m2[3] * m3[0] \ - m0[1] * m1[3] * m2[0] * m3[2] + m0[1] * m1[3] * m2[2] * m3[0] \ + m0[2] * m1[0] * m2[1] * m3[3] - m0[2] * m1[0] * m2[3] * m3[1] \ - m0[2] * m1[1] * m2[0] * m3[3] + m0[2] * m1[1] * m2[3] * m3[0] \ + m0[2] * m1[3] * m2[0] * m3[1] - m0[2] * m1[3] * m2[1] * m3[0] \ - m0[3] * m1[0] * m2[1] * m3[2] + m0[3] * m1[0] * m2[2] * m3[1] \ + m0[3] * m1[1] * m2[0] * m3[2] - m0[3] * m1[1] * m2[2] * m3[0] \ - m0[3] * m1[2] * m2[0] * m3[1] + m0[3] * m1[2] * m2[1] * m3[0] else # For bigger matrices, use an efficient and general algorithm. # Currently, we use the Gauss-Bareiss algorithm determinant_bareiss end end ```

### #determinant_e ⇒ ObjectAlso known as: det_e

deprecated; use Matrix#determinant

 ``` 1092 1093 1094 1095``` ```# File 'lib/matrix.rb', line 1092 def determinant_e warn "#{caller(1)[0]}: warning: Matrix#determinant_e is deprecated; use #determinant" determinant end ```

### #diagonal? ⇒ Boolean

Returns `true` is this is a diagonal matrix. Raises an error if matrix is not square.

 ``` 600 601 602 603``` ```# File 'lib/matrix.rb', line 600 def diagonal? Matrix.Raise ErrDimensionMismatch unless square? each(:off_diagonal).all?(&:zero?) end ```

### #each(which = :all) ⇒ Object

Yields all elements of the matrix, starting with those of the first row, or returns an Enumerator is no block given. Elements can be restricted by passing an argument:

• :all (default): yields all elements

• :diagonal: yields only elements on the diagonal

• :off_diagonal: yields all elements except on the diagonal

• :lower: yields only elements on or below the diagonal

• :strict_lower: yields only elements below the diagonal

• :strict_upper: yields only elements above the diagonal

• :upper: yields only elements on or above the diagonal

Matrix[ [1,2], [3,4] ].each { |e| puts e }

``````# => prints the numbers 1 to 4
``````

Matrix[ [1,2], [3,4] ].each(:strict_lower).to_a # => [3]

 ``` 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452``` ```# File 'lib/matrix.rb', line 405 def each(which = :all) # :yield: e return to_enum :each, which unless block_given? last = column_count - 1 case which when :all block = Proc.new @rows.each do |row| row.each(&block) end when :diagonal @rows.each_with_index do |row, row_index| yield row.fetch(row_index){return self} end when :off_diagonal @rows.each_with_index do |row, row_index| column_count.times do |col_index| yield row[col_index] unless row_index == col_index end end when :lower @rows.each_with_index do |row, row_index| 0.upto([row_index, last].min) do |col_index| yield row[col_index] end end when :strict_lower @rows.each_with_index do |row, row_index| [row_index, column_count].min.times do |col_index| yield row[col_index] end end when :strict_upper @rows.each_with_index do |row, row_index| (row_index+1).upto(last) do |col_index| yield row[col_index] end end when :upper @rows.each_with_index do |row, row_index| row_index.upto(last) do |col_index| yield row[col_index] end end else raise ArgumentError, "expected #{which.inspect} to be one of :all, :diagonal, :off_diagonal, :lower, :strict_lower, :strict_upper or :upper" end self end ```

### #each_with_index(which = :all) ⇒ Object

Same as #each, but the row index and column index in addition to the element

``````Matrix[ [1,2], [3,4] ].each_with_index do |e, row, col|
puts "#{e} at #{row}, #{col}"
end
# => Prints:
#    1 at 0, 0
#    2 at 0, 1
#    3 at 1, 0
#    4 at 1, 1
``````
 ``` 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514``` ```# File 'lib/matrix.rb', line 466 def each_with_index(which = :all) # :yield: e, row, column return to_enum :each_with_index, which unless block_given? last = column_count - 1 case which when :all @rows.each_with_index do |row, row_index| row.each_with_index do |e, col_index| yield e, row_index, col_index end end when :diagonal @rows.each_with_index do |row, row_index| yield row.fetch(row_index){return self}, row_index, row_index end when :off_diagonal @rows.each_with_index do |row, row_index| column_count.times do |col_index| yield row[col_index], row_index, col_index unless row_index == col_index end end when :lower @rows.each_with_index do |row, row_index| 0.upto([row_index, last].min) do |col_index| yield row[col_index], row_index, col_index end end when :strict_lower @rows.each_with_index do |row, row_index| [row_index, column_count].min.times do |col_index| yield row[col_index], row_index, col_index end end when :strict_upper @rows.each_with_index do |row, row_index| (row_index+1).upto(last) do |col_index| yield row[col_index], row_index, col_index end end when :upper @rows.each_with_index do |row, row_index| row_index.upto(last) do |col_index| yield row[col_index], row_index, col_index end end else raise ArgumentError, "expected #{which.inspect} to be one of :all, :diagonal, :off_diagonal, :lower, :strict_lower, :strict_upper or :upper" end self end ```

### #eigensystem ⇒ ObjectAlso known as: eigen

Returns the Eigensystem of the matrix; see `EigenvalueDecomposition`.

``````m = Matrix[[1, 2], [3, 4]]
v, d, v_inv = m.eigensystem
d.diagonal? # => true
v.inv == v_inv # => true
(v * d * v_inv).round(5) == m # => true
``````
 ``` 1191 1192 1193``` ```# File 'lib/matrix.rb', line 1191 def eigensystem EigenvalueDecomposition.new(self) end ```

### #elements_to_f ⇒ Object

 ``` 1312 1313 1314 1315``` ```# File 'lib/matrix.rb', line 1312 def elements_to_f warn "#{caller(1)[0]}: warning: Matrix#elements_to_f is deprecated, use map(&:to_f)" map(&:to_f) end ```

### #elements_to_i ⇒ Object

 ``` 1317 1318 1319 1320``` ```# File 'lib/matrix.rb', line 1317 def elements_to_i warn "#{caller(1)[0]}: warning: Matrix#elements_to_i is deprecated, use map(&:to_i)" map(&:to_i) end ```

### #elements_to_r ⇒ Object

 ``` 1322 1323 1324 1325``` ```# File 'lib/matrix.rb', line 1322 def elements_to_r warn "#{caller(1)[0]}: warning: Matrix#elements_to_r is deprecated, use map(&:to_r)" map(&:to_r) end ```

### #empty? ⇒ Boolean

Returns `true` if this is an empty matrix, i.e. if the number of rows or the number of columns is 0.

 ``` 609 610 611``` ```# File 'lib/matrix.rb', line 609 def empty? column_count == 0 || row_count == 0 end ```

### #eql?(other) ⇒ Boolean

 ``` 774 775 776 777 778``` ```# File 'lib/matrix.rb', line 774 def eql?(other) return false unless Matrix === other && column_count == other.column_count # necessary for empty matrices rows.eql? other.rows end ```

### #hash ⇒ Object

Returns a hash-code for the matrix.

 ``` 792 793 794``` ```# File 'lib/matrix.rb', line 792 def hash @rows.hash end ```

### #hermitian? ⇒ Boolean

Returns `true` is this is an hermitian matrix. Raises an error if matrix is not square.

 ``` 617 618 619 620 621 622``` ```# File 'lib/matrix.rb', line 617 def hermitian? Matrix.Raise ErrDimensionMismatch unless square? each_with_index(:upper).all? do |e, row, col| e == rows[col][row].conj end end ```

### #imaginary ⇒ ObjectAlso known as: imag

Returns the imaginary part of the matrix.

``````Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]]
=> 1+2i  i  0
1  2  3
Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]].imaginary
=>   2i  i  0
0  0  0
``````
 ``` 1238 1239 1240``` ```# File 'lib/matrix.rb', line 1238 def imaginary collect(&:imaginary) end ```

### #index(*args) ⇒ ObjectAlso known as: find_index

:call-seq:

``````index(value, selector = :all) -> [row, column]
index(selector = :all){ block } -> [row, column]
index(selector = :all) -> an_enumerator
``````

The index method is specialized to return the index as [row, column] It also accepts an optional `selector` argument, see #each for details.

``````Matrix[ [1,2], [3,4] ].index(&:even?) # => [0, 1]
Matrix[ [1,1], [1,1] ].index(1, :strict_lower) # => [1, 0]
``````

Raises:

• (ArgumentError)
 ``` 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544``` ```# File 'lib/matrix.rb', line 529 def index(*args) raise ArgumentError, "wrong number of arguments(#{args.size} for 0-2)" if args.size > 2 which = (args.size == 2 || SELECTORS.include?(args.last)) ? args.pop : :all return to_enum :find_index, which, *args unless block_given? || args.size == 1 if args.size == 1 value = args.first each_with_index(which) do |e, row_index, col_index| return row_index, col_index if e == value end else each_with_index(which) do |e, row_index, col_index| return row_index, col_index if yield e end end nil end ```

### #inspect ⇒ Object

Overrides Object#inspect

 ``` 1347 1348 1349 1350 1351 1352 1353``` ```# File 'lib/matrix.rb', line 1347 def inspect if empty? "#{self.class}.empty(#{row_count}, #{column_count})" else "#{self.class}#{@rows.inspect}" end end ```

### #inverse ⇒ ObjectAlso known as: inv

Returns the inverse of the matrix.

``````Matrix[[-1, -1], [0, -1]].inverse
=> -1  1
0 -1
``````
 ``` 913 914 915 916``` ```# File 'lib/matrix.rb', line 913 def inverse Matrix.Raise ErrDimensionMismatch unless square? self.class.I(row_count).send(:inverse_from, self) end ```

### #lower_triangular? ⇒ Boolean

Returns `true` is this is a lower triangular matrix.

 ``` 627 628 629``` ```# File 'lib/matrix.rb', line 627 def lower_triangular? each(:strict_upper).all?(&:zero?) end ```

### #lup ⇒ ObjectAlso known as: lup_decomposition

Returns the LUP decomposition of the matrix; see `LUPDecomposition`.

``````a = Matrix[[1, 2], [3, 4]]
l, u, p = a.lup
l.lower_triangular? # => true
u.upper_triangular? # => true
p.permutation?      # => true
l * u == p * a      # => true
a.lup.solve([2, 5]) # => Vector[(1/1), (1/2)]
``````
 ``` 1206 1207 1208``` ```# File 'lib/matrix.rb', line 1206 def lup LUPDecomposition.new(self) end ```

### #minor(*param) ⇒ Object

Returns a section of the matrix. The parameters are either:

• start_row, nrows, start_col, ncols; OR

• row_range, col_range

``````Matrix.diagonal(9, 5, -3).minor(0..1, 0..2)
=> 9 0 0
0 5 0
``````

Like Array#[], negative indices count backward from the end of the row or column (-1 is the last element). Returns nil if the starting row or column is greater than row_count or column_count respectively.

 ``` 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590``` ```# File 'lib/matrix.rb', line 559 def minor(*param) case param.size when 2 row_range, col_range = param from_row = row_range.first from_row += row_count if from_row < 0 to_row = row_range.end to_row += row_count if to_row < 0 to_row += 1 unless row_range.exclude_end? size_row = to_row - from_row from_col = col_range.first from_col += column_count if from_col < 0 to_col = col_range.end to_col += column_count if to_col < 0 to_col += 1 unless col_range.exclude_end? size_col = to_col - from_col when 4 from_row, size_row, from_col, size_col = param return nil if size_row < 0 || size_col < 0 from_row += row_count if from_row < 0 from_col += column_count if from_col < 0 else raise ArgumentError, param.inspect end return nil if from_row > row_count || from_col > column_count || from_row < 0 || from_col < 0 rows = @rows[from_row, size_row].collect{|row| row[from_col, size_col] } new_matrix rows, [column_count - from_col, size_col].min end ```

### #normal? ⇒ Boolean

Returns `true` is this is a normal matrix. Raises an error if matrix is not square.

 ``` 635 636 637 638 639 640 641 642 643 644 645 646 647``` ```# File 'lib/matrix.rb', line 635 def normal? Matrix.Raise ErrDimensionMismatch unless square? rows.each_with_index do |row_i, i| rows.each_with_index do |row_j, j| s = 0 rows.each_with_index do |row_k, k| s += row_i[k] * row_j[k].conj - row_k[i].conj * row_k[j] end return false unless s == 0 end end true end ```

### #orthogonal? ⇒ Boolean

Returns `true` is this is an orthogonal matrix Raises an error if matrix is not square.

 ``` 653 654 655 656 657 658 659 660 661 662 663 664 665``` ```# File 'lib/matrix.rb', line 653 def orthogonal? Matrix.Raise ErrDimensionMismatch unless square? rows.each_with_index do |row, i| column_count.times do |j| s = 0 row_count.times do |k| s += row[k] * rows[k][j] end return false unless s == (i == j ? 1 : 0) end end true end ```

### #permutation? ⇒ Boolean

Returns `true` is this is a permutation matrix Raises an error if matrix is not square.

 ``` 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687``` ```# File 'lib/matrix.rb', line 671 def permutation? Matrix.Raise ErrDimensionMismatch unless square? cols = Array.new(column_count) rows.each_with_index do |row, i| found = false row.each_with_index do |e, j| if e == 1 return false if found || cols[j] found = cols[j] = true elsif e != 0 return false end end return false unless found end true end ```

### #rank ⇒ Object

Returns the rank of the matrix. Beware that using Float values can yield erroneous results because of their lack of precision. Consider using exact types like Rational or BigDecimal instead.

``````Matrix[[7,6], [3,9]].rank
=> 2
``````
 ``` 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133``` ```# File 'lib/matrix.rb', line 1107 def rank # We currently use Bareiss' multistep integer-preserving gaussian elimination # (see comments on determinant) a = to_a last_column = column_count - 1 last_row = row_count - 1 pivot_row = 0 previous_pivot = 1 0.upto(last_column) do |k| switch_row = (pivot_row .. last_row).find {|row| a[row][k] != 0 } if switch_row a[switch_row], a[pivot_row] = a[pivot_row], a[switch_row] unless pivot_row == switch_row pivot = a[pivot_row][k] (pivot_row+1).upto(last_row) do |i| ai = a[i] (k+1).upto(last_column) do |j| ai[j] = (pivot * ai[j] - ai[k] * a[pivot_row][j]) / previous_pivot end end pivot_row += 1 previous_pivot = pivot end end pivot_row end ```

### #rank_e ⇒ Object

deprecated; use Matrix#rank

 ``` 1138 1139 1140 1141``` ```# File 'lib/matrix.rb', line 1138 def rank_e warn "#{caller(1)[0]}: warning: Matrix#rank_e is deprecated; use #rank" rank end ```

### #real ⇒ Object

Returns the real part of the matrix.

``````Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]]
=> 1+2i  i  0
1  2  3
Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]].real
=>    1  0  0
1  2  3
``````
 ``` 1252 1253 1254``` ```# File 'lib/matrix.rb', line 1252 def real collect(&:real) end ```

### #real? ⇒ Boolean

Returns `true` if all entries of the matrix are real.

 ``` 692 693 694``` ```# File 'lib/matrix.rb', line 692 def real? all?(&:real?) end ```

### #rect ⇒ ObjectAlso known as: rectangular

Returns an array containing matrices corresponding to the real and imaginary parts of the matrix

m.rect == [m.real, m.imag] # ==> true for all matrices m

 ``` 1262 1263 1264``` ```# File 'lib/matrix.rb', line 1262 def rect [real, imag] end ```

### #regular? ⇒ Boolean

Returns `true` if this is a regular (i.e. non-singular) matrix.

 ``` 699 700 701``` ```# File 'lib/matrix.rb', line 699 def regular? not singular? end ```

### #round(ndigits = 0) ⇒ Object

Returns a matrix with entries rounded to the given precision (see Float#round)

 ``` 1146 1147 1148``` ```# File 'lib/matrix.rb', line 1146 def round(ndigits=0) map{|e| e.round(ndigits)} end ```

### #row(i, &block) ⇒ Object

Returns row vector number `i` of the matrix as a Vector (starting at 0 like an array). When a block is given, the elements of that vector are iterated.

 ``` 345 346 347 348 349 350 351 352``` ```# File 'lib/matrix.rb', line 345 def row(i, &block) # :yield: e if block_given? @rows.fetch(i){return self}.each(&block) self else Vector.elements(@rows.fetch(i){return nil}) end end ```

### #row_count ⇒ ObjectAlso known as: row_size

Returns the number of rows.

 ``` 330 331 332``` ```# File 'lib/matrix.rb', line 330 def row_count @rows.size end ```

### #row_vectors ⇒ Object

Returns an array of the row vectors of the matrix. See Vector.

 ``` 1290 1291 1292 1293 1294``` ```# File 'lib/matrix.rb', line 1290 def row_vectors Array.new(row_count) {|i| row(i) } end ```

### #singular? ⇒ Boolean

Returns `true` is this is a singular matrix.

 ``` 706 707 708``` ```# File 'lib/matrix.rb', line 706 def singular? determinant == 0 end ```

### #square? ⇒ Boolean

Returns `true` is this is a square matrix.

 ``` 713 714 715``` ```# File 'lib/matrix.rb', line 713 def square? column_count == row_count end ```

### #symmetric? ⇒ Boolean

Returns `true` is this is a symmetric matrix. Raises an error if matrix is not square.

 ``` 721 722 723 724 725 726 727``` ```# File 'lib/matrix.rb', line 721 def symmetric? Matrix.Raise ErrDimensionMismatch unless square? each_with_index(:strict_upper) do |e, row, col| return false if e != rows[col][row] end true end ```

### #to_a ⇒ Object

Returns an array of arrays that describe the rows of the matrix.

 ``` 1308 1309 1310``` ```# File 'lib/matrix.rb', line 1308 def to_a @rows.collect(&:dup) end ```

### #to_s ⇒ Object

Overrides Object#to_s

 ``` 1334 1335 1336 1337 1338 1339 1340 1341 1342``` ```# File 'lib/matrix.rb', line 1334 def to_s if empty? "#{self.class}.empty(#{row_count}, #{column_count})" else "#{self.class}[" + @rows.collect{|row| "[" + row.collect{|e| e.to_s}.join(", ") + "]" }.join(", ")+"]" end end ```

### #trace ⇒ ObjectAlso known as: tr

Returns the trace (sum of diagonal elements) of the matrix.

``````Matrix[[7,6], [3,9]].trace
=> 16
``````
 ``` 1155 1156 1157 1158 1159 1160``` ```# File 'lib/matrix.rb', line 1155 def trace Matrix.Raise ErrDimensionMismatch unless square? (0...column_count).inject(0) do |tr, i| tr + @rows[i][i] end end ```

### #transpose ⇒ ObjectAlso known as: t

Returns the transpose of the matrix.

``````Matrix[[1,2], [3,4], [5,6]]
=> 1 2
3 4
5 6
Matrix[[1,2], [3,4], [5,6]].transpose
=> 1 3 5
2 4 6
``````
 ``` 1173 1174 1175 1176``` ```# File 'lib/matrix.rb', line 1173 def transpose return self.class.empty(column_count, 0) if row_count.zero? new_matrix @rows.transpose, row_count end ```

### #unitary? ⇒ Boolean

Returns `true` is this is a unitary matrix Raises an error if matrix is not square.

 ``` 733 734 735 736 737 738 739 740 741 742 743 744 745``` ```# File 'lib/matrix.rb', line 733 def unitary? Matrix.Raise ErrDimensionMismatch unless square? rows.each_with_index do |row, i| column_count.times do |j| s = 0 row_count.times do |k| s += row[k].conj * rows[k][j] end return false unless s == (i == j ? 1 : 0) end end true end ```

### #upper_triangular? ⇒ Boolean

Returns `true` is this is an upper triangular matrix.

 ``` 750 751 752``` ```# File 'lib/matrix.rb', line 750 def upper_triangular? each(:strict_lower).all?(&:zero?) end ```

### #zero? ⇒ Boolean

Returns `true` is this is a matrix with only zero elements

 ``` 757 758 759``` ```# File 'lib/matrix.rb', line 757 def zero? all?(&:zero?) end ```