package lacaml

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Matrix operations
Creation of matrices
Unary matrix operations
Ternary matrix operations
Creation of matrices and accessors
Matrix transformations
Operations on one matrix
Operations on two matrices
Iterators over matrices

package lacaml

lacaml
- Library lacaml
  - Lacaml
    
    Io
    
    Common
    
    D
    
    S
    
    Z
    
    C
    
    Utils
  - Lacaml_C
    
    Vec
    
    Mat
  - Lacaml_D
    
    Vec
    
    Mat
  - Lacaml_S
    
    Vec
    
    Mat
  - Lacaml_Z
    
    Vec
    
    Mat
  - Lacaml_common
    
    Types
    
    Vec
    
    Mat
  - Lacaml_complex32
    
    Types
    
    Vec
    
    Mat
  - Lacaml_complex64
    
    Types
    
    Vec
    
    Mat
  - Lacaml_float32
    
    Types
    
    Vec
    
    Mat
  - Lacaml_float64
    
    Types
    
    Vec
    
    Mat
  - Lacaml_io
    
    Context
    
    Toplevel
  - Lacaml_utils
- Library lacaml.top
  - Install_printers
- Sources
  - lacaml
    
    lacaml_complex32.ml
    
    lacaml_complex64.ml
    
    lacaml_float32.ml
    
    lacaml_float64.ml
    
    lacaml_utils.ml
  - lacaml.top
    
    install_printers.ml

Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module `Lacaml_S.Mat`

type t = mat

Matrix operations

Creation of matrices

val hilbert : int -> Lacaml_float32.mat

hilbert n

returns
an nxn Hilbert matrix.

val hankel : int -> Lacaml_float32.mat

hankel n

returns
an nxn Hankel matrix.

val pascal : int -> Lacaml_float32.mat

pascal n

returns
an nxn Pascal matrix.

val rosser : unit -> Lacaml_float32.mat

rosser n

returns
8x8 Rosser matrix.

val toeplitz : Lacaml_float32.vec -> Lacaml_float32.mat

toeplitz v

returns
the Toeplitz matrix associated with v. The constant diagonals are read from left to right from v.

raises Invalid_argument
if the length of v is not an odd number.

val vandermonde : Lacaml_float32.vec -> Lacaml_float32.mat

vandermonde v

returns
the Vandermonde matrix associated with v.

val wilkinson : int -> Lacaml_float32.mat

wilkinson n

returns
the nxn Wilkinson matrix.

raises Invalid_argument
if n is not an odd number >= 3.

val random : 
  ?rnd_state:Random.State.t ->
  ?from:float ->
  ?range:float ->
  int ->
  int ->
  Lacaml_float32.mat

random ?rnd_state ?from ?range m n

returns
an mxn matrix initialized with random elements sampled uniformly from range starting at from. A random state rnd_state can be passed.

parameter rnd_state
default = Random.get_state ()

parameter from
default = -1.0

parameter range
default = 2.0

Unary matrix operations

val sqr : Lacaml_float32.Types.Mat.unop

sqr ?m ?n ?br ?bc ?b ?ar ?ac a computes the square of the elements in the m by n sub-matrix of the matrix a starting in row ar and column ac. If b is given, the result will be stored in there using offsets br and bc, otherwise a fresh matrix will be used. The resulting matrix is returned.

parameter m
default = greater n s.t. ar + m - 1 <= dim1 a

parameter n
default = greater n s.t. ac + n - 1 <= dim2 a

parameter br
default = 1

parameter bc
default = 1

parameter b
default = fresh matrix with br + m - 1 rows and bc + n - 1 columns

parameter ar
default = 1

parameter ac
default = 1

val sqrt : Lacaml_float32.Types.Mat.unop

sqrt ?m ?n ?br ?bc ?b ?ar ?ac a computes the square root of the elements in the m by n sub-matrix of the matrix a starting in row ar and column ac. If b is given, the result will be stored in there using offsets br and bc, otherwise a fresh matrix will be used. The resulting matrix is returned.

parameter m
default = greater n s.t. ar + m - 1 <= dim1 a

