class LA::GeneralMatrix(T)

• LA::GeneralMatrix(T)
• LA::Matrix(T)
• Reference
• Object

Overview

generic matrix, heap-allocated

Data are stored in column-major as this is a storage used by LAPACK

See SUPPORTED_TYPES for supported types

Included Modules

• LA::DenseMatrix

Defined in:

Constructors

• .new(nrows : Int32, ncolumns : Int32, values : Indexable, col_major = false, flags : LA::MatrixFlags = MatrixFlags::None)

  Creates matrix with given size and populate elements from values

• .new(nrows : Int32, ncolumns : Int32, flags : LA::MatrixFlags = MatrixFlags::None)

  Creates zero-initialized matrix of given size

• .new(nrows : Int32, ncolumns : Int32, flags : LA::MatrixFlags = MatrixFlags::None, &)

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

• .new(values : Indexable)

  Creates matrix from any Indexable of Indexables

• .new(matrix : Matrix)

  Creates matrix with same content as another matrix

Class Method Summary

• .[](*args)

  Alias for #new

• .columns(*args)

  Creates matrix from a number of columns

• .diag(nrows, ncolumns, values)

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

• .diag(nrows, ncolumns, &)

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

• .rows(*args)

  Creates matrix from a number of rows

Instance Method Summary

• #==(other : self)

  see LA::Matrix#==

• #abs(kind : MatrixNorm = MatrixNorm::Frobenius)

  Alias for #norm

• #add!(m : Matrix, *, alpha = 1, beta = 1)

  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

• #add_mult(a, b : Matrix(T), *, alpha = 1.0, beta = 1.0)

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

• #balance!(*, permute = true, scale = true, separate = false)
• #cat!(other : Matrix(T), dimension)

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

• #cho_solve(b : self, *, overwrite_b = false)
• #cholesky!(*, lower = false, dont_clean = false)
• #clone

  returns copy of matrix

• #conjtranspose!

  Conjurgate transposes matrix inplace

• #det(*, overwrite_a = false)

  Calculates determinant for a square matrix

• #dup

  returns copy of matrix

• #eigs(*, left = false, overwrite_a = false)
• #eigs(*, need_left : Bool, need_right : Bool, overwrite_a = false)
• #eigs(*, b : GeneralMatrix(T), need_left : Bool, need_right : Bool, overwrite_a = false, overwrite_b = false)

  generalized eigenvalues problem

• #eigvals(*, overwrite_a = false)
• #expm(*, schur_fact = false)

  Computes matrix exponential

• #flags : MatrixFlags

  Matrix flags (see MatrixFlags for description)

• #flags=(flags : MatrixFlags)

  Matrix flags (see MatrixFlags for description)

• #hcat!(other)

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

• #hessenberg!
• #hessenberg!(*, calc_q = false)
• #inv!

  Calculate matrix inversion inplace Method selects optimal algorithm depending on MatrixFlags transpose returned if matrix is orthogonal trtri is used if matrix is triangular potrf, potri are used if matrix is positive definite hetrf, hetri are used if matrix is hermitian sytrf, sytri are used if matrix is symmetric getrf, getri are used otherwise

• #lq(*, overwrite_a = false)
• #lq_r(*, overwrite_a = false)
• #lstsq(b : self, method : LSMethod = LSMethod::Auto, *, overwrite_a = false, overwrite_b = false, cond = -1)
• #lu(*, overwrite_a = false)

  Compute pivoted LU decomposition of a matrix

• #lu_factor! : LUMatrix(T)

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

• #ncolumns : Int32

  Count of columns in matrix

• #norm(kind : MatrixNorm = MatrixNorm::Frobenius)

  returns matrix norm

• #nrows : Int32

  Count of rows in matrix

• #ql(*, overwrite_a = false)
• #ql_r(*, overwrite_a = false)
• #qr(*, overwrite_a = false, pivoting = false)
• #qr_r(*, overwrite_a = false, pivoting = false)
• #qr_raw(*, overwrite_a = false, pivoting = false)
• #qz(b : self, overwrite_a = false, overwrite_b = false)
• #rank(eps = self.tolerance, *, method : RankMethod = RankMethod::SVD, overwrite_a = false)

  determine effective rank either by SVD method or QR-factorization with pivoting

• #raw : Slice(T)

  Pointer to a raw data

• #reshape(anrows, ancolumns, col_major = false)

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

• #reshape!(anrows : Int32, ancolumns : Int32, col_major = false)

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

• #resize!(anrows : Int32, ancolumns : Int32)

  Change number of rows and columns in matrix.

• #rq(*, overwrite_a = false)
• #rq_r(*, overwrite_a = false)
• #schur(*, overwrite_a = false)
• #solve(b : self, *, overwrite_a = false, overwrite_b = false)

  Solves matrix equation self*x = b and returns x

• #solvels(b : self, *, overwrite_a = false, overwrite_b = false, cond = -1)
• #svd(*, overwrite_a = false)

  Calculates singular value decomposition for a matrix

• #svdvals(*, overwrite_a = false)

  Calculates array of singular values for a matrix

• #to_a(col_major = false)

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

• #to_aa(col_major = false)

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

• #to_unsafe

  Returns pointer to raw data, suitable to e.g.

• #tr_mult!(a : Matrix(T), *, alpha = 1.0, left = false)

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

• #transpose!

  transposes matrix inplace

• #unsafe_fetch(i, j)

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

• #unsafe_set(i, j, value)

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

• #vcat!(other)

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

Constructor Detail

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

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

Class Method Detail

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

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

Instance Method Detail

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

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

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