package lacaml

  1. Overview
  2. Docs

This module Lacaml.C contains linear algebra routines for complex numbers (precision: complex32). It is recommended to use this module by writing

open Lacaml.C

at the top of your file.

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

Complex vectors (precision: complex32).

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

Vectors of reals (precision: float32).

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

Complex matrices (precision: complex32).

type trans3 = [
  1. | `C
  2. | `N
  3. | `T
]

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

val prec : (Stdlib.Complex.t, Stdlib.Bigarray.complex32_elt) Stdlib.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) Lacaml_io.pp_vec

Pretty-printer for column vectors.

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

Pretty-printer for matrices.

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

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 -> Lacaml_complex32.vec -> ?ofsy:int -> ?incy:int -> Lacaml_complex32.vec -> Lacaml_complex32.num_type

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 -> Lacaml_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:Lacaml_common.norm4 -> ?work:Lacaml_complex32.rvec -> ?ar:int -> ?ac:int -> Lacaml_complex32.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

gecon_min_lwork n

  • returns

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

  • parameter n

    the logical dimensions of the matrix given to the gecon-function

val gecon_min_lrwork : int -> int

gecon_min_lrwork n

  • returns

    the minimum length of the rwork array used by the gecon-function.

  • parameter n

    the logical dimensions of the matrix given to gecon-function

val gecon : ?n:int -> ?norm:Lacaml_common.norm2 -> ?anorm:float -> ?work:Lacaml_complex32.vec -> ?rwork:Lacaml_complex32.rvec -> ?ar:int -> ?ac:int -> Lacaml_complex32.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

sycon_min_lwork n

  • returns

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

  • parameter n

    the logical dimensions of the matrix given to the sycon-function

val sycon : ?n:int -> ?up:bool -> ?ipiv:Lacaml_common.int32_vec -> ?anorm:float -> ?work:Lacaml_complex32.vec -> ?ar:int -> ?ac:int -> Lacaml_complex32.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

pocon_min_lwork n

  • returns

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

  • parameter n

    the logical dimensions of the matrix given to the pocon-function

val pocon_min_lrwork : int -> int

pocon_min_lrwork n

  • returns

    the minimum length of the rwork array used by the pocon-function.

  • parameter n

    the logical dimensions of the matrix given to pocon-function

val pocon : ?n:int -> ?up:bool -> ?anorm:float -> ?work:Lacaml_complex32.vec -> ?rwork:Lacaml_complex32.rvec -> ?ar:int -> ?ac:int -> Lacaml_complex32.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:Lacaml_common.schur_vectors -> ?sort:Lacaml_common.eigen_value_sort -> ?w:Lacaml_complex32.vec -> ?vsr:int -> ?vsc:int -> ?vs:Lacaml_complex32.mat -> ?work:Lacaml_complex32.vec -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> int * Lacaml_complex32.vec * Lacaml_complex32.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

gesvd_min_lwork ~m ~n

  • returns

    the minimum length of the work array used by the gesvd-function for matrices with m rows and n columns.

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

gesvd_lrwork m n

  • returns

    the (minimum) length of the rwork array used by the gesvd-function.

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

geev_min_lwork n

  • returns

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

  • parameter n

    the logical dimensions of the matrix given to geev-function

val geev_min_lrwork : int -> int

geev_min_lrwork n

  • returns

    the minimum length of the rwork array used by the geev-function.

  • parameter n

    the logical dimensions of the matrix given to geev-function

val geev_opt_lwork : ?n:int -> ?vlr:int -> ?vlc:int -> ?vl:Lacaml_complex32.mat option -> ?vrr:int -> ?vrc:int -> ?vr:Lacaml_complex32.mat option -> ?ofsw:int -> ?w:Lacaml_complex32.vec -> ?ar:int -> ?ac:int -> Lacaml_complex32.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:Lacaml_complex32.vec -> ?rwork:Lacaml_complex32.vec -> ?vlr:int -> ?vlc:int -> ?vl:Lacaml_complex32.mat option -> ?vrr:int -> ?vrc:int -> ?vr:Lacaml_complex32.mat option -> ?ofsw:int -> ?w:Lacaml_complex32.vec -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> Lacaml_complex32.mat * Lacaml_complex32.vec * Lacaml_complex32.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 -> x:Lacaml_complex32.vec -> ?ofsy:int -> ?incy:int -> Lacaml_complex32.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 -> Lacaml_complex32.num_type -> ?ofsx:int -> ?incx:int -> Lacaml_complex32.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:Lacaml_complex32.vec -> ?ofsx:int -> ?incx:int -> Lacaml_complex32.vec -> Lacaml_complex32.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 -> Lacaml_complex32.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:Lacaml_complex32.num_type -> ?n:int -> ?ofsx:int -> ?incx:int -> Lacaml_complex32.vec -> ?ofsy:int -> ?incy:int -> Lacaml_complex32.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 -> Lacaml_complex32.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 -> Lacaml_complex32.vec -> Lacaml_complex32.num_type

amax ?n ?ofsx ?incx x

  • returns

    the greater of the absolute values of the elements of the vector x.

  • parameter n

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

  • parameter ofsx

    default = 1

  • parameter incx

    default = 1

BLAS-2 interface
val gemv : ?m:int -> ?n:int -> ?beta:Lacaml_complex32.num_type -> ?ofsy:int -> ?incy:int -> ?y:Lacaml_complex32.vec -> ?trans:Lacaml_complex32.trans3 -> ?alpha:Lacaml_complex32.num_type -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> ?ofsx:int -> ?incx:int -> Lacaml_complex32.vec -> Lacaml_complex32.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.

  • 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:Lacaml_complex32.num_type -> ?ofsy:int -> ?incy:int -> ?y:Lacaml_complex32.vec -> ?trans:Lacaml_complex32.trans3 -> ?alpha:Lacaml_complex32.num_type -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> int -> int -> ?ofsx:int -> ?incx:int -> Lacaml_complex32.vec -> Lacaml_complex32.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:Lacaml_complex32.num_type -> ?ofsy:int -> ?incy:int -> ?y:Lacaml_complex32.vec -> ?up:bool -> ?alpha:Lacaml_complex32.num_type -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> ?ofsx:int -> ?incx:int -> Lacaml_complex32.vec -> Lacaml_complex32.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:Lacaml_complex32.trans3 -> ?diag:Lacaml_common.diag -> ?up:bool -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> ?ofsx:int -> ?incx:int -> Lacaml_complex32.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:Lacaml_complex32.trans3 -> ?diag:Lacaml_common.diag -> ?up:bool -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> ?ofsx:int -> ?incx:int -> Lacaml_complex32.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:Lacaml_complex32.trans3 -> ?diag:Lacaml_common.diag -> ?up:bool -> ?ofsap:int -> Lacaml_complex32.vec -> ?ofsx:int -> ?incx:int -> Lacaml_complex32.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:Lacaml_complex32.trans3 -> ?diag:Lacaml_common.diag -> ?up:bool -> ?ofsap:int -> Lacaml_complex32.vec -> ?ofsx:int -> ?incx:int -> Lacaml_complex32.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:Lacaml_complex32.num_type -> ?cr:int -> ?cc:int -> ?c:Lacaml_complex32.mat -> ?transa:Lacaml_complex32.trans3 -> ?alpha:Lacaml_complex32.num_type -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> ?transb:Lacaml_complex32.trans3 -> ?br:int -> ?bc:int -> Lacaml_complex32.mat -> Lacaml_complex32.mat

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

  • 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:Lacaml_common.side -> ?up:bool -> ?beta:Lacaml_complex32.num_type -> ?cr:int -> ?cc:int -> ?c:Lacaml_complex32.mat -> ?alpha:Lacaml_complex32.num_type -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> ?br:int -> ?bc:int -> Lacaml_complex32.mat -> Lacaml_complex32.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:Lacaml_common.side -> ?up:bool -> ?transa:Lacaml_complex32.trans3 -> ?diag:Lacaml_common.diag -> ?alpha:Lacaml_complex32.num_type -> ?ar:int -> ?ac:int -> a:Lacaml_complex32.mat -> ?br:int -> ?bc:int -> Lacaml_complex32.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:Lacaml_common.side -> ?up:bool -> ?transa:Lacaml_complex32.trans3 -> ?diag:Lacaml_common.diag -> ?alpha:Lacaml_complex32.num_type -> ?ar:int -> ?ac:int -> a:Lacaml_complex32.mat -> ?br:int -> ?bc:int -> Lacaml_complex32.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:Lacaml_complex32.num_type -> ?cr:int -> ?cc:int -> ?c:Lacaml_complex32.mat -> ?trans:Lacaml_common.trans2 -> ?alpha:Lacaml_complex32.num_type -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> Lacaml_complex32.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:Lacaml_complex32.num_type -> ?cr:int -> ?cc:int -> ?c:Lacaml_complex32.mat -> ?trans:Lacaml_common.trans2 -> ?alpha:Lacaml_complex32.num_type -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> ?br:int -> ?bc:int -> Lacaml_complex32.mat -> Lacaml_complex32.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 ] -> ?m:int -> ?n:int -> ?br:int -> ?bc:int -> ?b:Lacaml_complex32.mat -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> Lacaml_complex32.mat

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

  • parameter uplo

    default = whole matrix

val lassq : ?n:int -> ?scale:float -> ?sumsq:float -> ?ofsx:int -> ?incx:int -> Lacaml_complex32.vec -> float * float

lassq ?n ?ofsx ?incx ?scale ?sumsq

  • returns

    (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!

  • parameter n

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

  • parameter ofsx

    default = 1

  • parameter incx

    default = 1

  • parameter scale

    default = 0.

  • parameter sumsq

    default = 1.

val larnv : ?idist:[ `Uniform0 | `Uniform1 | `Normal ] -> ?iseed:Lacaml_common.int32_vec -> ?n:int -> ?ofsx:int -> ?x:Lacaml_complex32.vec -> unit -> Lacaml_complex32.vec

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

  • returns

    a random vector with random distribution as specifified by idist, random seed iseed, vector offset ofsx and optional vector x.

  • parameter idist

    default = `Normal

  • parameter iseed

    default = integer vector of size 4 with all ones.

  • parameter n

    default = dim x - ofsx + 1 if x is provided, 1 otherwise.

  • parameter ofsx

    default = 1

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

  • 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:Lacaml_common.norm4 -> ?work:Lacaml_complex32.rvec -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> float

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

  • returns

    the value of the one norm (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.

  • parameter m

    default = number of rows of matrix a

  • parameter n

    default = number of columns of matrix a

  • parameter norm

    default = `O

  • parameter work

    default = allocated work space for norm `I

  • parameter ar

    default = 1

  • parameter ac

    default = 1

val lauum : ?up:bool -> ?n:int -> ?ar:int -> ?ac:int -> Lacaml_complex32.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.

  • parameter up

    default = true

  • parameter n

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

  • parameter ar

    default = 1

  • parameter ac

    default = 1

Linear equations (computational routines)
val getrf : ?m:int -> ?n:int -> ?ipiv:Lacaml_common.int32_vec -> ?ar:int -> ?ac:int -> Lacaml_complex32.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.

  • 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:Lacaml_common.int32_vec -> ?trans:Lacaml_complex32.trans3 -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> ?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex32.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

getri_min_lwork n

  • returns

    the minimum length of the work array used by the getri-function if the matrix has n columns.

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

getri_opt_lwork ?n ?ar ?ac a

  • returns

    the optimal size of the work array used by the getri-function.

  • parameter n

    default = number of columns of matrix a

  • parameter ar

    default = 1

  • parameter ac

    default = 1

val getri : ?n:int -> ?ipiv:Lacaml_common.int32_vec -> ?work:Lacaml_complex32.vec -> ?ar:int -> ?ac:int -> Lacaml_complex32.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

sytrf_min_lwork ()

  • returns

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

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

sytrf_opt_lwork ?n ?up ?ar ?ac a

  • returns

    the optimal size of the work array used by the sytrf-function.

  • parameter n

    default = number of columns of matrix a

  • parameter up

    default = true (store upper triangle in a)

  • parameter a

    the matrix a

  • parameter ar

    default = 1

  • parameter ac

    default = 1

val sytrf : ?n:int -> ?up:bool -> ?ipiv:Lacaml_common.int32_vec -> ?work:Lacaml_complex32.vec -> ?ar:int -> ?ac:int -> Lacaml_complex32.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.

  • 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:Lacaml_common.int32_vec -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> ?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex32.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

sytri_min_lwork n

  • returns

    the minimum length of the work array used by the sytri-function if the matrix has n columns.

val sytri : ?n:int -> ?up:bool -> ?ipiv:Lacaml_common.int32_vec -> ?work:Lacaml_complex32.vec -> ?ar:int -> ?ac:int -> Lacaml_complex32.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 -> ?jitter:Lacaml_complex32.num_type -> Lacaml_complex32.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.

  • 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

  • parameter jitter

    default = nothing

val potrs : ?n:int -> ?up:bool -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> ?nrhs:int -> ?br:int -> ?bc:int -> ?factorize:bool -> ?jitter:Lacaml_complex32.num_type -> Lacaml_complex32.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.

  • 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

  • parameter factorize

    default = true (calls potrf implicitly)

  • parameter jitter

    default = nothing

val potri : ?n:int -> ?up:bool -> ?ar:int -> ?ac:int -> ?factorize:bool -> ?jitter:Lacaml_complex32.num_type -> Lacaml_complex32.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.

  • 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

  • parameter factorize

    default = true (calls potrf implicitly)

  • parameter jitter

    default = nothing

val trtrs : ?n:int -> ?up:bool -> ?trans:Lacaml_complex32.trans3 -> ?diag:Lacaml_common.diag -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> ?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex32.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:Lacaml_complex32.trans3 -> ?diag:Lacaml_common.diag -> ?abr:int -> ?abc:int -> Lacaml_complex32.mat -> ?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex32.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:Lacaml_common.diag -> ?ar:int -> ?ac:int -> Lacaml_complex32.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 -> Lacaml_complex32.mat -> int

geqrf_opt_lwork ?m ?n ?ar ?ac a

  • returns

    the optimum length of the work-array used by the geqrf-function given matrix a and optionally its logical dimensions m and n.

  • parameter m

    default = number of rows in matrix a

  • parameter n

    default = number of columns in matrix a

  • parameter ar

    default = 1

  • parameter ac

    default = 1

val geqrf_min_lwork : n:int -> int

geqrf_min_lwork ~n

  • returns

    the minimum length of the work-array used by the geqrf-function if the matrix has n columns.

val geqrf : ?m:int -> ?n:int -> ?work:Lacaml_complex32.vec -> ?tau:Lacaml_complex32.vec -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> Lacaml_complex32.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:Lacaml_common.int32_vec -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> ?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex32.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:Lacaml_common.int32_vec -> ?abr:int -> ?abc:int -> Lacaml_complex32.mat -> int -> int -> ?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex32.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 -> Lacaml_complex32.vec -> ?ofsd:int -> Lacaml_complex32.vec -> ?ofsdu:int -> Lacaml_complex32.vec -> ?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex32.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 -> Lacaml_complex32.mat -> ?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex32.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 -> Lacaml_complex32.vec -> ?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex32.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 -> Lacaml_complex32.mat -> ?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex32.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 -> Lacaml_complex32.vec -> ?ofse:int -> Lacaml_complex32.vec -> ?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex32.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 -> Lacaml_complex32.mat -> ?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex32.mat -> int

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

  • returns

    the optimum length of the work-array used by the sysv-function given matrix a, optionally its logical dimension n and given right hand side matrix b with an optional number nrhs of vectors.

  • 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 sysv : ?n:int -> ?up:bool -> ?ipiv:Lacaml_common.int32_vec -> ?work:Lacaml_complex32.vec -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> ?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex32.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:Lacaml_common.int32_vec -> ?ofsap:int -> Lacaml_complex32.vec -> ?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex32.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

gels_min_lwork ~m ~n ~nrhs

  • returns

    the minimum length of the work-array used by the 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_complex32.mat -> ?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex32.mat -> int

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

  • returns

    the optimum length of the work-array used by the 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.

  • parameter m

    default = available number of rows in matrix a

  • parameter n

    default = available number of columns in matrix 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 gels : ?m:int -> ?n:int -> ?work:Lacaml_complex32.vec -> ?trans:Lacaml_common.trans2 -> ?ar:int -> ?ac:int -> Lacaml_complex32.mat -> ?nrhs:int -> ?br:int -> ?bc:int -> Lacaml_complex32.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 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

OCaml

Innovation. Community. Security.