Creates matrix with given size and populate elements from values

if col_major is true, values content is just copied to #raw, otherwise a conversion from row-major form is performed Example:

values = [1, 2, 3, 4]
a = GMat.new(2, 2, values)
a.to_aa # => [[1,2],[3,4]]
b = GMat.new(2, 2, values, col_major: true)
b.to_aa # => [[1,3],[2,4]]

Creates zero-initialized matrix of given size

Example: LA::GMat.new(4,4)

Creates matrix of given size and then call block to initialize each element

Example: LA::GMat.new(4,4){|i,j| i+j }

Creates matrix from any Indexable of Indexables

Example:

m = GMat.new([
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9],
  [10, 11, 12],
])

Creates matrix with same content as another matrix

Alias for #new

Creates matrix from a number of columns

Example:

a = GMat.columns([1, 2, 3, 4], [5, 6, 7, 8])
a.to_aa # => [[1, 5], [2, 6], [3, 7], [4, 8]]

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

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

Creates matrix from a number of rows

Example:

a = GMat.rows([1, 2, 3, 4], [5, 6, 7, 8])
a.to_aa # => [[1,2,3,4], [5,6,7,8]]

see LA::Matrix#==

Alias for #norm.

Perform inplace linear combination with matrix m a.add!(m, alpha: alpha, beta: beta) is equal to a = alpha * a + beta * m, but faster as no new matrix is allocated

performs c = alphaab + beta*c (BLAS routines gemm/symm/hemm)

Balances a square matrix in-place to improve eigenvalue accuracy.

Arguments:

• permute (Bool) : If true, performs permutations. Default: true.
• scale (Bool) : If true, performs scaling. Default: true.
• separate (Bool) : If true, returns scaling factors separately. Default: false.

Returns:

• GeneralMatrix(T) : If separate is true, returns scaling factors; otherwise, returns diagonal matrix.

Raises:

• ArgumentError : If matrix is not square.

LAPACK Routine:

• Uses gebal (balance matrix).

Concatenate matrix adding another matrix by dimension Axis::Rows (horizontal) or Axis::Columns (vertical)

Solves A * X = B given Cholesky factorization of A (A = L*L' or U'*U).

Arguments:

• b (GeneralMatrix(T)) : Right-hand side matrix.
• overwrite_b (Bool) : Allows overwriting b with solution. Default: false.

Returns:

• GeneralMatrix(T) : Solution matrix X.

Raises:

• ArgumentError : If #nrows mismatch, self is not square, or not triangular.

LAPACK Routine:

• Uses potrs (positive-definite solve).

Performs in-place Cholesky decomposition.

Arguments:

• lower (Bool) : If true, computes lower triangular factor (L). Otherwise, upper (U). Default: false.
• dont_clean (Bool) : If true, leaves the unused triangle unmodified. Default: false.

Returns:

• self : On successful decomposition, self becomes the triangular factor.

Raises:

• ArgumentError : If matrix is not square.

LAPACK Routine:

• Uses potrf (real/complex positive-definite factorization).

returns copy of matrix

Conjurgate transposes matrix inplace

Currently, transpose of non-square matrix still allocates temporary buffer

Calculates the determinant of a square matrix.

Arguments:

• overwrite_a (Bool) : If true, allows overwriting self. Default: false.

Returns:

• T : Determinant value.

Raises:

• ArgumentError : If matrix is not square.

LAPACK Routine:

• Uses getrf (LU factorization).

returns copy of matrix

• 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)

Computes eigenvalues and optionally left and right eigenvectors.

Arguments:

• need_left: Whether to compute left eigenvectors.
• need_right: Whether to compute right eigenvectors.
• overwrite_a: If true, allows overwriting matrix self.

Returns: A tuple {values, left_vectors, right_vectors} where:

• values is an Array(T) of eigenvalues (or Array(Complex) if complex eigenvalues arise in real matrices).
• left_vectors is a GeneralMatrix(T)? containing left eigenvectors if need_left == true, else nil.
• right_vectors is a GeneralMatrix(T)? containing right eigenvectors if need_right == true, else nil.

For Hermitian (complex) or symmetric (real) matrices, eigenvalues are real, and eigenvectors are orthonormal.

Exceptions:

• ArgumentError: if the matrix is not square.

Called LAPACK routines:

