[index]

Algebra::MatrixAlgebra / Algebra::Vector / Algebra::Covector / Algebra::SquareMatrix / Algebra::GaussianElimination

Algebra::MatrixAlgebra

(Class of Matrices)

This class expresses matrices. For creating an actual class, use the class method ::create or the function Algebra.MatrixAlgebra(), giving the ground ring and sizes.

That has Algebra::Vector(column vectorj, Algebra::Covector(row vector), Algebra::SquareMatrix(square matrix) as subclass.

File Name:

• matrix-algebra.rb

SuperClass:

• Object

Included Module:

• Algebra::GaussianElimination

Associated Function:

Algebra.MatrixAlgebra(ring, m, n)

Same as ::create(ring, m, n).

Class Methods:

::create(ring, m, n)

Creates the class of matrix of type (m, n) with elements of the ring ring.

The return value of this method is a subclass of Algebra::MatrixAlgebra. The subclass has class methods: ground, rsize, csize and sizes, which returns the ground ring, the size of rows( m ), the size of columns( n ) and the array of [m, n] respectively.

To create the actual matrix, use the class methods: ::new, ::matrix or ::[].

::new(array)

Returns the matrix of the elements designated by the array of arrays array.

Example:

M = Algebra.MatrixAlgebra(Integer, 2, 3)
a = M.new([[1, 2, 3], [4, 5, 6]])
a.display
  #=> [1, 2, 3]
  #=> [4, 5, 6]

::matrix{|i, j| ... }

Returns the matrix which has the i-j-th elements evaluating ..., where i and j are the row and the column indices

Example:

M = Algebra.MatrixAlgebra(Integer, 2, 3)
a = M.matrix{|i, j| 10*(i + 1) + j + 1}
a.display
  #=> [11, 12, 13]
  #=> [21, 22, 23]

::[array1, array2, ..., array]

Returns the matrix which has array1, array2, ..., array as rows.

Example:

M = Algebra.MatrixAlgebra(Integer, 2, 3)
a = M[[1, 2, 3], [4, 5, 6]]
a.display
  #=> [1, 2, 3]
  #=> [4, 5, 6]

::collect_ij{|i, j| ... }

Returns the array of arrays with the value ... as the j-th element of the i-th array.

::collect_row{|i| ... }

Returns the matrix whose i-th row is the array obtained by evaluating ....

Example:

M = Algebra.MatrixAlgebra(Integer, 2, 3)
A = M.collect_row{|i| [i*10 + 11, i*10 + 12, i*10 + 13]}
A.display
  #=> [11, 12, 13]
  #=> [21, 22, 23]

::collect_column{|j| ... }

Returns the matrix whose j-th column is the array obtained by evaluating ....

Example:

M = Algebra.MatrixAlgebra(Integer, 2, 3)
A = M.collect_column{|j| [11 + j, 21 + j]}
A.display
  #=> [11, 12, 13]
  #=> [21, 22, 23]

::*(otype)

Returns the class of matrix multiplicated by otype.

Example:

M = Algebra.MatrixAlgebra(Integer, 2, 3)
N = Algebra.MatrixAlgebra(Integer, 3, 4)
L = M * N
p L.sizes #=> [3, 4]

::vector

Returns the class of column-vector(Vector) which has the same size of rsize.

::covector

Returns the class of row-vector(CoVector) which has the same size of csize.

::transpose

Returns the transposed matrix

::zero

Returns the zero matrix.

Methods:

[i, j]

Returns the (i, j)-th component.

[i, j] = x

Replaces the (i, j)-th component with x.

rsize

Same as ::rsize.

csize

Same as ::csize.

sizes

Same as ::sizes.

rows

Returns the array of rows.

Example:

M = Algebra.MatrixAlgebra(Integer, 2, 3)
a = M.new([[1, 2, 3], [4, 5, 6]])
p a.rows #=> [[1, 2, 3], [4, 5, 6]]
p a.row(1) #=> [4, 5, 6]
a.set_row(1, [40, 50, 60])
a.display #=> [1, 2, 3]
          #=> [40, 50, 60]

row(i)

Returns the i-th row as an array.

set_row(i, array)

Replaces the i-th row with array.

columns

Returns the array of columns.

—á:

M = Algebra.MatrixAlgebra(Integer, 2, 3)
a = M.new([[1, 2, 3], [4, 5, 6]])
p a.columns #=> [[1, 4], [2, 5], [3, 6]]
p a.column(1) #=> [2, 5]
a.set_column(1, [20, 50])
a.display #=> [1, 20, 3]
          #=> [4, 50, 6]

column(j)

Returns the j-th column as an array.

set_column(j, array)

Replaces the i-th column with array.

each{|row| ...}

Iterates with row.

each_index{|i, j| ...}

Iterates with indices (i, j) .

each_i{|i| ...}

Iterates with the index i of rows.

each_j{|j| ...}

Iterates with the index j of columns.

each_row{|r| ... }

Iterates with the row r. Same as each.

each_column{|c| ... }

Iterates with the column c.

matrix{|i, j| ... }

Same as ::matrix.

collect_ij{|i, j| ... }

Same as ::collect_ij.

collect_row{|i| ... }

Same as ::collect_row.

collect_column{|j| ... }

Same as ::collect_column.

==(other)

Returns true if self is equal to other.

+(other)

Returns the sum of self and other.

-(other)

Returns the difference of self from other.

*(other)

Returns the product of self and other.

Example:

M = Algebra.MatrixAlgebra(Integer, 2, 3)
N = Algebra.MatrixAlgebra(Integer, 3, 4)
L = M * N
a = M[[1, 2, 3], [4, 5, 6]]
b = N[[-3, -2, -1, 0], [1, 2, 3, 4], [5, 6, 7, 8]]
c = a * b
p c.type  #=> L
c.display #=> [14, 20, 26, 32]
          #=> [23, 38, 53, 68]

**(n)

Returns the n-th power of self.

/(other)

Returns the quotient self by other.

dsum(other)

Returns the direct sum of self and other.

Example:

a = Algebra.MatrixAlgebra(Integer, 2, 3)[
      [1, 2, 3],
      [4, 5, 6]
    ]
b = Algebra.MatrixAlgebra(Integer, 3, 2)[
      [-1, -2],
      [-3, -4],
      [-5, -6]
    ]
(a.dsum b).display #=> 1,   2,   3,   0,   0
                   #=> 4,   5,   6,   0,   0
                   #=> 0,   0,   0,  -1,  -2
                   #=> 0,   0,   0,  -3,  -4
                   #=> 0,   0,   0,  -5,  -6

diag

Returns the array of the diagonal compotents.

convert_to(ring)

Returns the conversion of self to ring's object.

Example:

require "matrix-algebra"
require "residue-class-ring"
Z3 = Algebra.ResidueClassRing(Integer, 3)
a = Algebra.MatrixAlgebra(Integer, 2, 3)[
  [1, 2, 3],
  [4, 5, 6]
]

a.convert_to(Algebra.MatrixAlgebra(Z3, 2, 3)).display
                                     #=>  1,   2,   0
                                     #=>  1,   2,   0

transpose

Returns the transposed matrix.

Example:

M = Algebra.MatrixAlgebra(Integer, 2, 3)
a = M.new([[1, 2, 3], [4, 5, 6]])
Mt = M.transpose
b = a.transpose
p b.type  #=> Mt
b.display #=> [1, 4]
          #=> [2, 5]
          #=> [3, 6]

dup

Returns the duplication of self.

Example:

M = Algebra.MatrixAlgebra(Integer, 2, 3)
a = M.new([[1, 2, 3], [4, 5, 6]])
b = a.dup
b[1, 1] = 50
a.display #=> [1, 2, 3]
          #=> [4, 5, 6]
b.display #=> [1, 2, 3]
          #=> [4, 50, 6]

display([out])

Displays self to out. If out is omitted, out is $stdout.

Algebra::Vector

(Class of Vector)

The class of column vectors.

SuperClass:

• MatrixAlgebra

Included Module

none.

Associated Functions:

Algebra.Vector(ring, n)

Same as Algebra::Matrix::Vector.create(ring, n).

Class Methods:

Algebra::Vector.create(ring, n)

Creates the class of the n-th dimensional (column) vector over the ring.

The return value of this is a subclass of Algebra::Vector. This subclass has the class methods: ground and size, which returns ring and the size n respectively.

To get actual vectors, use the class methods: new, matrix or [].

Algebra::Vector is identified with Algebra::MatrixAlgebra of type [n, 1].

Algebra::Vector::new(array)

Returns the vector of the array.

Example:

V = Algebra.Vector(Integer, 3)
a = V.new([1, 2, 3])
a.display
  #=> [1]
  #=> [2]
  #=> [3]

Algebra::Vector::vector{|i| ... }

Returns the vector of ... as the i-th element.

Example:

V = Algebra.Vector(Integer, 3)
a = V.vector{|j| j + 1}
a.display
  #=> [1]
  #=> [2]
  #=> [3]

Algebra::Vector::matrix{|i, j| ... }

Returns the vector of ... as the i-th element. j is always 0.

Methods

size

Returns the dimension.

to_a

Returns the array of elements.

transpose

Transpose to the row vector Algebra::Covector.

Algebra::Covector

(Row Vector Class)

The class of row vectors.

SuperClass:

• MatrixAlgebra

Included Module

none.

Associated Functions:

Algebra.Covector(ring, n)

Same as Algebra::Covector::create(ring, n).

Class Methods:

Algebra::Covector::create(ring, n)

Creates the class of the n-th dimensional (row) vector over the ring.

The return value of this is a subclass of Algebra::MatrixAlgebra::CoVector. This subclass has the class methods: ground and size, whic h returns ring and the size n respectively.

To get actual vectors, use the class methods: new, matrix or [].

Algebra::Covector is identified with [1, n]-type Algebra::MatrixAlgebra.

Algebra::Covector::new(array)

Returns the row vector of the array.

Example:

V = Algebra::Covector(Integer, 3)
a = V.new([1, 2, 3])
a.display
  #=> [1, 2, 3]

Algebra::Covector::covector{|j| ... }

Returns the vector of ... as the j-th element.

Example:

V = Algebra.Covector(Integer, 3)
a = V.covector{|j| j + 1}
a.display
  #=> [1, 2, 3]

Algebra::Covector::matrix{|i, j| ... }

Returns the vector of ... as the j-th element. i is always 0.

Methods:

size

Returns the dimension.

to_a

Returns the array of elements.

transpose

Transpose to the column vector Algebra::Vector.

Algebra::SquareMatrix

(Class of SquareMatrix)

The Ring of Square Matrices over a ring.

SuperClass:

• Algebra::MatrixAlgebra

Included Module

none.

Associated Functions:

Algebra.SquareMatrix(ring, size)

Same as Algebra::SquareMatrix.create(ring, n).

Class Methods:

Algebra::SquareMatrix::create(ring, n)

Creates the class of square matrices.

The return value of this is the subclass of Algebra::SquareMatrix. This subclass has the class methods ground and size which returns ring and the size n respectively.

Algebra::SquareMatrix is identified with Algebra::MatrixAlgebra::MatrixAlgebra of type [n, n].

To get the actual matrices, use the class methods Algebra::SquareMatrix::new, Algebra::SquareMatrix::matrix or Algebra::SquareMatrix::[].

Algebra::SquareMatrix::unity

Returns the unity.

Algebra::SquareMatrix::zero

Returns the zero.

Algebra::SquareMatrix::const(x)

Returns the scalar matrix with by the diagonal components x.

Methods:

size

Returns the dimension.

const(x)

Returns the scalar matrix with the diagonal components x.

determinant

Returns the determinant.

char_polynomial(ring)

Returns the characteristic polynomial over ring.

Algebra::GaussianElimination

(Module of Gaussian Elimination)

Module of the elimination method of Gauss.

FileName:

gaussian-elimination.rb

Included Module

none.

Class Method:

none.

Methods:

swap_r!(i, j)

Swaps i-th row and j-th row.

swap_r(i, j)

Returns the new matrix with i-th row and j-th row swapped.

swap_c!(i, j)

Swaps i-th column and j-th column.

swap_c(i, j)

Returns the new matrix with i-th column and j-th column swapped.

multiply_r!(i, c)

Multiplys the i-th row by c.

multiply_r(i, c)

Returns the new Matrix with the i-th row multiplied by c.

multiply_c!(j, c)

Multiplys the j-th column by c.

multiply_c(j, c)

Returns the new Matrix with the j-th column multiplied by c.

divide_r!(i, c)

Divides the i-th row by c.

divide_r(i, c)

Returns the new Matrix with the i-th row divided by c.

divide_c!(j, c)

Divides the j-th column by c.

divide_c(j, c)

Returns the new Matrix with the j-th column divided by c.

mix_r!(i, j, c)

Adds the j-th row multiplied by c to the i-th row.

mix_r(i, j, c)

Returns the new matrix such that the j-th row multiplied by c is added to the i-th row.

mix_c!(i, j, c)

Adds the j-th column multiplied by c to the i-th column.

mix_c(i, j, c)

Returns the new matrix such that the j-th column multiplied by c is added to the i-th column.

left_eliminate!

Transform to the step matrix by the left fundamental transformation.

The return value is the array of the square matrix which used to transform and its determinant.

Example:

require "matrix-algebra"
require "mathn"
class Rational < Numeric
  def inspect; to_s; end
end
M = Algebra.MatrixAlgebra(Rational, 4, 3)
a = M.matrix{|i, j| i*10 + j}
b = a.dup
c, d = b.left_eliminate!
b.display #=> [1, 0, -1]
          #=> [0, 1, 2]
          #=> [0, 0, 0]
          #=> [0, 0, 0]
c.display #=> [-11/10, 1/10, 0, 0]
          #=> [1, 0, 0, 0]
          #=> [1, -2, 1, 0]
          #=> [2, -3, 0, 1]
p c*a == b#=> true
p d       #=> 1/10

left_inverse

The general inverse matrix obtained by the left fundamental transformation.

left_sweep

Returns the step matrix by the left fundamental transformation.

step_matrix?

Returns the array of pivots if self is a step matrix, otherwise returns nil.

kernel_basis

Returns the array of vector( Algebra::Vector ) such that the right multiplication of it is null.

Example:

require "matrix-algebra"
require "mathn"
M = Algebra.MatrixAlgebra(Rational, 5, 4)
a = M.matrix{|i, j| i + j}
a.display #=>
  #[0, 1, 2, 3]
  #[1, 2, 3, 4]
  #[2, 3, 4, 5]
  #[3, 4, 5, 6]
  #[4, 5, 6, 7]
a.kernel_basis.each do |v|
  puts "a * #{v} = #{a * v}"
    #=> a * [1, -2, 1, 0] = [0, 0, 0, 0, 0]
    #=> a * [2, -3, 0, 1] = [0, 0, 0, 0, 0]
end

determinant_by_elimination

Calculate the determinant by elimination.