parameter n
default = greater n s.t. ac + n - 1 <= dim2 a

parameter br
default = 1

parameter bc
default = 1

parameter b
default = fresh matrix with br + m - 1 rows and bc + n - 1 columns

parameter ar
default = 1

parameter ac
default = 1

val exp : Lacaml_float32.Types.Mat.unop

exp ?m ?n ?br ?bc ?b ?ar ?ac a computes the exponential of the elements in the m by n sub-matrix of the matrix a starting in row ar and column ac. If b is given, the result will be stored in there using offsets br and bc, otherwise a fresh matrix will be used. The resulting matrix is returned.

parameter m
default = greater n s.t. ar + m - 1 <= dim1 a

parameter n
default = greater n s.t. ac + n - 1 <= dim2 a

parameter br
default = 1

parameter bc
default = 1

parameter b
default = fresh matrix with br + m - 1 rows and bc + n - 1 columns

parameter ar
default = 1

parameter ac
default = 1

val log : Lacaml_float32.Types.Mat.unop

log ?m ?n ?br ?bc ?b ?ar ?ac a computes the logarithm of the elements in the m by n sub-matrix of the matrix a starting in row ar and column ac. If b is given, the result will be stored in there using offsets br and bc, otherwise a fresh matrix will be used. The resulting matrix is returned.

parameter m
default = greater n s.t. ar + m - 1 <= dim1 a

parameter n
default = greater n s.t. ac + n - 1 <= dim2 a

parameter br
default = 1

parameter bc
default = 1

parameter b
default = fresh matrix with br + m - 1 rows and bc + n - 1 columns

parameter ar
default = 1

parameter ac
default = 1

val sin : Lacaml_float32.Types.Mat.unop

sin ?m ?n ?br ?bc ?b ?ar ?ac a computes the sine of the elements in the m by n sub-matrix of the matrix a starting in row ar and column ac. If b is given, the result will be stored in there using offsets br and bc, otherwise a fresh matrix will be used. The resulting matrix is returned.

parameter m
default = greater n s.t. ar + m - 1 <= dim1 a

parameter n
default = greater n s.t. ac + n - 1 <= dim2 a

parameter br
default = 1

parameter bc
default = 1

parameter b
default = fresh matrix with br + m - 1 rows and bc + n - 1 columns

parameter ar
default = 1

parameter ac
default = 1

val cos : Lacaml_float32.Types.Mat.unop

cos ?m ?n ?br ?bc ?b ?ar ?ac a computes the cosine of the elements in the m by n sub-matrix of the matrix a starting in row ar and column ac. If b is given, the result will be stored in there using offsets br and bc, otherwise a fresh matrix will be used. The resulting matrix is returned.

parameter m
default = greater n s.t. ar + m - 1 <= dim1 a

parameter n
default = greater n s.t. ac + n - 1 <= dim2 a

parameter br
default = 1

parameter bc
default = 1

parameter b
default = fresh matrix with br + m - 1 rows and bc + n - 1 columns

parameter ar
default = 1

parameter ac
default = 1

val tan : Lacaml_float32.Types.Mat.unop

tan ?m ?n ?br ?bc ?b ?ar ?ac a computes the tangent of the elements in the m by n sub-matrix of the matrix a starting in row ar and column ac. If b is given, the result will be stored in there using offsets br and bc, otherwise a fresh matrix will be used. The resulting matrix is returned.

parameter m
default = greater n s.t. ar + m - 1 <= dim1 a

parameter n
default = greater n s.t. ac + n - 1 <= dim2 a

parameter br
default = 1

parameter bc
default = 1

parameter b
default = fresh matrix with br + m - 1 rows and bc + n - 1 columns

parameter ar
default = 1

parameter ac
default = 1

val tanh : Lacaml_float32.Types.Mat.unop

tanh ?m ?n ?br ?bc ?b ?ar ?ac a computes the hyperbolic tangent of the elements in the m by n sub-matrix of the matrix a starting in row ar and column ac. If b is given, the result will be stored in there using offsets br and bc, otherwise a fresh matrix will be used. The resulting matrix is returned.

