class Matrix

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[*rows] `

• ` Matrix.[](*rows) `

• ` Matrix.rows(rows, copy = true) `

• ` Matrix.columns(columns) `

• ` Matrix.build(row_size, column_size, &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_size `

• ` #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 `

SELECTORS

Attributes

column_size[R]

Returns the number of columns.

rows[R]

instance creations

Public Class Methods

I(n)
Alias for: identity
[](*rows) click to toggle source

Creates a matrix where each argument is a row.

```Matrix[ [25, 93], [-1, 66] ]
=>  25 93
-1 66
```
```# File rake/lib/matrix.rb, line 139
def Matrix.[](*rows)
Matrix.rows(rows, false)
end```
build(row_size, column_size = row_size) { |i, j| ... } click to toggle source

Creates a matrix of size `row_size` x `column_size`. 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
```
```# File rake/lib/matrix.rb, line 184
def Matrix.build(row_size, column_size = row_size)
row_size = CoercionHelper.coerce_to_int(row_size)
column_size = CoercionHelper.coerce_to_int(column_size)
raise ArgumentError if row_size < 0 || column_size < 0
return to_enum :build, row_size, column_size unless block_given?
rows = Array.new(row_size) do |i|
Array.new(column_size) do |j|
yield i, j
end
end
new rows, column_size
end```
column_vector(column) click to toggle source

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
```
```# File rake/lib/matrix.rb, line 269
def Matrix.column_vector(column)
column = convert_to_array(column)
new [column].transpose, 1
end```
columns(columns) click to toggle source

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

```Matrix.columns([[25, 93], [-1, 66]])
=>  25 -1
93 66
```
```# File rake/lib/matrix.rb, line 169
def Matrix.columns(columns)
Matrix.rows(columns, false).transpose
end```
diagonal(*values) click to toggle source

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
```
```# File rake/lib/matrix.rb, line 204
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_size = 0, column_size = 0) click to toggle source

Creates a empty matrix of `row_size` x `column_size`. At least one of `row_size` or `column_size` 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]]
```
```# File rake/lib/matrix.rb, line 287
def Matrix.empty(row_size = 0, column_size = 0)
Matrix.Raise ArgumentError, "One size must be 0" if column_size != 0 && row_size != 0
Matrix.Raise ArgumentError, "Negative size" if column_size < 0 || row_size < 0

new([[]]*row_size, column_size)
end```
identity(n) click to toggle source

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

```Matrix.identity(2)
=> 1 0
0 1
```
```# File rake/lib/matrix.rb, line 231
def Matrix.identity(n)
Matrix.scalar(n, 1)
end```
Also aliased as: unit, I
new(rows, column_size = rows[0].size) click to toggle source

::new is private; use ::rows, columns, [], etc... to create.

```# File rake/lib/matrix.rb, line 297
def initialize(rows, column_size = rows[0].size)
# No checking is done at this point. rows must be an Array of Arrays.
# column_size 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_size = column_size
end```
row_vector(row) click to toggle source

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
```
```# File rake/lib/matrix.rb, line 256
def Matrix.row_vector(row)
row = convert_to_array(row)
new [row]
end```
rows(rows, copy = true) click to toggle source

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
```
```# File rake/lib/matrix.rb, line 151
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|
Matrix.Raise ErrDimensionMismatch, "row size differs (#{row.size} should be #{size})" unless row.size == size
end
new rows, size
end```
scalar(n, value) click to toggle source

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

```Matrix.scalar(2, 5)
=> 5 0
0 5
```
```# File rake/lib/matrix.rb, line 221
def Matrix.scalar(n, value)
Matrix.diagonal(*Array.new(n, value))
end```
unit(n)
Alias for: identity
zero(row_size, column_size = row_size) click to toggle source

Creates a zero matrix.

```Matrix.zero(2)
=> 0 0
0 0
```
```# File rake/lib/matrix.rb, line 245
def Matrix.zero(row_size, column_size = row_size)
rows = Array.new(row_size){Array.new(column_size, 0)}
new rows, column_size
end```

Public Instance Methods

*(m) click to toggle source

Matrix multiplication.

```Matrix[[2,4], [6,8]] * Matrix.identity(2)
=> 2 4
6 8
```
```# File rake/lib/matrix.rb, line 802
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_size
when Vector
m = Matrix.column_vector(m)
r = self * m
return r.column(0)
when Matrix
Matrix.Raise ErrDimensionMismatch if column_size != m.row_size

