Create row from start_val...end_val with step of delta between

Create a block diagonal matrix from provided matrices

Given the inputs A, B and C, the output will have these matrices arranged on the diagonal:

Example:

m = Mat.block_diag(a, b, c)

m will have following structure:

[[a, 0, 0],
 [0, b, 0],
 [0, 0, c]]

Construct a Circulant matrix

c - first column of matrix

Example:

a = circulant([1, 2, 3])
a.to_aa # => [[1, 3, 2],[2, 1, 3],[3, 2, 1]])

Behaviour copied from scipy

Returns single column matrix with elements taken from array values

Create a companion matrix associated with the polynomial whose coefficients are given in a

Behaviour copied from scipy

Example:

Mat.companion([1, -10, 31, -30]) # =>
# LA::GeneralMatrix(Float64) (3x3, None):
# [10.0, -31.0, 30.0]
# [1.0, 0.0, 0.0]
# [0.0, 1.0, 0.0]

Returns diagonal matrix of given size with all diagonal elements equal to value

Returns diagonal matrix of given size with diagonal elements taken from array values

Returns square diagonal matrix with diagonal elements taken from array values

Returns diagonal matrix of given size with diagonal elements equal to block value

returns identity matrix of size n

Returns a symmetric Fiedler matrix

Given an sequence of numbers values, Fiedler matrices have the structure f[i, j] = (values[i] - values[j]).abs, and hence zero diagonals and nonnegative entries. A Fiedler matrix has a dominant positive eigenvalue and other eigenvalues are negative.

Behaviour copied from scipy

Example:

Mat.fiedler([1, 4, 12, 45, 77]) # =>
# LA::GeneralMatrix(Float64) (5x5, Symmetric | Hermitian):
# [0.0, 3.0, 11.0, 44.0, 76.0]
# [3.0, 0.0, 8.0, 41.0, 73.0]
# [11.0, 8.0, 0.0, 33.0, 65.0]
# [44.0, 41.0, 33.0, 0.0, 32.0]
# [76.0, 73.0, 65.0, 32.0, 0.0]

Converts a string of given format to matrix Example:

str = "( 1,2,3 | 4,5,6 | 7,8,9 )"
LA::GMat.from_custom(str, "(", ",", "|", ")")

Converts a string of given format to matrix Example:

str = "( 1,2,3 | 4,5,6 | 7,8,9 )"
LA::GMat.from_custom(IO::Memory.new(str), prefix: "(", columns_separator: ",", rows_separator: "|", postfix: ")")

Converts a string from matlab format to matrix Example:

str = "[1,2,3; 4,5,6; 7,8,9]"
LA::GMat.from_matlab(str)

Constructs an n-by-n Hadamard matrix, n must be power of 2

Behaviour copied from scipy

Example:

Mat.hadamard(4) # =>
# LA::GeneralMatrix(Float64) (4x4,  Symmetric | Hermitian):
# [1.0, 1.0, 1.0, 1.0]
# [1.0, -1.0, 1.0, -1.0]
# [1.0, 1.0, -1.0, -1.0]
# [1.0, -1.0, -1.0, 1.0]