parameter m
default = greater n s.t. ar + m - 1 <= dim1 a

parameter n
default = greater n s.t. ac + n - 1 <= dim2 a

parameter br
default = 1

parameter bc
default = 1

parameter b
default = fresh matrix with br + m - 1 rows and bc + n - 1 columns

parameter ar
default = 1

parameter ac
default = 1

Ternary matrix operations

val cpab : 
  ?m:int ->
  ?n:int ->
  ?cr:int ->
  ?cc:int ->
  Lacaml_float32.mat ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  ?br:int ->
  ?bc:int ->
  Lacaml_float32.mat ->
  unit

cpab ?m ?n ?cr ?cc c ?ar ?ac a ?br ?bc b multiplies designated m-by-n range of elements of matrices a and b elementwise, and adds the result to and stores it in the specified range in c. This function is useful for convolutions. Similar to Vec.zpxy.

parameter m
default = number of rows of a

parameter n
default = number of columns of a

parameter cr
default = 1

parameter cc
default = 1

parameter ar
default = 1

parameter ac
default = 1

parameter br
default = 1

parameter bc
default = 1

val cmab : 
  ?m:int ->
  ?n:int ->
  ?cr:int ->
  ?cc:int ->
  Lacaml_float32.mat ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  ?br:int ->
  ?bc:int ->
  Lacaml_float32.mat ->
  unit

cmab ?m ?n ?cr ?cc c ?ar ?ac a ?br ?bc b multiplies designated m-by-n range of elements of matrices a and b elementwise, and subtracts the result from and stores it in the specified range in c. This function is useful for convolutions. Similar to Vec.zmxy.

parameter m
default = number of rows of a

parameter n
default = number of columns of a

parameter cr
default = 1

parameter cc
default = 1

parameter ar
default = 1

parameter ac
default = 1

parameter br
default = 1

parameter bc
default = 1

Creation of matrices and accessors

val create : int -> int -> Lacaml_float32.mat

create m n

returns
a matrix containing m rows and n columns.

val make : int -> int -> Lacaml_float32.num_type -> Lacaml_float32.mat

make m n x

returns
a matrix containing m rows and n columns initialized with value x.

val make0 : int -> int -> Lacaml_float32.mat

make0 m n x

returns
a matrix containing m rows and n columns initialized with the zero element.

val of_array : Lacaml_float32.num_type array array -> Lacaml_float32.mat

of_array ar

returns
a matrix initialized from the array of arrays ar. It is assumed that the OCaml matrix is in row major order (standard).

val to_array : Lacaml_float32.mat -> Lacaml_float32.num_type array array

to_array mat

returns
an array of arrays initialized from matrix mat.

val of_list : Lacaml_float32.num_type list list -> Lacaml_float32.mat

of_list ls

returns
a matrix initialized from the list of lists ls. Each sublist of ls represents a row of the desired matrix, and must be of the same length.

val to_list : Lacaml_float32.mat -> Lacaml_float32.num_type list list

to_array mat

returns
mat in row major order as lists.

val of_col_vecs : Lacaml_float32.vec array -> Lacaml_float32.mat

of_col_vecs ar

returns
a matrix whose columns are initialized from the array of vectors ar. The vectors must be of same length.

val to_col_vecs : Lacaml_float32.mat -> Lacaml_float32.vec array

to_col_vecs mat

returns
an array of column vectors initialized from matrix mat.

val of_col_vecs_list : Lacaml_float32.vec list -> Lacaml_float32.mat

of_col_vecs_list ar

returns
a matrix whose columns are initialized from the list of vectors ar. The vectors must be of same length.

val to_col_vecs_list : Lacaml_float32.mat -> Lacaml_float32.vec list

to_col_vecs_list mat

returns
a list of column vectors initialized from matrix mat.

val as_vec : Lacaml_float32.mat -> Lacaml_float32.vec

as_vec mat

returns
a vector containing all elements of the matrix in column-major order. The data is shared.

val init_rows : 
  int ->
  int ->
  (int -> int -> Lacaml_float32.num_type) ->
  Lacaml_float32.mat

init_cols m n f