• heevr — for complex Hermitian matrices.
• syevr — for real symmetric matrices.
• geev — for general complex or real non-symmetric/Hermitian matrices.

Computes generalized eigenvalues and optionally left and right eigenvectors.

Arguments:

• b: Right-hand matrix in the generalized eigenvalue problem.
• need_left: Whether to compute left eigenvectors.
• need_right: Whether to compute right eigenvectors.
• overwrite_a: If true, allows overwriting matrix self.
• overwrite_b: If true, allows overwriting matrix b.

Returns: A tuple {alpha, beta, left_vectors, right_vectors} where:

• alpha is an Array(T) of generalized eigenvalue numerators (or Array(Complex) if complex values arise).
• beta is an Array(T) of generalized eigenvalue denominators (λ = alpha[i] / beta[i]).
• left_vectors is a GeneralMatrix(T)? containing left eigenvectors if need_left == true, else nil.
• right_vectors is a GeneralMatrix(T)? containing right eigenvectors if need_right == true, else nil.

For Hermitian/symmetric A and positive definite B, the problem is solved using a specialized algorithm ensuring real eigenvalues.

Exceptions:

• ArgumentError: if self is not square or if b does not have the same size as self.

Called LAPACK routines:

• hegvd — for complex Hermitian-definite generalized problems.
• sygvd — for real symmetric-definite generalized problems.
• ggev — for general complex or real non-symmetric/Hermitian problems.

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

Computes matrix exponential

It exploits triangularity (if any) of A. if schur_fact is true, function uses an initial transformation to Schur form.

Reference: A. H. Al-Mohy and N. J. Higham, A New Scaling and Squaring Algorithm for the Matrix Exponential, SIAM J. Matrix Anal. Appl. 31(3): 970-989, 2009. Awad H. Al-Mohy and Nicholas J. Higham, April 20, 2010.

Matrix flags (see MatrixFlags for description)

Matrix flags (see MatrixFlags for description)

Concatenate matrix adding another matrix horizontally (so they form a row)

Computes the Hessenberg form in-place (without Q).

Returns:

• self : Hessenberg matrix.

Computes the Hessenberg form of a matrix in-place.

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.

Raises:

• ArgumentError : If matrix is not square.

LAPACK Routines:

• gebal (balance)
• gehrd (Hessenberg reduction)
• orghr (generate Q)

Calculate matrix inversion in-place.

Method selects optimal algorithm depending on MatrixFlags:

• #transpose! returned if matrix is orthogonal.
• trtri used if matrix is triangular.
• potrf + potri used if matrix is positive definite.
• hetrf + hetri used if matrix is hermitian (complex only).
• sytrf + sytri used if matrix is symmetric.
• getrf + getri used otherwise.

Returns:

• self : On successful inversion, self becomes the inverse.

Raises:

• ArgumentError : If matrix is not square.

LAPACK Routines:

• trtri (triangular inverse)
• potrf/potri (positive definite)
• hetrf/hetri (hermitian)
• sytrf/sytri (symmetric)
• getrf/getri (general)

Computes LQ decomposition.

Arguments:

• overwrite_a (Bool) : If true, allows overwriting self. Default: false.

Returns:

• Tuple(GeneralMatrix(T), GeneralMatrix(T)) : L and Q factors.

LAPACK Routines:

• gelqf (LQ factorization)
• orglq (generate Q from elementary reflectors)

Solves the linear least squares problem with multiple method options.

Arguments:

• b (GeneralMatrix(T)) : Right-hand side matrix.
• method (LSMethod) : Algorithm to use. Default: LSMethod::Auto.
• overwrite_a (Bool) : If true, allows overwriting self. Default: false.
• overwrite_b (Bool) : If true, allows overwriting b. Default: false.
• cond (Number) : Cutoff for rank determination. Default: -1 (machine precision).

Returns:

• Tuple(GeneralMatrix(T), Int32, Array(T)) : Solution X, effective rank, singular values (if applicable).

Raises:

• ArgumentError : If #nrows mismatch.

LAPACK Routines:

• gels (QR least squares)
• gelsd (SVD-based least squares)
• gelsy (QR with pivoting)

Compute pivoted LU decomposition of a matrix

If you call p,l,u = a.lu for a matrix m*n a then

• p will be m*m permutation matrix
• l will be m*k lower triangular matrix with unit diagonal. K = min(M, N)
• u will be k*n upper triangular matrix
• (p*l*u) will be equal to a (within calculation tolerance)

