Module Lacaml.C

Single precision complex BLAS and LAPACK functions.

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

Complex vectors (precision: complex32).

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

Vectors of reals (precision: float32).

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

Complex matrices (precision: complex32).

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

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

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

Precision for this submodule C. 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) Io.pp_vec

Pretty-printer for column vectors.

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

Pretty-printer for matrices.

BLAS-1 interface

val dotu : ?⁠n:int -> ?⁠ofsx:int -> ?⁠incx:int -> vec -> ?⁠ofsy:int -> ?⁠incy:int -> vec -> Stdlib.Complex.t

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

parameter n

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

parameter ofsx

default = 1

parameter incx

default = 1

parameter ofsy

default = 1

parameter incy

default = 1

val dotc : ?⁠n:int -> ?⁠ofsx:int -> ?⁠incx:int -> vec -> ?⁠ofsy:int -> ?⁠incy:int -> vec -> Stdlib.Complex.t

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

parameter n

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

parameter ofsx

default = 1

parameter incx

default = 1

parameter ofsy

default = 1

parameter incy

default = 1

LAPACK interface

val lansy_min_lwork : int -> Common.norm4 -> int

lansy_min_lwork m norm

returns

the minimum length of the work array used by the lansy-function.

parameter norm

type of norm that will be computed by lansy

parameter n

the number of columns (and rows) in the matrix

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

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

parameter norm

default = `O

parameter up

default = true (reference upper triangular part of a)

parameter n

default = number of columns of matrix a

parameter work

default = allocated work space for norm `I

val gecon_min_lwork : int -> int
val gecon_min_lrwork : int -> int
val gecon : ?⁠n:int -> ?⁠norm:Common.norm2 -> ?⁠anorm:float -> ?⁠work:vec -> ?⁠rwork:rvec -> ?⁠ar:int -> ?⁠ac:int -> mat -> float

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

returns

estimate of the reciprocal of the condition number of matrix a

parameter n

default = available number of columns of matrix a

parameter norm

default = 1-norm

parameter anorm

default = norm of the matrix a as returned by lange

parameter work

default = automatically allocated workspace

parameter rwork

default = automatically allocated workspace

parameter ar

default = 1

parameter ac

default = 1

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

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

returns

estimate of the reciprocal of the condition number of symmetric matrix a

parameter n

default = available number of columns of matrix a

parameter up

default = upper triangle of the factorization of a is stored

parameter ipiv

default = vec of length n

parameter anorm

default = 1-norm of the matrix a as returned by lange

parameter work

default = automatically allocated workspace

val pocon_min_lwork : int -> int
val pocon_min_lrwork : int -> int
val pocon : ?⁠n:int -> ?⁠up:bool -> ?⁠anorm:float -> ?⁠work:vec -> ?⁠rwork:rvec -> ?⁠ar:int -> ?⁠ac:int -> mat -> float

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

returns

estimate of the reciprocal of the condition number of complex Hermitian positive definite matrix a

parameter n

default = available number of columns of matrix a

parameter up

default = upper triangle of Cholesky factorization of a is stored

parameter work

default = automatically allocated workspace

parameter rwork

default = automatically allocated workspace

parameter anorm

default = 1-norm of the matrix a as returned by lange

General Schur factorization

val gees : ?⁠n:int -> ?⁠jobvs:Common.schur_vectors -> ?⁠sort:Common.eigen_value_sort -> ?⁠w:vec -> ?⁠vsr:int -> ?⁠vsc:int -> ?⁠vs:mat -> ?⁠work:vec -> ?⁠ar:int -> ?⁠ac:int -> mat -> int * vec * mat

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

returns

(sdim, w, vs)

General SVD routines