returns
a matrix containing m rows and n columns, where each element at row and col is initialized by the result of calling f row col. The elements are passed row-wise.

val init_cols : 
  int ->
  int ->
  (int -> int -> Lacaml_float32.num_type) ->
  Lacaml_float32.mat

init_cols m n f

returns
a matrix containing m rows and n columns, where each element at row and col is initialized by the result of calling f row col. The elements are passed column-wise.

val create_mvec : int -> Lacaml_float32.mat

create_mvec m

returns
a matrix with one column containing m rows.

val make_mvec : int -> Lacaml_float32.num_type -> Lacaml_float32.mat

make_mvec m x

returns
a matrix with one column containing m rows initialized with value x.

val mvec_of_array : Lacaml_float32.num_type array -> Lacaml_float32.mat

mvec_of_array ar

returns
a matrix with one column initialized with values from array ar.

val mvec_to_array : Lacaml_float32.mat -> Lacaml_float32.num_type array

mvec_to_array mat

returns
an array initialized with values from the first (not necessarily only) column vector of matrix mat.

val from_col_vec : Lacaml_float32.vec -> Lacaml_float32.mat

from_col_vec v

returns
a matrix with one column representing vector v. The data is shared.

val from_row_vec : Lacaml_float32.vec -> Lacaml_float32.mat

from_row_vec v

returns
a matrix with one row representing vector v. The data is shared.

val empty : Lacaml_float32.mat

empty, the empty matrix.

val identity : int -> Lacaml_float32.mat

identity n

returns
the nxn identity matrix.

val of_diag : 
  ?n:int ->
  ?br:int ->
  ?bc:int ->
  ?b:Lacaml_float32.mat ->
  ?ofsx:int ->
  ?incx:int ->
  Lacaml_float32.vec ->
  Lacaml_float32.mat

of_diag ?n ?br ?bc ?b ?ofsx ?incx x

returns
matrix b with diagonal elements in the designated sub-matrix coming from the designated sub-vector in x.

parameter n
default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x

parameter br
default = 1

parameter bc
default = 1

parameter b
default = minimal fresh matrix consistent with n, br, and bc

parameter ofsx
default = 1

parameter incx
default = 1

val dim1 : Lacaml_float32.mat -> int

dim1 m

returns
the first dimension of matrix m (number of rows).

val dim2 : Lacaml_float32.mat -> int

dim2 m

returns
the second dimension of matrix m (number of columns).

val col : Lacaml_float32.mat -> int -> Lacaml_float32.vec

col m n

returns
the nth column of matrix m as a vector. The data is shared.

val copy_row : 
  ?vec:Lacaml_float32.vec ->
  Lacaml_float32.mat ->
  int ->
  Lacaml_float32.vec

copy_row ?vec mat int

returns
a copy of the nth row of matrix m in vector vec.

parameter vec
default = fresh vector of length dim2 mat

Matrix transformations

val swap : 
  ?uplo:[ `U | `L ] ->
  ?m:int ->
  ?n:int ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  ?br:int ->
  ?bc:int ->
  Lacaml_float32.mat ->
  unit

swap ?m ?n ?ar ?ac a ?br ?bc b swaps the contents of (sub-matrices) a and b.

parameter m
default = greater n s.t. ar + m - 1 <= dim1 a

parameter n
default = greater n s.t. ac + n - 1 <= dim2 a

parameter ar
default = 1

parameter ac
default = 1

parameter br
default = 1

parameter bc
default = 1

val transpose_copy : Lacaml_float32.Types.Mat.unop

transpose_copy ?m ?n ?br ?bc ?b ?ar ?ac a

returns
the transpose of (sub-)matrix a. If b is given, the result will be stored in there using offsets br and bc, otherwise a fresh matrix will be used. NOTE: this operations does _not_ support in-place transposes!

parameter m
default = greater n s.t. ar + m - 1 <= dim1 a

parameter n
default = greater n s.t. ac + n - 1 <= dim2 a

parameter br
default = 1

parameter bc
default = 1

parameter b
default = fresh matrix with br + m - 1 rows and bc + n - 1 columns

parameter ar
default = 1

