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:

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

Properties of a matrix:

Matrix arithmetic:

Matrix functions:

Matrix decompositions:

Complex arithmetic:

  • conj

  • conjugate

  • imag

  • imaginary

  • real

  • rect

  • rectangular

Conversion to other data types:

String representations:

Namespace
Methods
#
I
#
B
C
D
E
F
H
I
L
M
N
O
P
R
S
T
U
Z
Included Modules
Constants
SELECTORS = {all: true, diagonal: true, off_diagonal: true, lower: true, strict_lower: true, strict_upper: true, upper: true}.freeze
 
Attributes
[R] column_count

Returns the number of columns.
[R] column_size

Returns the number of columns.
[R] rows

instance creations
Class Public methods
I(n)
Alias for: identity
[](*rows)

Creates a matrix where each argument is a row.

Matrix[ [25, 93], [-1, 66] ]
   =>  25 93
       -1 66

Source: show | on GitHub 

# File lib/matrix.rb, line 139
def Matrix.[](*rows)
  rows(rows, false)
end
build(row_count, column_count = row_count)

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

Source: show | on GitHub 

# File lib/matrix.rb, line 184
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)

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

Source: show | on GitHub 

# File lib/matrix.rb, line 269
def Matrix.column_vector(column)
  column = convert_to_array(column)
  new [column].transpose, 1
end
columns(columns)

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

Matrix.columns([[25, 93], [-1, 66]])
   =>  25 -1
       93 66

Source: show | on GitHub 

# File lib/matrix.rb, line 169
def Matrix.columns(columns)
  rows(columns, false).transpose
end
diagonal(*values)

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

Source: show | on GitHub 

# File 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_count = 0, column_count = 0)

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]]

Source: show | on GitHub 

# File lib/matrix.rb, line 287
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)

Creates an n by n identity matrix.

Matrix.identity(2)
  => 1 0
     0 1
Also aliased as: unit, I

Source: show | on GitHub 

# File lib/matrix.rb, line 231
def Matrix.identity(n)
  scalar(n, 1)
end
new(rows, column_count = rows[0].size)

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

Source: show | on GitHub 

# File lib/matrix.rb, line 297
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
row_vector(row)

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

Source: show | on GitHub 

# File lib/matrix.rb, line 256
def Matrix.row_vector(row)
  row = convert_to_array(row)
  new [row]
end
rows(rows, copy = true)

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

Source: show | on GitHub 

# File 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|
    raise ErrDimensionMismatch, "row size differs (#{row.size} should be #{size})" unless row.size == size
  end
  new rows, size
end
scalar(n, value)

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

Matrix.scalar(2, 5)
  => 5 0
     0 5

Source: show | on GitHub 

# File lib/matrix.rb, line 221
def Matrix.scalar(n, value)
  diagonal(*Array.new(n, value))
end
unit(n)
Alias for: identity
zero(row_count, column_count = row_count)

Creates a zero matrix.

Matrix.zero(2)
  => 0 0
     0 0

Source: show | on GitHub 

# File lib/matrix.rb, line 245
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 Public methods
*(m)

Matrix multiplication.

Matrix[[2,4], [6,8]] * Matrix.identity(2)
  => 2 4
     6 8

Source: show | on GitHub 

# File lib/matrix.rb, line 805
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)

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

Source: show | on GitHub 

# File lib/matrix.rb, line 972
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)

Matrix addition.

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

Source: show | on GitHub 

# File lib/matrix.rb, line 838
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)

Matrix subtraction.

Matrix[[1,5], [4,2]] - Matrix[[9,3], [-4,1]]
  => -8  2
      8  1

Source: show | on GitHub 

# File lib/matrix.rb, line 865
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)

Matrix division (multiplication by the inverse).

Matrix[[7,6], [3,9]] / Matrix[[2,9], [3,1]]
  => -7  1
     -3 -6

Source: show | on GitHub 

# File lib/matrix.rb, line 892
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)

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

Source: show | on GitHub 

# File lib/matrix.rb, line 767
def ==(other)
  return false unless Matrix === other &&
                      column_count == other.column_count # necessary for empty matrices
  rows == other.rows
end
[](i, j)

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

Also aliased as: element, component

Source: show | on GitHub 

# File lib/matrix.rb, line 313
def [](i, j)
  @rows.fetch(i){return nil}[j]
end
clone()

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.

Source: show | on GitHub 

# File lib/matrix.rb, line 784
def clone
  new_matrix @rows.map(&:dup), column_count
end
coerce(other)

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.

Source: show | on GitHub 

# File lib/matrix.rb, line 1277
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()

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
Also aliased as: map

Source: show | on GitHub 

# File lib/matrix.rb, line 381
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)

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.

Source: show | on GitHub 

# File lib/matrix.rb, line 358
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()

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

Source: show | on GitHub 

# File lib/matrix.rb, line 1298
def column_vectors
  Array.new(column_count) {|i|
    column(i)
  }