Create a Hankel matrix The Hankel matrix has constant anti-diagonals, with .column as its first column and .row as its last row. If `row is nil, then row with elements equal to zero is assumed. Behaviour copied from scipy Examples:

a = Mat.hankel([1, 17, 99])
a.to_aa # => [
# [ 1, 17, 99],
# [17, 99,  0],
# [99,  0,  0]]
a = Mat.hankel([1, 2, 3, 4], [4, 7, 7, 8, 9])
a.to_aa # => [
# [1, 2, 3, 4, 7],
# [2, 3, 4, 7, 7],
# [3, 4, 7, 7, 8],
# [4, 7, 7, 8, 9]]

Create an Helmert matrix of order n

If full is true the (n x n) matrix will be returned. Otherwise the submatrix that does not include the first row will be returned

Behaviour copied from scipy

Example:

Mat.helmert(5, full: true) # =>
# LA::GeneralMatrix(Float64) (5x5, Orthogonal):
# [0.4472135954999579, 0.4472135954999579, 0.4472135954999579, 0.4472135954999579, 0.4472135954999579]
# [0.7071067811865476, -0.7071067811865476, 0.0, 0.0, 0.0]
# [0.408248290463863, 0.408248290463863, -0.816496580927726, 0.0, 0.0]
# [0.28867513459481287, 0.28867513459481287, 0.28867513459481287, -0.8660254037844386, 0.0]
# [0.22360679774997896, 0.22360679774997896, 0.22360679774997896, 0.22360679774997896, -0.8944271909999159]

Create a Hilbert matrix of order n.

Returns the n by n matrix with entries h[i,j] = 1 / (i + j + 1).

Behaviour copied from scipy

Example:

Mat.hilbert(3) # =>
# LA::GeneralMatrix(Float64) (3x3, Symmetric | Hermitian | PositiveDefinite):
# [1.0, 0.5, 0.3333333333333333]
# [0.5, 0.3333333333333333, 0.25]
# [0.3333333333333333, 0.25, 0.2]

returns identity matrix of size n

Compute the inverse of the Hilbert matrix of order n.

The entries in the inverse of a Hilbert matrix are integers.

Behaviour copied from scipy

Example:

Mat.invhilbert(4) # => LA::GeneralMatrix(Float64) (4x4, Symmetric | Hermitian | PositiveDefinite):
# [16.0, -120.0, 240.0, -140.0]
# [-120.0, 1200.0, -2700.0, 1680.0]
# [240.0, -2700.0, 6480.0, -4200.0]
# [-140.0, 1680.0, -4200.0, 2800.0]

Mat.invhilbert(16)[7, 7] # => 4.247509952853739e+19

Returns the inverse of the n x n Pascal matrix

The Pascal matrix is a matrix containing the binomial coefficients as its elements.

kind : see PascalKind

Behaviour copied from scipy

Example:

Mat.invpascal(4) # =>
# LA::GeneralMatrix(Float64) (5x5, Symmetric | Hermitian | PositiveDefinite):
# [5.0, -10.0, 10.0, -5.0, 1.0]
# [-10.0, 30.0, -35.0, 19.0, -4.0]
# [10.0, -35.0, 46.0, -27.0, 6.0]
# [-5.0, 19.0, -27.0, 17.0, -4.0]
# [1.0, -4.0, 6.0, -4.0, 1.0]
Mat.invpascal(5, PascalKind::Lower) # =>
# LA::GeneralMatrix(Float64) (5x5, LowerTriangular):
# [1.0, 0.0, 0.0, 0.0, 0.0]
# [-1.0, 1.0, 0.0, 0.0, 0.0]
# [1.0, -2.0, 1.0, 0.0, 0.0]
# [-1.0, 3.0, -3.0, 1.0, 0.0]
# [1.0, -4.0, 6.0, -4.0, 1.0]

Returns kroneker product of matrices

Resulting matrix size is {a.nrows*b.nrows, a.ncolumns*b.ncolumns}

Create a Leslie matrix

Given the length n array of fecundity coefficients f and the length n-1 array of survival coefficients s, return the associated Leslie matrix.

Behaviour copied from scipy

Example:

Mat.leslie([0.1, 2.0, 1.0, 0.1], [0.2, 0.8, 0.7]) # =>
# LA::GeneralMatrix(Float64) (4x4, None):
# [0.1, 2.0, 1.0, 0.1]
# [0.2, 0.0, 0.0, 0.0]
# [0.0, 0.8, 0.0, 0.0]
# [0.0, 0.0, 0.7, 0.0]

Loads a matrix from CSV (comma separated values) file Example:

LA::GMat.rand(30, 30).save_csv("./test.csv")
a = LA::GMat.load_csv("./test.csv")

Generate matrix of given size with all elements equal to one

Returns the n x n Pascal matrix.

The Pascal matrix is a matrix containing the binomial coefficients as its elements.

kind : see PascalKind

Behaviour copied from scipy

Example:

Mat.pascal(4) # =>
# LA::GeneralMatrix(Float64) (4x4, Symmetric | Hermitian | PositiveDefinite):
# [1.0, 1.0, 1.0, 1.0]
# [1.0, 2.0, 3.0, 4.0]
# [1.0, 3.0, 6.0, 10.0]
# [1.0, 4.0, 10.0, 20.0]
Mat.pascal(4, PascalKind::Lower) # =>
# LA::GeneralMatrix(Float64) (4x4, LowerTriangular):
# [1.0, 0.0, 0.0, 0.0]
# [1.0, 1.0, 0.0, 0.0]
# [1.0, 2.0, 1.0, 0.0]
# [1.0, 3.0, 3.0, 1.0]

Generate matrix of given size with elements randomly distributed from range 0.0..1.0

Alias for #repmat

Returns single row matrix with elements taken from array values

Create a Toeplitz matrix

.column - first column of matrix

.row - first row of matrix (if nil, it is assumed that row = column.map(&.conj))

Behaviour copied from scipy

Example:

MatComplex.toeplitz([1, 2, 3], [1, 4, 5, 6]) # =>
# LA::GeneralMatrix(Float64) (3x4, None):
# [1.0, 4.0, 5.0, 6.0]
# [2.0, 1.0, 4.0, 5.0]
# [3.0, 2.0, 1.0, 4.0]
MatComplex.toeplitz([1.0, 2 + 3.i, 4 - 1.i]) # =>
# LA::GeneralMatrix(Complex) (3x3, Hermitian):
# [1.0 + 0.0i, 2.0 - 3.0i, 4.0 + 1.0i]
# [2.0 + 3.0i, 1.0 + 0.0i, 2.0 - 3.0i]
# [4.0 - 1.0i, 2.0 + 3.0i, 1.0 + 0.0i]

Construct (nrows, ncolumns) matrix filled with ones at and below the kth diagonal.

The matrix has A[i,j] == 1 for j <= i + k

k - Number of subdiagonal below which matrix is filled with ones. k = 0 is the main diagonal, k < 0 subdiagonal and k > 0 superdiagonal.

Behaviour copied from scipy

Example:

Mat.tri(3, 5, 2).to_aa # => [[
# [1, 1, 1, 0, 0],
# [1, 1, 1, 1, 0],
# [1, 1, 1, 1, 1]]
Mat.tri(3, 5, -1).to_aa # => [[
# [0, 0, 0, 0, 0],
# [1, 0, 0, 0, 0],
# [1, 1, 0, 0, 0]]

Generate matrix of given size with all elements equal to zero

Complex utility macros that simplifies calling certain LAPACK functions It substitute first letter, allocate workareas, raise exception if return value is negative Check source to see supported functions Example:

# Calling *geev to calculate eigenvalues
lapack(geev, 'N'.ord.to_u8, 'N'.ord.to_u8, nrows, a, nrows,
  vals.to_unsafe.as(LibCBLAS::ComplexDouble*),
  Pointer(LibCBLAS::ComplexDouble).null, nrows,
  Pointer(LibCBLAS::ComplexDouble).null, nrows, worksize: [2*nrows])

Note that it should be called only from methods of Matrix or its descendants

Utility macros that simplifies calling certain LAPACK functions Arguments that point to matrix should be passed as matrix(arg) Example:

# Calling *lange to calculate infinity-norm
lapack_util(lange, worksize, 'I', m.nrows, m.ncolumns, matrix(m), m.nrows)

Note that it should be called only from methods of Matrix or its descendants

Multiplies matrix to scalar

Multiplies matrix to scalar

Matrix product to given m

Raises ArgumentError if inner dimensions do not match

This method automatically calls optimal function depending on MatrixFlags.

If one of the matrix is square and triangular - trmm is called

If one of the matrix is symmetric\hermitian - symm/hemm is called

Otherwise - gemm is called

Raises the square matrix to the integer power other

Implementation taken from https://github.com/Exilor/matrix/

Adds scalar value to every element

Adds scalar value to every element

Returns element-wise sum

This method raises if another matrix doesn't have same size

Substracts scalar value from every element

Returns element-wise substract

This method raises if another matrix doesn't have same size

Multiplies matrix to -1

Divides matrix to scalar

Compare with another matrix

Returns True only if all element are exactly equal. Use #almost_eq If you need approximate equality

Return element of matrix on row i and column j

If i or j negative they are counted from end of matrix If i>=nrows or j>=ncolumns exception is raised Use #unsafe_fetch if you need to skip these checks

Return submatrix over given ranges.

See SubMatrix(T) for details on submatrices Example:

m = GMat32.new([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
m1 = m[1..3, 2..3] # => [[7.0, 8.0], [11.0, 12.0], [15.0, 16.0]]
m2 = m[..3, 2]     # => [[3.0], [7.0], [11.0], [15.0]]

Return submatrix over given ranges.

See SubMatrix(T) for details on submatrices Example:

m = GMat32.new([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
m1 = m[1..3, 2..3] # => [[7.0, 8.0], [11.0, 12.0], [15.0, 16.0]]
m2 = m[..3, 2]     # => [[3.0], [7.0], [11.0], [15.0]]

Return submatrix over given ranges.

See SubMatrix(T) for details on submatrices Example:

m = GMat32.new([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
m1 = m[1..3, 2..3] # => [[7.0, 8.0], [11.0, 12.0], [15.0, 16.0]]
m2 = m[..3, 2]     # => [[3.0], [7.0], [11.0], [15.0]]

Assign element of matrix on row i and column j

If i or j negative they are counted from end of matrix If i>=nrows or j>=ncolumns exception is raised Use #unsafe_set if you need to skip these checks Note this method reset all matrix flags

Assign value to a given submatrix

value can be a scalar or a matrix of same size as affected submatrix

Assign value to a given submatrix

value can be a scalar or a matrix of same size as affected submatrix

Assign value to a given submatrix

value can be a scalar or a matrix of same size as affected submatrix

Calculate linear combination with matrix m a.add(m, alpha: alpha, beta: beta) is equal to alpha * a + beta * k, but faster as only one new matrix is allocated

Perform inplace addition with matrix m multiplied to scalar k

a.add!(k, b) is equal to a = a + k * b, but faster as no new matrix is allocated

Approximately compare with other matrix

Returns true if all elements are within eps from corresponding elements of other matrix

Approximately compare with other matrix

Returns true if all elements are within eps from corresponding elements of other matrix

Uses #tolerance as an eps by default

Directly set or reset matrix flag without check See MatrixFlags for description of flags

Balances a square matrix to improve eigenvalue accuracy.

Arguments:

• permute (Bool) : If true, permutes to isolate eigenvalues. Default: true.
• scale (Bool) : If true, scales to improve conditioning. Default: true.
• separate (Bool) : If true, returns scaling factors separately. Default: false.

Returns:

• Tuple(GeneralMatrix(T), GeneralMatrix(T)) : Balanced matrix and scaling factors (or diagonal).

LAPACK Routine:

• Uses gebal (balance matrix).

Returns concatenation with another matrix by Axis::Rows (horizontal) or Axis::Columns (vertical)

Computes the Cholesky decomposition of a symmetric/Hermitian positive-definite matrix.

Converts the matrix to GeneralMatrix and performs in-place decomposition.

Arguments:

• lower (Bool) : If true, returns lower triangular factor (L). Otherwise, upper (U). Default: false.
• dont_clean (Bool) : If true, does not zero out the opposite triangle. Default: false.

Returns:

• GeneralMatrix(T) : The lower (L) or upper (U) triangular factor such that A = L*L' or A = U'*U.

Side Effect:

• Marks the original matrix as PositiveDefinite if decomposition succeeds.

Converts complex matrix to real one if all imaginary parts are less then eps, returns nil otherwise

Returns just matrix if it is already real

Reset matrix flags to None Usually is done automatically, but this method could be needed if internal content was changed using #to_unsafe

Returns Indexable(SubMatrix(T)) that allows iterating over columns

alias to #conjtranspose

alias to #conjtranspose!

Returns conjurgate transposed matrix

result is same as #transpose for real matrices

Matrix hyperbolic cosine cosh(A) = (exp(A) + exp(-A))/2

Matrix cosine cos(A), computed via complex exponential.

Calculates the determinant of a square matrix.

Returns:

• T : Determinant value.

See GeneralMatrix#det for details.

Detect if given aflags are true or flase for a matrix with tolerance eps Update #flags property See MatrixFlags for description of matrix flags Returns self for method chaining

Detect if given aflags are true or flase for a matrix with tolerance eps Update #flags property See MatrixFlags for description of matrix flags Returns True if all given flags are set

Returns Indexable(T) that allow iterating over k-th diagonal of matrix

Example:

m = GMat32.new([[-1, 2, 3, 4],
                [5, -6, 7, 8],
                [9, 10, -11, 12]])
m.diag(0).to_a.should eq [-1, -6, -11]
m.diag(1).to_a.should eq [2, 7, 12]
m.diag(2).to_a.should eq [3, 8]
m.diag(3).to_a.should eq [4]
expect_raises(ArgumentError) { m.diag(4) }
m.diag(-1).to_a.should eq [5, 10]
m.diag(-2).to_a.should eq [9]
expect_raises(ArgumentError) { m.diag(-3) }
expect_raises(ArgumentError) { m.diag(-4) }

Yields every element of matrix

all argument controls whether to yield all or non-empty elements for banded\sparse matrices Example: m.each { |v| raise "negative element found" if v < 0 }

Yields every index

all argument controls whether to yield all or non-empty elements for banded\sparse matrices Example: m.each_index { |i, j| m[i, j] = -m[i, j] }

For every element of matrix that is below main diagonal it yields a block with value and with corresponding row and column

This method is useful for symmetric matrices and similar cases include_diagonal argument controls whether to include elements on main diagonal all argument controls whether to yield all or non-empty elements for banded\sparse matrices

For every element of matrix that is above main diagonal it yields a block with value and with corresponding row and column

This method is useful for symmetric matrices and similar cases include_diagonal argument controls whether to include elements on main diagonal all argument controls whether to yield all or non-empty elements for banded\sparse matrices

Yields every element of matrix with corresponding row and column

all argument controls whether to yield all or non-empty elements for banded\sparse matrices Example: m.each_with_index { |v, i, j| m2[i, j] = v }

See GeneralMatrix#eigs(*, need_left : Bool, need_right : Bool, overwrite_a = false). This version returns eigenvalues and either left or right eigenvectors (depending on left)

See GeneralMatrix#eigs(*, need_left : Bool, need_right : Bool, overwrite_a = false)

See GeneralMatrix#eigss(*, b : GeneralMatrix(T), need_left : Bool, need_right : Bool, overwrite_a = false, overwrite_b = false).

See GeneralMatrix#eigs(*, need_left : Bool, need_right : Bool, overwrite_a = false). This version returns only eigenvalues

Matrix exponential exp(A) See GeneralMatrix#expm for details

Returns flags of matrix (see MatrixFlags)

Returns horizontal concatenation with another matrix

Computes the Hessenberg form in-place.

Returns:

• GeneralMatrix(T) : Hessenberg matrix.

Computes the Hessenberg form of a matrix.

Arguments:

• calc_q (Bool) : If true, also computes the orthogonal matrix Q. Default: false.

Returns:

• Tuple(GeneralMatrix(T), GeneralMatrix(T)) : Hessenberg matrix and optionally Q.

See GeneralMatrix#hessenberg! for details.

Converts matrix to string for inspection

Output looks like:

GeneralMatrix(Float64) (10x10, MatrixFlags::None)
[1, 2, 3, .... 10]
[11, 12, 13, .... 20]
...
[91, 92, 93, .... 100]

Calculate matrix inversion.

Returns:

• GeneralMatrix(T) : The inverted matrix.

See GeneralMatrix#inv! for details on algorithm.

Returns kroneker product with matrix b

See GeneralMatrix#lq

See GeneralMatrix#lq_r

Compute pivoted LU decomposition of a matrix and returns it in a compact form, useful for solving linear equation systems.

Uses getrf LAPACK routine

Returns result of appliyng block to every element (without index)

Yields each element (without index) and replace it with returned value

Returns result of appliyng block to every element with index

Yields each element with index and replace it with returned value

Calculate maximum over given axis

Calculate minimum over given axis

Returns number of columns in matrix

Computes the norm of the matrix.

Arguments:

• kind (MatrixNorm) : Type of norm to compute. Default: MatrixNorm::Frobenius.

Returns:

• Float : Norm value.

Returns number of rows in matrix

Calculate Moore–Penrose pseudo-inverse of a matrix.

https://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_inverse

Implemented using SVD decomposition.

Returns:

• GeneralMatrix(T) : Pseudo-inverse matrix.

Perform product over given axis

See GeneralMatrix#ql

See GeneralMatrix#ql_r

See GeneralMatrix#qr

See GeneralMatrix#qr_r

See GeneralMatrix#qr_raw

See GeneralMatrix#qz

Perform #reduce from initial value over given axis

Return matrix repeated arows times by vertical and acolumns times by horizontal

Returns Indexable(SubMatrix(T)) that allows iterating over rows

See GeneralMatrix#rq

See GeneralMatrix#rq_r

Save a matrix to CSV (comma separated values) file Example:

LA::GMat.rand(30, 30).save_csv("./test.csv")
a = LA::GMat.load_csv("./test.csv")

Perform inplace multiplication to scalar k

See GeneralMatrix#schur

Returns shape of matrix in a form of tuple {nrows, ncolumns}

Returns shape of matrix as a string [5x7]

Matrix hyperbolic sine sinh(A) = (exp(A) - exp(-A))/2

Matrix sine sin(A), computed via complex exponential.

Returns shape of matrix in a form of tuple {nrows, ncolumns}

Solves the linear system A * X = B.

Arguments:

• b (Matrix(T)) : Right-hand side matrix.

Returns:

• GeneralMatrix(T) : Solution matrix X.

Solves the linear system A * X = B.

Arguments:

• b (GeneralMatrix(T)) : Right-hand side matrix.
• overwrite_b (Bool) : If true, allows overwriting b. Default: false.

Returns:

• GeneralMatrix(T) : Solution matrix X.

See GeneralMatrix#solve for details.

Returns True if matrix is square and False otherwise

Perform sum over given axis

Computes the singular value decomposition (SVD) of a matrix.

Returns:

• Tuple(GeneralMatrix(T), Array(T), GeneralMatrix(T)) : U, singular values, V.t.

See GeneralMatrix#svd for details.

Computes only the singular values of a matrix.

Returns:

• Array(T) : Singular values.

See GeneralMatrix#svdvals for details.

alias to #transpose

alias to #transpose!

Matrix hyperbolic tangent tanh(A) = sinhm(A) * coshm(A)⁻¹

Matrix tangent tan(A) = sinm(A) * cosm(A)⁻¹

to_custom(io, "[", ",", "],[", "]") Converts a matrix to string with custom format. Example:

a = LA::GMat[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
str = String.build do |io|
  a.to_custom(io, prefix: "(", columns_separator: ",", rows_separator: "|", postfix: ")")
end
str # => "(1,2,3|4,5,6|7,8,9)"

to_custom(io, "[", ",", "],[", "]") Converts a matrix to string with custom format. Example:

a = LA::GMat[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
str = a.to_custom(prefix: "(", columns_separator: ",", rows_separator: "|", postfix: ")")
str # => "(1,2,3|4,5,6|7,8,9)"

Creates general matrix with same content. Useful for banded\sparse matrices

Converts complex matrix to imaginary part

Converts a matrix to matlab format

Converts a matrix to matlab format string Example:

LA::GMat[[1, 2, 3], [4, 5, 6], [7, 8, 9]].to_matlab # => "[1,2,3; 4,5,6; 7,8,9]"

Converts complex matrix to real part

Converts matrix to string, with linefeeds before and after matrix:

Output looks like:

[1, 2, 3, .... 10]
[11, 12, 13, .... 20]
...
[91, 92, 93, .... 100]

Returns pointer to underlying data

Storage format depends of matrix type This method raises at runtime if matrix doesn't have raw pointer

Returns estimated tolerance of equality\inequality

This value is used by default in #almost_eq compare

Returns sum of diagonal elements (trace of matrix)

Returns transposed matrix

Same as tril in scipy - returns lower triangular or trapezoidal part of matrix

Returns a matrix with all elements above k-th diagonal zeroed

Works like a tril in scipy - remove all elements above k-diagonal

Same as triu in scipy - returns upper triangular or trapezoidal part of matrix

Returns a matrix with all elements below k-th diagonal zeroed

Works like a triu in scipy - remove all elements below k-diagonal

Returns vertical concatenation with another matrix