rows = Array.new(row_size) {|i|
Array.new(m.column_size) {|j|
(0 ... column_size).inject(0) do |vij, k|
vij + self[i, k] * m[k, j]
end
}
}
return new_matrix rows, m.column_size
else
return apply_through_coercion(m, __method__)
end
end```
**(other) click to toggle source

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
```
```# File rake/lib/matrix.rb, line 969
def ** (other)
case other
when Integer
x = self
if other <= 0
x = self.inverse
return Matrix.identity(self.column_size) 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 * Matrix.diagonal(*d.each(:diagonal).map{|e| e ** other}) * v_inv
else
Matrix.Raise ErrOperationNotDefined, "**", self.class, other.class
end
end```
+(m) click to toggle source

```Matrix.scalar(2,5) + Matrix[[1,0], [-4,7]]
=>  6  0
-4 12
```
```# File rake/lib/matrix.rb, line 835
def +(m)
case m
when Numeric
Matrix.Raise ErrOperationNotDefined, "+", self.class, m.class
when Vector
m = Matrix.column_vector(m)
when Matrix
else
return apply_through_coercion(m, __method__)
end

Matrix.Raise ErrDimensionMismatch unless row_size == m.row_size and column_size == m.column_size

rows = Array.new(row_size) {|i|
Array.new(column_size) {|j|
self[i, j] + m[i, j]
}
}
new_matrix rows, column_size
end```
-(m) click to toggle source

Matrix subtraction.

```Matrix[[1,5], [4,2]] - Matrix[[9,3], [-4,1]]
=> -8  2
8  1
```
```# File rake/lib/matrix.rb, line 862
def -(m)
case m
when Numeric
Matrix.Raise ErrOperationNotDefined, "-", self.class, m.class
when Vector
m = Matrix.column_vector(m)
when Matrix
else
return apply_through_coercion(m, __method__)
end

Matrix.Raise ErrDimensionMismatch unless row_size == m.row_size and column_size == m.column_size

rows = Array.new(row_size) {|i|
Array.new(column_size) {|j|
self[i, j] - m[i, j]
}
}
new_matrix rows, column_size
end```
/(other) click to toggle source

Matrix division (multiplication by the inverse).

```Matrix[[7,6], [3,9]] / Matrix[[2,9], [3,1]]
=> -7  1
-3 -6
```
```# File rake/lib/matrix.rb, line 889
def /(other)
case other
when Numeric
rows = @rows.collect {|row|
row.collect {|e| e / other }
}
return new_matrix rows, column_size
when Matrix
return self * other.inverse
else
return apply_through_coercion(other, __method__)
end
end```
==(other) click to toggle source

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

```# File rake/lib/matrix.rb, line 764
def ==(other)
return false unless Matrix === other &&
column_size == other.column_size # necessary for empty matrices
rows == other.rows
end```
[](i, j) click to toggle source

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

```# File rake/lib/matrix.rb, line 313
def [](i, j)
@rows.fetch(i){return nil}[j]
end```
Also aliased as: element, component
clone() click to toggle source

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.

```# File rake/lib/matrix.rb, line 781
def clone
new_matrix @rows.map(&:dup), column_size
end```
coerce(other) click to toggle source

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.

```# File rake/lib/matrix.rb, line 1274
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() { |e| ... } click to toggle source

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
```
```# File rake/lib/matrix.rb, line 379
def collect(&block) # :yield: e
rows = @rows.collect{|row| row.collect(&block)}
new_matrix rows, column_size
end```
Also aliased as: map
column(j) { |e| ... } click to toggle source

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.

```# File rake/lib/matrix.rb, line 356
def column(j) # :yield: e
if block_given?
return self if j >= column_size || j < -column_size
row_size.times do |i|
yield @rows[i][j]
end
self
else
return nil if j >= column_size || j < -column_size
col = Array.new(row_size) {|i|
@rows[i][j]
}
Vector.elements(col, false)
end
end```
column_vectors() click to toggle source

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

```# File rake/lib/matrix.rb, line 1295
def column_vectors
Array.new(column_size) {|i|
column(i)
}
end```
component(i, j)
Alias for: []
conj()
Alias for: conjugate
conjugate() click to toggle source

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
```
```# File rake/lib/matrix.rb, line 1220
def conjugate
collect(&:conjugate)
end```
Also aliased as: conj
det()
Alias for: determinant
det_e()
Alias for: determinant_e
determinant() click to toggle source

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
```
```# File rake/lib/matrix.rb, line 1006
def determinant
Matrix.Raise ErrDimensionMismatch unless square?
m = @rows
case row_size
# 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```
Also aliased as: det
determinant_e() click to toggle source

deprecated; use #determinant