end
component(i, j)
Alias for: []
conj()
Alias for: conjugate
conjugate()

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
Also aliased as: conj

Source: show | on GitHub 

# File lib/matrix.rb, line 1223
def conjugate
  collect(&:conjugate)
end
det()
Alias for: determinant
det_e()
Alias for: determinant_e
determinant()

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
Also aliased as: det

Source: show | on GitHub 

# File lib/matrix.rb, line 1009
def determinant
  Matrix.Raise ErrDimensionMismatch unless square?
  m = @rows
  case row_count
    # Up to 4x4, give result using Laplacian expansion by minors.
    # This will typically be faster, as well as giving good results
    # in case of Floats
  when 0
    +1
  when 1
    + m[0][0]
  when 2
    + m[0][0] * m[1][1] - m[0][1] * m[1][0]
  when 3
    m0, m1, m2 = m
    + m0[0] * m1[1] * m2[2] - m0[0] * m1[2] * m2[1]        - m0[1] * m1[0] * m2[2] + m0[1] * m1[2] * m2[0]        + m0[2] * m1[0] * m2[1] - m0[2] * m1[1] * m2[0]
  when 4
    m0, m1, m2, m3 = m
    + m0[0] * m1[1] * m2[2] * m3[3] - m0[0] * m1[1] * m2[3] * m3[2]        - m0[0] * m1[2] * m2[1] * m3[3] + m0[0] * m1[2] * m2[3] * m3[1]        + m0[0] * m1[3] * m2[1] * m3[2] - m0[0] * m1[3] * m2[2] * m3[1]        - m0[1] * m1[0] * m2[2] * m3[3] + m0[1] * m1[0] * m2[3] * m3[2]        + m0[1] * m1[2] * m2[0] * m3[3] - m0[1] * m1[2] * m2[3] * m3[0]        - m0[1] * m1[3] * m2[0] * m3[2] + m0[1] * m1[3] * m2[2] * m3[0]        + m0[2] * m1[0] * m2[1] * m3[3] - m0[2] * m1[0] * m2[3] * m3[1]        - m0[2] * m1[1] * m2[0] * m3[3] + m0[2] * m1[1] * m2[3] * m3[0]        + m0[2] * m1[3] * m2[0] * m3[1] - m0[2] * m1[3] * m2[1] * m3[0]        - m0[3] * m1[0] * m2[1] * m3[2] + m0[3] * m1[0] * m2[2] * m3[1]        + m0[3] * m1[1] * m2[0] * m3[2] - m0[3] * m1[1] * m2[2] * m3[0]        - m0[3] * m1[2] * m2[0] * m3[1] + m0[3] * m1[2] * m2[1] * m3[0]
  else
    # For bigger matrices, use an efficient and general algorithm.
    # Currently, we use the Gauss-Bareiss algorithm
    determinant_bareiss
  end
end
determinant_e()

deprecated; use #determinant

Also aliased as: det_e

Source: show | on GitHub 

# File lib/matrix.rb, line 1091
def determinant_e
  warn "#{caller(1)[0]}: warning: Matrix#determinant_e is deprecated; use #determinant"
  determinant
end
diagonal?()

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

Source: show | on GitHub 

# File lib/matrix.rb, line 599
def diagonal?
  Matrix.Raise ErrDimensionMismatch unless square?
  each(:off_diagonal).all?(&:zero?)
end
each(which = :all)

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]

Source: show | on GitHub 

# File lib/matrix.rb, line 404
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)

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

Source: show | on GitHub 

# File lib/matrix.rb, line 465
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
eigen()
Alias for: eigensystem
eigensystem()

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
Also aliased as: eigen

Source: show | on GitHub 

# File lib/matrix.rb, line 1190
def eigensystem
  EigenvalueDecomposition.new(self)
end
element(i, j)
Alias for: []
elements_to_f()

Source: show | on GitHub 

# File lib/matrix.rb, line 1311
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()

Source: show | on GitHub 

# File lib/matrix.rb, line 1316
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()

Source: show | on GitHub 

# File lib/matrix.rb, line 1321
def elements_to_r
  warn "#{caller(1)[0]}: warning: Matrix#elements_to_r is deprecated, use map(&:to_r)"
  map(&:to_r)
end
empty?()

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

Source: show | on GitHub 

# File lib/matrix.rb, line 608
def empty?
  column_count == 0 || row_count == 0
end
eql?(other)

Source: show | on GitHub 

# File lib/matrix.rb, line 773
def eql?(other)
  return false unless Matrix === other &&
                      column_count == other.column_count # necessary for empty matrices
  rows.eql? other.rows
end
find_index(*args)
Alias for: index
hash()

Returns a hash-code for the matrix.

Source: show | on GitHub 

# File lib/matrix.rb, line 791
def hash
  @rows.hash
end
hermitian?()

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

Source: show | on GitHub 

# File lib/matrix.rb, line 616
def hermitian?
  Matrix.Raise ErrDimensionMismatch unless square?
  each_with_index(:upper).all? do |e, row, col|
    e == rows[col][row].conj
  end
