package lacaml
- BLAS-1 interface
- BLAS-2 interface
- LAPACK interface
- Auxiliary routines
- Linear equations (computational routines)
- Least squares (expert drivers)
- General Schur factorization
- General SVD routines
- General eigenvalue problem (simple drivers)
- Symmetric-matrix eigenvalue and singular value problems (simple drivers)
- Symmetric-matrix eigenvalue and singular value problems (expert & RRR drivers)
- BLAS-1 interface
- BLAS-2 interface
- BLAS-3 interface
- LAPACK interface
- Auxiliary routines
- Linear equations (computational routines)
- Linear equations (simple drivers)
- Least squares (simple drivers)
Library
Module
Module type
Parameter
Class
Class type
Double precision real BLAS and LAPACK functions.
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.
type prec = Bigarray.float64_elt
type vec =
(float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Array1.t
Vectors (precision: float64).
type rvec = vec
type mat =
(float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Array2.t
Matrices (precision: float64).
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 : Format.formatter -> float -> unit
pp_num ppf el
is equivalent to fprintf ppf "%G" el
.
val pp_vec :
Format.formatter ->
(float, 'a, Bigarray.fortran_layout) Bigarray.Array1.t ->
unit
Pretty-printer for column vectors.
val pp_mat :
Format.formatter ->
(float, 'a, Bigarray.fortran_layout) Bigarray.Array2.t ->
unit
Pretty-printer for matrices.
BLAS-1 interface
dot ?n ?ofsx ?incx x ?ofsy ?incy y
see BLAS documentation!
val asum : ?n:int -> ?ofsx:int -> ?incx:int -> vec -> float
asum ?n ?ofsx ?incx x
see BLAS documentation!
BLAS-2 interface
val sbmv :
?n:int ->
?k:int ->
?ofsy:int ->
?incy:int ->
?y:vec ->
?ar:int ->
?ac:int ->
mat ->
?up:bool ->
?alpha:float ->
?beta:float ->
?ofsx:int ->
?incx:int ->
vec ->
vec
sbmv ?n ?k ?ofsy ?incy ?y ?ar ?ac a ?up ?alpha ?beta ?ofsx ?incx x
see BLAS documentation!
val ger :
?m:int ->
?n:int ->
?alpha:float ->
?ofsx:int ->
?incx:int ->
vec ->
?ofsy:int ->
?incy:int ->
vec ->
?ar:int ->
?ac:int ->
mat ->
unit
ger ?m ?n ?alpha ?ofsx ?incx x ?ofsy ?incy y n ?ar ?ac a
see BLAS documentation!
val syr :
?n:int ->
?alpha:float ->
?up:bool ->
?ofsx:int ->
?incx:int ->
vec ->
?ar:int ->
?ac:int ->
mat ->
unit
syr ?n ?alpha ?up ?ofsx ?incx x ?ar ?ac a
see BLAS documentation!
LAPACK interface
Auxiliary routines
val lansy :
?n:int ->
?up:bool ->
?norm:[ Lacaml__common.norm2 | `M | `F ] ->
?work:vec ->
?ar:int ->
?ac:int ->
mat ->
float
lansy ?norm ?up ?n ?ar ?ac ?work a
see LAPACK documentation!
lamch cmach
see LAPACK documentation!
Linear equations (computational routines)
orgqr_opt_lwork ?m ?n ?k ~tau ?ar ?ac a
orgqr ?m ?n ?k ?work ~tau ?ar ?ac a
see LAPACK documentation!
val ormqr_opt_lwork :
?side:[ `L | `R ] ->
?trans:[ `N | `T ] ->
?m:int ->
?n:int ->
?k:int ->
tau:vec ->
?ar:int ->
?ac:int ->
mat ->
?cr:int ->
?cc:int ->
mat ->
int
ormqr_opt_lwork ?side ?trans ?m ?n ?k ~tau ?ar ?ac a ?cr ?cc c
val ormqr :
?side:[ `L | `R ] ->
?trans:[ `N | `T ] ->
?m:int ->
?n:int ->
?k:int ->
?work:vec ->
tau:vec ->
?ar:int ->
?ac:int ->
mat ->
?cr:int ->
?cc:int ->
mat ->
unit
ormqr ?side ?trans ?m ?n ?k ?work ~tau ?ar ?ac a ?cr ?cc c
see LAPACK documentation!
val gecon :
?n:int ->
?norm:[ `O | `I ] ->
?anorm:float ->
?work:vec ->
?iwork:(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t ->
?ar:int ->
?ac:int ->
mat ->
float
gecon ?n ?norm ?anorm ?work ?rwork ?ar ?ac a
val sycon :
?n:int ->
?up:bool ->
?ipiv:(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t ->
?anorm:float ->
?work:vec ->
?iwork:(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t ->
?ar:int ->
?ac:int ->
mat ->
float
sycon ?n ?up ?ipiv ?anorm ?work ?iwork ?ar ?ac a
val pocon :
?n:int ->
?up:bool ->
?anorm:float ->
?work:vec ->
?iwork:(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t ->
?ar:int ->
?ac:int ->
mat ->
float
pocon ?n ?up ?anorm ?work ?iwork ?ar ?ac a
Least squares (expert drivers)
val gelsy_opt_lwork :
?m:int ->
?n:int ->
?ar:int ->
?ac:int ->
mat ->
?nrhs:int ->
?br:int ->
?bc:int ->
mat ->
int
gelsy_opt_lwork ?m ?n ?ar ?ac a ?nrhs ?br ?bc b
val gelsy :
?m:int ->
?n:int ->
?ar:int ->
?ac:int ->
mat ->
?rcond:float ->
?jpvt:(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t ->
?work:vec ->
?nrhs:int ->
?br:int ->
?bc:int ->
mat ->
int
gelsy ?m ?n ?ar ?ac a ?rcond ?jpvt ?ofswork ?work ?nrhs b
see LAPACK documentation!
val gelsd_opt_lwork :
?m:int ->
?n:int ->
?ar:int ->
?ac:int ->
mat ->
?nrhs:int ->
?br:int ->
?bc:int ->
mat ->
int
gelsd_opt_lwork ?m ?n ?ar ?ac a ?nrhs b
val gelsd :
?m:int ->
?n:int ->
?rcond:float ->
?ofss:int ->
?s:vec ->
?work:vec ->
?iwork:vec ->
?ar:int ->
?ac:int ->
mat ->
?nrhs:int ->
?br:int ->
?bc:int ->
mat ->
int
gelsd ?m ?n ?rcond ?ofss ?s ?ofswork ?work ?ar ?ac a ?nrhs b
see LAPACK documentation!
val gelss_opt_lwork :
?ar:int ->
?ac:int ->
mat ->
?m:int ->
?n:int ->
?nrhs:int ->
?br:int ->
?bc:int ->
mat ->
int
gelss_opt_lwork ?ar ?ac a ?m ?n ?nrhs ?br ?bc b
val gelss :
?m:int ->
?n:int ->
?rcond:float ->
?ofss:int ->
?s:vec ->
?work:vec ->
?ar:int ->
?ac:int ->
mat ->
?nrhs:int ->
?br:int ->
?bc:int ->
mat ->
int
gelss ?m ?n ?rcond ?ofss ?s ?ofswork ?work ?ar ?ac a ?nrhs ?br ?bc b
see LAPACK documentation!
General Schur factorization
val gees :
?n:int ->
?jobvs:[ `No_Schur_vectors | `Compute_Schur_vectors ] ->
?sort:
[ `No_sort
| `Select_left_plane
| `Select_right_plane
| `Select_interior_disk
| `Select_exterior_disk
| `Select_custom of Complex.t -> bool ] ->
?wr:vec ->
?wi:vec ->
?vsr:int ->
?vsc:int ->
?vs:mat ->
?work:vec ->
?ar:int ->
?ac:int ->
mat ->
int * vec * vec * mat
gees ?n ?jobvs ?sort ?w ?vsr ?vsc ?vs ?work ?ar ?ac a
See gees
-function for details about arguments.
General SVD routines
gesdd_min_lwork ?jobz ~m ~n
val gesdd_opt_lwork :
?m:int ->
?n:int ->
?jobz:[ `A | `S | `O | `N ] ->
?s:vec ->
?ur:int ->
?uc:int ->
?u:mat ->
?vtr:int ->
?vtc:int ->
?vt:mat ->
?iwork:(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t ->
?ar:int ->
?ac:int ->
mat ->
int
val gesdd :
?m:int ->
?n:int ->
?jobz:[ `A | `S | `O | `N ] ->
?s:vec ->
?ur:int ->
?uc:int ->
?u:mat ->
?vtr:int ->
?vtc:int ->
?vt:mat ->
?work:vec ->
?iwork:(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t ->
?ar:int ->
?ac:int ->
mat ->
vec * mat * mat
General eigenvalue problem (simple drivers)
val geev_opt_lwork :
?n:int ->
?vlr:int ->
?vlc:int ->
?vl:mat option ->
?vrr:int ->
?vrc:int ->
?vr:mat option ->
?ofswr:int ->
?wr:vec ->
?ofswi:int ->
?wi:vec ->
?ar:int ->
?ac:int ->
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:vec ->
?vlr:int ->
?vlc:int ->
?vl:mat option ->
?vrr:int ->
?vrc:int ->
?vr:mat option ->
?ofswr:int ->
?wr:vec ->
?ofswi:int ->
?wi:vec ->
?ar:int ->
?ac:int ->
mat ->
mat * vec * vec * mat
geev ?work ?n
?vlr ?vlc ?vl
?vrr ?vrc ?vr
?ofswr ?wr ?ofswi ?wi
?ar ?ac a
Symmetric-matrix eigenvalue and singular value problems (simple drivers)
val syev_opt_lwork :
?n:int ->
?vectors:bool ->
?up:bool ->
?ar:int ->
?ac:int ->
mat ->
int
syev_opt_lwork ?n ?vectors ?up ?ar ?ac a
val syev :
?n:int ->
?vectors:bool ->
?up:bool ->
?work:vec ->
?ofsw:int ->
?w:vec ->
?ar:int ->
?ac:int ->
mat ->
vec
syev ?n ?vectors ?up ?ofswork ?work ?ofsw ?w ?ar ?ac a
computes all eigenvalues and, optionally, eigenvectors of the real symmetric matrix a
.
val syevd_opt_lwork :
?n:int ->
?vectors:bool ->
?up:bool ->
?ar:int ->
?ac:int ->
mat ->
int
syevd_opt_lwork ?n ?vectors ?up ?ar ?ac a
val syevd_opt_liwork :
?n:int ->
?vectors:bool ->
?up:bool ->
?ar:int ->
?ac:int ->
mat ->
int
syevd_opt_liwork ?n ?vectors ?up ?ar ?ac a
val syevd_opt_l_li_work :
?n:int ->
?vectors:bool ->
?up:bool ->
?ar:int ->
?ac:int ->
mat ->
int * int
syevd_opt_l_li_iwork ?n ?vectors ?up ?ar ?ac a
val syevd :
?n:int ->
?vectors:bool ->
?up:bool ->
?work:vec ->
?iwork:(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t ->
?ofsw:int ->
?w:vec ->
?ar:int ->
?ac:int ->
mat ->
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.
val sbev :
?n:int ->
?kd:int ->
?zr:int ->
?zc:int ->
?z:mat ->
?up:bool ->
?work:vec ->
?ofsw:int ->
?w:vec ->
?abr:int ->
?abc:int ->
mat ->
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
.
Symmetric-matrix eigenvalue and singular value problems (expert & RRR drivers)
val syevr_opt_lwork :
?n:int ->
?vectors:bool ->
?range:[ `A | `V of float * float | `I of int * int ] ->
?up:bool ->
?abstol:float ->
?ar:int ->
?ac:int ->
mat ->
int
syevr_opt_lwork ?n ?vectors ?range ?up ?abstol ?ar ?ac a
val syevr_opt_liwork :
?n:int ->
?vectors:bool ->
?range:[ `A | `V of float * float | `I of int * int ] ->
?up:bool ->
?abstol:float ->
?ar:int ->
?ac:int ->
mat ->
int
syevr_opt_liwork ?n ?vectors ?range ?up ?abstol ?ar ?ac a
val syevr_opt_l_li_work :
?n:int ->
?vectors:bool ->
?range:[ `A | `V of float * float | `I of int * int ] ->
?up:bool ->
?abstol:float ->
?ar:int ->
?ac:int ->
mat ->
int * int
syevr_opt_l_li_iwork ?n ?vectors ?range ?up ?abstol ?ar ?ac a
val syevr :
?n:int ->
?vectors:bool ->
?range:[ `A | `V of float * float | `I of int * int ] ->
?up:bool ->
?abstol:float ->
?work:vec ->
?iwork:(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t ->
?ofsw:int ->
?w:vec ->
?zr:int ->
?zc:int ->
?z:mat ->
?isuppz:
(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t ->
?ar:int ->
?ac:int ->
mat ->
int
* vec
* mat
* (int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t
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.
val sygv_opt_lwork :
?n:int ->
?vectors:bool ->
?up:bool ->
?itype:[ `A_B | `AB | `BA ] ->
?ar:int ->
?ac:int ->
mat ->
?br:int ->
?bc:int ->
mat ->
int
sygv_opt_lwork ?n ?vectors ?up ?ar ?ac a ?br ?bc b
val sygv :
?n:int ->
?vectors:bool ->
?up:bool ->
?work:vec ->
?ofsw:int ->
?w:vec ->
?itype:[ `A_B | `AB | `BA ] ->
?ar:int ->
?ac:int ->
mat ->
?br:int ->
?bc:int ->
mat ->
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.
val sbgv :
?n:int ->
?ka:int ->
?kb:int ->
?zr:int ->
?zc:int ->
?z:mat ->
?up:bool ->
?work:vec ->
?ofsw:int ->
?w:vec ->
?ar:int ->
?ac:int ->
mat ->
?br:int ->
?bc:int ->
mat ->
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.
BLAS-1 interface
swap ?n ?ofsx ?incx x ?ofsy ?incy y
see BLAS documentation!
val scal : ?n:int -> float -> ?ofsx:int -> ?incx:int -> vec -> unit
scal ?n alpha ?ofsx ?incx x
see BLAS documentation!
copy ?n ?ofsy ?incy ?y ?ofsx ?incx x
see BLAS documentation!
val nrm2 : ?n:int -> ?ofsx:int -> ?incx:int -> vec -> float
nrm2 ?n ?ofsx ?incx x
see BLAS documentation!
val axpy :
?alpha:float ->
?n:int ->
?ofsx:int ->
?incx:int ->
vec ->
?ofsy:int ->
?incy:int ->
vec ->
unit
axpy ?alpha ?n ?ofsx ?incx x ?ofsy ?incy y
see BLAS documentation!
val iamax : ?n:int -> ?ofsx:int -> ?incx:int -> vec -> int
iamax ?n ?ofsx ?incx x
see BLAS documentation!
val amax : ?n:int -> ?ofsx:int -> ?incx:int -> vec -> float
amax ?n ?ofsx ?incx x
BLAS-2 interface
val gemv :
?m:int ->
?n:int ->
?beta:float ->
?ofsy:int ->
?incy:int ->
?y:vec ->
?trans:trans3 ->
?alpha:float ->
?ar:int ->
?ac:int ->
mat ->
?ofsx:int ->
?incx:int ->
vec ->
vec
gemv ?m ?n ?beta ?ofsy ?incy ?y ?trans ?alpha ?ar ?ac a ?ofsx ?incx x
performs the operation y
:= alpha
* op(a
) * x
+ beta
* y
where op(a
) = a
or a
ᵀ according to the value of trans
. See BLAS documentation for more information. BEWARE that the 1988 BLAS-2 specification mandates that this function has no effect when n=0
while the mathematically expected behavior is y ← beta * y
.
val gbmv :
?m:int ->
?n:int ->
?beta:float ->
?ofsy:int ->
?incy:int ->
?y:vec ->
?trans:trans3 ->
?alpha:float ->
?ar:int ->
?ac:int ->
mat ->
int ->
int ->
?ofsx:int ->
?incx:int ->
vec ->
vec
gbmv
?m ?n ?beta ?ofsy ?incy ?y ?trans ?alpha ?ar ?ac a kl ku ?ofsx ?incx x
see BLAS documentation!
val symv :
?n:int ->
?beta:float ->
?ofsy:int ->
?incy:int ->
?y:vec ->
?up:bool ->
?alpha:float ->
?ar:int ->
?ac:int ->
mat ->
?ofsx:int ->
?incx:int ->
vec ->
vec
symv ?n ?beta ?ofsy ?incy ?y ?up ?alpha ?ar ?ac a ?ofsx ?incx x
see BLAS documentation!
val trmv :
?n:int ->
?trans:trans3 ->
?diag:[ `U | `N ] ->
?up:bool ->
?ar:int ->
?ac:int ->
mat ->
?ofsx:int ->
?incx:int ->
vec ->
unit
trmv ?n ?trans ?diag ?up ?ar ?ac a ?ofsx ?incx x
see BLAS documentation!
val trsv :
?n:int ->
?trans:trans3 ->
?diag:[ `U | `N ] ->
?up:bool ->
?ar:int ->
?ac:int ->
mat ->
?ofsx:int ->
?incx:int ->
vec ->
unit
trsv ?n ?trans ?diag ?up ?ar ?ac a ?ofsx ?incx x
see BLAS documentation!
val tpmv :
?n:int ->
?trans:trans3 ->
?diag:[ `U | `N ] ->
?up:bool ->
?ofsap:int ->
vec ->
?ofsx:int ->
?incx:int ->
vec ->
unit
tpmv ?n ?trans ?diag ?up ?ofsap ap ?ofsx ?incx x
see BLAS documentation!
val tpsv :
?n:int ->
?trans:trans3 ->
?diag:[ `U | `N ] ->
?up:bool ->
?ofsap:int ->
vec ->
?ofsx:int ->
?incx:int ->
vec ->
unit
tpsv ?n ?trans ?diag ?up ?ofsap ap ?ofsx ?incx x
see BLAS documentation!
BLAS-3 interface
val gemm :
?m:int ->
?n:int ->
?k:int ->
?beta:float ->
?cr:int ->
?cc:int ->
?c:mat ->
?transa:trans3 ->
?alpha:float ->
?ar:int ->
?ac:int ->
mat ->
?transb:trans3 ->
?br:int ->
?bc:int ->
mat ->
mat
gemm ?m ?n ?k ?beta ?cr ?cc ?c ?transa ?alpha ?ar ?ac a ?transb ?br ?bc b
performs the operation c
:= alpha
* op(a
) * op(b
) + beta
* c
where op(x
) = x
or x
ᵀ depending on transx
. See BLAS documentation for more information.
val symm :
?m:int ->
?n:int ->
?side:[ `L | `R ] ->
?up:bool ->
?beta:float ->
?cr:int ->
?cc:int ->
?c:mat ->
?alpha:float ->
?ar:int ->
?ac:int ->
mat ->
?br:int ->
?bc:int ->
mat ->
mat
symm ?m ?n ?side ?up ?beta ?cr ?cc ?c ?alpha ?ar ?ac a ?br ?bc b
see BLAS documentation!
val trmm :
?m:int ->
?n:int ->
?side:[ `L | `R ] ->
?up:bool ->
?transa:trans3 ->
?diag:[ `U | `N ] ->
?alpha:float ->
?ar:int ->
?ac:int ->
a:mat ->
?br:int ->
?bc:int ->
mat ->
unit
trmm ?m ?n ?side ?up ?transa ?diag ?alpha ?ar ?ac ~a ?br ?bc b
see BLAS documentation!
val trsm :
?m:int ->
?n:int ->
?side:[ `L | `R ] ->
?up:bool ->
?transa:trans3 ->
?diag:[ `U | `N ] ->
?alpha:float ->
?ar:int ->
?ac:int ->
a:mat ->
?br:int ->
?bc:int ->
mat ->
unit
trsm ?m ?n ?side ?up ?transa ?diag ?alpha ?ar ?ac ~a ?br ?bc b
see BLAS documentation!
val syrk :
?n:int ->
?k:int ->
?up:bool ->
?beta:float ->
?cr:int ->
?cc:int ->
?c:mat ->
?trans:[ `N | `T ] ->
?alpha:float ->
?ar:int ->
?ac:int ->
mat ->
mat
syrk ?n ?k ?up ?beta ?cr ?cc ?c ?trans ?alpha ?ar ?ac a
see BLAS documentation!
val syr2k :
?n:int ->
?k:int ->
?up:bool ->
?beta:float ->
?cr:int ->
?cc:int ->
?c:mat ->
?trans:[ `N | `T ] ->
?alpha:float ->
?ar:int ->
?ac:int ->
mat ->
?br:int ->
?bc:int ->
mat ->
mat
syr2k ?n ?k ?up ?beta ?cr ?cc ?c ?trans ?alpha ?ar ?ac a ?br ?bc b
see BLAS documentation!
LAPACK interface
Auxiliary routines
val lacpy :
?uplo:[ `U | `L ] ->
?m:int ->
?n:int ->
?br:int ->
?bc:int ->
?b:mat ->
?ar:int ->
?ac:int ->
mat ->
mat
lacpy ?uplo ?m ?n ?br ?bc ?b ?ar ?ac a
copy the (triangular) (sub-)matrix a
(to an optional (sub-)matrix b
) and return it.
val laswp :
?n:int ->
?ar:int ->
?ac:int ->
mat ->
?k1:int ->
?k2:int ->
?incx:int ->
(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t ->
unit
laswp ?n ?ar ?ac a ?k1 ?k2 ?incx ipiv
swap rows of a
according to ipiv
. See LAPACK-documentation for details!
val lapmt :
?forward:bool ->
?m:int ->
?n:int ->
?ar:int ->
?ac:int ->
mat ->
(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t ->
unit
lapmt ?forward ?n ?m ?ar ?ac a k
swap columns of a
according to the permutations in k
. See LAPACK-documentation for details!
val lassq :
?n:int ->
?scale:float ->
?sumsq:float ->
?ofsx:int ->
?incx:int ->
vec ->
float * float
lassq ?n ?ofsx ?incx ?scale ?sumsq
val larnv :
?idist:[ `Uniform0 | `Uniform1 | `Normal ] ->
?iseed:(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t ->
?n:int ->
?ofsx:int ->
?x:vec ->
unit ->
vec
larnv ?idist ?iseed ?n ?ofsx ?x ()
val lange :
?m:int ->
?n:int ->
?norm:[ Lacaml__common.norm2 | `M | `F ] ->
?work:rvec ->
?ar:int ->
?ac:int ->
mat ->
float
lange ?m ?n ?norm ?work ?ar ?ac a
val lauum : ?up:bool -> ?n:int -> ?ar:int -> ?ac:int -> 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.
Linear equations (computational routines)
val getrf :
?m:int ->
?n:int ->
?ipiv:(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t ->
?ar:int ->
?ac:int ->
mat ->
(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t
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.
val getrs :
?n:int ->
?ipiv:(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t ->
?trans:trans3 ->
?ar:int ->
?ac:int ->
mat ->
?nrhs:int ->
?br:int ->
?bc:int ->
mat ->
unit
val getri_opt_lwork : ?n:int -> ?ar:int -> ?ac:int -> mat -> int
getri_opt_lwork ?n ?ar ?ac a
val getri :
?n:int ->
?ipiv:(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t ->
?work:vec ->
?ar:int ->
?ac:int ->
mat ->
unit
val sytrf_opt_lwork : ?n:int -> ?up:bool -> ?ar:int -> ?ac:int -> mat -> int
sytrf_opt_lwork ?n ?up ?ar ?ac a
val sytrf :
?n:int ->
?up:bool ->
?ipiv:(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t ->
?work:vec ->
?ar:int ->
?ac:int ->
mat ->
(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t
sytrf ?n ?up ?ipiv ?work ?ar ?ac a
computes the factorization of the real symmetric matrix a
using the Bunch-Kaufman diagonal pivoting method.
val sytrs :
?n:int ->
?up:bool ->
?ipiv:(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t ->
?ar:int ->
?ac:int ->
mat ->
?nrhs:int ->
?br:int ->
?bc:int ->
mat ->
unit
val sytri :
?n:int ->
?up:bool ->
?ipiv:(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t ->
?work:vec ->
?ar:int ->
?ac:int ->
mat ->
unit
val potrf :
?n:int ->
?up:bool ->
?ar:int ->
?ac:int ->
?jitter:float ->
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.
val potrs :
?n:int ->
?up:bool ->
?ar:int ->
?ac:int ->
mat ->
?nrhs:int ->
?br:int ->
?bc:int ->
?factorize:bool ->
?jitter:float ->
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 potrf
.
val potri :
?n:int ->
?up:bool ->
?ar:int ->
?ac:int ->
?factorize:bool ->
?jitter:float ->
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 potrf
.
val trtrs :
?n:int ->
?up:bool ->
?trans:trans3 ->
?diag:[ `U | `N ] ->
?ar:int ->
?ac:int ->
mat ->
?nrhs:int ->
?br:int ->
?bc:int ->
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.
val tbtrs :
?n:int ->
?kd:int ->
?up:bool ->
?trans:trans3 ->
?diag:[ `U | `N ] ->
?abr:int ->
?abc:int ->
mat ->
?nrhs:int ->
?br:int ->
?bc:int ->
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.
val trtri :
?n:int ->
?up:bool ->
?diag:[ `U | `N ] ->
?ar:int ->
?ac:int ->
mat ->
unit
trtri ?n ?up ?diag ?ar ?ac a
computes the inverse of a real upper or lower triangular matrix a
.
val geqrf_opt_lwork : ?m:int -> ?n:int -> ?ar:int -> ?ac:int -> mat -> int
geqrf_opt_lwork ?m ?n ?ar ?ac a
geqrf ?m ?n ?work ?tau ?ar ?ac a
computes a QR factorization of a real m
-by-n
matrix a
. See LAPACK documentation.
Linear equations (simple drivers)
val gesv :
?n:int ->
?ipiv:(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t ->
?ar:int ->
?ac:int ->
mat ->
?nrhs:int ->
?br:int ->
?bc:int ->
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.
val gbsv :
?n:int ->
?ipiv:(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t ->
?abr:int ->
?abc:int ->
mat ->
int ->
int ->
?nrhs:int ->
?br:int ->
?bc:int ->
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
.
val gtsv :
?n:int ->
?ofsdl:int ->
vec ->
?ofsd:int ->
vec ->
?ofsdu:int ->
vec ->
?nrhs:int ->
?br:int ->
?bc:int ->
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
.
val posv :
?n:int ->
?up:bool ->
?ar:int ->
?ac:int ->
mat ->
?nrhs:int ->
?br:int ->
?bc:int ->
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
.
val ppsv :
?n:int ->
?up:bool ->
?ofsap:int ->
vec ->
?nrhs:int ->
?br:int ->
?bc:int ->
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
.
val pbsv :
?n:int ->
?up:bool ->
?kd:int ->
?abr:int ->
?abc:int ->
mat ->
?nrhs:int ->
?br:int ->
?bc:int ->
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
.
val ptsv :
?n:int ->
?ofsd:int ->
vec ->
?ofse:int ->
vec ->
?nrhs:int ->
?br:int ->
?bc:int ->
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.
val sysv_opt_lwork :
?n:int ->
?up:bool ->
?ar:int ->
?ac:int ->
mat ->
?nrhs:int ->
?br:int ->
?bc:int ->
mat ->
int
sysv_opt_lwork ?n ?up ?ar ?ac a ?nrhs ?br ?bc b
val sysv :
?n:int ->
?up:bool ->
?ipiv:(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t ->
?work:vec ->
?ar:int ->
?ac:int ->
mat ->
?nrhs:int ->
?br:int ->
?bc:int ->
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
.
val spsv :
?n:int ->
?up:bool ->
?ipiv:(int32, Bigarray.int32_elt, Bigarray.fortran_layout) Bigarray.Array1.t ->
?ofsap:int ->
vec ->
?nrhs:int ->
?br:int ->
?bc:int ->
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
.
Least squares (simple drivers)
- BLAS-1 interface
- BLAS-2 interface
- LAPACK interface
- Auxiliary routines
- Linear equations (computational routines)
- Least squares (expert drivers)
- General Schur factorization
- General SVD routines
- General eigenvalue problem (simple drivers)
- Symmetric-matrix eigenvalue and singular value problems (simple drivers)
- Symmetric-matrix eigenvalue and singular value problems (expert & RRR drivers)
- BLAS-1 interface
- BLAS-2 interface
- BLAS-3 interface
- LAPACK interface
- Auxiliary routines
- Linear equations (computational routines)
- Linear equations (simple drivers)
- Least squares (simple drivers)