parameter ac
default = 1

val detri : 
  ?up:bool ->
  ?n:int ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  unit

detri ?up ?n ?ar ?ac a takes a triangular (sub-)matrix a, i.e. one where only the upper (iff up is true) or lower triangle is defined, and makes it a symmetric matrix by mirroring the defined triangle along the diagonal.

parameter up
default = true

parameter n
default = Mat.dim1 a

parameter ar
default = 1

parameter ac
default = 1

val packed : 
  ?up:bool ->
  ?n:int ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  Lacaml_float32.vec

packed ?up ?n ?ar ?ac a

returns
(sub-)matrix a in packed storage format.

parameter up
default = true

parameter n
default = Mat.dim2 a

parameter ar
default = 1

parameter ac
default = 1

val unpacked : ?up:bool -> ?n:int -> Lacaml_float32.vec -> Lacaml_float32.mat

unpacked ?up x

returns
an upper or lower (depending on up) triangular matrix from packed representation vec. The other triangle of the matrix will be filled with zeros.

parameter up
default = true

parameter n
default = Vec.dim x

Operations on one matrix

val fill : 
  ?m:int ->
  ?n:int ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  Lacaml_float32.num_type ->
  unit

fill ?m ?n ?ar ?ac a x fills the specified sub-matrix in a with value x.

val sum : 
  ?m:int ->
  ?n:int ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  Lacaml_float32.num_type

sum ?m ?n ?ar ?ac a computes the sum of all elements in the m-by-n submatrix starting at row ar and column ac.

val add_const : 
  Lacaml_float32.num_type ->
  ?m:int ->
  ?n:int ->
  ?br:int ->
  ?bc:int ->
  ?b:Lacaml_float32.mat ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  Lacaml_float32.mat

add_const c ?m ?n ?br ?bc ?b ?ar ?ac a adds constant c to the designated m by n submatrix in a and stores the result in the designated submatrix in b.

parameter m
default = Mat.dim1 a

parameter n
default = Mat.dim2 a

parameter ar
default = 1

parameter ac
default = 1

parameter br
default = 1

parameter bc
default = 1

parameter b
default = fresh matrix of size m by n

val neg : 
  ?m:int ->
  ?n:int ->
  ?br:int ->
  ?bc:int ->
  ?b:Lacaml_float32.mat ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  Lacaml_float32.mat

neg ?m ?n ?br ?bc ?b ?ar ?ac a computes the negative of the elements in the m by n (sub-)matrix of the matrix a starting in row ar and column ac. If b is given, the result will be stored in there using offsets br and bc, otherwise a fresh matrix will be used. The resulting matrix is returned.

parameter m
default = greater n s.t. ar + m - 1 <= dim1 a

parameter n
default = greater n s.t. ac + n - 1 <= dim2 a

parameter br
default = 1

parameter bc
default = 1

parameter b
default = fresh matrix with br + m - 1 rows and bc + n - 1 columns

parameter ar
default = 1

parameter ac
default = 1

val reci : 
  ?m:int ->
  ?n:int ->
  ?br:int ->
  ?bc:int ->
  ?b:Lacaml_float32.mat ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  Lacaml_float32.mat

reci ?m ?n ?br ?bc ?b ?ar ?ac a computes the reciprocal of the elements in the m by n (sub-)matrix of the matrix a starting in row ar and column ac. If b is given, the result will be stored in there using offsets br and bc, otherwise a fresh matrix will be used. The resulting matrix is returned.

parameter m
default = greater n s.t. ar + m - 1 <= dim1 a

parameter n
default = greater n s.t. ac + n - 1 <= dim2 a

parameter br
default = 1

parameter bc
default = 1

parameter b
default = fresh matrix with br + m - 1 rows and bc + n - 1 columns

parameter ar
default = 1

parameter ac
default = 1

val copy_diag : 
  ?n:int ->
  ?ofsy:int ->
  ?incy:int ->
  ?y:Lacaml_float32.vec ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  Lacaml_float32.vec

copy_diag ?n ?ofsy ?incy ?y ?ar ?ac a

returns
the diagonal of the (sub-)matrix a in a (sub-)vector.

