Module Lacaml.Z

module Z: Lacaml_Z

Double precision complex BLAS and LAPACK functions.


type prec = Bigarray.complex64_elt 
type num_type = Stdlib.Complex.t 
type vec = (Stdlib.Complex.t, Bigarray.complex64_elt, Bigarray.fortran_layout)
Bigarray.Array1.t

Complex vectors (precision: complex64).

type rvec = (float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Array1.t 

Vectors of reals (precision: float64).

type mat = (Stdlib.Complex.t, Bigarray.complex64_elt, Bigarray.fortran_layout)
Bigarray.Array2.t

Complex matrices (precision: complex64).

type trans3 = [ `C | `N | `T ] 

Transpose parameter (conjugate transposed, normal, or transposed).

val prec : (Stdlib.Complex.t, Bigarray.complex64_elt) Bigarray.kind

Precision for this submodule Z. Allows to write precision independent code.

module Vec: sig .. end
module Mat: sig .. end
val pp_num : Stdlib.Format.formatter -> Stdlib.Complex.t -> unit

pp_num ppf el is equivalent to fprintf ppf "(%G, %Gi)" el.re el.im.

val pp_vec : (Stdlib.Complex.t, 'a) Lacaml_io.pp_vec

Pretty-printer for column vectors.

val pp_mat : (Stdlib.Complex.t, 'a) Lacaml_io.pp_mat

Pretty-printer for matrices.

BLAS-1 interface
val dotu : ?n:int ->
?ofsx:int ->
?incx:int ->
Lacaml_complex64.vec ->
?ofsy:int -> ?incy:int -> Lacaml_complex64.vec -> Lacaml_complex64.num_type

dotu ?n ?ofsx ?incx x ?ofsy ?incy y see BLAS documentation!

n : default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsx : default = 1
incx : default = 1
ofsy : default = 1
incy : default = 1
val dotc : ?n:int ->
?ofsx:int ->
?incx:int ->
Lacaml_complex64.vec ->
?ofsy:int -> ?incy:int -> Lacaml_complex64.vec -> Lacaml_complex64.num_type

dotc ?n ?ofsx ?incx x ?ofsy ?incy y see BLAS documentation!

n : default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsx : default = 1
incx : default = 1
ofsy : default = 1
incy : default = 1
LAPACK interface
val lansy_min_lwork : int -> Lacaml_common.norm4 -> int

lansy_min_lwork m norm

val lansy : ?n:int ->
?up:bool ->
?norm:Lacaml_common.norm4 ->
?work:Lacaml_complex64.rvec ->
?ar:int -> ?ac:int -> Lacaml_complex64.mat -> float

lansy ?n ?up ?norm ?work ?ar ?ac a see LAPACK documentation!

n : default = number of columns of matrix a
up : default = true (reference upper triangular part of a)
norm : default = `O
work : default = allocated work space for norm `I
val gecon_min_lwork : int -> int

gecon_min_lwork n

val gecon_min_lrwork : int -> int

gecon_min_lrwork n

val gecon : ?n:int ->
?norm:Lacaml_common.norm2 ->
?anorm:float ->
?work:Lacaml_complex64.vec ->
?rwork:Lacaml_complex64.rvec ->
?ar:int -> ?ac:int -> Lacaml_complex64.mat -> float

gecon ?n ?norm ?anorm ?work ?rwork ?ar ?ac a

n : default = available number of columns of matrix a
norm : default = 1-norm
anorm : default = norm of the matrix a as returned by lange
work : default = automatically allocated workspace
rwork : default = automatically allocated workspace
ar : default = 1
ac : default = 1
val sycon_min_lwork : int -> int

sycon_min_lwork n

val sycon : ?n:int ->
?up:bool ->
?ipiv:Lacaml_common.int32_vec ->
?anorm:float ->
?work:Lacaml_complex64.vec ->
?ar:int -> ?ac:int -> Lacaml_complex64.mat -> float

sycon ?n ?up ?ipiv ?anorm ?work ?ar ?ac a

n : default = available number of columns of matrix a
up : default = upper triangle of the factorization of a is stored
ipiv : default = vec of length n
anorm : default = 1-norm of the matrix a as returned by lange
work : default = automatically allocated workspace
val pocon_min_lwork : int -> int

pocon_min_lwork n

val pocon_min_lrwork : int -> int

pocon_min_lrwork n

val pocon : ?n:int ->
?up:bool ->
?anorm:float ->
?work:Lacaml_complex64.vec ->
?rwork:Lacaml_complex64.rvec ->
?ar:int -> ?ac:int -> Lacaml_complex64.mat -> float

pocon ?n ?up ?anorm ?work ?rwork ?ar ?ac a

n : default = available number of columns of matrix a
up : default = upper triangle of Cholesky factorization of a is stored
anorm : default = 1-norm of the matrix a as returned by lange
work : default = automatically allocated workspace
rwork : default = automatically allocated workspace
General Schur factorization
val gees : ?n:int ->
?jobvs:Lacaml_common.schur_vectors ->
?sort:Lacaml_common.eigen_value_sort ->
?w:Lacaml_complex64.vec ->
?vsr:int ->
?vsc:int ->
?vs:Lacaml_complex64.mat ->
?work:Lacaml_complex64.vec ->
?ar:int ->
?ac:int ->
Lacaml_complex64.mat -> int * Lacaml_complex64.vec * Lacaml_complex64.mat

gees ?n ?jobvs ?sort ?w ?vsr ?vsc ?vs ?work ?ar ?ac a See gees-function for details about arguments.

General SVD routines
val gesvd_min_lwork : m:int -> n:int -> int

gesvd_min_lwork ~m ~n

val gesvd_lrwork : m:int -> n:int -> int

gesvd_lrwork m n

val gesvd_opt_lwork : ?m:int ->
?n:int ->
?jobu:Lacaml_common.svd_job ->
?jobvt:Lacaml_common.svd_job ->
?s:Lacaml_complex64.rvec ->
?ur:int ->
?uc:int ->
?u:Lacaml_complex64.mat ->
?vtr:int ->
?vtc:int ->
?vt:Lacaml_complex64.mat -> ?ar:int -> ?ac:int -> Lacaml_complex64.mat -> int
val gesvd : ?m:int ->
?n:int ->
?jobu:Lacaml_common.svd_job ->
?jobvt:Lacaml_common.svd_job ->
?s:Lacaml_complex64.rvec ->
?ur:int ->
?uc:int ->
?u:Lacaml_complex64.mat ->
?vtr:int ->
?vtc:int ->
?vt:Lacaml_complex64.mat ->
?work:Lacaml_complex64.vec ->
?rwork:Lacaml_complex64.rvec ->
?ar:int ->
?ac:int ->
Lacaml_complex64.mat ->
Lacaml_complex64.rvec * Lacaml_complex64.mat * Lacaml_complex64.mat
General eigenvalue problem (simple drivers)
val geev_min_lwork : int -> int

geev_min_lwork n

val geev_min_lrwork : int -> int

geev_min_lrwork n

val geev_opt_lwork : ?n:int ->
?vlr:int ->
?vlc:int ->
?vl:Lacaml_complex64.mat option ->
?vrr:int ->
?vrc:int ->
?vr:Lacaml_complex64.mat option ->
?ofsw:int ->
?w:Lacaml_complex64.vec -> ?ar:int -> ?ac:int -> Lacaml_complex64.mat -> int

geev ?work ?rwork ?n ?vlr ?vlc ?vl ?vrr ?vrc ?vr ?ofsw w ?ar ?ac a See geev-function for details about arguments.

val geev : ?n:int ->
?work:Lacaml_complex64.vec ->
?rwork:Lacaml_complex64.vec ->
?vlr:int ->
?vlc:int ->
?vl:Lacaml_complex64.mat option ->
?vrr:int ->
?vrc:int ->
?vr:Lacaml_complex64.mat option ->
?ofsw:int ->
?w:Lacaml_complex64.vec ->
?ar:int ->
?ac:int ->
Lacaml_complex64.mat ->
Lacaml_complex64.mat * Lacaml_complex64.vec * Lacaml_complex64.mat

geev ?work ?rwork ?n ?vlr ?vlc ?vl ?vrr ?vrc ?vr ?ofsw w ?ar ?ac a

n : default = available number of columns of matrix a
work : default = automatically allocated workspace
rwork : default = automatically allocated workspace
vl : default = Automatically allocated left eigenvectors. Pass None if you do not want to compute them, Some lv if you want to provide the storage. You can set vlr, vlc in the last case. (See LAPACK GEEV docs for details about storage of complex eigenvectors)
vr : default = Automatically allocated right eigenvectors. Pass None if you do not want to compute them, Some rv if you want to provide the storage. You can set vrr, vrc in the last case.
w : default = automatically allocate eigenvalues
BLAS-1 interface
val swap : ?n:int ->
?ofsx:int ->
?incx:int ->
x:Lacaml_complex64.vec ->
?ofsy:int -> ?incy:int -> Lacaml_complex64.vec -> unit

swap ?n ?ofsx ?incx ~x ?ofsy ?incy y see BLAS documentation!

n : default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsx : default = 1
incx : default = 1
ofsy : default = 1
incy : default = 1
val scal : ?n:int ->
Lacaml_complex64.num_type ->
?ofsx:int -> ?incx:int -> Lacaml_complex64.vec -> unit

scal ?n alpha ?ofsx ?incx x see BLAS documentation!

n : default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsx : default = 1
incx : default = 1
val copy : ?n:int ->
?ofsy:int ->
?incy:int ->
?y:Lacaml_complex64.vec ->
?ofsx:int -> ?incx:int -> Lacaml_complex64.vec -> Lacaml_complex64.vec

copy ?n ?ofsy ?incy ?y ?ofsx ?incx x see BLAS documentation!

n : default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsy : default = 1
incy : default = 1
y : default = new vector with ofsy+(n-1)(abs incy) rows
ofsx : default = 1
incx : default = 1
val nrm2 : ?n:int -> ?ofsx:int -> ?incx:int -> Lacaml_complex64.vec -> float

nrm2 ?n ?ofsx ?incx x see BLAS documentation!

n : default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsx : default = 1
incx : default = 1
val axpy : ?alpha:Lacaml_complex64.num_type ->
?n:int ->
?ofsx:int ->
?incx:int ->
Lacaml_complex64.vec ->
?ofsy:int -> ?incy:int -> Lacaml_complex64.vec -> unit

axpy ?alpha ?n ?ofsx ?incx x ?ofsy ?incy y see BLAS documentation!

alpha : default = { re = 1.; im = 0. }
n : default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsx : default = 1
incx : default = 1
ofsy : default = 1
incy : default = 1
val iamax : ?n:int -> ?ofsx:int -> ?incx:int -> Lacaml_complex64.vec -> int

iamax ?n ?ofsx ?incx x see BLAS documentation!

n : default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsx : default = 1
incx : default = 1
val amax : ?n:int ->
?ofsx:int -> ?incx:int -> Lacaml_complex64.vec -> Lacaml_complex64.num_type

amax ?n ?ofsx ?incx x

n : default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsx : default = 1
incx : default = 1
BLAS-2 interface
val gemv : ?m:int ->
?n:int ->
?beta:Lacaml_complex64.num_type ->
?ofsy:int ->
?incy:int ->
?y:Lacaml_complex64.vec ->
?trans:Lacaml_complex64.trans3 ->
?alpha:Lacaml_complex64.num_type ->
?ar:int ->
?ac:int ->
Lacaml_complex64.mat ->
?ofsx:int -> ?incx:int -> Lacaml_complex64.vec -> Lacaml_complex64.vec

gemv ?m ?n ?beta ?ofsy ?incy ?y ?trans ?alpha ?ar ?ac a ?ofsx ?incx x see BLAS documentation! BEWARE that the 1988 BLAS-2 specification mandates that this function has no effect when n=0 while the mathematically expected behabior is y ← beta * y.

m : default = number of available rows in matrix a
n : default = available columns in matrix a
beta : default = { re = 0.; im = 0. }
ofsy : default = 1
incy : default = 1
y : default = vector with minimal required length (see BLAS)
trans : default = `N
alpha : default = { re = 1.; im = 0. }
ar : default = 1
ac : default = 1
ofsx : default = 1
incx : default = 1
val gbmv : ?m:int ->
?n:int ->
?beta:Lacaml_complex64.num_type ->
?ofsy:int ->
?incy:int ->
?y:Lacaml_complex64.vec ->
?trans:Lacaml_complex64.trans3 ->
?alpha:Lacaml_complex64.num_type ->
?ar:int ->
?ac:int ->
Lacaml_complex64.mat ->
int ->
int -> ?ofsx:int -> ?incx:int -> Lacaml_complex64.vec -> Lacaml_complex64.vec

gbmv ?m ?n ?beta ?ofsy ?incy ?y ?trans ?alpha ?ar ?ac a kl ku ?ofsx ?incx x see BLAS documentation!

m : default = same as n (i.e., a is a square matrix)
n : default = available number of columns in matrix a
beta : default = { re = 0.; im = 0. }
ofsy : default = 1
incy : default = 1
y : default = vector with minimal required length (see BLAS)
trans : default = `N
alpha : default = { re = 1.; im = 0. }
ar : default = 1
ac : default = 1
ofsx : default = 1
incx : default = 1
val symv : ?n:int ->
?beta:Lacaml_complex64.num_type ->
?ofsy:int ->
?incy:int ->
?y:Lacaml_complex64.vec ->
?up:bool ->
?alpha:Lacaml_complex64.num_type ->
?ar:int ->
?ac:int ->
Lacaml_complex64.mat ->
?ofsx:int -> ?incx:int -> Lacaml_complex64.vec -> Lacaml_complex64.vec

symv ?n ?beta ?ofsy ?incy ?y ?up ?alpha ?ar ?ac a ?ofsx ?incx x see BLAS documentation!

n : default = dimension of symmetric matrix a
beta : default = { re = 0.; im = 0. }
ofsy : default = 1
incy : default = 1
y : default = vector with minimal required length (see BLAS)
up : default = true (upper triangular portion of a is accessed)
alpha : default = { re = 1.; im = 0. }
ar : default = 1
ac : default = 1
ofsx : default = 1
incx : default = 1
val trmv : ?n:int ->
?trans:Lacaml_complex64.trans3 ->
?diag:Lacaml_common.diag ->
?up:bool ->
?ar:int ->
?ac:int ->
Lacaml_complex64.mat ->
?ofsx:int -> ?incx:int -> Lacaml_complex64.vec -> unit

trmv ?n ?trans ?diag ?up ?ar ?ac a ?ofsx ?incx x see BLAS documentation!

n : default = dimension of triangular matrix a
trans : default = `N
diag : default = false (not a unit triangular matrix)
up : default = true (upper triangular portion of a is accessed)
ar : default = 1
ac : default = 1
ofsx : default = 1
incx : default = 1
val trsv : ?n:int ->
?trans:Lacaml_complex64.trans3 ->
?diag:Lacaml_common.diag ->
?up:bool ->
?ar:int ->
?ac:int ->
Lacaml_complex64.mat ->
?ofsx:int -> ?incx:int -> Lacaml_complex64.vec -> unit

trsv ?n ?trans ?diag ?up ?ar ?ac a ?ofsx ?incx x see BLAS documentation!

n : default = dimension of triangular matrix a
trans : default = `N
diag : default = false (not a unit triangular matrix)
up : default = true (upper triangular portion of a is accessed)
ar : default = 1
ac : default = 1
ofsx : default = 1
incx : default = 1
val tpmv : ?n:int ->
?trans:Lacaml_complex64.trans3 ->
?diag:Lacaml_common.diag ->
?up:bool ->
?ofsap:int ->
Lacaml_complex64.vec ->
?ofsx:int -> ?incx:int -> Lacaml_complex64.vec -> unit

tpmv ?n ?trans ?diag ?up ?ofsap ap ?ofsx ?incx x see BLAS documentation!

n : default = dimension of packed triangular matrix ap
trans : default = `N
diag : default = false (not a unit triangular matrix)
up : default = true (upper triangular portion of ap is accessed)
ofsap : default = 1
ofsx : default = 1
incx : default = 1
val tpsv : ?n:int ->
?trans:Lacaml_complex64.trans3 ->
?diag:Lacaml_common.diag ->
?up:bool ->
?ofsap:int ->
Lacaml_complex64.vec ->
?ofsx:int -> ?incx:int -> Lacaml_complex64.vec -> unit

tpsv ?n ?trans ?diag ?up ?ofsap ap ?ofsx ?incx x see BLAS documentation!

n : default = dimension of packed triangular matrix ap
trans : default = `N
diag : default = false (not a unit triangular matrix)
up : default = true (upper triangular portion of ap is accessed)
ofsap : default = 1
ofsx : default = 1
incx : default = 1
BLAS-3 interface
val gemm : ?m:int ->
?n:int ->
?k:int ->
?beta:Lacaml_complex64.num_type ->
?cr:int ->
?cc:int ->
?c:Lacaml_complex64.mat ->
?transa:Lacaml_complex64.trans3 ->
?alpha:Lacaml_complex64.num_type ->
?ar:int ->
?ac:int ->
Lacaml_complex64.mat ->
?transb:Lacaml_complex64.trans3 ->
?br:int -> ?bc:int -> Lacaml_complex64.mat -> Lacaml_complex64.mat

gemm ?m ?n ?k ?beta ?cr ?cc ?c ?transa ?alpha ?ar ?ac a ?transb ?br ?bc b see BLAS documentation!

m : default = number of rows of a (or tr a) and c
n : default = number of columns of b (or tr b) and c
k : default = number of columns of a (or tr a) and number of rows of b (or tr b)
beta : default = { re = 0.; im = 0. }
cr : default = 1
cc : default = 1
c : default = matrix with minimal required dimension
transa : default = `N
alpha : default = { re = 1.; im = 0. }
ar : default = 1
ac : default = 1
transb : default = `N
br : default = 1
bc : default = 1
val symm : ?m:int ->
?n:int ->
?side:Lacaml_common.side ->
?up:bool ->
?beta:Lacaml_complex64.num_type ->
?cr:int ->
?cc:int ->
?c:Lacaml_complex64.mat ->
?alpha:Lacaml_complex64.num_type ->
?ar:int ->
?ac:int ->
Lacaml_complex64.mat ->
?br:int -> ?bc:int -> Lacaml_complex64.mat -> Lacaml_complex64.mat

symm ?m ?n ?side ?up ?beta ?cr ?cc ?c ?alpha ?ar ?ac a ?br ?bc b see BLAS documentation!

m : default = number of rows of c
n : default = number of columns of c
side : default = `L (left - multiplication is ab)
up : default = true (upper triangular portion of a is accessed)
beta : default = { re = 0.; im = 0. }
cr : default = 1
cc : default = 1
c : default = matrix with minimal required dimension
alpha : default = { re = 1.; im = 0. }
ar : default = 1
ac : default = 1
br : default = 1
bc : default = 1
val trmm : ?m:int ->
?n:int ->
?side:Lacaml_common.side ->
?up:bool ->
?transa:Lacaml_complex64.trans3 ->
?diag:Lacaml_common.diag ->
?alpha:Lacaml_complex64.num_type ->
?ar:int ->
?ac:int ->
a:Lacaml_complex64.mat -> ?br:int -> ?bc:int -> Lacaml_complex64.mat -> unit

trmm ?m ?n ?side ?up ?transa ?diag ?alpha ?ar ?ac ~a ?br ?bc b see BLAS documentation!

m : default = number of rows of b
n : default = number of columns of b
side : default = `L (left - multiplication is ab)
up : default = true (upper triangular portion of a is accessed)
transa : default = `N
diag : default = `N (non-unit)
alpha : default = { re = 1.; im = 0. }
ar : default = 1
ac : default = 1
br : default = 1
bc : default = 1
val trsm : ?m:int ->
?n:int ->
?side:Lacaml_common.side ->
?up:bool ->
?transa:Lacaml_complex64.trans3 ->
?diag:Lacaml_common.diag ->
?alpha:Lacaml_complex64.num_type ->
?ar:int ->
?ac:int ->
a:Lacaml_complex64.mat -> ?br:int -> ?bc:int -> Lacaml_complex64.mat -> unit

trsm ?m ?n ?side ?up ?transa ?diag ?alpha ?ar ?ac ~a ?br ?bc b see BLAS documentation!

m : default = number of rows of b
n : default = number of columns of b
side : default = `L (left - multiplication is ab)
up : default = true (upper triangular portion of a is accessed)
transa : default = `N
diag : default = `N (non-unit)
alpha : default = { re = 1.; im = 0. }
ar : default = 1
ac : default = 1
br : default = 1
bc : default = 1
val syrk : ?n:int ->
?k:int ->
?up:bool ->
?beta:Lacaml_complex64.num_type ->
?cr:int ->
?cc:int ->
?c:Lacaml_complex64.mat ->
?trans:Lacaml_common.trans2 ->
?alpha:Lacaml_complex64.num_type ->
?ar:int -> ?ac:int -> Lacaml_complex64.mat -> Lacaml_complex64.mat

syrk ?n ?k ?up ?beta ?cr ?cc ?c ?trans ?alpha ?ar ?ac a see BLAS documentation!

n : default = number of rows of a (or a'), c
k : default = number of columns of a (or a')
up : default = true (upper triangular portion of c is accessed)
beta : default = { re = 0.; im = 0. }
cr : default = 1
cc : default = 1
c : default = matrix with minimal required dimension
trans : default = `N
alpha : default = { re = 1.; im = 0. }
ar : default = 1
ac : default = 1
val syr2k : ?n:int ->
?k:int ->
?up:bool ->
?beta:Lacaml_complex64.num_type ->
?cr:int ->
?cc:int ->
?c:Lacaml_complex64.mat ->
?trans:Lacaml_common.trans2 ->
?alpha:Lacaml_complex64.num_type ->
?ar:int ->
?ac:int ->
Lacaml_complex64.mat ->
?br:int -> ?bc:int -> Lacaml_complex64.mat -> Lacaml_complex64.mat

syr2k ?n ?k ?up ?beta ?cr ?cc ?c ?trans ?alpha ?ar ?ac a ?br ?bc b see BLAS documentation!

n : default = number of rows of a (or a'), c
k : default = number of columns of a (or a')
up : default = true (upper triangular portion of c is accessed)
beta : default = { re = 0.; im = 0. }
cr : default = 1
cc : default = 1
c : default = matrix with minimal required dimension
trans : default = `N
alpha : default = { re = 1.; im = 0. }
ar : default = 1
ac : default = 1
br : default = 1
bc : default = 1
LAPACK interface
Auxiliary routines
val lacpy : ?uplo:[ `L | `U ] ->
?m:int ->
?n:int ->
?br:int ->
?bc:int ->
?b:Lacaml_complex64.mat ->
?ar:int -> ?ac:int -> Lacaml_complex64.mat -> Lacaml_complex64.mat

lacpy ?uplo ?m ?n ?br ?bc ?b ?ar ?ac a copy a (triangular) (sub-)matrix a (to an optional (sub-)matrix b).

uplo : default = whole matrix
val lassq : ?n:int ->
?scale:float ->
?sumsq:float ->
?ofsx:int -> ?incx:int -> Lacaml_complex64.vec -> float * float

lassq ?n ?ofsx ?incx ?scale ?sumsq

n : default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
scale : default = 0.
sumsq : default = 1.
ofsx : default = 1
incx : default = 1
val larnv : ?idist:[ `Normal | `Uniform0 | `Uniform1 ] ->
?iseed:Lacaml_common.int32_vec ->
?n:int ->
?ofsx:int -> ?x:Lacaml_complex64.vec -> unit -> Lacaml_complex64.vec

larnv ?idist ?iseed ?n ?ofsx ?x ()

idist : default = `Normal
iseed : default = integer vector of size 4 with all ones.
n : default = dim x - ofsx + 1 if x is provided, 1 otherwise.
ofsx : default = 1
x : default = vector of length ofsx - 1 + n if n is provided.
val lange_min_lwork : int -> Lacaml_common.norm4 -> int

lange_min_lwork m norm

val lange : ?m:int ->
?n:int ->
?norm:Lacaml_common.norm4 ->
?work:Lacaml_complex64.rvec ->
?ar:int -> ?ac:int -> Lacaml_complex64.mat -> float

lange ?m ?n ?norm ?work ?ar ?ac a

m : default = number of rows of matrix a
n : default = number of columns of matrix a
norm : default = `O
work : default = allocated work space for norm `I
ar : default = 1
ac : default = 1
val lauum : ?up:bool -> ?n:int -> ?ar:int -> ?ac:int -> Lacaml_complex64.mat -> unit

lauum ?up ?n ?ar ?ac a computes the product U * U**T or L**T * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array a. The upper or lower part of a is overwritten.

up : default = true
n : default = minimum of available number of rows/columns in matrix a
ar : default = 1
ac : default = 1
Linear equations (computational routines)
val getrf : ?m:int ->
?n:int ->
?ipiv:Lacaml_common.int32_vec ->
?ar:int -> ?ac:int -> Lacaml_complex64.mat -> Lacaml_common.int32_vec

getrf ?m ?n ?ipiv ?ar ?ac a computes an LU factorization of a general m-by-n matrix a using partial pivoting with row interchanges. See LAPACK documentation.

m : default = number of rows in matrix a
n : default = number of columns in matrix a
ipiv : = vec of length min(m, n)
ar : default = 1
ac : default = 1
val getrs : ?n:int ->
?ipiv:Lacaml_common.int32_vec ->
?trans:Lacaml_complex64.trans3 ->
?ar:int ->
?ac:int ->
Lacaml_complex64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex64.mat -> unit

getrs ?n ?ipiv ?trans ?ar ?ac a ?nrhs ?br ?bc b solves a system of linear equations a * X = b or a' * X = b with a general n-by-n matrix a using the LU factorization computed by Lacaml_Z.getrf. Note that matrix a will be passed to Lacaml_Z.getrf if ipiv was not provided.

n : default = number of columns in matrix a
ipiv : default = result from getrf applied to a
trans : default = `N
ar : default = 1
ac : default = 1
nrhs : default = available number of columns in matrix b
br : default = 1
bc : default = 1
val getri_min_lwork : int -> int

getri_min_lwork n

val getri_opt_lwork : ?n:int -> ?ar:int -> ?ac:int -> Lacaml_complex64.mat -> int

getri_opt_lwork ?n ?ar ?ac a

n : default = number of columns of matrix a
ar : default = 1
ac : default = 1
val getri : ?n:int ->
?ipiv:Lacaml_common.int32_vec ->
?work:Lacaml_complex64.vec ->
?ar:int -> ?ac:int -> Lacaml_complex64.mat -> unit

getri ?n ?ipiv ?work ?ar ?ac a computes the inverse of a matrix using the LU factorization computed by Lacaml_Z.getrf. Note that matrix a will be passed to Lacaml_Z.getrf if ipiv was not provided.

n : default = number of columns in matrix a
ipiv : default = vec of length m from getri
work : default = vec of optimum length
ar : default = 1
ac : default = 1
val sytrf_min_lwork : unit -> int

sytrf_min_lwork ()

val sytrf_opt_lwork : ?n:int -> ?up:bool -> ?ar:int -> ?ac:int -> Lacaml_complex64.mat -> int

sytrf_opt_lwork ?n ?up ?ar ?ac a

n : default = number of columns of matrix a
up : default = true (store upper triangle in a)
ar : default = 1
ac : default = 1
val sytrf : ?n:int ->
?up:bool ->
?ipiv:Lacaml_common.int32_vec ->
?work:Lacaml_complex64.vec ->
?ar:int -> ?ac:int -> Lacaml_complex64.mat -> Lacaml_common.int32_vec

sytrf ?n ?up ?ipiv ?work ?ar ?ac a computes the factorization of the real symmetric matrix a using the Bunch-Kaufman diagonal pivoting method.

n : default = number of columns in matrix a
up : default = true (store upper triangle in a)
ipiv : = vec of length n
work : default = vec of optimum length
ar : default = 1
ac : default = 1
val sytrs : ?n:int ->
?up:bool ->
?ipiv:Lacaml_common.int32_vec ->
?ar:int ->
?ac:int ->
Lacaml_complex64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex64.mat -> unit

sytrs ?n ?up ?ipiv ?ar ?ac a ?nrhs ?br ?bc b solves a system of linear equations a*X = b with a real symmetric matrix a using the factorization a = U*D*U**T or a = L*D*L**T computed by Lacaml_Z.sytrf. Note that matrix a will be passed to Lacaml_Z.sytrf if ipiv was not provided.

n : default = number of columns in matrix a
up : default = true (store upper triangle in a)
ipiv : default = vec of length n
ar : default = 1
ac : default = 1
nrhs : default = available number of columns in matrix b
br : default = 1
bc : default = 1
val sytri_min_lwork : int -> int

sytri_min_lwork n

val sytri : ?n:int ->
?up:bool ->
?ipiv:Lacaml_common.int32_vec ->
?work:Lacaml_complex64.vec ->
?ar:int -> ?ac:int -> Lacaml_complex64.mat -> unit

sytri ?n ?up ?ipiv ?work ?ar ?ac a computes the inverse of the real symmetric indefinite matrix a using the factorization a = U*D*U**T or a = L*D*L**T computed by Lacaml_Z.sytrf. Note that matrix a will be passed to Lacaml_Z.sytrf if ipiv was not provided.

n : default = number of columns in matrix a
up : default = true (store upper triangle in a)
ipiv : default = vec of length n from Lacaml_Z.sytrf
work : default = vec of optimum length
ar : default = 1
ac : default = 1
val potrf : ?n:int ->
?up:bool ->
?ar:int ->
?ac:int -> ?jitter:Lacaml_complex64.num_type -> Lacaml_complex64.mat -> unit

potrf ?n ?up ?ar ?ac ?jitter a factorizes symmetric positive definite matrix a (or the designated submatrix) using Cholesky factorization.

Due to rounding errors ill-conditioned matrices may actually appear as if they were not positive definite, thus leading to an exception. One remedy for this problem is to add a small jitter to the diagonal of the matrix, which will usually allow Cholesky to complete successfully (though at a small bias). For extremely ill-conditioned matrices it is recommended to use (symmetric) eigenvalue decomposition instead of this function for a numerically more stable factorization.

n : default = number of columns in matrix a
up : default = true (store upper triangle in a)
ar : default = 1
ac : default = 1
jitter : default = nothing
val potrs : ?n:int ->
?up:bool ->
?ar:int ->
?ac:int ->
Lacaml_complex64.mat ->
?nrhs:int ->
?br:int ->
?bc:int ->
?factorize:bool ->
?jitter:Lacaml_complex64.num_type -> Lacaml_complex64.mat -> unit

potrs ?n ?up ?ar ?ac a ?nrhs ?br ?bc ?factorize ?jitter b solves a system of linear equations a*X = b, where a is symmetric positive definite matrix, using the Cholesky factorization a = U**T*U or a = L*L**T computed by Lacaml_Z.potrf.

n : default = number of columns in matrix a
up : default = true
ar : default = 1
ac : default = 1
nrhs : default = available number of columns in matrix b
br : default = 1
bc : default = 1
factorize : default = true (calls Lacaml_Z.potrf implicitly)
jitter : default = nothing
val potri : ?n:int ->
?up:bool ->
?ar:int ->
?ac:int ->
?factorize:bool ->
?jitter:Lacaml_complex64.num_type -> Lacaml_complex64.mat -> unit

potri ?n ?up ?ar ?ac ?factorize ?jitter a computes the inverse of the real symmetric positive definite matrix a using the Cholesky factorization a = U**T*U or a = L*L**T computed by Lacaml_Z.potrf.

n : default = number of columns in matrix a
up : default = true (upper triangle stored in a)
ar : default = 1
ac : default = 1
factorize : default = true (calls Lacaml_Z.potrf implicitly)
jitter : default = nothing
val trtrs : ?n:int ->
?up:bool ->
?trans:Lacaml_complex64.trans3 ->
?diag:Lacaml_common.diag ->
?ar:int ->
?ac:int ->
Lacaml_complex64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex64.mat -> unit

trtrs ?n ?up ?trans ?diag ?ar ?ac a ?nrhs ?br ?bc b solves a triangular system of the form a * X = b or a**T * X = n, where a is a triangular matrix of order n, and b is an n-by-nrhs matrix.

n : default = number of columns in matrix a
up : default = true
trans : default = `N
diag : default = `N
ar : default = 1
ac : default = 1
nrhs : default = available number of columns in matrix b
br : default = 1
bc : default = 1
val tbtrs : ?n:int ->
?kd:int ->
?up:bool ->
?trans:Lacaml_complex64.trans3 ->
?diag:Lacaml_common.diag ->
?abr:int ->
?abc:int ->
Lacaml_complex64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex64.mat -> unit

tbtrs ?n ?kd ?up ?trans ?diag ?abr ?abc ab ?nrhs ?br ?bc b solves a triangular system of the form a * X = b or a**T * X = b, where a is a triangular band matrix of order n, and b is an n-by-nrhs matrix.

n : default = number of columns in matrix ab
kd : default = number of rows in matrix ab - 1
up : default = true
trans : default = `N
diag : default = `N
abr : default = 1
abc : default = 1
nrhs : default = available number of columns in matrix b
br : default = 1
bc : default = 1
val trtri : ?n:int ->
?up:bool ->
?diag:Lacaml_common.diag ->
?ar:int -> ?ac:int -> Lacaml_complex64.mat -> unit

trtri ?n ?up ?diag ?ar ?ac a computes the inverse of a real upper or lower triangular matrix a.

n : default = number of columns in matrix a
up : default = true (upper triangle stored in a)
diag : default = `N
ar : default = 1
ac : default = 1
val geqrf_opt_lwork : ?m:int -> ?n:int -> ?ar:int -> ?ac:int -> Lacaml_complex64.mat -> int

geqrf_opt_lwork ?m ?n ?ar ?ac a

m : default = number of rows in matrix a
n : default = number of columns in matrix a
ar : default = 1
ac : default = 1
val geqrf_min_lwork : n:int -> int

geqrf_min_lwork ~n

val geqrf : ?m:int ->
?n:int ->
?work:Lacaml_complex64.vec ->
?tau:Lacaml_complex64.vec ->
?ar:int -> ?ac:int -> Lacaml_complex64.mat -> Lacaml_complex64.vec

geqrf ?m ?n ?work ?tau ?ar ?ac a computes a QR factorization of a real m-by-n matrix a. See LAPACK documentation.

m : default = number of rows in matrix a
n : default = number of columns in matrix a
work : default = vec of optimum length
tau : default = vec of required length
ar : default = 1
ac : default = 1
Linear equations (simple drivers)
val gesv : ?n:int ->
?ipiv:Lacaml_common.int32_vec ->
?ar:int ->
?ac:int ->
Lacaml_complex64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex64.mat -> unit

gesv ?n ?ipiv ?ar ?ac a ?nrhs ?br ?bc b computes the solution to a real system of linear equations a * X = b, where a is an n-by-n matrix and X and b are n-by-nrhs matrices. The LU decomposition with partial pivoting and row interchanges is used to factor a as a = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of a is then used to solve the system of equations a * X = b. On exit, b contains the solution matrix X.

n : default = available number of columns in matrix a
ipiv : default = vec of length n
ar : default = 1
ac : default = 1
nrhs : default = available number of columns in matrix b
br : default = 1
bc : default = 1
val gbsv : ?n:int ->
?ipiv:Lacaml_common.int32_vec ->
?abr:int ->
?abc:int ->
Lacaml_complex64.mat ->
int -> int -> ?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex64.mat -> unit

gbsv ?n ?ipiv ?abr ?abc ab kl ku ?nrhs ?br ?bc b computes the solution to a real system of linear equations a * X = b, where a is a band matrix of order n with kl subdiagonals and ku superdiagonals, and X and b are n-by-nrhs matrices. The LU decomposition with partial pivoting and row interchanges is used to factor a as a = L * U, where L is a product of permutation and unit lower triangular matrices with kl subdiagonals, and U is upper triangular with kl+ku superdiagonals. The factored form of a is then used to solve the system of equations a * X = b.

n : default = available number of columns in matrix ab
ipiv : default = vec of length n
abr : default = 1
abc : default = 1
nrhs : default = available number of columns in matrix b
br : default = 1
bc : default = 1
val gtsv : ?n:int ->
?ofsdl:int ->
Lacaml_complex64.vec ->
?ofsd:int ->
Lacaml_complex64.vec ->
?ofsdu:int ->
Lacaml_complex64.vec ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex64.mat -> unit

gtsv ?n ?ofsdl dl ?ofsd d ?ofsdu du ?nrhs ?br ?bc b solves the equation a * X = b where a is an n-by-n tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation A'*X = b may be solved by interchanging the order of the arguments du and dl.

n : default = available length of vector d
ofsdl : default = 1
ofsd : default = 1
ofsdu : default = 1
nrhs : default = available number of columns in matrix b
br : default = 1
bc : default = 1
val posv : ?n:int ->
?up:bool ->
?ar:int ->
?ac:int ->
Lacaml_complex64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex64.mat -> unit

posv ?n ?up ?ar ?ac a ?nrhs ?br ?bc b computes the solution to a real system of linear equations a * X = b, where a is an n-by-n symmetric positive definite matrix and X and b are n-by-nrhs matrices. The Cholesky decomposition is used to factor a as a = U**T * U, if up = true, or a = L * L**T, if up = false, where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of a is then used to solve the system of equations a * X = b.

n : default = available number of columns in matrix a
up : default = true i.e., upper triangle of a is stored
ar : default = 1
ac : default = 1
nrhs : default = available number of columns in matrix b
br : default = 1
bc : default = 1
val ppsv : ?n:int ->
?up:bool ->
?ofsap:int ->
Lacaml_complex64.vec ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex64.mat -> unit

ppsv ?n ?up ?ofsap ap ?nrhs ?br ?bc b computes the solution to the real system of linear equations a * X = b, where a is an n-by-n symmetric positive definite matrix stored in packed format and X and b are n-by-nrhs matrices. The Cholesky decomposition is used to factor a as a = U**T * U, if up = true, or a = L * L**T, if up = false, where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of a is then used to solve the system of equations a * X = b.

n : default = the greater n s.t. n(n+1)/2 <= Vec.dim ap
up : default = true i.e., upper triangle of ap is stored
ofsap : default = 1
nrhs : default = available number of columns in matrix b
br : default = 1
bc : default = 1
val pbsv : ?n:int ->
?up:bool ->
?kd:int ->
?abr:int ->
?abc:int ->
Lacaml_complex64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex64.mat -> unit

pbsv ?n ?up ?kd ?abr ?abc ab ?nrhs ?br ?bc b computes the solution to a real system of linear equations a * X = b, where a is an n-by-n symmetric positive definite band matrix and X and b are n-by-nrhs matrices. The Cholesky decomposition is used to factor a as a = U**T * U, if up = true, or a = L * L**T, if up = false, where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as a. The factored form of a is then used to solve the system of equations a * X = b.

n : default = available number of columns in matrix ab
up : default = true i.e., upper triangle of ab is stored
kd : default = available number of rows in matrix ab - 1
abr : default = 1
abc : default = 1
nrhs : default = available number of columns in matrix b
br : default = 1
bc : default = 1
val ptsv : ?n:int ->
?ofsd:int ->
Lacaml_complex64.vec ->
?ofse:int ->
Lacaml_complex64.vec ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex64.mat -> unit

ptsv ?n ?ofsd d ?ofse e ?nrhs ?br ?bc b computes the solution to the real system of linear equations a*X = b, where a is an n-by-n symmetric positive definite tridiagonal matrix, and X and b are n-by-nrhs matrices. A is factored as a = L*D*L**T, and the factored form of a is then used to solve the system of equations.

n : default = available length of vector d
ofsd : default = 1
ofse : default = 1
nrhs : default = available number of columns in matrix b
br : default = 1
bc : default = 1
val sysv_opt_lwork : ?n:int ->
?up:bool ->
?ar:int ->
?ac:int ->
Lacaml_complex64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex64.mat -> int

sysv_opt_lwork ?n ?up ?ar ?ac a ?nrhs ?br ?bc b

n : default = available number of columns in matrix a
up : default = true i.e., upper triangle of a is stored
ar : default = 1
ac : default = 1
nrhs : default = available number of columns in matrix b
br : default = 1
bc : default = 1
val sysv : ?n:int ->
?up:bool ->
?ipiv:Lacaml_common.int32_vec ->
?work:Lacaml_complex64.vec ->
?ar:int ->
?ac:int ->
Lacaml_complex64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex64.mat -> unit

sysv ?n ?up ?ipiv ?work ?ar ?ac a ?nrhs ?br ?bc b computes the solution to a real system of linear equations a * X = b, where a is an N-by-N symmetric matrix and X and b are n-by-nrhs matrices. The diagonal pivoting method is used to factor a as a = U * D * U**T, if up = true, or a = L * D * L**T, if up = false, where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of a is then used to solve the system of equations a * X = b.

n : default = available number of columns in matrix a
up : default = true i.e., upper triangle of a is stored
ipiv : default = vec of length n
work : default = vec of optimum length (-> sysv_opt_lwork)
ar : default = 1
ac : default = 1
nrhs : default = available number of columns in matrix b
br : default = 1
bc : default = 1
val spsv : ?n:int ->
?up:bool ->
?ipiv:Lacaml_common.int32_vec ->
?ofsap:int ->
Lacaml_complex64.vec ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex64.mat -> unit

spsv ?n ?up ?ipiv ?ofsap ap ?nrhs ?br ?bc b computes the solution to the real system of linear equations a * X = b, where a is an n-by-n symmetric matrix stored in packed format and X and b are n-by-nrhs matrices. The diagonal pivoting method is used to factor a as a = U * D * U**T, if up = true, or a = L * D * L**T, if up = false, where U (or L) is a product of permutation and unit upper (lower) triangular matrices, D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of a is then used to solve the system of equations a * X = b.

n : default = the greater n s.t. n(n+1)/2 <= Vec.dim ap
up : default = true i.e., upper triangle of ap is stored
ipiv : default = vec of length n
ofsap : default = 1
nrhs : default = available number of columns in matrix b
br : default = 1
bc : default = 1
Least squares (simple drivers)
val gels_min_lwork : m:int -> n:int -> nrhs:int -> int

gels_min_lwork ~m ~n ~nrhs

val gels_opt_lwork : ?m:int ->
?n:int ->
?trans:Lacaml_common.trans2 ->
?ar:int ->
?ac:int ->
Lacaml_complex64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex64.mat -> int

gels_opt_lwork ?m ?n ?trans ?ar ?ac a ?nrhs ?br ?bc b

m : default = available number of rows in matrix a
n : default = available number of columns in matrix a
trans : default = `N
ar : default = 1
ac : default = 1
nrhs : default = available number of columns in matrix b
br : default = 1
bc : default = 1
val gels : ?m:int ->
?n:int ->
?work:Lacaml_complex64.vec ->
?trans:Lacaml_common.trans2 ->
?ar:int ->
?ac:int ->
Lacaml_complex64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex64.mat -> unit

gels ?m ?n ?work ?trans ?ar ?ac a ?nrhs ?br ?bc b see LAPACK documentation!

m : default = available number of rows in matrix a
n : default = available number of columns of matrix a
work : default = vec of optimum length (-> Lacaml_Z.gels_opt_lwork)
trans : default = `N
ar : default = 1
ac : default = 1
nrhs : default = available number of columns in matrix b
br : default = 1
bc : default = 1