val gesvd_min_lwork : m:int -> n:int -> int
val gesvd_lrwork : m:int -> n:int -> int
val gesvd_opt_lwork : ?⁠m:int -> ?⁠n:int -> ?⁠jobu:Common.svd_job -> ?⁠jobvt:Common.svd_job -> ?⁠s:rvec -> ?⁠ur:int -> ?⁠uc:int -> ?⁠u:mat -> ?⁠vtr:int -> ?⁠vtc:int -> ?⁠vt:mat -> ?⁠ar:int -> ?⁠ac:int -> mat -> int
val gesvd : ?⁠m:int -> ?⁠n:int -> ?⁠jobu:Common.svd_job -> ?⁠jobvt:Common.svd_job -> ?⁠s:rvec -> ?⁠ur:int -> ?⁠uc:int -> ?⁠u:mat -> ?⁠vtr:int -> ?⁠vtc:int -> ?⁠vt:mat -> ?⁠work:vec -> ?⁠rwork:rvec -> ?⁠ar:int -> ?⁠ac:int -> mat -> rvec * mat * mat

General eigenvalue problem (simple drivers)

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

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

returns

"optimal" work size

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

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

returns

(lv, w, rv), where lv and rv correspond to the left and right eigenvectors respectively, w to the eigenvalues. lv (rv) is the empty matrix if vl (vr) is set to None.

raises Failure

if the function fails to converge

parameter n

default = available number of columns of matrix a

parameter work

default = automatically allocated workspace

parameter rwork

default = automatically allocated workspace

parameter 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)

parameter 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.

parameter w

default = automatically allocate eigenvalues

parameter a

the matrix whose eigensystem is computed

BLAS-1 interface

val swap : ?⁠n:int -> ?⁠ofsx:int -> ?⁠incx:int -> vec -> ?⁠ofsy:int -> ?⁠incy:int -> vec -> unit

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

parameter n

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

parameter ofsx

default = 1

parameter incx

default = 1

parameter ofsy

default = 1

parameter incy

default = 1

val scal : ?⁠n:int -> Stdlib.Complex.t -> ?⁠ofsx:int -> ?⁠incx:int -> vec -> unit

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

parameter n

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

parameter ofsx

default = 1

parameter incx

default = 1

val copy : ?⁠n:int -> ?⁠ofsy:int -> ?⁠incy:int -> ?⁠y:vec -> ?⁠ofsx:int -> ?⁠incx:int -> vec -> vec

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

returns

vector y, which is overwritten.

parameter n

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

parameter ofsy

default = 1

parameter incy

default = 1

parameter y

default = new vector with ofsy+(n-1)(abs incy) rows

parameter ofsx

default = 1

parameter incx

default = 1

val nrm2 : ?⁠n:int -> ?⁠ofsx:int -> ?⁠incx:int -> vec -> float

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

parameter n

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

parameter ofsx

default = 1

parameter incx

default = 1

val axpy : ?⁠alpha:Stdlib.Complex.t -> ?⁠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!

parameter alpha

default = { re = 1.; im = 0. }

parameter n

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

parameter ofsx

default = 1

parameter incx

default = 1

parameter ofsy

default = 1

parameter incy

default = 1

val iamax : ?⁠n:int -> ?⁠ofsx:int -> ?⁠incx:int -> vec -> int

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

parameter n

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

parameter ofsx

default = 1

parameter incx

default = 1

val amax : ?⁠n:int -> ?⁠ofsx:int -> ?⁠incx:int -> vec -> Stdlib.Complex.t

BLAS-2 interface

val gemv : ?⁠m:int -> ?⁠n:int -> ?⁠beta:Stdlib.Complex.t -> ?⁠ofsy:int -> ?⁠incy:int -> ?⁠y:vec -> ?⁠trans:trans3 -> ?⁠alpha:Stdlib.Complex.t -> ?⁠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.

returns

vector y, which is overwritten.

parameter m

default = number of available rows in matrix a

parameter n

default = available columns in matrix a

parameter beta

default = { re = 0.; im = 0. }

parameter ofsy

default = 1

parameter incy

default = 1

parameter y

default = vector with minimal required length (see BLAS)

parameter trans

