module Lacaml_D:sig
..end
This module Lacaml.D
contains linear algebra routines for
real numbers (precision: float64). It is recommended to use this
module by writing
open Lacaml.D
at the top of your file.
typeprec =
Bigarray.float64_elt
typenum_type =
float
typevec =
(float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Array1.t
Vectors (precision: float64).
typervec =
vec
typemat =
(float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Array2.t
Matrices (precision: float64).
typetrans3 =
[ `N | `T ]
Transpose parameter (normal or transposed). For complex matrices, conjugate transpose is also offered, hence the name.
val prec : (float, Bigarray.float64_elt) Bigarray.kind
Precision for this submodule D
. Allows to write precision
independent code.
module Vec:sig
..end
module Mat:sig
..end
val pp_num : Stdlib.Format.formatter -> float -> unit
pp_num ppf el
is equivalent to fprintf ppf "%G" el
.
val pp_vec : (float, 'a) Lacaml_io.pp_vec
Pretty-printer for column vectors.
val pp_mat : (float, 'a) Lacaml_io.pp_mat
Pretty-printer for matrices.
val dot : ?n:int ->
?ofsx:int ->
?incx:int ->
Lacaml_float64.vec -> ?ofsy:int -> ?incy:int -> Lacaml_float64.vec -> float
dot ?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 = 1incx
: default = 1ofsy
: default = 1incy
: default = 1val asum : ?n:int -> ?ofsx:int -> ?incx:int -> Lacaml_float64.vec -> float
asum ?n ?ofsx ?incx x
see BLAS documentation!
n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsx
: default = 1incx
: default = 1val sbmv : ?n:int ->
?k:int ->
?ofsy:int ->
?incy:int ->
?y:Lacaml_float64.vec ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?up:bool ->
?alpha:float ->
?beta:float ->
?ofsx:int -> ?incx:int -> Lacaml_float64.vec -> Lacaml_float64.vec
sbmv ?n ?k ?ofsy ?incy ?y ?ar ?ac a ?up ?alpha ?beta ?ofsx ?incx x
see
BLAS documentation!
y
, which is overwritten.n
: default = number of available columns to the right of ac
.k
: default = number of available rows in matrix a
- 1ofsy
: default = 1incy
: default = 1y
: default = uninitialized vector of minimal length (see BLAS)ar
: default = 1ac
: default = 1up
: default = true i.e., upper band of a
is suppliedalpha
: default = 1.0beta
: default = 0.0ofsx
: default = 1incx
: default = 1val ger : ?m:int ->
?n:int ->
?alpha:float ->
?ofsx:int ->
?incx:int ->
Lacaml_float64.vec ->
?ofsy:int ->
?incy:int ->
Lacaml_float64.vec ->
?ar:int -> ?ac:int -> Lacaml_float64.mat -> Lacaml_float64.mat
ger ?m ?n ?alpha ?ofsx ?incx x ?ofsy ?incy y n ?ar ?ac a
see
BLAS documentation!
a
, which is overwrittenm
: default = number of rows of a
n
: default = number of columns of a
alpha
: default = 1.0ofsx
: default = 1incx
: default = 1ofsy
: default = 1incy
: default = 1ar
: default = 1ac
: default = 1val syr : ?n:int ->
?alpha:float ->
?up:bool ->
?ofsx:int ->
?incx:int ->
Lacaml_float64.vec ->
?ar:int -> ?ac:int -> Lacaml_float64.mat -> Lacaml_float64.mat
syr ?n ?alpha ?up ?ofsx ?incx x ?ar ?ac a
see BLAS documentation!
a
, which is overwrittenn
: default = number of rows of a
alpha
: default = 1.0up
: default = true i.e., upper triangle of a
is suppliedofsx
: default = 1incx
: default = 1ar
: default = 1ac
: default = 1val lansy_min_lwork : int -> Lacaml_common.norm4 -> int
lansy_min_lwork m norm
lansy
-function.val lansy : ?n:int ->
?up:bool ->
?norm:Lacaml_common.norm4 ->
?work:Lacaml_float64.vec -> ?ar:int -> ?ac:int -> Lacaml_float64.mat -> float
lansy ?norm ?up ?n ?ar ?ac ?work a
see LAPACK documentation!
n
: default = number of columns of matrix a
up
: default = true (reference upper triangular part of a
)norm
: default = `Owork
: default = allocated work space for norm `Ival lamch : [ `B | `E | `L | `M | `N | `O | `P | `R | `S | `U ] -> float
lamch cmach
see LAPACK documentation!
val orgqr_min_lwork : n:int -> int
orgqr_min_lwork ~n
orgqr
-function if the matrix has n
columns.val orgqr_opt_lwork : ?m:int ->
?n:int ->
?k:int ->
tau:Lacaml_float64.vec -> ?ar:int -> ?ac:int -> Lacaml_float64.mat -> int
orgqr_opt_lwork ?m ?n ?k ~tau ?ar ?ac a
orgqr
-function given matrix a
,
optionally its logical dimensions m
and n
, and the number of reflectors
k
.m
: default = available number of rows in matrix a
n
: default = available number of columns in matrix a
k
: default = available number of elements in vector tau
val orgqr : ?m:int ->
?n:int ->
?k:int ->
?work:Lacaml_float64.vec ->
tau:Lacaml_float64.vec -> ?ar:int -> ?ac:int -> Lacaml_float64.mat -> unit
orgqr ?m ?n ?k ?work ~tau ?ar ?ac a
see LAPACK documentation!
m
: default = available number of rows in matrix a
n
: default = available number of columns in matrix a
k
: default = available number of elements in vector tau
val ormqr_opt_lwork : ?side:Lacaml_common.side ->
?trans:Lacaml_common.trans2 ->
?m:int ->
?n:int ->
?k:int ->
tau:Lacaml_float64.vec ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat -> ?cr:int -> ?cc:int -> Lacaml_float64.mat -> int
ormqr_opt_lwork ?side ?trans ?m ?n ?k ~tau ?ar ?ac a ?cr ?cc c
ormqr
-function
given matrix a
and b
, optionally its logical dimensions m
and n
,
and the number of reflectors k
.m
: default = available number of rows in matrix a
n
: default = available number of columns in matrix a
k
: default = available number of elements in vector tau
val ormqr : ?side:Lacaml_common.side ->
?trans:Lacaml_common.trans2 ->
?m:int ->
?n:int ->
?k:int ->
?work:Lacaml_float64.vec ->
tau:Lacaml_float64.vec ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat -> ?cr:int -> ?cc:int -> Lacaml_float64.mat -> unit
ormqr ?side ?trans ?m ?n ?k ?work ~tau ?ar ?ac a ?cr ?cc c
see LAPACK documentation!
side
: default = `L
trans
: default = `N
m
: default = available number of rows in matrix a
n
: default = available number of columns in matrix a
k
: default = available number of elements in vector tau
val gecon_min_lwork : int -> int
gecon_min_lwork n
gecon
-function.val gecon_min_liwork : int -> int
gecon_min_liwork n
gecon
-function.val gecon : ?n:int ->
?norm:Lacaml_common.norm2 ->
?anorm:float ->
?work:Lacaml_float64.vec ->
?iwork:Lacaml_common.int32_vec ->
?ar:int -> ?ac:int -> Lacaml_float64.mat -> float
gecon ?n ?norm ?anorm ?work ?rwork ?ar ?ac a
a
n
: default = available number of columns of matrix a
norm
: default = 1-normanorm
: default = norm of the matrix a
as returned by lange
work
: default = automatically allocated workspaceiwork
: default = automatically allocated workspacear
: default = 1ac
: default = 1val sycon_min_lwork : int -> int
sycon_min_lwork n
sycon
-function.val sycon_min_liwork : int -> int
sycon_min_liwork n
sycon
-function.val sycon : ?n:int ->
?up:bool ->
?ipiv:Lacaml_common.int32_vec ->
?anorm:float ->
?work:Lacaml_float64.vec ->
?iwork:Lacaml_common.int32_vec ->
?ar:int -> ?ac:int -> Lacaml_float64.mat -> float
sycon ?n ?up ?ipiv ?anorm ?work ?iwork ?ar ?ac a
a
n
: default = available number of columns of matrix a
up
: default = upper triangle of the factorization of a
is storedipiv
: default = vec of length n
anorm
: default = 1-norm of the matrix a
as returned by lange
work
: default = automatically allocated workspaceiwork
: default = automatically allocated workspaceval pocon_min_lwork : int -> int
pocon_min_lwork n
pocon
-function.val pocon_min_liwork : int -> int
pocon_min_liwork n
pocon
-function.val pocon : ?n:int ->
?up:bool ->
?anorm:float ->
?work:Lacaml_float64.vec ->
?iwork:Lacaml_common.int32_vec ->
?ar:int -> ?ac:int -> Lacaml_float64.mat -> float
pocon ?n ?up ?anorm ?work ?iwork ?ar ?ac a
a
n
: default = available number of columns of matrix a
up
: default = upper triangle of Cholesky factorization
of a
is storedanorm
: default = 1-norm of the matrix a
as returned by lange
work
: default = automatically allocated workspaceiwork
: default = automatically allocated workspaceval gelsy_min_lwork : m:int -> n:int -> nrhs:int -> int
gelsy_min_lwork ~m ~n ~nrhs
gelsy
-function if the logical dimensions
of the matrix are m
rows and n
columns and if there are nrhs
right hand side vectors.val gelsy_opt_lwork : ?m:int ->
?n:int ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_float64.mat -> int
gelsy_opt_lwork ?m ?n ?ar ?ac a ?nrhs ?br ?bc b
gelsy
-function given matrix
a
, optionally its logical dimensions m
and n
and given right
hand side matrix b
with an optional number nrhs
of vectors.m
: default = available number of rows in matrix a
n
: default = available number of columns in matrix a
nrhs
: default = available number of columns in matrix b
val gelsy : ?m:int ->
?n:int ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?rcond:float ->
?jpvt:Lacaml_common.int32_vec ->
?work:Lacaml_float64.vec ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_float64.mat -> int
gelsy ?m ?n ?ar ?ac a ?rcond ?jpvt ?ofswork ?work ?nrhs b
see LAPACK
documentation!
a
.m
: default = available number of rows in matrix a
n
: default = available number of columns of matrix a
rcond
: default = (-1) => machine precisionjpvt
: default = vec of length n
work
: default = vec of optimum length (-> gelsy_opt_lwork
)nrhs
: default = available number of columns in matrix b
val gelsd_min_lwork : m:int -> n:int -> nrhs:int -> int
gelsd_min_lwork ~m ~n ~nrhs
gelsd
-function if the logical dimensions
of the matrix are m
and n
and if there are nrhs
right hand
side vectors.val gelsd_opt_lwork : ?m:int ->
?n:int ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_float64.mat -> int
gelsd_opt_lwork ?m ?n ?ar ?ac a ?nrhs b
gelsd
-function given matrix a
,
optionally its logical dimensions m
and n
and given right hand
side matrix b
with an optional number nrhs
of vectors.m
: default = available number of rows in matrix a
n
: default = available number of columns in matrix a
nrhs
: default = available number of columns in matrix b
val gelsd_min_iwork : int -> int -> int
gelsd_min_iwork m n
gelsd
-function if the logical
dimensions of the matrix are m
and n
.val gelsd : ?m:int ->
?n:int ->
?rcond:float ->
?ofss:int ->
?s:Lacaml_float64.vec ->
?work:Lacaml_float64.vec ->
?iwork:Lacaml_float64.vec ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_float64.mat -> int
gelsd ?m ?n ?rcond ?ofss ?s ?ofswork ?work ?ar ?ac a ?nrhs b
see LAPACK documentation!
Failure
if the function fails to converge.a
.m
: default = available number of rows in matrix a
n
: default = available number of columns of matrix a
rcond
: default = (-1) => machine precisionofss
: default = 1 or ignored if s
is not givens
: default = vec of length min rows cols
work
: default = vec of optimum length (-> gelsd_opt_lwork
)iwork
: default = vec of optimum (= minimum) lengthnrhs
: default = available number of columns in matrix b
val gelss_min_lwork : m:int -> n:int -> nrhs:int -> int
gelss_min_lwork ~m ~n ~nrhs
gelss
-function if the logical dimensions
of the matrix are m
rows and n
columns and if there are nrhs
right hand side vectors.val gelss_opt_lwork : ?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?m:int ->
?n:int -> ?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_float64.mat -> int
gelss_opt_lwork ?ar ?ac a ?m ?n ?nrhs ?br ?bc b
gelss
-function given matrix
a
, optionally its logical dimensions m
and n
and given right
hand side matrix b
with an optional number nrhs
of vectors.m
: default = available number of rows in matrix a
n
: default = available number of columns in matrix a
nrhs
: default = available number of columns in matrix b
val gelss : ?m:int ->
?n:int ->
?rcond:float ->
?ofss:int ->
?s:Lacaml_float64.vec ->
?work:Lacaml_float64.vec ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_float64.mat -> int
gelss ?m ?n ?rcond ?ofss ?s ?ofswork ?work ?ar ?ac a ?nrhs ?br ?bc b
see LAPACK documentation!
Failure
if the function fails to converge.a
.m
: default = available number of rows in matrix a
n
: default = available number of columns of matrix a
rcond
: default = (-1) => machine precisionofss
: default = 1 or ignored if s
is not givens
: default = vec of length min m n
work
: default = vec of optimum length (-> gelss_opt_lwork
)nrhs
: default = available number of columns in matrix b
val gees : ?n:int ->
?jobvs:Lacaml_common.schur_vectors ->
?sort:Lacaml_common.eigen_value_sort ->
?wr:Lacaml_float64.vec ->
?wi:Lacaml_float64.vec ->
?vsr:int ->
?vsc:int ->
?vs:Lacaml_float64.mat ->
?work:Lacaml_float64.vec ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
int * Lacaml_float64.vec * Lacaml_float64.vec * Lacaml_float64.mat
gees ?n ?jobvs ?sort ?w ?vsr ?vsc ?vs ?work ?ar ?ac a
See gees
-function for details about arguments.
val gesvd_min_lwork : m:int -> n:int -> int
gesvd_min_lwork ~m ~n
gesvd
-function for matrices with m
rows and n
columns.val gesvd_opt_lwork : ?m:int ->
?n:int ->
?jobu:Lacaml_common.svd_job ->
?jobvt:Lacaml_common.svd_job ->
?s:Lacaml_float64.vec ->
?ur:int ->
?uc:int ->
?u:Lacaml_float64.mat ->
?vtr:int ->
?vtc:int ->
?vt:Lacaml_float64.mat -> ?ar:int -> ?ac:int -> Lacaml_float64.mat -> int
val gesvd : ?m:int ->
?n:int ->
?jobu:Lacaml_common.svd_job ->
?jobvt:Lacaml_common.svd_job ->
?s:Lacaml_float64.vec ->
?ur:int ->
?uc:int ->
?u:Lacaml_float64.mat ->
?vtr:int ->
?vtc:int ->
?vt:Lacaml_float64.mat ->
?work:Lacaml_float64.vec ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
Lacaml_float64.vec * Lacaml_float64.mat * Lacaml_float64.mat
val gesdd_liwork : m:int -> n:int -> int
val gesdd_min_lwork : ?jobz:Lacaml_common.svd_job -> m:int -> n:int -> unit -> int
gesdd_min_lwork ?jobz ~m ~n
gesdd
-function for matrices with m
rows
and n
columns for SVD-job jobz
.val gesdd_opt_lwork : ?m:int ->
?n:int ->
?jobz:Lacaml_common.svd_job ->
?s:Lacaml_float64.vec ->
?ur:int ->
?uc:int ->
?u:Lacaml_float64.mat ->
?vtr:int ->
?vtc:int ->
?vt:Lacaml_float64.mat ->
?iwork:Lacaml_common.int32_vec ->
?ar:int -> ?ac:int -> Lacaml_float64.mat -> int
val gesdd : ?m:int ->
?n:int ->
?jobz:Lacaml_common.svd_job ->
?s:Lacaml_float64.vec ->
?ur:int ->
?uc:int ->
?u:Lacaml_float64.mat ->
?vtr:int ->
?vtc:int ->
?vt:Lacaml_float64.mat ->
?work:Lacaml_float64.vec ->
?iwork:Lacaml_common.int32_vec ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
Lacaml_float64.vec * Lacaml_float64.mat * Lacaml_float64.mat
val geev_min_lwork : ?vectors:bool -> int -> int
geev_min_lwork vectors n
geev
-function. vectors
indicates whether
eigenvectors are supposed to be computed.vectors
: default = trueval geev_opt_lwork : ?n:int ->
?vlr:int ->
?vlc:int ->
?vl:Lacaml_float64.mat option ->
?vrr:int ->
?vrc:int ->
?vr:Lacaml_float64.mat option ->
?ofswr:int ->
?wr:Lacaml_float64.vec ->
?ofswi:int ->
?wi:Lacaml_float64.vec -> ?ar:int -> ?ac:int -> Lacaml_float64.mat -> int
geev_opt_lwork
?n
?vlr ?vlc ?vl
?vrr ?vrc ?vr
?ofswr wr
?ofswi wi
?ar ?ac a
See geev
-function for details about arguments.
val geev : ?n:int ->
?work:Lacaml_float64.vec ->
?vlr:int ->
?vlc:int ->
?vl:Lacaml_float64.mat option ->
?vrr:int ->
?vrc:int ->
?vr:Lacaml_float64.mat option ->
?ofswr:int ->
?wr:Lacaml_float64.vec ->
?ofswi:int ->
?wi:Lacaml_float64.vec ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
Lacaml_float64.mat * Lacaml_float64.vec * Lacaml_float64.vec *
Lacaml_float64.mat
geev ?work ?n
?vlr ?vlc ?vl
?vrr ?vrc ?vr
?ofswr wr ?ofswi wi
?ar ?ac a
Failure
if the function fails to convergelv
, wr
, wi
, rv
), where wr
and wv
are the real
and imaginary components of the eigenvalues, and lv
and rv
are the left and right eigenvectors. lv
(rv
) is the empty
matrix if vl
(vr
) is set to None
.n
: default = available number of columns of matrix a
work
: default = automatically allocated workspacevl
: 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.wr
: default = vector of size n
; real components of the eigenvalueswi
: default = vector of size n
;
imaginary components of the eigenvaluesval syev_min_lwork : int -> int
syev_min_lwork n
Lacaml_D.syev
-function if the logical dimensions of the matrix
are n
.val syev_opt_lwork : ?n:int ->
?vectors:bool -> ?up:bool -> ?ar:int -> ?ac:int -> Lacaml_float64.mat -> int
syev_opt_lwork ?n ?vectors ?up ?ar ?ac a
Lacaml_D.syev
-function given matrix
a
, optionally its logical dimension n
and whether the eigenvectors
must be computed (vectors
).n
: default = available number of columns of matrix a
vectors
: default = false, i.e. eigenvectors are not computedup
: default = true, i.e. upper triangle of a
is storedval syev : ?n:int ->
?vectors:bool ->
?up:bool ->
?work:Lacaml_float64.vec ->
?ofsw:int ->
?w:Lacaml_float64.vec ->
?ar:int -> ?ac:int -> Lacaml_float64.mat -> Lacaml_float64.vec
syev ?n ?vectors ?up ?ofswork ?work ?ofsw ?w ?ar ?ac a
computes
all eigenvalues and, optionally, eigenvectors of the real symmetric
matrix a
.
Failure
if the function fails to converge.w
of eigenvalues in ascending order.n
: default = available number of columns of matrix a
vectors
: default = false i.e, eigenvectors are not computedup
: default = true i.e., upper triangle of a
is storedwork
: default = vec of optimum length (-> Lacaml_D.syev_opt_lwork
)ofsw
: default = 1 or ignored if w
is not givenw
: default = vec of length n
val syevd_min_lwork : vectors:bool -> int -> int
syevd_min_lwork vectors n
Lacaml_D.syevd
-function if the logical dimensions of
the matrix are n
and given whether eigenvectors should be computed
(vectors
).val syevd_min_liwork : vectors:bool -> int -> int
syevd_min_liwork vectors n
Lacaml_D.syevd
-function if the logical dimensions of
the matrix are n
and given whether eigenvectors should be computed
(vectors
).val syevd_opt_lwork : ?n:int ->
?vectors:bool -> ?up:bool -> ?ar:int -> ?ac:int -> Lacaml_float64.mat -> int
syevd_opt_lwork ?n ?vectors ?up ?ar ?ac a
Lacaml_D.syevd
-function given matrix
a
, optionally its logical dimension n
and whether the eigenvectors
must be computed (vectors
).n
: default = available number of columns of matrix a
vectors
: default = false, i.e. eigenvectors are not computedup
: default = true, i.e. upper triangle of a
is storedval syevd_opt_liwork : ?n:int ->
?vectors:bool -> ?up:bool -> ?ar:int -> ?ac:int -> Lacaml_float64.mat -> int
syevd_opt_liwork ?n ?vectors ?up ?ar ?ac a
Lacaml_D.syevd
-function given matrix
a
, optionally its logical dimension n
and whether the eigenvectors
must be computed (vectors
).n
: default = available number of columns of matrix a
vectors
: default = false, i.e. eigenvectors are not computedup
: default = true, i.e. upper triangle of a
is storedval syevd_opt_l_li_work : ?n:int ->
?vectors:bool ->
?up:bool -> ?ar:int -> ?ac:int -> Lacaml_float64.mat -> int * int
syevd_opt_l_li_iwork ?n ?vectors ?up ?ar ?ac a
Lacaml_D.syevd
-function given matrix a
, optionally its
logical dimension n
and whether the eigenvectors must be computed
(vectors
).n
: default = available number of columns of matrix a
vectors
: default = false, i.e. eigenvectors are not computedup
: default = true, i.e. upper triangle of a
is storedval syevd : ?n:int ->
?vectors:bool ->
?up:bool ->
?work:Lacaml_float64.vec ->
?iwork:Lacaml_common.int32_vec ->
?ofsw:int ->
?w:Lacaml_float64.vec ->
?ar:int -> ?ac:int -> Lacaml_float64.mat -> Lacaml_float64.vec
syevd ?n ?vectors ?up ?ofswork ?work ?iwork ?ofsw ?w ?ar ?ac a
computes all eigenvalues and, optionally, eigenvectors of the real
symmetric matrix a
. If eigenvectors are desired, it uses a
divide and conquer algorithm.
Failure
if the function fails to converge.w
of eigenvalues in ascending order.n
: default = available number of columns of matrix a
vectors
: default = false i.e, eigenvectors are not computedup
: default = true i.e., upper triangle of a
is storedwork
: default = vec of optimum length (-> Lacaml_D.syev_opt_lwork
)iwork
: default = int32_vec of optimum length (-> Lacaml_D.syevd_opt_liwork
)ofsw
: default = 1 or ignored if w
is not givenw
: default = vec of length n
val sbev_min_lwork : int -> int
sbev_min_lwork n
Lacaml_D.sbev
-function if the logical dimensions of the matrix
are n
.val sbev : ?n:int ->
?kd:int ->
?zr:int ->
?zc:int ->
?z:Lacaml_float64.mat ->
?up:bool ->
?work:Lacaml_float64.vec ->
?ofsw:int ->
?w:Lacaml_float64.vec ->
?abr:int -> ?abc:int -> Lacaml_float64.mat -> Lacaml_float64.vec
sbev ?n ?vectors ?zr ?zc ?z ?up ?ofswork ?work ?ofsw ?w ?abr ?abc ab
computes all the eigenvalues and, optionally, eigenvectors of the
real symmetric band matrix ab
.
Failure
if the function fails to converge.Failure
if the function fails to converge.w
of eigenvalues in ascending order.n
: default = available number of columns of matrix ab
kd
: default = number of rows in matrix ab
- 1z
: matrix to contain the orthonormal eigenvectors of ab
,
the i
-th column of z
holding the eigenvector associated
with w.{i}
.
default = None
i.e, eigenvectors are not computedup
: default = true i.e., upper triangle of the matrix is storedwork
: default = vec of minimal length (-> Lacaml_D.sbev_min_lwork
)ofsw
: default = 1 or ignored if w
is not givenw
: default = vec of length n
abr
: default = 1abc
: default = 1val syevr_min_lwork : int -> int
syevr_min_lwork n
Lacaml_D.syevr
-function if the logical dimensions
of the matrix are n
.val syevr_min_liwork : int -> int
syevr_min_liwork n
Lacaml_D.syevr
-function if the logical dimensions
of the matrix are n
.val syevr_opt_lwork : ?n:int ->
?vectors:bool ->
?range:[ `A | `I of int * int | `V of float * float ] ->
?up:bool -> ?abstol:float -> ?ar:int -> ?ac:int -> Lacaml_float64.mat -> int
syevr_opt_lwork ?n ?vectors ?range ?up ?abstol ?ar ?ac a
Lacaml_D.syevr
-function
given matrix a
, optionally its logical dimension n
and whether
the eigenvectors must be computed (vectors
).n
: default = available number of columns of matrix a
vectors
: default = false, i.e. eigenvectors are not computedup
: default = true, i.e. upper triangle of a
is storedval syevr_opt_liwork : ?n:int ->
?vectors:bool ->
?range:[ `A | `I of int * int | `V of float * float ] ->
?up:bool -> ?abstol:float -> ?ar:int -> ?ac:int -> Lacaml_float64.mat -> int
syevr_opt_liwork ?n ?vectors ?range ?up ?abstol ?ar ?ac a
Lacaml_D.syevr
-function
given matrix a
, optionally its logical dimension n
and whether
the eigenvectors must be computed (vectors
).n
: default = available number of columns of matrix a
vectors
: default = false, i.e. eigenvectors are not computedup
: default = true, i.e. upper triangle of a
is storedval syevr_opt_l_li_work : ?n:int ->
?vectors:bool ->
?range:[ `A | `I of int * int | `V of float * float ] ->
?up:bool ->
?abstol:float -> ?ar:int -> ?ac:int -> Lacaml_float64.mat -> int * int
syevr_opt_l_li_iwork ?n ?vectors ?range ?up ?abstol ?ar ?ac a
Lacaml_D.syevr
-function given matrix a
,
optionally its logical dimension n
and whether the eigenvectors
must be computed (vectors
).n
: default = available number of columns of matrix a
vectors
: default = false, i.e. eigenvectors are not computedup
: default = true, i.e. upper triangle of a
is storedval syevr : ?n:int ->
?vectors:bool ->
?range:[ `A | `I of int * int | `V of float * float ] ->
?up:bool ->
?abstol:float ->
?work:Lacaml_float64.vec ->
?iwork:Lacaml_common.int32_vec ->
?ofsw:int ->
?w:Lacaml_float64.vec ->
?zr:int ->
?zc:int ->
?z:Lacaml_float64.mat ->
?isuppz:Lacaml_common.int32_vec ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
int * Lacaml_float64.vec * Lacaml_float64.mat * Lacaml_common.int32_vec
syevr
?n ?vectors ?range ?up ?abstol ?work ?iwork
?ofsw ?w ?zr ?zc ?z ?isuppz ?ar ?ac a
range
is either `A
for computing all eigenpairs, `V (vl, vu)
defines the lower and upper range of computed eigenvalues, `I (il,
iu)
defines the indexes of the computed eigenpairs, which are sorted
in ascending order.
(m, w, z, isuppz)
, where m
is the number
of computed eigenpairs, vector w
contains the computed
eigenvalues in ascending order, z
contains the computed
eigenvectors in same order, and isuppz
indicates the
nonzero elements in z
.n
: default = available number of columns of matrix a
vectors
: default = false i.e, eigenvectors are not computedrange
: default = `Aup
: default = true i.e., upper triangle of a
is storedabstol
: default = result of calling lamch `S
work
: default = vec of optimum length (-> Lacaml_D.syev_opt_lwork
)iwork
: default = int32_vec of optimum length (-> Lacaml_D.syevr_opt_liwork
)ofsw
: default = 1 or ignored if w
is not givenw
: default = vec of length n
zr
: default = 1zc
: default = 1z
: default = matrix with minimal required dimensionisuppz
: default = int32_vec
with minimal required dimensionar
: default = 1ac
: default = 1val sygv_opt_lwork : ?n:int ->
?vectors:bool ->
?up:bool ->
?itype:[ `AB | `A_B | `BA ] ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat -> ?br:int -> ?bc:int -> Lacaml_float64.mat -> int
sygv_opt_lwork ?n ?vectors ?up ?ar ?ac a ?br ?bc b
Lacaml_D.sygv
-function
for the given matrices a
and b
, optionally their logical
dimension n
and whether the eigenvectors must be computed
(vectors
).n
: default = available number of columns of matrix a
vectors
: default = false, i.e. eigenvectors are not computedup
: default = true, i.e. upper triangle of a
is storeditype
: specifies the problem type to be solved:`A_B
(default): a*x = (lambda)*a*x`AB
: a*b*x = (lambda)*x`BA
: b*a*x = (lambda)*xval sygv : ?n:int ->
?vectors:bool ->
?up:bool ->
?work:Lacaml_float64.vec ->
?ofsw:int ->
?w:Lacaml_float64.vec ->
?itype:[ `AB | `A_B | `BA ] ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?br:int -> ?bc:int -> Lacaml_float64.mat -> Lacaml_float64.vec
sygv ?n ?vectors ?up ?ofswork ?work ?ofsw ?w ?ar ?ac a
computes all the eigenvalues, and optionally, the eigenvectors
of a real generalized symmetric-definite eigenproblem, of the
form a*x=(lambda)*b*x
, a*b*x=(lambda)*x
, or b*a*x=(lambda)*x
.
Here a
and b
are assumed to be symmetric and b
is also
positive definite.
Failure
if the function fails to converge.w
of eigenvalues in ascending order.n
: default = available number of columns of matrix a
vectors
: default = false i.e, eigenvectors are not computedup
: default = true i.e., upper triangle of a
is storedwork
: default = vec of optimum length (-> Lacaml_D.sygv_opt_lwork
)ofsw
: default = 1 or ignored if w
is not givenw
: default = vec of length n
itype
: specifies the problem type to be solved:`A_B
(default): a*x = (lambda)*a*x`AB
: a*b*x = (lambda)*x`BA
: b*a*x = (lambda)*xval sbgv : ?n:int ->
?ka:int ->
?kb:int ->
?zr:int ->
?zc:int ->
?z:Lacaml_float64.mat ->
?up:bool ->
?work:Lacaml_float64.vec ->
?ofsw:int ->
?w:Lacaml_float64.vec ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?br:int -> ?bc:int -> Lacaml_float64.mat -> Lacaml_float64.vec
sbgv ?n ?ka ?kb ?zr ?zc ?z ?up ?work ?ofsw ?w ?ar ?ac a ?br ?bc b
computes all the eigenvalues, and optionally, the eigenvectors of a
real generalized symmetric-definite banded eigenproblem, of the
form a*x=(lambda)*b*x
. Here a
and b
are assumed to be
symmetric and banded, and b
is also positive definite.
Failure
if the function fails to converge.w
of eigenvalues in ascending order.n
: default = available number of columns of matrix a
ka
: the number of superdiagonals (or subdiagonals if up = false
)
of the matrix a
. Default = dim1 a - ar
.kb
: same as ka
but for the matrix b
.z
: default = None
i.e, eigenvectors are not computedup
: default = true
i.e., upper triangle of a
is storedwork
: default = vec of optimum length (3 * n
)ofsw
: default = 1 or ignored if w
is not givenw
: default = vec of length n
val swap : ?n:int ->
?ofsx:int ->
?incx:int ->
x:Lacaml_float64.vec -> ?ofsy:int -> ?incy:int -> Lacaml_float64.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 = 1incx
: default = 1ofsy
: default = 1incy
: default = 1val scal : ?n:int ->
Lacaml_float64.num_type ->
?ofsx:int -> ?incx:int -> Lacaml_float64.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 = 1incx
: default = 1val copy : ?n:int ->
?ofsy:int ->
?incy:int ->
?y:Lacaml_float64.vec ->
?ofsx:int -> ?incx:int -> Lacaml_float64.vec -> Lacaml_float64.vec
copy ?n ?ofsy ?incy ?y ?ofsx ?incx x
see BLAS documentation!
y
, which is overwritten.n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsy
: default = 1incy
: default = 1y
: default = new vector with ofsy+(n-1)(abs incy)
rowsofsx
: default = 1incx
: default = 1val nrm2 : ?n:int -> ?ofsx:int -> ?incx:int -> Lacaml_float64.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 = 1incx
: default = 1val axpy : ?alpha:Lacaml_float64.num_type ->
?n:int ->
?ofsx:int ->
?incx:int ->
Lacaml_float64.vec -> ?ofsy:int -> ?incy:int -> Lacaml_float64.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 = 1incx
: default = 1ofsy
: default = 1incy
: default = 1val iamax : ?n:int -> ?ofsx:int -> ?incx:int -> Lacaml_float64.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 = 1incx
: default = 1val amax : ?n:int ->
?ofsx:int -> ?incx:int -> Lacaml_float64.vec -> Lacaml_float64.num_type
amax ?n ?ofsx ?incx x
x
.n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
ofsx
: default = 1incx
: default = 1val gemv : ?m:int ->
?n:int ->
?beta:Lacaml_float64.num_type ->
?ofsy:int ->
?incy:int ->
?y:Lacaml_float64.vec ->
?trans:Lacaml_float64.trans3 ->
?alpha:Lacaml_float64.num_type ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?ofsx:int -> ?incx:int -> Lacaml_float64.vec -> Lacaml_float64.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
.
y
, which is overwritten.m
: default = number of available rows in matrix a
n
: default = available columns in matrix a
beta
: default = { re = 0.; im = 0. }
ofsy
: default = 1incy
: default = 1y
: default = vector with minimal required length (see BLAS)trans
: default = `Nalpha
: default = { re = 1.; im = 0. }
ar
: default = 1ac
: default = 1ofsx
: default = 1incx
: default = 1val gbmv : ?m:int ->
?n:int ->
?beta:Lacaml_float64.num_type ->
?ofsy:int ->
?incy:int ->
?y:Lacaml_float64.vec ->
?trans:Lacaml_float64.trans3 ->
?alpha:Lacaml_float64.num_type ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
int ->
int -> ?ofsx:int -> ?incx:int -> Lacaml_float64.vec -> Lacaml_float64.vec
gbmv
?m ?n ?beta ?ofsy ?incy ?y ?trans ?alpha ?ar ?ac a kl ku ?ofsx ?incx x
see BLAS documentation!
y
, which is overwritten.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 = 1incy
: default = 1y
: default = vector with minimal required length (see BLAS)trans
: default = `Nalpha
: default = { re = 1.; im = 0. }
ar
: default = 1ac
: default = 1ofsx
: default = 1incx
: default = 1val symv : ?n:int ->
?beta:Lacaml_float64.num_type ->
?ofsy:int ->
?incy:int ->
?y:Lacaml_float64.vec ->
?up:bool ->
?alpha:Lacaml_float64.num_type ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?ofsx:int -> ?incx:int -> Lacaml_float64.vec -> Lacaml_float64.vec
symv ?n ?beta ?ofsy ?incy ?y ?up ?alpha ?ar ?ac a ?ofsx ?incx x
see BLAS documentation!
y
, which is overwritten.n
: default = dimension of symmetric matrix a
beta
: default = { re = 0.; im = 0. }
ofsy
: default = 1incy
: default = 1y
: 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 = 1ac
: default = 1ofsx
: default = 1incx
: default = 1val trmv : ?n:int ->
?trans:Lacaml_float64.trans3 ->
?diag:Lacaml_common.diag ->
?up:bool ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat -> ?ofsx:int -> ?incx:int -> Lacaml_float64.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 = `Ndiag
: default = false (not a unit triangular matrix)up
: default = true (upper triangular portion of a
is accessed)ar
: default = 1ac
: default = 1ofsx
: default = 1incx
: default = 1val trsv : ?n:int ->
?trans:Lacaml_float64.trans3 ->
?diag:Lacaml_common.diag ->
?up:bool ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat -> ?ofsx:int -> ?incx:int -> Lacaml_float64.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 = `Ndiag
: default = false (not a unit triangular matrix)up
: default = true (upper triangular portion of a
is accessed)ar
: default = 1ac
: default = 1ofsx
: default = 1incx
: default = 1val tpmv : ?n:int ->
?trans:Lacaml_float64.trans3 ->
?diag:Lacaml_common.diag ->
?up:bool ->
?ofsap:int ->
Lacaml_float64.vec -> ?ofsx:int -> ?incx:int -> Lacaml_float64.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 = `Ndiag
: default = false (not a unit triangular matrix)up
: default = true (upper triangular portion of ap
is accessed)ofsap
: default = 1ofsx
: default = 1incx
: default = 1val tpsv : ?n:int ->
?trans:Lacaml_float64.trans3 ->
?diag:Lacaml_common.diag ->
?up:bool ->
?ofsap:int ->
Lacaml_float64.vec -> ?ofsx:int -> ?incx:int -> Lacaml_float64.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 = `Ndiag
: default = false (not a unit triangular matrix)up
: default = true (upper triangular portion of ap
is accessed)ofsap
: default = 1ofsx
: default = 1incx
: default = 1val gemm : ?m:int ->
?n:int ->
?k:int ->
?beta:Lacaml_float64.num_type ->
?cr:int ->
?cc:int ->
?c:Lacaml_float64.mat ->
?transa:Lacaml_float64.trans3 ->
?alpha:Lacaml_float64.num_type ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?transb:Lacaml_float64.trans3 ->
?br:int -> ?bc:int -> Lacaml_float64.mat -> Lacaml_float64.mat
gemm ?m ?n ?k ?beta ?cr ?cc ?c ?transa ?alpha ?ar ?ac a ?transb ?br ?bc b
see BLAS documentation!
c
, which is overwritten.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 = 1cc
: default = 1c
: default = matrix with minimal required dimensiontransa
: default = `Nalpha
: default = { re = 1.; im = 0. }
ar
: default = 1ac
: default = 1transb
: default = `Nbr
: default = 1bc
: default = 1val symm : ?m:int ->
?n:int ->
?side:Lacaml_common.side ->
?up:bool ->
?beta:Lacaml_float64.num_type ->
?cr:int ->
?cc:int ->
?c:Lacaml_float64.mat ->
?alpha:Lacaml_float64.num_type ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?br:int -> ?bc:int -> Lacaml_float64.mat -> Lacaml_float64.mat
symm ?m ?n ?side ?up ?beta ?cr ?cc ?c ?alpha ?ar ?ac a ?br ?bc b
see BLAS documentation!
c
, which is overwritten.m
: default = number of rows of c
n
: default = number of columns of c
side
: default = `L (left - multiplication is a
b
)up
: default = true (upper triangular portion of a
is accessed)beta
: default = { re = 0.; im = 0. }
cr
: default = 1cc
: default = 1c
: default = matrix with minimal required dimensionalpha
: default = { re = 1.; im = 0. }
ar
: default = 1ac
: default = 1br
: default = 1bc
: default = 1val trmm : ?m:int ->
?n:int ->
?side:Lacaml_common.side ->
?up:bool ->
?transa:Lacaml_float64.trans3 ->
?diag:Lacaml_common.diag ->
?alpha:Lacaml_float64.num_type ->
?ar:int ->
?ac:int ->
a:Lacaml_float64.mat -> ?br:int -> ?bc:int -> Lacaml_float64.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 a
b
)up
: default = true (upper triangular portion of a
is accessed)transa
: default = `Ndiag
: default = `N (non-unit)alpha
: default = { re = 1.; im = 0. }
ar
: default = 1ac
: default = 1br
: default = 1bc
: default = 1val trsm : ?m:int ->
?n:int ->
?side:Lacaml_common.side ->
?up:bool ->
?transa:Lacaml_float64.trans3 ->
?diag:Lacaml_common.diag ->
?alpha:Lacaml_float64.num_type ->
?ar:int ->
?ac:int ->
a:Lacaml_float64.mat -> ?br:int -> ?bc:int -> Lacaml_float64.mat -> unit
trsm ?m ?n ?side ?up ?transa ?diag ?alpha ?ar ?ac ~a ?br ?bc b
see BLAS documentation!
b
, which is overwritten.m
: default = number of rows of b
n
: default = number of columns of b
side
: default = `L (left - multiplication is a
b
)up
: default = true (upper triangular portion of a
is accessed)transa
: default = `Ndiag
: default = `N (non-unit)alpha
: default = { re = 1.; im = 0. }
ar
: default = 1ac
: default = 1br
: default = 1bc
: default = 1val syrk : ?n:int ->
?k:int ->
?up:bool ->
?beta:Lacaml_float64.num_type ->
?cr:int ->
?cc:int ->
?c:Lacaml_float64.mat ->
?trans:Lacaml_common.trans2 ->
?alpha:Lacaml_float64.num_type ->
?ar:int -> ?ac:int -> Lacaml_float64.mat -> Lacaml_float64.mat
syrk ?n ?k ?up ?beta ?cr ?cc ?c ?trans ?alpha ?ar ?ac a
see BLAS documentation!
c
, which is overwritten.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 = 1cc
: default = 1c
: default = matrix with minimal required dimensiontrans
: default = `Nalpha
: default = { re = 1.; im = 0. }
ar
: default = 1ac
: default = 1val syr2k : ?n:int ->
?k:int ->
?up:bool ->
?beta:Lacaml_float64.num_type ->
?cr:int ->
?cc:int ->
?c:Lacaml_float64.mat ->
?trans:Lacaml_common.trans2 ->
?alpha:Lacaml_float64.num_type ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?br:int -> ?bc:int -> Lacaml_float64.mat -> Lacaml_float64.mat
syr2k ?n ?k ?up ?beta ?cr ?cc ?c ?trans ?alpha ?ar ?ac a ?br ?bc b
see BLAS documentation!
c
, which is overwritten.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 = 1cc
: default = 1c
: default = matrix with minimal required dimensiontrans
: default = `Nalpha
: default = { re = 1.; im = 0. }
ar
: default = 1ac
: default = 1br
: default = 1bc
: default = 1val lacpy : ?uplo:[ `L | `U ] ->
?m:int ->
?n:int ->
?br:int ->
?bc:int ->
?b:Lacaml_float64.mat ->
?ar:int -> ?ac:int -> Lacaml_float64.mat -> Lacaml_float64.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 matrixval lassq : ?n:int ->
?scale:float ->
?sumsq:float -> ?ofsx:int -> ?incx:int -> Lacaml_float64.vec -> float * float
lassq ?n ?ofsx ?incx ?scale ?sumsq
(scl, ssq)
, where
scl
is a scaling factor and ssq
the sum of squares of vector
x
starting at ofs
and using increment incx
and initial
scale
and sumsq
. The following equality holds:
scl**2. *. ssq = x.{1}**2. +. ... +. x.{n}**2. +. scale**2. *. sumsq
.
See LAPACK-documentation for details!n
: default = greater n s.t. ofsx+(n-1)(abs incx) <= dim x
scale
: default = 0.sumsq
: default = 1.ofsx
: default = 1incx
: default = 1val larnv : ?idist:[ `Normal | `Uniform0 | `Uniform1 ] ->
?iseed:Lacaml_common.int32_vec ->
?n:int -> ?ofsx:int -> ?x:Lacaml_float64.vec -> unit -> Lacaml_float64.vec
larnv ?idist ?iseed ?n ?ofsx ?x ()
idist
, random seed iseed
, vector offset
ofsx
and optional vector 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
lange
-function.val lange : ?m:int ->
?n:int ->
?norm:Lacaml_common.norm4 ->
?work:Lacaml_float64.rvec ->
?ar:int -> ?ac:int -> Lacaml_float64.mat -> float
lange ?m ?n ?norm ?work ?ar ?ac a
norm = `O
), or the Frobenius norm (norm = `F
), or the infinity
norm (norm = `I
), or the element of largest absolute value
(norm = `M
) of a real matrix 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 = 1ac
: default = 1val lauum : ?up:bool -> ?n:int -> ?ar:int -> ?ac:int -> Lacaml_float64.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 = 1ac
: default = 1val getrf : ?m:int ->
?n:int ->
?ipiv:Lacaml_common.int32_vec ->
?ar:int -> ?ac:int -> Lacaml_float64.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.
Failure
if the matrix is singular.ipiv
, the pivot indices.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 = 1ac
: default = 1val getrs : ?n:int ->
?ipiv:Lacaml_common.int32_vec ->
?trans:Lacaml_float64.trans3 ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_float64.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_D.getrf
.
Note that matrix a
will be passed to Lacaml_D.getrf
if ipiv
was not
provided.
Failure
if the matrix is singular.n
: default = number of columns in matrix a
ipiv
: default = result from getrf
applied to a
trans
: default = `Nar
: default = 1ac
: default = 1nrhs
: default = available number of columns in matrix b
br
: default = 1bc
: default = 1val getri_min_lwork : int -> int
getri_min_lwork n
Lacaml_D.getri
-function if the matrix has n
columns.val getri_opt_lwork : ?n:int -> ?ar:int -> ?ac:int -> Lacaml_float64.mat -> int
getri_opt_lwork ?n ?ar ?ac a
Lacaml_D.getri
-function.n
: default = number of columns of matrix a
ar
: default = 1ac
: default = 1val getri : ?n:int ->
?ipiv:Lacaml_common.int32_vec ->
?work:Lacaml_float64.vec -> ?ar:int -> ?ac:int -> Lacaml_float64.mat -> unit
getri ?n ?ipiv ?work ?ar ?ac a
computes the inverse of a matrix
using the LU factorization computed by Lacaml_D.getrf
. Note that matrix
a
will be passed to Lacaml_D.getrf
if ipiv
was not provided.
Failure
if the matrix is singular.n
: default = number of columns in matrix a
ipiv
: default = vec of length m
from getriwork
: default = vec of optimum lengthar
: default = 1ac
: default = 1val sytrf_min_lwork : unit -> int
sytrf_min_lwork ()
Lacaml_D.sytrf
-function.val sytrf_opt_lwork : ?n:int -> ?up:bool -> ?ar:int -> ?ac:int -> Lacaml_float64.mat -> int
sytrf_opt_lwork ?n ?up ?ar ?ac a
Lacaml_D.sytrf
-function.n
: default = number of columns of matrix a
up
: default = true (store upper triangle in a
)ar
: default = 1ac
: default = 1val sytrf : ?n:int ->
?up:bool ->
?ipiv:Lacaml_common.int32_vec ->
?work:Lacaml_float64.vec ->
?ar:int -> ?ac:int -> Lacaml_float64.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.
Failure
if D in a
= U*D*U' or L*D*L' is singular.n
: default = number of columns in matrix a
up
: default = true (store upper triangle in a
)ipiv
: = vec of length nwork
: default = vec of optimum lengthar
: default = 1ac
: default = 1val sytrs : ?n:int ->
?up:bool ->
?ipiv:Lacaml_common.int32_vec ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_float64.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_D.sytrf
. Note that matrix a
will be passed to Lacaml_D.sytrf
if
ipiv
was not provided.
Failure
if the matrix is singular.n
: default = number of columns in matrix a
up
: default = true (store upper triangle in a
)ipiv
: default = vec of length n
ar
: default = 1ac
: default = 1nrhs
: default = available number of columns in matrix b
br
: default = 1bc
: default = 1val sytri_min_lwork : int -> int
sytri_min_lwork n
Lacaml_D.sytri
-function if the matrix has n
columns.val sytri : ?n:int ->
?up:bool ->
?ipiv:Lacaml_common.int32_vec ->
?work:Lacaml_float64.vec -> ?ar:int -> ?ac:int -> Lacaml_float64.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_D.sytrf
. Note that matrix
a
will be passed to Lacaml_D.sytrf
if ipiv
was not provided.
Failure
if the matrix is singular.n
: default = number of columns in matrix a
up
: default = true (store upper triangle in a
)work
: default = vec of optimum lengthar
: default = 1ac
: default = 1val potrf : ?n:int ->
?up:bool ->
?ar:int ->
?ac:int -> ?jitter:Lacaml_float64.num_type -> Lacaml_float64.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.
Failure
if the matrix is singular.n
: default = number of columns in matrix a
up
: default = true (store upper triangle in a
)ar
: default = 1ac
: default = 1jitter
: default = nothingval potrs : ?n:int ->
?up:bool ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?nrhs:int ->
?br:int ->
?bc:int ->
?factorize:bool ->
?jitter:Lacaml_float64.num_type -> Lacaml_float64.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_D.potrf
.
Failure
if the matrix is singular.n
: default = number of columns in matrix a
up
: default = truear
: default = 1ac
: default = 1nrhs
: default = available number of columns in matrix b
br
: default = 1bc
: default = 1factorize
: default = true (calls Lacaml_D.potrf
implicitly)jitter
: default = nothingval potri : ?n:int ->
?up:bool ->
?ar:int ->
?ac:int ->
?factorize:bool ->
?jitter:Lacaml_float64.num_type -> Lacaml_float64.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_D.potrf
.
Failure
if the matrix is singular.n
: default = number of columns in matrix a
up
: default = true (upper triangle stored in a
)ar
: default = 1ac
: default = 1factorize
: default = true (calls Lacaml_D.potrf
implicitly)jitter
: default = nothingval trtrs : ?n:int ->
?up:bool ->
?trans:Lacaml_float64.trans3 ->
?diag:Lacaml_common.diag ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_float64.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.
Failure
if the matrix a
is singular.n
: default = number of columns in matrix a
up
: default = truetrans
: default = `Ndiag
: default = `Nar
: default = 1ac
: default = 1nrhs
: default = available number of columns in matrix b
br
: default = 1bc
: default = 1val tbtrs : ?n:int ->
?kd:int ->
?up:bool ->
?trans:Lacaml_float64.trans3 ->
?diag:Lacaml_common.diag ->
?abr:int ->
?abc:int ->
Lacaml_float64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_float64.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.
Failure
if the matrix a
is singular.n
: default = number of columns in matrix ab
kd
: default = number of rows in matrix ab
- 1up
: default = truetrans
: default = `Ndiag
: default = `Nabr
: default = 1abc
: default = 1nrhs
: default = available number of columns in matrix b
br
: default = 1bc
: default = 1val trtri : ?n:int ->
?up:bool ->
?diag:Lacaml_common.diag -> ?ar:int -> ?ac:int -> Lacaml_float64.mat -> unit
trtri ?n ?up ?diag ?ar ?ac a
computes the inverse of a real
upper or lower triangular matrix a
.
Failure
if the matrix a
is singular.n
: default = number of columns in matrix a
up
: default = true (upper triangle stored in a
)diag
: default = `Nar
: default = 1ac
: default = 1val geqrf_opt_lwork : ?m:int -> ?n:int -> ?ar:int -> ?ac:int -> Lacaml_float64.mat -> int
geqrf_opt_lwork ?m ?n ?ar ?ac a
Lacaml_D.geqrf
-function given matrix
a
and optionally its logical dimensions m
and n
.m
: default = number of rows in matrix a
n
: default = number of columns in matrix a
ar
: default = 1ac
: default = 1val geqrf_min_lwork : n:int -> int
geqrf_min_lwork ~n
Lacaml_D.geqrf
-function if the matrix has n
columns.val geqrf : ?m:int ->
?n:int ->
?work:Lacaml_float64.vec ->
?tau:Lacaml_float64.vec ->
?ar:int -> ?ac:int -> Lacaml_float64.mat -> Lacaml_float64.vec
geqrf ?m ?n ?work ?tau ?ar ?ac a
computes a QR factorization of
a real m
-by-n
matrix a
. See LAPACK documentation.
tau
, the scalar factors of the elementary reflectors.m
: default = number of rows in matrix a
n
: default = number of columns in matrix a
work
: default = vec of optimum lengthtau
: default = vec of required lengthar
: default = 1ac
: default = 1val gesv : ?n:int ->
?ipiv:Lacaml_common.int32_vec ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_float64.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.
Failure
if the matrix a
is singular.n
: default = available number of columns in matrix a
ipiv
: default = vec of length n
ar
: default = 1ac
: default = 1nrhs
: default = available number of columns in matrix b
br
: default = 1bc
: default = 1val gbsv : ?n:int ->
?ipiv:Lacaml_common.int32_vec ->
?abr:int ->
?abc:int ->
Lacaml_float64.mat ->
int -> int -> ?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_float64.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
.
Failure
if the matrix a
is singular.n
: default = available number of columns in matrix ab
ipiv
: default = vec of length n
abr
: default = 1abc
: default = 1nrhs
: default = available number of columns in matrix b
br
: default = 1bc
: default = 1val gtsv : ?n:int ->
?ofsdl:int ->
Lacaml_float64.vec ->
?ofsd:int ->
Lacaml_float64.vec ->
?ofsdu:int ->
Lacaml_float64.vec ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_float64.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
.
Failure
if the matrix is singular.n
: default = available length of vector d
ofsdl
: default = 1ofsd
: default = 1ofsdu
: default = 1nrhs
: default = available number of columns in matrix b
br
: default = 1bc
: default = 1val posv : ?n:int ->
?up:bool ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_float64.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
.
Failure
if the matrix is singular.n
: default = available number of columns in matrix a
up
: default = true i.e., upper triangle of a
is storedar
: default = 1ac
: default = 1nrhs
: default = available number of columns in matrix b
br
: default = 1bc
: default = 1val ppsv : ?n:int ->
?up:bool ->
?ofsap:int ->
Lacaml_float64.vec ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_float64.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
.
Failure
if the matrix is singular.n
: default = the greater n s.t. n(n+1)/2 <= Vec.dim ap
up
: default = true i.e., upper triangle of ap
is storedofsap
: default = 1nrhs
: default = available number of columns in matrix b
br
: default = 1bc
: default = 1val pbsv : ?n:int ->
?up:bool ->
?kd:int ->
?abr:int ->
?abc:int ->
Lacaml_float64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_float64.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
.
Failure
if the matrix is singular.n
: default = available number of columns in matrix ab
up
: default = true i.e., upper triangle of ab
is storedkd
: default = available number of rows in matrix ab
- 1abr
: default = 1abc
: default = 1nrhs
: default = available number of columns in matrix b
br
: default = 1bc
: default = 1val ptsv : ?n:int ->
?ofsd:int ->
Lacaml_float64.vec ->
?ofse:int ->
Lacaml_float64.vec ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_float64.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.
Failure
if the matrix is singular.n
: default = available length of vector d
ofsd
: default = 1ofse
: default = 1nrhs
: default = available number of columns in matrix b
br
: default = 1bc
: default = 1val sysv_opt_lwork : ?n:int ->
?up:bool ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_float64.mat -> int
sysv_opt_lwork ?n ?up ?ar ?ac a ?nrhs ?br ?bc b
sysv
-function given matrix
a
, optionally its logical dimension n
and given right hand side
matrix b
with an optional number nrhs
of vectors.n
: default = available number of columns in matrix a
up
: default = true i.e., upper triangle of a
is storedar
: default = 1ac
: default = 1nrhs
: default = available number of columns in matrix b
br
: default = 1bc
: default = 1val sysv : ?n:int ->
?up:bool ->
?ipiv:Lacaml_common.int32_vec ->
?work:Lacaml_float64.vec ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_float64.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
.
Failure
if the matrix is singular.n
: default = available number of columns in matrix a
up
: default = true i.e., upper triangle of a
is storedipiv
: default = vec of length n
work
: default = vec of optimum length (-> sysv_opt_lwork
)ar
: default = 1ac
: default = 1nrhs
: default = available number of columns in matrix b
br
: default = 1bc
: default = 1val spsv : ?n:int ->
?up:bool ->
?ipiv:Lacaml_common.int32_vec ->
?ofsap:int ->
Lacaml_float64.vec ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_float64.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
.
Failure
if the matrix is singular.n
: default = the greater n s.t. n(n+1)/2 <= Vec.dim ap
up
: default = true i.e., upper triangle of ap
is storedipiv
: default = vec of length n
ofsap
: default = 1nrhs
: default = available number of columns in matrix b
br
: default = 1bc
: default = 1val gels_min_lwork : m:int -> n:int -> nrhs:int -> int
gels_min_lwork ~m ~n ~nrhs
gels
-function if the logical dimensions
of the matrix are m
rows and n
columns and if there are nrhs
right hand side vectors.val gels_opt_lwork : ?m:int ->
?n:int ->
?trans:Lacaml_common.trans2 ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_float64.mat -> int
gels_opt_lwork ?m ?n ?trans ?ar ?ac a ?nrhs ?br ?bc b
gels
-function given
matrix a
, optionally its logical dimensions m
and n
and given
right hand side matrix b
with an optional number nrhs
of vectors.m
: default = available number of rows in matrix a
n
: default = available number of columns in matrix a
trans
: default = `Nar
: default = 1ac
: default = 1nrhs
: default = available number of columns in matrix b
br
: default = 1bc
: default = 1val gels : ?m:int ->
?n:int ->
?work:Lacaml_float64.vec ->
?trans:Lacaml_common.trans2 ->
?ar:int ->
?ac:int ->
Lacaml_float64.mat ->
?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_float64.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_D.gels_opt_lwork
)trans
: default = `Nar
: default = 1ac
: default = 1nrhs
: default = available number of columns in matrix b
br
: default = 1bc
: default = 1