if overwrite_a is true, a will be overriden in process of calculation

Uses getrf LAPACK routine

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

Overrides source matrix in a process of calculation

Uses getrf LAPACK routine

Count of columns in matrix

Computes the norm of the matrix.

Method selects optimal algorithm depending on MatrixFlags:

• lantr used for triangular matrices.
• lanhe used for hermitian matrices (complex only).
• lansy used for symmetric matrices.
• lange used for general matrices.

Arguments:

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

Returns:

• T : Norm value.

LAPACK Routines:

• lantr (triangular matrix norm)
• lanhe (hermitian matrix norm)
• lansy (symmetric matrix norm)
• lange (general matrix norm)

Count of rows in matrix

Computes QL decomposition.

Arguments:

• overwrite_a (Bool) : If true, allows overwriting self. Default: false.

Returns:

• Tuple(GeneralMatrix(T), GeneralMatrix(T)) : Q and L factors.

LAPACK Routines:

• geqlf (QL factorization)
• orgql (generate Q from elementary reflectors)

Computes the complete QR decomposition with orthogonal Q.

Arguments:

• overwrite_a (Bool) : If true, allows overwriting self. Default: false.
• pivoting (Bool) : If true, performs QR with column pivoting. Default: false.

Returns:

• Tuple(GeneralMatrix(T), GeneralMatrix(T), Array(Int32)) : Orthogonal matrix Q (m×m or m×n depending on dimensions) Upper triangular matrix R (n×n) Pivot indices (empty if pivoting = false)

Properties:

• For an m×n matrix A with m ≥ n: A = Q * R
• For m < n: A = Q * R where Q is m×m and R is m×n
• When pivoting is enabled: A * P = Q * R where P is the permutation matrix defined by pivot indices

Side Effects:

• Marks Q as Orthogonal on successful decomposition

LAPACK Routines:

• geqrf/geqp3 (QR factorization)
• orgqr (generate Q from elementary reflectors)

Performs in-place QR factorization, returning only the R factor.

Arguments:

• overwrite_a (Bool) : If true, allows overwriting self. Default: false.
• pivoting (Bool) : If true, uses QR with column pivoting. Default: false.

Returns:

• Tuple(GeneralMatrix(T), Array(Int32)) : Upper triangular matrix R and pivot indices.

LAPACK Routines:

• geqrf (QR without pivoting)
• geqp3 (QR with column pivoting)

See GeneralMatrix#qr_raw

Performs in-place QZ (generalized Schur) decomposition.

Arguments:

• b (GeneralMatrix(T)) : Second matrix in the generalized eigenvalue problem.
• overwrite_a (Bool) : If true, allows overwriting the first matrix. Default: false.
• overwrite_b (Bool) : If true, allows overwriting the second matrix. Default: false.

Returns:

• Tuple(GeneralMatrix(T), GeneralMatrix(T), GeneralMatrix(T), GeneralMatrix(T)) : A tuple containing:
  • Generalized Schur form of A.
  • Generalized Schur form of B.
  • Left transformation matrix VSL.
  • Right transformation matrix VSR.

Raises:

• ArgumentError : If either matrix is not square.

LAPACK Routine:

• Uses gges (generalized Schur decomposition).

Determines the effective rank of the matrix.

Arguments:

• eps (Number) : Tolerance for singular value comparison. Default: self.tolerance.
• method (RankMethod) : Method to use. Default: RankMethod::SVD.
• overwrite_a (Bool) : If true, allows overwriting self. Default: false.

Returns:

• Int32 : Estimated rank.

LAPACK Routines:

• SVD method uses gesdd (singular values)
• QRP method uses QR with pivoting

Pointer to a raw data

Returns a matrix with different nrows and ncolumns but same elements (total number of elements must not change)

if col_major is true, just nrows and ncolumns are changed, data kept the same Otherwise, elements are reordered to emulate row-major storage Example:

a = GMat[[1, 2, 3], [4, 5, 6]]
a.reshape(2, 3).to_aa # => [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]
b = GMat[[1, 2, 3], [4, 5, 6]]
this is because in-memory order of values is (1, 4, 2, 5, 3, 6)
b.reshape(2, 3, col_major: true).to_aa # => [[1.0, 5.0], [4.0, 3.0], [2.0, 6.0]]