default = `N

parameter alpha

default = { re = 1.; im = 0. }

parameter ar

default = 1

parameter ac

default = 1

parameter ofsx

default = 1

parameter incx

default = 1

val gbmv : ?⁠m:int -> ?⁠n:int -> ?⁠beta:Stdlib.Complex.t -> ?⁠ofsy:int -> ?⁠incy:int -> ?⁠y:vec -> ?⁠trans:trans3 -> ?⁠alpha:Stdlib.Complex.t -> ?⁠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!

returns

vector y, which is overwritten.

parameter m

default = same as n (i.e., a is a square matrix)

parameter n

default = available number of columns in matrix a

parameter beta

default = { re = 0.; im = 0. }

parameter ofsy

default = 1

parameter incy

default = 1

parameter y

default = vector with minimal required length (see BLAS)

parameter trans

default = `N

parameter alpha

default = { re = 1.; im = 0. }

parameter ar

default = 1

parameter ac

default = 1

parameter ofsx

default = 1

parameter incx

default = 1

val symv : ?⁠n:int -> ?⁠beta:Stdlib.Complex.t -> ?⁠ofsy:int -> ?⁠incy:int -> ?⁠y:vec -> ?⁠up:bool -> ?⁠alpha:Stdlib.Complex.t -> ?⁠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!

returns

vector y, which is overwritten.

parameter n

default = dimension of symmetric matrix a

parameter beta

default = { re = 0.; im = 0. }

parameter ofsy

default = 1

parameter incy

default = 1

parameter y

default = vector with minimal required length (see BLAS)

parameter up

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

parameter alpha

default = { re = 1.; im = 0. }

parameter ar

default = 1

parameter ac

default = 1

parameter ofsx

default = 1

parameter incx

default = 1

val trmv : ?⁠n:int -> ?⁠trans:trans3 -> ?⁠diag:Common.diag -> ?⁠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!

parameter n

default = dimension of triangular matrix a

parameter trans

default = `N

parameter diag

default = false (not a unit triangular matrix)

parameter up

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

parameter ar

default = 1

parameter ac

default = 1

parameter ofsx

default = 1

parameter incx

default = 1

val trsv : ?⁠n:int -> ?⁠trans:trans3 -> ?⁠diag:Common.diag -> ?⁠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!

parameter n

default = dimension of triangular matrix a

parameter trans

default = `N

parameter diag

default = false (not a unit triangular matrix)

parameter up

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

parameter ar

default = 1

parameter ac

default = 1

parameter ofsx

default = 1

parameter incx

default = 1

val tpmv : ?⁠n:int -> ?⁠trans:trans3 -> ?⁠diag:Common.diag -> ?⁠up:bool -> ?⁠ofsap:int -> vec -> ?⁠ofsx:int -> ?⁠incx:int -> vec -> unit

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

parameter n

default = dimension of packed triangular matrix ap

parameter trans

default = `N

parameter diag

default = false (not a unit triangular matrix)

parameter up

default = true (upper triangular portion of ap is accessed)

parameter ofsap

default = 1

parameter ofsx

default = 1

parameter incx

default = 1

val tpsv : ?⁠n:int -> ?⁠trans:trans3 -> ?⁠diag:Common.diag -> ?⁠up:bool -> ?⁠ofsap:int -> vec -> ?⁠ofsx:int -> ?⁠incx:int -> vec -> unit

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

parameter n

default = dimension of packed triangular matrix ap

parameter trans

default = `N

parameter diag

default = false (not a unit triangular matrix)

parameter up

default = true (upper triangular portion of ap is accessed)

parameter ofsap

default = 1

parameter ofsx

default = 1

parameter incx

default = 1

BLAS-3 interface

val gemm : ?⁠m:int -> ?⁠n:int -> ?⁠k:int -> ?⁠beta:Stdlib.Complex.t -> ?⁠cr:int -> ?⁠cc:int -> ?⁠c:mat -> ?⁠transa:trans3 -> ?⁠alpha:Stdlib.Complex.t -> ?⁠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.

returns

matrix c, which is overwritten.

parameter m

default = number of rows of a (or tr a) and c

parameter n

