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

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#==

• #cat!(other : Matrix(T), dimension)

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

• #clone

  returns copy of matrix

• #conjtranspose!

  Conjurgate transposes matrix inplace

• #dup

  returns copy of matrix

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

• #ncolumns : Int32

  Count of columns in matrix

• #nrows : Int32

  Count of rows in matrix

• #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.

• #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.

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