parameter n
default = greatest n that does not exceed matrix dimensions

parameter ofsy
default = 1

parameter incy
default = 1

parameter y
default = fresh vector of length n

parameter ar
default = 1

parameter ac
default = 1

val trace : Lacaml_float32.mat -> Lacaml_float32.num_type

trace m

returns
the trace of matrix m. If m is not a square matrix, the sum of the longest possible sequence of diagonal elements will be returned.

val scal : 
  ?m:int ->
  ?n:int ->
  Lacaml_float32.num_type ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  unit

scal ?m ?n alpha ?ar ?ac a BLAS scal function for (sub-)matrices.

val scal_cols : 
  ?m:int ->
  ?n:int ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  ?ofs:int ->
  Lacaml_float32.vec ->
  unit

scal_cols ?m ?n ?ar ?ac a ?ofs alphas column-wise scal function for matrices.

val scal_rows : 
  ?m:int ->
  ?n:int ->
  ?ofs:int ->
  Lacaml_float32.vec ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  unit

scal_rows ?m ?n ?ofs alphas ?ar ?ac a row-wise scal function for matrices.

val syrk_trace : 
  ?n:int ->
  ?k:int ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  Lacaml_float32.num_type

syrk_trace ?n ?k ?ar ?ac a computes the trace of either a' * a or a * a', whichever is more efficient (results are identical), of the (sub-)matrix a multiplied by its own transpose. This is the same as the square of the Frobenius norm of a matrix. n is the number of rows to consider in a, and k the number of columns to consider.

parameter n
default = number of rows of a

parameter k
default = number of columns of a

parameter ar
default = 1

parameter ac
default = 1

val syrk_diag : 
  ?n:int ->
  ?k:int ->
  ?beta:Lacaml_float32.num_type ->
  ?ofsy:int ->
  ?y:Lacaml_float32.vec ->
  ?trans:Lacaml_common.trans2 ->
  ?alpha:Lacaml_float32.num_type ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  Lacaml_float32.vec

syrk_diag ?n ?k ?beta ?ofsy ?y ?trans ?alpha ?ar ?ac a computes the diagonal of the symmetric rank-k product of the (sub-)matrix a, multiplying it with alpha and adding beta times y, storing the result in y starting at the specified offset. n elements of the diagonal will be computed, and k elements of the matrix will be part of the dot product associated with each diagonal element.

parameter n
default = number of rows of a (or tra)

parameter k
default = number of columns of a (or tra)

parameter beta
default = 0

parameter ofsy
default = 1

parameter y
default = fresh vector of size n + ofsy - 1