default = number of columns of b (or tr b) and c

parameter k

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

parameter beta

default = { re = 0.; im = 0. }

parameter cr

default = 1

parameter cc

default = 1

parameter c

default = matrix with minimal required dimension

parameter transa

default = `N

parameter alpha

default = { re = 1.; im = 0. }

parameter ar

default = 1

parameter ac

default = 1

parameter transb

default = `N

parameter br

default = 1

parameter bc

default = 1

val symm : ?⁠m:int -> ?⁠n:int -> ?⁠side:Common.side -> ?⁠up:bool -> ?⁠beta:Stdlib.Complex.t -> ?⁠cr:int -> ?⁠cc:int -> ?⁠c:mat -> ?⁠alpha:Stdlib.Complex.t -> ?⁠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!

returns

matrix c, which is overwritten.

parameter m

default = number of rows of c

parameter n

default = number of columns of c

parameter side

default = `L (left - multiplication is ab)

parameter up

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

parameter beta

default = { re = 0.; im = 0. }

parameter cr

default = 1

parameter cc

default = 1

parameter c

default = matrix with minimal required dimension

parameter alpha

default = { re = 1.; im = 0. }

parameter ar

default = 1

parameter ac

default = 1

parameter br

default = 1

parameter bc

default = 1

val trmm : ?⁠m:int -> ?⁠n:int -> ?⁠side:Common.side -> ?⁠up:bool -> ?⁠transa:trans3 -> ?⁠diag:Common.diag -> ?⁠alpha:Stdlib.Complex.t -> ?⁠ar:int -> ?⁠ac:int -> mat -> ?⁠br:int -> ?⁠bc:int -> mat -> unit

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

parameter m

default = number of rows of b

parameter n

default = number of columns of b

parameter side

default = `L (left - multiplication is ab)

parameter up

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

parameter transa

default = `N

parameter diag

default = `N (non-unit)

parameter alpha

default = { re = 1.; im = 0. }

parameter ar

default = 1

parameter ac

default = 1

parameter br

default = 1

parameter bc

default = 1

val trsm : ?⁠m:int -> ?⁠n:int -> ?⁠side:Common.side -> ?⁠up:bool -> ?⁠transa:trans3 -> ?⁠diag:Common.diag -> ?⁠alpha:Stdlib.Complex.t -> ?⁠ar:int -> ?⁠ac:int -> mat -> ?⁠br:int -> ?⁠bc:int -> mat -> unit

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

returns

matrix b, which is overwritten.

parameter m

default = number of rows of b

parameter n

default = number of columns of b

parameter side

default = `L (left - multiplication is ab)

parameter up

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

parameter transa

default = `N

parameter diag

default = `N (non-unit)

parameter alpha

default = { re = 1.; im = 0. }

parameter ar

default = 1

parameter ac

default = 1

parameter br

default = 1

parameter bc

default = 1

val syrk : ?⁠n:int -> ?⁠k:int -> ?⁠up:bool -> ?⁠beta:Stdlib.Complex.t -> ?⁠cr:int -> ?⁠cc:int -> ?⁠c:mat -> ?⁠trans:Common.trans2 -> ?⁠alpha:Stdlib.Complex.t -> ?⁠ar:int -> ?⁠ac:int -> mat -> mat

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

returns

matrix c, which is overwritten.

parameter n

default = number of rows of a (or a'), c

parameter k

default = number of columns of a (or a')

parameter up

default = true (upper triangular portion of c is accessed)

parameter beta

default = { re = 0.; im = 0. }

parameter cr

default = 1

parameter cc

default = 1

parameter c

default = matrix with minimal required dimension

parameter trans

default = `N

parameter alpha

default = { re = 1.; im = 0. }

parameter ar

default = 1

parameter ac

default = 1

val syr2k : ?⁠n:int -> ?⁠k:int -> ?⁠up:bool -> ?⁠beta:Stdlib.Complex.t -> ?⁠cr:int -> ?⁠cc:int -> ?⁠c:mat -> ?⁠trans:Common.trans2 -> ?⁠alpha:Stdlib.Complex.t -> ?⁠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!