```# File rake/lib/matrix.rb, line 1088
def determinant_e
warn "#{caller(1)[0]}: warning: Matrix#determinant_e is deprecated; use #determinant"
rank
end```
Also aliased as: det_e
diagonal?() click to toggle source

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

```# File rake/lib/matrix.rb, line 597
def diagonal?
Matrix.Raise ErrDimensionMismatch unless square?
each(:off_diagonal).all?(&:zero?)
end```
each(which = :all) { |e| ... } click to toggle source

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]

```# File rake/lib/matrix.rb, line 402
def each(which = :all) # :yield: e
last = column_size - 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_size.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_size].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
Matrix.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) { |e, row, column| ... } click to toggle source

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
```
```# File rake/lib/matrix.rb, line 463
def each_with_index(which = :all) # :yield: e, row, column
last = column_size - 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_size.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_size].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
Matrix.Raise ArgumentError, "expected #{which.inspect} to be one of :all, :diagonal, :off_diagonal, :lower, :strict_lower, :strict_upper or :upper"
end
self
end```
eigen()
Alias for: eigensystem
eigensystem() click to toggle source

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
```
```# File rake/lib/matrix.rb, line 1187
def eigensystem
EigenvalueDecomposition.new(self)
end```
Also aliased as: eigen
element(i, j)
Alias for: []
elements_to_f() click to toggle source
```# File rake/lib/matrix.rb, line 1308
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() click to toggle source
```# File rake/lib/matrix.rb, line 1313
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() click to toggle source
```# File rake/lib/matrix.rb, line 1318
def elements_to_r
warn "#{caller(1)[0]}: warning: Matrix#elements_to_r is deprecated, use map(&:to_r)"
map(&:to_r)
end```
empty?() click to toggle source

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

```# File rake/lib/matrix.rb, line 606
def empty?
column_size == 0 || row_size == 0
end```
eql?(other) click to toggle source
```# File rake/lib/matrix.rb, line 770
def eql?(other)
return false unless Matrix === other &&
column_size == other.column_size # necessary for empty matrices
rows.eql? other.rows
end```
find_index(*args)
Alias for: index
hash() click to toggle source

Returns a hash-code for the matrix.

```# File rake/lib/matrix.rb, line 788
def hash
@rows.hash
end```
hermitian?() click to toggle source

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

```# File rake/lib/matrix.rb, line 614
def hermitian?
Matrix.Raise ErrDimensionMismatch unless square?
each_with_index(:strict_upper).all? do |e, row, col|
e == rows[col][row].conj
end
end```
imag()
Alias for: imaginary
imaginary() click to toggle source

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
```
```# File rake/lib/matrix.rb, line 1234
def imaginary
collect(&:imaginary)
end```
Also aliased as: imag
index(value, selector = :all) → [row, column] click to toggle source
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]
```
```# File rake/lib/matrix.rb, line 526
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```
Also aliased as: find_index
inspect() click to toggle source

Overrides Object#inspect

```# File rake/lib/matrix.rb, line 1343
def inspect
if empty?
"Matrix.empty(#{row_size}, #{column_size})"
else
"Matrix#{@rows.inspect}"
end
end```
inv()
Alias for: inverse
inverse() click to toggle source

Returns the inverse of the matrix.

```Matrix[[-1, -1], [0, -1]].inverse
=> -1  1
0 -1
```
```# File rake/lib/matrix.rb, line 909
def inverse
Matrix.Raise ErrDimensionMismatch unless square?
Matrix.I(row_size).send(:inverse_from, self)
end```
Also aliased as: inv
lower_triangular?() click to toggle source

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

```# File rake/lib/matrix.rb, line 624
def lower_triangular?
each(:strict_upper).all?(&:zero?)
end```
lup() click to toggle source

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 == a * p      # => true
a.lup.solve([2, 5]) # => Vector[(1/1), (1/2)]
```
```# File rake/lib/matrix.rb, line 1202
def lup
LUPDecomposition.new(self)
end```
Also aliased as: lup_decomposition
lup_decomposition()
Alias for: lup
map()
Alias for: collect
minor(*param) click to toggle source

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_size or #column_size respectively.

```# File rake/lib/matrix.rb, line 556
def minor(*param)
case param.size
when 2
row_range, col_range = param
from_row = row_range.first
from_row += row_size if from_row < 0
to_row = row_range.end
to_row += row_size 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_size if from_col < 0
to_col = col_range.end
to_col += column_size 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_size if from_row < 0
from_col += column_size if from_col < 0
else
Matrix.Raise ArgumentError, param.inspect
end

return nil if from_row > row_size || from_col > column_size || from_row < 0 || from_col < 0
rows = @rows[from_row, size_row].collect{|row|
row[from_col, size_col]
}
new_matrix rows, [column_size - from_col, size_col].min
end```
normal?() click to toggle source

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

