module Mat:sig
..end
val random : ?rnd_state:Stdlib.Random.State.t ->
?re_from:float ->
?re_range:float ->
?im_from:float -> ?im_range:float -> int -> int -> Lacaml_complex32.mat
random ?rnd_state ?re_from ?re_range ?im_from ?im_range m n
m
xn
matrix initialized with random elements sampled
uniformly from re_range
and im_range
starting at re_from
and
im_from
for real and imaginary numbers respectively. A random state
rnd_state
can be passed.rnd_state
: default = Random.get_state ()re_from
: default = -1.0re_range
: default = 2.0im_from
: default = -1.0im_range
: default = 2.0val create : int -> int -> Lacaml_complex32.mat
create m n
m
rows and n
columns.val make : int -> int -> Lacaml_complex32.num_type -> Lacaml_complex32.mat
make m n x
m
rows and n
columns
initialized with value x
.val make0 : int -> int -> Lacaml_complex32.mat
make0 m n x
m
rows and n
columns
initialized with the zero element.val of_array : Lacaml_complex32.num_type array array -> Lacaml_complex32.mat
of_array ar
ar
. It is assumed that the OCaml matrix is in row major order
(standard).val to_array : Lacaml_complex32.mat -> Lacaml_complex32.num_type array array
to_array mat
mat
.val of_col_vecs : Lacaml_complex32.vec array -> Lacaml_complex32.mat
of_col_vecs ar
ar
. The vectors must be of same length.val to_col_vecs : Lacaml_complex32.mat -> Lacaml_complex32.vec array
to_col_vecs mat
mat
.val as_vec : Lacaml_complex32.mat -> Lacaml_complex32.vec
as_vec mat
val init_rows : int ->
int -> (int -> int -> Lacaml_complex32.num_type) -> Lacaml_complex32.mat
init_cols m n f
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_complex32.num_type) -> Lacaml_complex32.mat
init_cols m n f
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_complex32.mat
create_mvec m
m
rows.val make_mvec : int -> Lacaml_complex32.num_type -> Lacaml_complex32.mat
make_mvec m x
m
rows
initialized with value x
.val mvec_of_array : Lacaml_complex32.num_type array -> Lacaml_complex32.mat
mvec_of_array ar
ar
.val mvec_to_array : Lacaml_complex32.mat -> Lacaml_complex32.num_type array
mvec_to_array mat
mat
.val from_col_vec : Lacaml_complex32.vec -> Lacaml_complex32.mat
from_col_vec v
v
.
The data is shared.val from_row_vec : Lacaml_complex32.vec -> Lacaml_complex32.mat
from_row_vec v
v
.
The data is shared.val empty : Lacaml_complex32.mat
empty
, the empty matrix.
val identity : int -> Lacaml_complex32.mat
identity n
n
xn
identity matrix.val of_diag : Lacaml_complex32.vec -> Lacaml_complex32.mat
of_diag v
v
.val dim1 : Lacaml_complex32.mat -> int
dim1 m
m
(number of rows).val dim2 : Lacaml_complex32.mat -> int
dim2 m
m
(number of columns).val col : Lacaml_complex32.mat -> int -> Lacaml_complex32.vec
col m n
n
th column of matrix m
as a vector.
The data is shared.val copy_row : ?vec:Lacaml_complex32.vec ->
Lacaml_complex32.mat -> int -> Lacaml_complex32.vec
copy_row ?vec mat int
n
th row of matrix m
in vector vec
.vec
: default = fresh vector of length dim2 mat
val transpose_copy : ?m:int ->
?n:int ->
?ar:int ->
?ac:int ->
Lacaml_complex32.mat -> ?br:int -> ?bc:int -> Lacaml_complex32.mat -> unit
transpose_copy ?m ?n ?ar ?ac a ?br ?bc b
copy the transpose
of (sub-)matrix a
into (sub-)matrix b
.
m
: default = Mat.dim1 a
n
: default = Mat.dim2 a
ar
: default = 1
ac
: default = 1
br
: default = 1
bc
: default = 1
val transpose : ?m:int ->
?n:int -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> Lacaml_complex32.mat
transpose ?m ?n ?ar ?ac aa
a
.m
: default = Mat.dim1 a
n
: default = Mat.dim2 a
ar
: default = 1
ac
: default = 1
val detri : ?up:bool -> ?n:int -> ?ar:int -> ?ac:int -> Lacaml_complex32.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.
up
: default = true
n
: default = Mat.dim1 a
ar
: default = 1
ac
: default = 1
val packed : ?up:bool ->
?n:int -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> Lacaml_complex32.vec
packed ?up ?n ?ar ?ac a
a
in packed
storage format.up
: default = true
n
: default = Mat.dim2 a
ar
: default = 1
ac
: default = 1
val unpacked : ?up:bool -> ?n:int -> Lacaml_complex32.vec -> Lacaml_complex32.mat
unpacked ?up x
up
)
triangular matrix from packed representation vec
. The other
triangle of the matrix will be filled with zeros.up
: default = true
n
: default = Vec.dim x
val add_const : Lacaml_complex32.num_type ->
?m:int ->
?n:int ->
?br:int ->
?bc:int ->
?b:Lacaml_complex32.mat ->
?ar:int -> ?ac:int -> Lacaml_complex32.mat -> Lacaml_complex32.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
.
m
: default = Mat.dim1 a
n
: default = Mat.dim2 a
br
: default = 1
bc
: default = 1
b
: default = fresh matrix of size m
by n
ar
: default = 1
ac
: default = 1
val sum : ?m:int ->
?n:int ->
?ar:int -> ?ac:int -> Lacaml_complex32.mat -> Lacaml_complex32.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 fill : ?m:int ->
?n:int ->
?ar:int ->
?ac:int -> Lacaml_complex32.mat -> Lacaml_complex32.num_type -> unit
fill ?m ?n ?ar ?ac a x
fills the specified sub-matrix in a
with value
x
.
val copy_diag : Lacaml_complex32.mat -> Lacaml_complex32.vec
copy_diag m
m
as a vector.
If m
is not a square matrix, the longest possible sequence
of diagonal elements will be returned.val trace : Lacaml_complex32.mat -> Lacaml_complex32.num_type
trace m
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_complex32.num_type ->
?ar:int -> ?ac:int -> Lacaml_complex32.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_complex32.mat -> ?ofs:int -> Lacaml_complex32.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_complex32.vec -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> unit
scal_rows ?m ?n ?ofs alphas ?ar ?ac a
row-wise scal
function for matrices.
val axpy : ?alpha:Lacaml_complex32.num_type ->
?m:int ->
?n:int ->
?xr:int ->
?xc:int ->
Lacaml_complex32.mat -> ?yr:int -> ?yc:int -> Lacaml_complex32.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_complex32.num_type ->
?ofsy:int ->
?y:Lacaml_complex32.vec ->
?transa:Lacaml_complex32.trans3 ->
?alpha:Lacaml_complex32.num_type ->
?ar:int ->
?ac:int ->
Lacaml_complex32.mat ->
?transb:Lacaml_complex32.trans3 ->
?br:int -> ?bc:int -> Lacaml_complex32.mat -> Lacaml_complex32.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.
n
: default = number of rows of a
(or tr a
) and
number of columns of b
(or tr b
)k
: default = number of columns of a
(or tr a
) and
number of rows of b
(or tr b
)beta
: default = 0
ofsy
: default = 1
y
: default = fresh vector of size n + ofsy - 1
transa
: default = `N
alpha
: default = 1
ar
: default = 1
ac
: default = 1
transb
: default = `N
br
: default = 1
bc
: default = 1
val syrk_diag : ?n:int ->
?k:int ->
?beta:Lacaml_complex32.num_type ->
?ofsy:int ->
?y:Lacaml_complex32.vec ->
?trans:Lacaml_common.trans2 ->
?alpha:Lacaml_complex32.num_type ->
?ar:int -> ?ac:int -> Lacaml_complex32.mat -> Lacaml_complex32.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.
n
: default = number of rows of a
(or tra
)k
: default = number of columns of a
(or tra
)beta
: default = 0
ofsy
: default = 1
y
: default = fresh vector of size n + ofsy - 1
trans
: default = `N
alpha
: default = 1
ar
: default = 1
ac
: default = 1
val gemm_trace : ?n:int ->
?k:int ->
?transa:Lacaml_complex32.trans3 ->
?ar:int ->
?ac:int ->
Lacaml_complex32.mat ->
?transb:Lacaml_complex32.trans3 ->
?br:int -> ?bc:int -> Lacaml_complex32.mat -> Lacaml_complex32.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
.
n
: default = number of rows of a
(or tr a
) and
number of columns of b
(or tr b
)k
: default = number of columns of a
(or tr a
) and
number of rows of b
(or tr b
)transa
: default = `N
ar
: default = 1
ac
: default = 1
transb
: default = `N
br
: default = 1
bc
: default = 1
val syrk_trace : ?n:int ->
?k:int ->
?ar:int -> ?ac:int -> Lacaml_complex32.mat -> Lacaml_complex32.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.
n
: default = number of rows of a
k
: default = number of columns of a
ar
: default = 1
ac
: default = 1
val symm2_trace : ?n:int ->
?upa:bool ->
?ar:int ->
?ac:int ->
Lacaml_complex32.mat ->
?upb:bool ->
?br:int -> ?bc:int -> Lacaml_complex32.mat -> Lacaml_complex32.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
.
n
: default = dimensions of a
and b
upa
: default = true (upper triangular portion of a
is accessed)ar
: default = 1
ac
: default = 1
upb
: default = true (upper triangular portion of b
is accessed)br
: default = 1
bc
: default = 1
val map : (Lacaml_complex32.num_type -> Lacaml_complex32.num_type) ->
?m:int ->
?n:int ->
?br:int ->
?bc:int ->
?b:Lacaml_complex32.mat ->
?ar:int -> ?ac:int -> Lacaml_complex32.mat -> Lacaml_complex32.mat
map f ?m ?n ?br ?bc ?b ?ar ?ac a
f
applied to each element of a
.m
: default = number of rows of a
n
: default = number of columns of a
b
: default = fresh matrix of size m by nval fold_cols : ('a -> Lacaml_complex32.vec -> 'a) ->
?n:int -> ?ac:int -> 'a -> Lacaml_complex32.mat -> 'a
fold_cols f ?n ?ac acc a
n
: default = number of columns of a
ac
: default = 1