Class: Matrix
- Inherits:
-
Object
- Object
- Matrix
- 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.[](*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
Instance Attribute Summary collapse
-
#column_count ⇒ Object
(also: #column_size)
readonly
Returns the number of columns.
Class Method Summary collapse
-
.[](*rows) ⇒ Object
Creates a matrix where each argument is a row.
-
.build(row_count, column_count = row_count) ⇒ Object
Creates a matrix of size
row_count
xcolumn_count
. -
.column_vector(column) ⇒ Object
Creates a single-column matrix where the values of that column are as given in
column
. -
.columns(columns) ⇒ Object
Creates a matrix using
columns
as an array of column vectors. -
.diagonal(*values) ⇒ Object
Creates a matrix where the diagonal elements are composed of
values
. -
.empty(row_count = 0, column_count = 0) ⇒ Object
Creates a empty matrix of
row_count
xcolumn_count
. -
.identity(n) ⇒ Object
(also: unit, I)
Creates an
n
byn
identity matrix. -
.row_vector(row) ⇒ Object
Creates a single-row matrix where the values of that row are as given in
row
. -
.rows(rows, copy = true) ⇒ Object
Creates a matrix where
rows
is an array of arrays, each of which is a row of the matrix. -
.scalar(n, value) ⇒ Object
Creates an
n
byn
diagonal matrix where each diagonal element isvalue
. -
.zero(row_count, column_count = row_count) ⇒ Object
Creates a zero matrix.
Instance Method Summary collapse
-
#*(m) ⇒ Object
Matrix multiplication.
-
#**(other) ⇒ Object
Matrix exponentiation.
-
#+(m) ⇒ Object
Matrix addition.
-
#-(m) ⇒ Object
Matrix subtraction.
-
#/(other) ⇒ Object
Matrix division (multiplication by the inverse).
-
#==(other) ⇒ Object
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. -
#clone ⇒ Object
Returns a clone of the matrix, so that the contents of each do not reference identical objects.
-
#coerce(other) ⇒ Object
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.
-
#column(j) ⇒ Object
Returns column vector number
j
of the matrix as a Vector (starting at 0 like an array). -
#column_vectors ⇒ Object
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.
-
#diagonal? ⇒ Boolean
Returns
true
is this is a diagonal matrix. -
#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.
-
#each_with_index(which = :all) ⇒ Object
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
. - #elements_to_f ⇒ Object
- #elements_to_i ⇒ Object
- #elements_to_r ⇒ Object
-
#empty? ⇒ Boolean
Returns
true
if this is an empty matrix, i.e. - #eql?(other) ⇒ Boolean
-
#hash ⇒ Object
Returns a hash-code for the matrix.
-
#hermitian? ⇒ Boolean
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.
-
#initialize(rows, column_count = rows[0].size) ⇒ Matrix
constructor
Matrix.new is private; use Matrix.rows, columns, [], etc…
-
#inspect ⇒ Object
Overrides Object#inspect.
-
#inverse ⇒ Object
(also: #inv)
Returns the inverse of the matrix.
-
#lower_triangular? ⇒ Boolean
Returns
true
is this is a lower triangular matrix. -
#lup ⇒ Object
(also: #lup_decomposition)
Returns the LUP decomposition of the matrix; see
LUPDecomposition
. -
#minor(*param) ⇒ Object
Returns a section of the matrix.
-
#normal? ⇒ Boolean
Returns
true
is this is a normal matrix. -
#orthogonal? ⇒ Boolean
Returns
true
is this is an orthogonal matrix Raises an error if matrix is not square. -
#permutation? ⇒ Boolean
Returns
true
is this is a permutation matrix Raises an error if matrix is not square. -
#rank ⇒ Object
Returns the rank of the matrix.
-
#rank_e ⇒ Object
deprecated; use Matrix#rank.
-
#real ⇒ Object
Returns the real part of the matrix.
-
#real? ⇒ Boolean
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.
-
#regular? ⇒ Boolean
Returns
true
if this is a regular (i.e. non-singular) matrix. -
#round(ndigits = 0) ⇒ Object
Returns a matrix with entries rounded to the given precision (see Float#round).
-
#row(i, &block) ⇒ Object
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.
-
#row_vectors ⇒ Object
Returns an array of the row vectors of the matrix.
-
#singular? ⇒ Boolean
Returns
true
is this is a singular matrix. -
#square? ⇒ Boolean
Returns
true
is this is a square matrix. -
#symmetric? ⇒ Boolean
Returns
true
is this is a symmetric matrix. -
#to_a ⇒ Object
Returns an array of arrays that describe the rows of the matrix.
-
#to_s ⇒ Object
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.
-
#unitary? ⇒ Boolean
Returns
true
is this is a unitary matrix Raises an error if matrix is not square. -
#upper_triangular? ⇒ Boolean
Returns
true
is this is an upper triangular matrix. -
#zero? ⇒ Boolean
Returns
true
is this is a matrix with only zero elements.
Methods included from CoercionHelper
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
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]]
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) ⇒ Object Also 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 addition.
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) ⇒ Object Also 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) ⇒ Object Also 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 ⇒ Object Also 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 ⇒ Object Also 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 end end |
#determinant_e ⇒ Object Also 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 ⇒ Object Also 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 ⇒ Object Also 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) ⇒ Object Also 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]
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 ⇒ Object Also 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 ⇒ Object Also 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 ⇒ Object Also 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 ⇒ Object Also 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 ⇒ Object Also 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 ⇒ Object Also 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 |