```# File rake/lib/matrix.rb, line 632
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?() click to toggle source

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

```# File rake/lib/matrix.rb, line 650
def orthogonal?
Matrix.Raise ErrDimensionMismatch unless square?
rows.each_with_index do |row, i|
column_size.times do |j|
s = 0
row_size.times do |k|
s += row[k] * rows[k][j]
end
return false unless s == (i == j ? 1 : 0)
end
end
true
end```
permutation?() click to toggle source

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

```# File rake/lib/matrix.rb, line 668
def permutation?
Matrix.Raise ErrDimensionMismatch unless square?
cols = Array.new(column_size)
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() click to toggle source

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
```
```# File rake/lib/matrix.rb, line 1103
def rank
# We currently use Bareiss' multistep integer-preserving gaussian elimination
# (see comments on determinant)
a = to_a
last_column = column_size - 1
last_row = row_size - 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() click to toggle source

deprecated; use #rank

```# File rake/lib/matrix.rb, line 1134
def rank_e
warn "#{caller(1)[0]}: warning: Matrix#rank_e is deprecated; use #rank"
rank
end```
real() click to toggle source

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
```
```# File rake/lib/matrix.rb, line 1248
def real
collect(&:real)
end```
real?() click to toggle source

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

```# File rake/lib/matrix.rb, line 689
def real?
all?(&:real?)
end```
rect() click to toggle source

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

```# File rake/lib/matrix.rb, line 1258
def rect
[real, imag]
end```
Also aliased as: rectangular
rectangular()
Alias for: rect
regular?() click to toggle source

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

```# File rake/lib/matrix.rb, line 696
def regular?
not singular?
end```
round(ndigits=0) click to toggle source

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

```# File rake/lib/matrix.rb, line 1142
def round(ndigits=0)
map{|e| e.round(ndigits)}
end```
row(i) { |e| ... } click to toggle source

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.

```# File rake/lib/matrix.rb, line 342
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_size() click to toggle source

Returns the number of rows.

```# File rake/lib/matrix.rb, line 329
def row_size
@rows.size
end```
row_vectors() click to toggle source

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

```# File rake/lib/matrix.rb, line 1286
def row_vectors
Array.new(row_size) {|i|
row(i)
}
end```
singular?() click to toggle source

Returns `true` is this is a singular matrix.

```# File rake/lib/matrix.rb, line 703
def singular?
determinant == 0
end```
square?() click to toggle source

Returns `true` is this is a square matrix.

```# File rake/lib/matrix.rb, line 710
def square?
column_size == row_size
end```
symmetric?() click to toggle source

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

```# File rake/lib/matrix.rb, line 718
def symmetric?
Matrix.Raise ErrDimensionMismatch unless square?
each_with_index(:strict_upper).all? do |e, row, col|
e == rows[col][row]
end
end```
t()
Alias for: transpose
to_a() click to toggle source

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

```# File rake/lib/matrix.rb, line 1304
def to_a
@rows.collect(&:dup)
end```
to_s() click to toggle source

Overrides Object#to_s

```# File rake/lib/matrix.rb, line 1330
def to_s
if empty?
"Matrix.empty(#{row_size}, #{column_size})"
else
"Matrix[" + @rows.collect{|row|
"[" + row.collect{|e| e.to_s}.join(", ") + "]"
}.join(", ")+"]"
end
end```
tr()
Alias for: trace
trace() click to toggle source

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

```Matrix[[7,6], [3,9]].trace
=> 16
```
```# File rake/lib/matrix.rb, line 1151
def trace
Matrix.Raise ErrDimensionMismatch unless square?
(0...column_size).inject(0) do |tr, i|
tr + @rows[i][i]
end
end```
Also aliased as: tr
transpose() click to toggle source

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
```
```# File rake/lib/matrix.rb, line 1169
def transpose
return Matrix.empty(column_size, 0) if row_size.zero?
new_matrix @rows.transpose, row_size
end```
Also aliased as: t
unitary?() click to toggle source

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

```# File rake/lib/matrix.rb, line 729
def unitary?
Matrix.Raise ErrDimensionMismatch unless square?
rows.each_with_index do |row, i|
column_size.times do |j|
s = 0
row_size.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?() click to toggle source

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

```# File rake/lib/matrix.rb, line 746
def upper_triangular?
each(:strict_lower).all?(&:zero?)
end```
zero?() click to toggle source

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

```# File rake/lib/matrix.rb, line 753
def zero?
all?(&:zero?)
end```