end
imag()
Alias for: imaginary
imaginary()

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
Also aliased as: imag

Source: show | on GitHub 

# File lib/matrix.rb, line 1237
def imaginary
  collect(&:imaginary)
end
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]
Also aliased as: find_index

Source: show | on GitHub 

# File lib/matrix.rb, line 528
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()

Overrides Object#inspect

Source: show | on GitHub 

# File lib/matrix.rb, line 1346
def inspect
  if empty?
    "#{self.class}.empty(#{row_count}, #{column_count})"
  else
    "#{self.class}#{@rows.inspect}"
  end
end
inv()
Alias for: inverse
inverse()

Returns the inverse of the matrix.

Matrix[[-1, -1], [0, -1]].inverse
  => -1  1
      0 -1
Also aliased as: inv

Source: show | on GitHub 

# File lib/matrix.rb, line 912
def inverse
  Matrix.Raise ErrDimensionMismatch unless square?
  self.class.I(row_count).send(:inverse_from, self)
end
lower_triangular?()

Returns true is this is a lower triangular matrix.

Source: show | on GitHub 

# File lib/matrix.rb, line 626
def lower_triangular?
  each(:strict_upper).all?(&:zero?)
end
lup()

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)]
Also aliased as: lup_decomposition

Source: show | on GitHub 

# File lib/matrix.rb, line 1205
def lup
  LUPDecomposition.new(self)
end
lup_decomposition()
Alias for: lup
map()
Alias for: collect
minor(*param)

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.

Source: show | on GitHub 

# File lib/matrix.rb, line 558
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?()

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

Source: show | on GitHub 

# File lib/matrix.rb, line 634
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?()

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

Source: show | on GitHub 

# File lib/matrix.rb, line 652
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?()

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

Source: show | on GitHub 

# File lib/matrix.rb, line 670
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()

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

Source: show | on GitHub 

# File lib/matrix.rb, line 1106
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()

deprecated; use #rank

Source: show | on GitHub 

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

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

Source: show | on GitHub 

# File lib/matrix.rb, line 1251
def real
  collect(&:real)
end
real?()

Returns true if all entries of the matrix are real.

Source: show | on GitHub 

# File lib/matrix.rb, line 691
def real?
  all?(&:real?)
end
rect()

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

Also aliased as: rectangular

Source: show | on GitHub 

# File lib/matrix.rb, line 1261
def rect
  [real, imag]
end
rectangular()
Alias for: rect
regular?()

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

Source: show | on GitHub 

# File lib/matrix.rb, line 698
def regular?
  not singular?
end
round(ndigits=0)

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

Source: show | on GitHub 

# File lib/matrix.rb, line 1145
def round(ndigits=0)
  map{|e| e.round(ndigits)}
end
row(i)

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.

Source: show | on GitHub 

# File lib/matrix.rb, line 344
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()

Returns the number of rows.

Also aliased as: row_size

Source: show | on GitHub 

# File lib/matrix.rb, line 329
def row_count
  @rows.size
end
row_size()
Alias for: row_count
row_vectors()

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

Source: show | on GitHub 

# File lib/matrix.rb, line 1289
def row_vectors
  Array.new(row_count) {|i|
    row(i)
  }
end
singular?()

Returns true is this is a singular matrix.

Source: show | on GitHub 

# File lib/matrix.rb, line 705
def singular?
  determinant == 0
end
square?()

Returns true is this is a square matrix.

Source: show | on GitHub 

# File lib/matrix.rb, line 712
def square?
  column_count == row_count
end
symmetric?()

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

Source: show | on GitHub 

# File lib/matrix.rb, line 720
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
t()
Alias for: transpose
to_a()

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

Source: show | on GitHub 

# File lib/matrix.rb, line 1307
def to_a
  @rows.collect(&:dup)
end
to_s()

Overrides Object#to_s

Source: show | on GitHub 

# File lib/matrix.rb, line 1333
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
tr()
Alias for: trace
trace()

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

Matrix[[7,6], [3,9]].trace
  => 16
Also aliased as: tr

Source: show | on GitHub 

# File lib/matrix.rb, line 1154
def trace
  Matrix.Raise ErrDimensionMismatch unless square?
  (0...column_count).inject(0) do |tr, i|
    tr + @rows[i][i]
  end
end
transpose()

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
Also aliased as: t

Source: show | on GitHub 

# File lib/matrix.rb, line 1172
def transpose
  return self.class.empty(column_count, 0) if row_count.zero?
  new_matrix @rows.transpose, row_count
end
unitary?()

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

Source: show | on GitHub 

# File lib/matrix.rb, line 732
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?()

Returns true is this is an upper triangular matrix.

Source: show | on GitHub 

# File lib/matrix.rb, line 749
def upper_triangular?
  each(:strict_lower).all?(&:zero?)
end
zero?()

Returns true is this is a matrix with only zero elements

Source: show | on GitHub 

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