Changes nrows and ncolumns of matrix (total number of elements must not change)

if col_major is true, just nrows and ncolumns are changed, data kept the same Otherwise, elements are reordered to emulate row-major storage Example:

a = GMat[[1, 2, 3], [4, 5, 6]]
a.reshape!(2, 3)
a.to_aa # => [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]
b = GMat[[1, 2, 3], [4, 5, 6]]
b.reshape!(2, 3, col_major: true)
this is because in-memory order of values is (1, 4, 2, 5, 3, 6)
b.to_aa # => [[1.0, 5.0], [4.0, 3.0], [2.0, 6.0]]

Change number of rows and columns in matrix.

if new number is higher zero elements are added, if new number is lower, exceeding elements are lost

Computes RQ decomposition.

Arguments:

• overwrite_a (Bool) : If true, allows overwriting self. Default: false.

Returns:

• Tuple(GeneralMatrix(T), GeneralMatrix(T)) : Q and R factors.

LAPACK Routines:

• gerqf (RQ factorization)
• orgrq (generate Q from elementary reflectors)

Performs in-place Schur decomposition.

Arguments:

• overwrite_a (Bool) : If true, allows overwriting the matrix with its Schur form. Default: false.

Returns:

• Tuple(GeneralMatrix(T), GeneralMatrix(T)) : A tuple containing:
  • Schur form matrix (upper triangular for complex, quasi-triangular for real).
  • Orthogonal/unitary transformation matrix Z.

Raises:

• ArgumentError : If matrix is not square.

LAPACK Routine:

• Uses gees (Schur decomposition).

Solves the linear system A * X = B.

Method selects optimal algorithm depending on MatrixFlags:

• trtrs used if matrix is triangular.
• posv used if matrix is positive definite.
• hesv used if matrix is hermitian (complex only).
• sysv used if matrix is symmetric.
• gesv used otherwise.

Arguments:

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

Returns:

• GeneralMatrix(T) : Solution matrix X.

Raises:

• ArgumentError : If #nrows mismatch or matrix not square.

LAPACK Routines:

• trtrs (triangular solve)
• posv (positive definite solve)
• hesv (hermitian solve)
• sysv (symmetric solve)
• gesv (general solve)

Solves the linear least squares problem using QR factorization.

Arguments:

• b (GeneralMatrix(T)) : Right-hand side matrix.
• overwrite_a (Bool) : If true, allows overwriting self. Default: false.
• overwrite_b (Bool) : If true, allows overwriting b. Default: false.
• cond (Number) : Cutoff for rank determination. Default: -1 (machine precision).

Returns:

• GeneralMatrix(T) : Solution matrix X (may include residuals).

Raises:

• ArgumentError : If #nrows mismatch.

LAPACK Routine:

• Uses gels (QR least squares).

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

For an m×n matrix A, returns:

• u : m×m orthogonal matrix
• s : Array of singular values of length min(m,n)
• vt : n×n orthogonal matrix

Such that A = u * diag(s) * vt.

Arguments:

• overwrite_a (Bool) : If true, allows overwriting self. Default: false.

Returns:

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

LAPACK Routine:

• Uses gesdd (divide-and-conquer SVD).

Computes only the singular values of a matrix.

Arguments:

• overwrite_a (Bool) : If true, allows overwriting self. Default: false.

Returns:

• Array(T) : Singular values.

LAPACK Routine:

• Uses gesdd (SVD, singular values only).

Converts matrix to plain array of elements if col_major is true, elements are returned as stored inplace, otherwise row-major storage is emulated

Converts matrix to array of array of elements if col_major is true, elements are returned as stored inplace, otherwise row-major storage is emulated Example:

a = GMat[[1, 2], [3, 4]]
a.to_aa                  # => [[1.0, 2.0],[3.0, 4.0]]
a.to_aa(col_major: true) # => [[1.0, 3.0],[2.0, 4.0]]

Returns pointer to raw data, suitable to e.g. use with LAPACK

performs b = alphaab or b = alphaba (BLAS routine trmm)

a must be a square triangular GeneralMatrix(T)

if left is true, alpha*a*b is calculated, otherwise alpha*b*a

transposes matrix inplace

Currently, transpose of non-square matrix still allocates temporary buffer

returns element at row i and column j, without performing any checks

sets element at row i and column j to value, without performing any checks

Concatenate matrix adding another matrix vertically (so they form a column)