parameter trans
default = `N

parameter alpha
default = 1

parameter ar
default = 1

parameter ac
default = 1

Operations on two matrices

val add : 
  ?m:int ->
  ?n:int ->
  ?cr:int ->
  ?cc:int ->
  ?c:Lacaml_float32.mat ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  ?br:int ->
  ?bc:int ->
  Lacaml_float32.mat ->
  Lacaml_float32.mat

add ?m ?n ?cr ?cc ?c ?ar ?ac a ?br ?bc b computes the sum of the m by n sub-matrix of the matrix a starting in row ar and column ac with the corresponding sub-matrix of the matrix b starting in row br and column bc. If c is given, the result will be stored in there starting in row cr and column cc, otherwise a fresh matrix will be used. The resulting matrix is returned.

parameter m
default = greater n s.t. ar + m - 1 <= dim1 a

parameter n
default = greater n s.t. ac + n - 1 <= dim2 a

parameter cr
default = 1

parameter cc
default = 1

parameter c
default = fresh matrix with cr + m - 1 rows and cc + n - 1 columns

parameter br
default = 1

parameter bc
default = 1

parameter ar
default = 1

parameter ac
default = 1

val sub : 
  ?m:int ->
  ?n:int ->
  ?cr:int ->
  ?cc:int ->
  ?c:Lacaml_float32.mat ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  ?br:int ->
  ?bc:int ->
  Lacaml_float32.mat ->
  Lacaml_float32.mat

sub ?m ?n ?cr ?cc ?c ?ar ?ac a ?br ?bc b computes the difference of the m by n sub-matrix of the matrix a starting in row ar and column ac with the corresponding sub-matrix of the matrix b starting in row br and column bc. If c is given, the result will be stored in there starting in row cr and column cc, otherwise a fresh matrix will be used. The resulting matrix is returned.

parameter m
default = greater n s.t. ar + m - 1 <= dim1 a

parameter n
default = greater n s.t. ac + n - 1 <= dim2 a

parameter cr
default = 1

parameter cc
default = 1

parameter c
default = fresh matrix with cr + m - 1 rows and cc + n - 1 columns

parameter br
default = 1

parameter bc
default = 1

parameter ar
default = 1

parameter ac
default = 1

val mul : 
  ?m:int ->
  ?n:int ->
  ?cr:int ->
  ?cc:int ->
  ?c:Lacaml_float32.mat ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  ?br:int ->
  ?bc:int ->
  Lacaml_float32.mat ->
  Lacaml_float32.mat

mul ?m ?n ?cr ?cc ?c ?ar ?ac a ?br ?bc b computes the product of the m by n sub-matrix of the matrix a starting in row ar and column ac with the corresponding sub-matrix of the matrix b starting in row br and column bc. If c is given, the result will be stored in there starting in row cr and column cc, otherwise a fresh matrix will be used. The resulting matrix is returned.

parameter m
default = greater n s.t. ar + m - 1 <= dim1 a

parameter n
default = greater n s.t. ac + n - 1 <= dim2 a

parameter cr
default = 1

parameter cc
default = 1

parameter c
default = fresh matrix with cr + m - 1 rows and cc + n - 1 columns

parameter br
default = 1

parameter bc
default = 1

parameter ar
default = 1

parameter ac
default = 1

val div : 
  ?m:int ->
  ?n:int ->
  ?cr:int ->
  ?cc:int ->
  ?c:Lacaml_float32.mat ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  ?br:int ->
  ?bc:int ->
  Lacaml_float32.mat ->
  Lacaml_float32.mat

div ?m ?n ?cr ?cc ?c ?ar ?ac a ?br ?bc b computes the division of the m by n sub-matrix of the matrix a starting in row ar and column ac with the corresponding sub-matrix of the matrix b starting in row br and column bc. If c is given, the result will be stored in there starting in row cr and column cc, otherwise a fresh matrix will be used. The resulting matrix is returned.

parameter m
default = greater n s.t. ar + m - 1 <= dim1 a

parameter n
default = greater n s.t. ac + n - 1 <= dim2 a

parameter cr
default = 1

parameter cc
default = 1

parameter c
default = fresh matrix with cr + m - 1 rows and cc + n - 1 columns

parameter br
default = 1

parameter bc
default = 1

parameter ar
default = 1

parameter ac
default = 1

val axpy : 
  ?alpha:Lacaml_float32.num_type ->
  ?m:int ->
  ?n:int ->
  ?xr:int ->
  ?xc:int ->
  Lacaml_float32.mat ->
  ?yr:int ->
  ?yc:int ->
  Lacaml_float32.mat ->
  unit

axpy ?alpha ?m ?n ?xr ?xc x ?yr ?yc y BLAS axpy function for matrices.

val gemm_diag : 
  ?n:int ->
  ?k:int ->
  ?beta:Lacaml_float32.num_type ->
  ?ofsy:int ->
  ?y:Lacaml_float32.vec ->
  ?transa:Lacaml_float32.trans3 ->
  ?alpha:Lacaml_float32.num_type ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  ?transb:Lacaml_float32.trans3 ->
  ?br:int ->
  ?bc:int ->
  Lacaml_float32.mat ->
  Lacaml_float32.vec

gemm_diag ?n ?k ?beta ?ofsy ?y ?transa ?transb ?alpha ?ar ?ac a ?br ?bc b computes the diagonal of the product of the (sub-)matrices a and b (taking into account potential transposing), multiplying it with alpha and adding beta times y, storing the result in y starting at the specified offset. n elements of the diagonal will be computed, and k elements of the matrices will be part of the dot product associated with each diagonal element.

parameter n
default = number of rows of a (or tr a) and number of columns of b (or tr b)

parameter k
default = number of columns of a (or tr a) and number of rows of b (or tr b)

parameter beta
default = 0

parameter ofsy
default = 1

parameter y
default = fresh vector of size n + ofsy - 1

parameter transa
default = `N