returns

matrix c, which is overwritten.

parameter n

default = number of rows of a (or a'), c

parameter k

default = number of columns of a (or a')

parameter up

default = true (upper triangular portion of c is accessed)

parameter beta

default = { re = 0.; im = 0. }

parameter cr

default = 1

parameter cc

default = 1

parameter c

default = matrix with minimal required dimension

parameter trans

default = `N

parameter alpha

default = { re = 1.; im = 0. }

parameter ar

default = 1

parameter ac

default = 1

parameter br

default = 1

parameter bc

default = 1

LAPACK interface

Auxiliary routines

val lacpy : ?⁠uplo:[ `U | `L ] -> ?⁠patt:Common.Types.Mat.patt -> ?⁠m:int -> ?⁠n:int -> ?⁠br:int -> ?⁠bc:int -> ?⁠b:mat -> ?⁠ar:int -> ?⁠ac:int -> mat -> mat

lacpy ?patt ?uplo ?m ?n ?br ?bc ?b ?ar ?ac a copy the (triangular) (sub-)matrix a (to an optional (sub-)matrix b) and return it. patt is more general than uplo and should be used in its place whenever strict BLAS conformance is not required. Only one of patt and uplo can be specified at a time.

raises Failure

if both patt and uplo are specified simultaneously

parameter patt

default = `Full

parameter uplo

default = whole matrix

parameter b

The target matrix. By default a fresh matrix to accommodate the sizes m and n and the offsets br and bc is created.

val laswp : ?⁠n:int -> ?⁠ar:int -> ?⁠ac:int -> mat -> ?⁠k1:int -> ?⁠k2:int -> ?⁠incx:int -> Common.int32_vec -> unit

laswp ?n ?ar ?ac a ?k1 ?k2 ?incx ipiv swap rows of a according to ipiv. See LAPACK-documentation for details!

parameter n

default = number of columns of matrix

parameter ar

default = 1

parameter ac

default = 1

parameter k1

default = 1

parameter k2

default = dimension of ipiv

parameter incx

default = 1

parameter ipiv

is a vector of sequential row interchanges.

val lapmt : ?⁠forward:bool -> ?⁠m:int -> ?⁠n:int -> ?⁠ar:int -> ?⁠ac:int -> mat -> Common.int32_vec -> unit

lapmt ?forward ?n ?m ?ar ?ac a k swap columns of a according to the permutations in k. See LAPACK-documentation for details!

parameter forward

default = true

parameter m

default = number of rows of matrix

parameter n

default = number of columns of matrix

parameter ar

default = 1

parameter ac

default = 1

parameter k

is vector of column permutations and must be of length n. Note that checking for duplicates in k is not performed and this could lead to undefined behavior. Furthermore, LAPACK uses k as a workspace and restore it upon completion, sharing this permutation array is not thread safe.

val lassq : ?⁠n:int -> ?⁠scale:float -> ?⁠sumsq:float -> ?⁠ofsx:int -> ?⁠incx:int -> vec -> float * float
val larnv : ?⁠idist:[ `Uniform0 | `Uniform1 | `Normal ] -> ?⁠iseed:Common.int32_vec -> ?⁠n:int -> ?⁠ofsx:int -> ?⁠x:vec -> unit -> vec
val lange_min_lwork : int -> Common.norm4 -> int

lange_min_lwork m norm

returns

the minimum length of the work array used by the lange-function.

parameter m

the number of rows in the matrix

parameter norm

type of norm that will be computed by lange

val lange : ?⁠m:int -> ?⁠n:int -> ?⁠norm:Common.norm4 -> ?⁠work:rvec -> ?⁠ar:int -> ?⁠ac:int -> mat -> float
val lauum : ?⁠n:int -> ?⁠up:bool -> ?⁠ar:int -> ?⁠ac:int -> mat -> unit

lauum ?n ?up ?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.

parameter n

default = minimum of available number of rows/columns in matrix a

parameter up

default = true

parameter ar

default = 1

parameter ac

default = 1

Linear equations (computational routines)

val getrf : ?⁠m:int -> ?⁠n:int -> ?⁠ipiv:Common.int32_vec -> ?⁠ar:int -> ?⁠ac:int -> mat -> 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.

returns

ipiv, the pivot indices.

raises Failure

if the matrix is singular.

parameter m

default = number of rows in matrix a

parameter n

default = number of columns in matrix a

parameter ipiv

= vec of length min(m, n)

parameter ar

default = 1

parameter ac

default = 1

val getrs : ?⁠n:int -> ?⁠ipiv:Common.int32_vec -> ?⁠trans:trans3 -> ?⁠ar:int -> ?⁠ac:int -> mat -> ?⁠nrhs:int -> ?⁠br:int -> ?⁠bc:int -> 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 getrf. Note that matrix a will be passed to getrf if ipiv was not provided.

raises Failure

if the matrix is singular.

parameter n

default = number of columns in matrix a

parameter ipiv

default = result from getrf applied to a

parameter trans

default = `N

parameter ar

default = 1

parameter ac

default = 1

parameter nrhs

default = available number of columns in matrix b

parameter br

default = 1

parameter bc

default = 1

val getri_min_lwork : int -> int
val getri_opt_lwork : ?⁠n:int -> ?⁠ar:int -> ?⁠ac:int -> mat -> int
val getri : ?⁠n:int -> ?⁠ipiv:Common.int32_vec -> ?⁠work:vec -> ?⁠ar:int -> ?⁠ac:int -> mat -> unit

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

raises Failure

if the matrix is singular.

parameter n

default = number of columns in matrix a

parameter ipiv

default = vec of length m from getri

parameter work

default = vec of optimum length

parameter ar

default = 1

parameter ac

default = 1

val sytrf_min_lwork : unit -> int
val sytrf_opt_lwork : ?⁠n:int -> ?⁠up:bool -> ?⁠ar:int -> ?⁠ac:int -> mat -> int
val sytrf : ?⁠n:int -> ?⁠up:bool -> ?⁠ipiv:Common.int32_vec -> ?⁠work:vec -> ?⁠ar:int -> ?⁠ac:int -> mat -> 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.

raises Failure

if D in a = U*D*U' or L*D*L' is singular.

parameter n

default = number of columns in matrix a

parameter up

default = true (store upper triangle in a)

parameter ipiv

= vec of length n

parameter work

default = vec of optimum length

parameter ar

default = 1

parameter ac

default = 1

val sytrs : ?⁠n:int -> ?⁠up:bool -> ?⁠ipiv:Common.int32_vec -> ?⁠ar:int -> ?⁠ac:int -> mat -> ?⁠nrhs:int -> ?⁠br:int -> ?⁠bc:int -> 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 sytrf. Note that matrix a will be passed to sytrf if ipiv was not provided.

raises Failure

if the matrix is singular.

parameter n

default = number of columns in matrix a

parameter up

default = true (store upper triangle in a)

parameter ipiv

default = vec of length n

parameter ar

default = 1

parameter ac

default = 1

parameter nrhs

default = available number of columns in matrix b

parameter br

default = 1

parameter bc

default = 1

val sytri_min_lwork : int -> int
val sytri : ?⁠n:int -> ?⁠up:bool -> ?⁠ipiv:Common.int32_vec -> ?⁠work:vec -> ?⁠ar:int -> ?⁠ac:int -> 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 sytrf. Note that matrix a will be passed to sytrf if ipiv was not provided.

raises Failure

if the matrix is singular.

parameter n

default = number of columns in matrix a

parameter up

default = true (store upper triangle in a)

parameter ipiv

default = vec of length n from sytrf

parameter work

default = vec of optimum length

parameter ar

default = 1

parameter ac

default = 1

val potrf : ?⁠n:int -> ?⁠up:bool -> ?⁠ar:int -> ?⁠ac:int -> mat -> unit

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

raises Failure

if the matrix is singular.

parameter n

default = number of columns in matrix a

parameter up

default = true (store upper triangle in a)

parameter ar

default = 1

parameter ac

default = 1

val potrs : ?⁠n:int -> ?⁠up:bool -> ?⁠ar:int -> ?⁠ac:int -> mat -> ?⁠nrhs:int -> ?⁠br:int -> ?⁠bc:int -> mat -> unit

potrs ?n ?up ?ar ?ac a ?nrhs ?br ?bc 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.

raises Failure

if the matrix is singular.

parameter n

default = number of columns in matrix a

parameter up

default = true

parameter ar

default = 1

parameter ac

default = 1

parameter nrhs

default = available number of columns in matrix b

parameter br

default = 1

parameter bc

default = 1

val potri : ?⁠n:int -> ?⁠up:bool -> ?⁠ar:int -> ?⁠ac:int -> mat -> unit

potri ?n ?up ?ar ?ac 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.

raises Failure

if the matrix is singular.

parameter n

default = number of columns in matrix a

parameter up

default = true (upper triangle stored in a)

parameter ar

default = 1

parameter ac

default = 1

val trtrs : ?⁠n:int -> ?⁠up:bool -> ?⁠trans:trans3 -> ?⁠diag:Common.diag -> ?⁠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.

raises Failure

if the matrix a is singular.

parameter n

default = number of columns in matrix a

parameter up

default = true

parameter trans

default = `N

parameter diag

default = `N

parameter ar

default = 1

parameter ac

default = 1

parameter nrhs

default = available number of columns in matrix b

parameter br

default = 1

parameter bc

default = 1

val tbtrs : ?⁠n:int -> ?⁠kd:int -> ?⁠up:bool -> ?⁠trans:trans3 -> ?⁠diag:Common.diag -> ?⁠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.

raises Failure

if the matrix a is singular.

parameter n

default = number of columns in matrix ab

parameter kd

default = number of rows in matrix ab - 1

parameter up

default = true

parameter trans

default = `N

parameter diag

default = `N

parameter abr

default = 1

parameter abc

default = 1

parameter nrhs

default = available number of columns in matrix b

parameter br

default = 1

parameter bc

default = 1

val trtri : ?⁠n:int -> ?⁠up:bool -> ?⁠diag:Common.diag -> ?⁠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.

raises Failure

if the matrix a is singular.

parameter n

default = number of columns in matrix a

parameter up

default = true (upper triangle stored in a)

parameter diag

default = `N

parameter ar

default = 1

parameter ac

default = 1

val geqrf_opt_lwork : ?⁠m:int -> ?⁠n:int -> ?⁠ar:int -> ?⁠ac:int -> mat -> int
val geqrf_min_lwork : n:int -> int
val geqrf : ?⁠m:int -> ?⁠n:int -> ?⁠work:vec -> ?⁠tau:vec -> ?⁠ar:int -> ?⁠ac:int -> mat -> vec

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

returns

tau, the scalar factors of the elementary reflectors.

parameter m

default = number of rows in matrix a

parameter n

default = number of columns in matrix a

parameter work

default = vec of optimum length

parameter tau

default = vec of required length

parameter ar

default = 1

parameter ac

default = 1

Linear equations (simple drivers)

val gesv : ?⁠n:int -> ?⁠ipiv:Common.int32_vec -> ?⁠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.

raises Failure

if the matrix a is singular.

parameter n

default = available number of columns in matrix a

parameter ipiv

default = vec of length n

parameter ar

default = 1

parameter ac

default = 1

parameter nrhs

default = available number of columns in matrix b

parameter br

default = 1

parameter bc

default = 1

val gbsv : ?⁠n:int -> ?⁠ipiv:Common.int32_vec -> ?⁠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.

raises Failure

if the matrix a is singular.

parameter n

default = available number of columns in matrix ab

parameter ipiv

default = vec of length n

parameter abr

default = 1

parameter abc

default = 1

parameter nrhs

default = available number of columns in matrix b

parameter br

default = 1

parameter bc

default = 1

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.

raises Failure

if the matrix is singular.

parameter n

default = available length of vector d

parameter ofsdl

default = 1

parameter ofsd

default = 1

parameter ofsdu

default = 1

parameter nrhs

default = available number of columns in matrix b

parameter br

default = 1

parameter bc

default = 1

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.

raises Failure

if the matrix is singular.

parameter n

default = available number of columns in matrix a

parameter up

default = true i.e., upper triangle of a is stored

parameter ar

default = 1

parameter ac

default = 1

parameter nrhs

default = available number of columns in matrix b

parameter br

default = 1

parameter bc

default = 1

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.

raises Failure

if the matrix is singular.

parameter n

default = the greater n s.t. n(n+1)/2 <= Vec.dim ap

parameter up

default = true i.e., upper triangle of ap is stored

parameter ofsap

default = 1

parameter nrhs

default = available number of columns in matrix b

parameter br

default = 1

parameter bc

default = 1

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.

raises Failure

if the matrix is singular.

parameter n

default = available number of columns in matrix ab

parameter up

default = true i.e., upper triangle of ab is stored

parameter kd

default = available number of rows in matrix ab - 1

parameter abr

default = 1

parameter abc

default = 1

parameter nrhs

default = available number of columns in matrix b

parameter br

default = 1

parameter bc

default = 1

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.

raises Failure

if the matrix is singular.

parameter n

default = available length of vector d

parameter ofsd

default = 1

parameter ofse

default = 1

parameter nrhs

default = available number of columns in matrix b

parameter br

default = 1

parameter bc

default = 1

val sysv_opt_lwork : ?⁠n:int -> ?⁠up:bool -> ?⁠ar:int -> ?⁠ac:int -> mat -> ?⁠nrhs:int -> ?⁠br:int -> ?⁠bc:int -> mat -> int
val sysv : ?⁠n:int -> ?⁠up:bool -> ?⁠ipiv:Common.int32_vec -> ?⁠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.

raises Failure

if the matrix is singular.

parameter n

default = available number of columns in matrix a

parameter up

default = true i.e., upper triangle of a is stored

parameter ipiv

default = vec of length n

parameter work

default = vec of optimum length (-> sysv_opt_lwork)

parameter ar

default = 1

parameter ac

default = 1

parameter nrhs

default = available number of columns in matrix b

parameter br

default = 1

parameter bc

default = 1

val spsv : ?⁠n:int -> ?⁠up:bool -> ?⁠ipiv:Common.int32_vec -> ?⁠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.

raises Failure

if the matrix is singular.

parameter n

default = the greater n s.t. n(n+1)/2 <= Vec.dim ap

parameter up

default = true i.e., upper triangle of ap is stored

parameter ipiv

default = vec of length n

parameter ofsap

default = 1

parameter nrhs

default = available number of columns in matrix b

parameter br

default = 1

parameter bc

default = 1

Least squares (simple drivers)

val gels_min_lwork : m:int -> n:int -> nrhs:int -> int
val gels_opt_lwork : ?⁠m:int -> ?⁠n:int -> ?⁠trans:Common.trans2 -> ?⁠ar:int -> ?⁠ac:int -> mat -> ?⁠nrhs:int -> ?⁠br:int -> ?⁠bc:int -> mat -> int
val gels : ?⁠m:int -> ?⁠n:int -> ?⁠work:vec -> ?⁠trans:Common.trans2 -> ?⁠ar:int -> ?⁠ac:int -> mat -> ?⁠nrhs:int -> ?⁠br:int -> ?⁠bc:int -> mat -> unit

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

parameter m

default = available number of rows in matrix a

parameter n

default = available number of columns of matrix a

parameter work

default = vec of optimum length (-> gels_opt_lwork)

parameter trans

default = `N

parameter ar

default = 1

parameter ac

default = 1

parameter nrhs

default = available number of columns in matrix b

parameter br

default = 1

parameter bc

default = 1