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

Constants

SELECTORS

Attributes

column_size[R]

Returns the number of columns.

rows[R]

instance creations

Public Class Methods

I(n) click to toggle source

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 matrix.rb, line 139
def Matrix.[](*rows)
  Matrix.rows(rows, false)
end

build(row_size, column_size = row_size) 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 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 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 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 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 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 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 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 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 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 matrix.rb, line 221
def Matrix.scalar(n, value)
  Matrix.diagonal(*Array.new(n, value))
end

unit(n) click to toggle source

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 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 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 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 addition.

Matrix.scalar(2,5) + Matrix[[1,0], [-4,7]]
  =>  6  0
     -4 12

 
               # File 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 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 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 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 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 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 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() 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 matrix.rb, line 379
def collect(&block) # :yield: e
  return to_enum(:collect) unless block_given?
  rows = @rows.collect{|row| row.collect(&block)}
  new_matrix rows, column_size
end

Also aliased as: map

column(j) 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 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 matrix.rb, line 1295
def column_vectors
  Array.new(column_size) {|i|
    column(i)
  }
end

component(i, j) click to toggle source

Alias for: []

conj() click to toggle source

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 matrix.rb, line 1220
def conjugate
  collect(&:conjugate)
end

Also aliased as: conj

det() click to toggle source

Alias for: determinant

det_e() click to toggle source

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 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 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 matrix.rb, line 597
def diagonal?
  Matrix.Raise ErrDimensionMismatch unless square?
  each(:off_diagonal).all?(&:zero?)
end

each(which = :all) 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 matrix.rb, line 402
def each(which = :all) # :yield: e
  return to_enum :each, which unless block_given?
  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) 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 matrix.rb, line 463
def each_with_index(which = :all) # :yield: e, row, column
  return to_enum :each_with_index, which unless block_given?
  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() click to toggle source

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 matrix.rb, line 1187
def eigensystem
  EigenvalueDecomposition.new(self)
end

Also aliased as: eigen

element(i, j) click to toggle source

Alias for: []

elements_to_f() click to toggle source

 
               # File 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 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 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 matrix.rb, line 606
def empty?
  column_size == 0 || row_size == 0
end

eql?(other) click to toggle source

 
               # File 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) click to toggle source

Alias for: index

hash() click to toggle source

Returns a hash-code for the matrix.

 
               # File 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 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() click to toggle source

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 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 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 matrix.rb, line 1343
def inspect
  if empty?
    "Matrix.empty(#{row_size}, #{column_size})"
  else
    "Matrix#{@rows.inspect}"
  end
end

inv() click to toggle source

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 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 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 matrix.rb, line 1202
def lup
  LUPDecomposition.new(self)
end

Also aliased as: lup_decomposition

lup_decomposition() click to toggle source

Alias for: lup

map() click to toggle source

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 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 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 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 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 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 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 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 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 matrix.rb, line 1258
def rect
  [real, imag]
end

Also aliased as: rectangular

rectangular() click to toggle source

Alias for: rect

regular?() click to toggle source

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

 
               # File 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 matrix.rb, line 1142
def round(ndigits=0)
  map{|e| e.round(ndigits)}
end

row(i) 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 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 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 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 matrix.rb, line 703
def singular?
  determinant == 0
end

square?() click to toggle source

Returns true is this is a square matrix.

 
               # File 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 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() click to toggle source

Alias for: transpose

to_a() click to toggle source

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

 
               # File matrix.rb, line 1304
def to_a
  @rows.collect(&:dup)
end

to_s() click to toggle source

Overrides Object#to_s

 
               # File 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() click to toggle source

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 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 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 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 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 matrix.rb, line 753
def zero?
  all?(&:zero?)
end

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.

Home Classes Methods

In Files

Parent

Namespace

Methods

Included Modules

Class/Module Index