parameter alpha
default = 1

parameter ar
default = 1

parameter ac
default = 1

parameter transb
default = `N

parameter br
default = 1

parameter bc
default = 1

val gemm_trace : 
  ?n:int ->
  ?k:int ->
  ?transa:Lacaml_float32.trans3 ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  ?transb:Lacaml_float32.trans3 ->
  ?br:int ->
  ?bc:int ->
  Lacaml_float32.mat ->
  Lacaml_float32.num_type

gemm_trace ?n ?k ?transa ?ar ?ac a ?transb ?br ?bc b computes the trace of the product of the (sub-)matrices a and b (taking into account potential transposing). This is also sometimes referred to as the Frobenius product. n is the number of rows (columns) to consider in a, and k the number of columns (rows) in b.

parameter n
default = number of rows of a (or tr a) and number of columns of b (or tr b)

parameter k
default = number of columns of a (or tr a) and number of rows of b (or tr b)

parameter transa
default = `N

parameter ar
default = 1

parameter ac
default = 1

parameter transb
default = `N

parameter br
default = 1

parameter bc
default = 1

val symm2_trace : 
  ?n:int ->
  ?upa:bool ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  ?upb:bool ->
  ?br:int ->
  ?bc:int ->
  Lacaml_float32.mat ->
  Lacaml_float32.num_type

symm2_trace ?n ?upa ?ar ?ac a ?upb ?br ?bc b computes the trace of the product of the symmetric (sub-)matrices a and b. n is the number of rows and columns to consider in a and b.

parameter n
default = dimensions of a and b

parameter upa
default = true (upper triangular portion of a is accessed)

parameter ar
default = 1

parameter ac
default = 1

parameter upb
default = true (upper triangular portion of b is accessed)

parameter br
default = 1

parameter bc
default = 1

val ssqr_diff : 
  ?m:int ->
  ?n:int ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  ?br:int ->
  ?bc:int ->
  Lacaml_float32.mat ->
  Lacaml_float32.num_type

ssqr_diff ?m ?n ?ar ?ac a ?br ?bc b

returns
the sum of squared differences between the m by n sub-matrix of the matrix a starting in row ar and column ac with the corresponding sub-matrix of the matrix b starting in row br and column bc.

parameter m
default = greater n s.t. ar + m - 1 <= dim1 a

parameter n
default = greater n s.t. ac + n - 1 <= dim2 a

parameter ar
default = 1

parameter ac
default = 1

parameter br
default = 1

parameter bc
default = 1

Iterators over matrices

val map : 
  (Lacaml_float32.num_type -> Lacaml_float32.num_type) ->
  ?m:int ->
  ?n:int ->
  ?br:int ->
  ?bc:int ->
  ?b:Lacaml_float32.mat ->
  ?ar:int ->
  ?ac:int ->
  Lacaml_float32.mat ->
  Lacaml_float32.mat

map f ?m ?n ?br ?bc ?b ?ar ?ac a

returns
matrix with f applied to each element of a.

parameter m
default = number of rows of a

parameter n
default = number of columns of a

parameter b
default = fresh matrix of size m by n

val fold_cols : 
  ('a -> Lacaml_float32.vec -> 'a) ->
  ?n:int ->
  ?ac:int ->
  'a ->
  Lacaml_float32.mat ->
  'a

fold_cols f ?n ?ac acc a

returns
accumulator resulting from folding over each column vector.

parameter ac
default = 1

parameter n
default = number of columns of a

package lacaml

Module Lacaml_S.Mat

Matrix operations

Creation of matrices

Unary matrix operations

Ternary matrix operations

Creation of matrices and accessors

Matrix transformations

Operations on one matrix

Operations on two matrices

Iterators over matrices

Module `Lacaml_S.Mat`