package slap

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

BLAS interface
1. Level 1
2. Level 2
3. Level 3
LAPACK interface
BLAS interface
1. Level 1
2. Level 2
LAPACK interface

A linear algebra library with static size checking for matrix operations

Install

dune-project

Dependency

akabe.github.io Edit opam file Versions (5)

Authors

A

Akinori ABE <abe@sf.ecei.tohoku.ac.jp>

Maintainers

A

abe@sf.ecei.tohoku.ac.jp

Sources

v4.1.0.tar.gz

sha256=9a859ca657964c0adeeb29f3ba56291bbc6305f1c88ad71a1f532b1e7acdff55

md5=e06c98c671bee929dcda3231516d8d87

doc/slap/Slap_D/index.html

Module `Slap_D`

type prec = Bigarray.float64_elt

type num_type = float

type (+'indim, +'outdim, +'tag) trans3 =
  ('indim, 'outdim, 'tag) Slap_common.trans2

A type of transpose parameters (Slap_common.normal and Slap_common.trans). For complex matrices, Slap_common.conjtr is also offered, hence the name.

type (+'n, +'cnt_or_dsc) vec = ('n, num_type, prec, 'cnt_or_dsc) Slap_vec.t

Vectors.

type (+'m, +'n, +'cnt_or_dsc) mat =
  ('m, 'n, num_type, prec, 'cnt_or_dsc) Slap_mat.t

Matrices.

type rprec = Bigarray.float64_elt

type (+'n, +'cnt_or_dsc) rvec = ('n, float, rprec, 'cnt_or_dsc) Slap_vec.t

Real vectors. (In Slap.S and Slap.D, rvec is equal to vec.)

val prec : (num_type, prec) Bigarray.kind

val rprec : (float, rprec) Bigarray.kind

module Vec : sig ... end

module Mat : sig ... end

val pp_num : Format.formatter -> num_type -> unit

A pretty-printer for elements in vectors and matrices.

val pp_vec : Format.formatter -> ('n, 'cnt_or_dsc) vec -> unit

A pretty-printer for column vectors.

val pp_mat : Format.formatter -> ('m, 'n, 'cnt_or_dsc) mat -> unit

A pretty-printer for matrices.

BLAS interface

Level 1

val swap : ('n, 'x_cd) vec -> ('n, 'y_cd) vec -> unit

swap x y swaps elements in x and y.

val scal : num_type -> ('n, 'cd) vec -> unit

scal c x multiplies all elements in x by scalar value c, and destructively assigns the result to x.

val copy : ?y:('n, 'y_cd) vec -> ('n, 'x_cd) vec -> ('n, 'y_cd) vec

copy ?y x copies x into y.

returns
vector y, which is overwritten.

val nrm2 : ('n, 'cd) vec -> float

nrm2 x retruns the L2 norm of vector x: ||x||.

val axpy : ?alpha:num_type -> ('n, 'x_cd) vec -> ('n, 'y_cd) vec -> unit

axpy ?alpha x y executes y := alpha * x + y with scalar value alpha, and vectors x and y.

parameter alpha
default = 1.0

val iamax : ('n, 'cd) vec -> int

iamax x returns the index of the maximum value of all elements in x.

val amax : ('n, 'cd) vec -> num_type

amax x finds the maximum value of all elements in x.

Level 2

val gemv : 
  ?beta:num_type ->
  ?y:('m, 'y_cd) vec ->
  trans:('a_m * 'a_n, 'm * 'n, _) trans3 ->
  ?alpha:num_type ->
  ('a_m, 'a_n, 'a_cd) mat ->
  ('n, 'x_cd) vec ->
  ('m, 'y_cd) vec

gemv ?beta ?y ~trans ?alpha a x executes y := alpha * OP(a) * x + beta * y.

parameter beta
default = 0.0

parameter trans
the transpose flag for a:
- If trans = Slap_common.normal, then OP(a) = a;
- If trans = Slap_common.trans, then OP(a) = a^T;
- If trans = Slap_common.conjtr, then OP(a) = a^H (the conjugate transpose of a).

parameter alpha
default = 1.0

val gbmv : 
  m:'a_m Slap_size.t ->
  ?beta:num_type ->
  ?y:('m, 'y_cd) vec ->
  trans:('a_m * 'a_n, 'm * 'n, _) trans3 ->
  ?alpha:num_type ->
  (('a_m, 'a_n, 'kl, 'ku) Slap_size.geband, 'a_n, 'a_cd) mat ->
  'kl Slap_size.t ->
  'ku Slap_size.t ->
  ('n, 'x_cd) vec ->
  ('m, 'y_cd) vec

gbmv ~m ?beta ?y ~trans ?alpha a kl ku x computes y := alpha * OP(a) * x + beta * y where a is a band matrix stored in band storage.

returns
vector y, which is overwritten.

parameter beta
default = 0.0

parameter trans
the transpose flag for a:
- If trans = Slap_common.normal, then OP(a) = a;
- If trans = Slap_common.trans, then OP(a) = a^T;
- If trans = Slap_common.conjtr, then OP(a) = a^H (the conjugate transpose of a).

parameter alpha
default = 1.0

parameter kl
the number of subdiagonals of a

parameter ku
the number of superdiagonals of a

since 0.2.0

val symv : 
  ?beta:num_type ->
  ?y:('n, 'y_cd) vec ->
  ?up:[< `L | `U ] Slap_common.uplo ->
  ?alpha:num_type ->
  ('n, 'n, 'a_cd) mat ->
  ('n, 'x_cd) vec ->
  ('n, 'y_cd) vec

symv ?beta ?y ?up ?alpha a x executes y := alpha * a * x + beta * y.

parameter beta
default = 0.0

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

parameter alpha
default = 1.0

val trmv : 
  trans:('n * 'n, 'n * 'n, _) trans3 ->
  ?diag:Slap_common.diag ->
  ?up:[< `L | `U ] Slap_common.uplo ->
  ('n, 'n, 'a_cd) mat ->
  ('n, 'x_cd) vec ->
  unit

trmv ~trans ?diag ?up a x executes x := OP(a) * x.

parameter trans
the transpose flag for a:
- If trans = Slap_common.normal, then OP(a) = a;
- If trans = Slap_common.trans, then OP(a) = a^T;
- If trans = Slap_common.conjtr, then OP(a) = a^H (the conjugate transpose of a).

parameter diag
default = Slap_common.non_unit
- If diag = Slap_common.unit, then a is unit triangular;
- If diag = Slap_common.non_unit, then a is not unit triangular.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

val trsv : 
  trans:('n * 'n, 'n * 'n, _) trans3 ->
  ?diag:Slap_common.diag ->
  ?up:[< `L | `U ] Slap_common.uplo ->
  ('n, 'n, 'a_cd) mat ->
  ('n, 'b_cd) vec ->
  unit

trmv ~trans ?diag ?up a b solves linear system OP(a) * x = b and destructively assigns x to b.

parameter trans
the transpose flag for a:
- If trans = Slap_common.normal, then OP(a) = a;
- If trans = Slap_common.trans, then OP(a) = a^T;
- If trans = Slap_common.conjtr, then OP(a) = a^H (the conjugate transpose of a).

parameter diag
default = Slap_common.non_unit
- If diag = Slap_common.unit, then a is unit triangular;
- If diag = Slap_common.non_unit, then a is not unit triangular.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

val tpmv : 
  trans:('n * 'n, 'n * 'n, _) trans3 ->
  ?diag:Slap_common.diag ->
  ?up:[< `L | `U ] Slap_common.uplo ->
  ('n Slap_size.packed, Slap_misc.cnt) vec ->
  ('n, 'x_cd) vec ->
  unit

tpmv ~trans ?diag ?up a x executes x := OP(a) * x where a is a packed triangular matrix.

parameter trans
the transpose flag for a:
- If trans = Slap_common.normal, then OP(a) = a;
- If trans = Slap_common.trans, then OP(a) = a^T;
- If trans = Slap_common.conjtr, then OP(a) = a^H (the conjugate transpose of a).

parameter diag
default = Slap_common.non_unit
- If diag = Slap_common.unit, then a is unit triangular;
- If diag = Slap_common.non_unit, then a is not unit triangular.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

since 0.2.0

val tpsv : 
  trans:('n * 'n, 'n * 'n, _) trans3 ->
  ?diag:Slap_common.diag ->
  ?up:[< `L | `U ] Slap_common.uplo ->
  ('n Slap_size.packed, Slap_misc.cnt) vec ->
  ('n, 'x_cd) vec ->
  unit

tpsv ~trans ?diag ?up a b solves linear system OP(a) * x = b and destructively assigns x to b where a is a packed triangular matrix.

parameter trans
the transpose flag for a:
- If trans = Slap_common.normal, then OP(a) = a;
- If trans = Slap_common.trans, then OP(a) = a^T;
- If trans = Slap_common.conjtr, then OP(a) = a^H (the conjugate transpose of a).

parameter diag
default = Slap_common.non_unit
- If diag = Slap_common.unit, then a is unit triangular;
- If diag = Slap_common.non_unit, then a is not unit triangular.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

since 0.2.0

Level 3

val gemm : 
  ?beta:num_type ->
  ?c:('m, 'n, 'c_cd) mat ->
  transa:('a_m * 'a_k, 'm * 'k, _) trans3 ->
  ?alpha:num_type ->
  ('a_m, 'a_k, 'a_cd) mat ->
  transb:('b_k * 'b_n, 'k * 'n, _) trans3 ->
  ('b_k, 'b_n, 'b_cd) mat ->
  ('m, 'n, 'c_cd) mat

gemm ?beta ?c ~transa ?alpha a ~transb b executes c := alpha * OP(a) * OP(b) + beta * c.

parameter beta
default = 0.0

parameter transa
the transpose flag for a:
- If transa = Slap_common.normal, then OP(a) = a;
- If transa = Slap_common.trans, then OP(a) = a^T;
- If transa = Slap_common.conjtr, then OP(a) = a^H (the conjugate transpose of a).

parameter alpha
default = 1.0

parameter transb
the transpose flag for b:
- If transb = Slap_common.normal, then OP(b) = b;
- If transb = Slap_common.trans, then OP(b) = b^T;
- If transb = Slap_common.conjtr, then OP(b) = b^H (the conjugate transpose of b).

val symm : 
  side:('k, 'm, 'n) Slap_common.side ->
  ?up:[< `U | `L ] Slap_common.uplo ->
  ?beta:num_type ->
  ?c:('m, 'n, 'c_cd) mat ->
  ?alpha:num_type ->
  ('k, 'k, 'a_cd) mat ->
  ('m, 'n, 'b_cd) mat ->
  ('m, 'n, 'c_cd) mat

symm ~side ?up ?beta ?c ?alpha a b executes

c := alpha * a * b + beta * c (if side = Slap_common.left) or
c := alpha * b * a + beta * c (if side = Slap_common.right)

where a is a symmterix matrix, and b and c are general matrices.

parameter side
the side flag to specify direction of multiplication of a and b.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

parameter beta
default = 0.0

parameter alpha
default = 1.0

val trmm : 
  side:('k, 'm, 'n) Slap_common.side ->
  ?up:[< `U | `L ] Slap_common.uplo ->
  transa:('k * 'k, 'k * 'k, _) trans3 ->
  ?diag:Slap_common.diag ->
  ?alpha:num_type ->
  a:('k, 'k, 'a_cd) mat ->
  ('m, 'n, 'b_cd) mat ->
  unit

trmm ~side ?up ~transa ?diag ?alpha ~a b executes

b := alpha * OP(a) * b (if side = Slap_common.left) or
b := alpha * b * OP(a) (if side = Slap_common.right)

where a is a triangular matrix, and b is a general matrix.

parameter side
the side flag to specify direction of multiplication of a and b.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

parameter transa
the transpose flag for a:
- If transa = Slap_common.normal, then OP(a) = a;
- If transa = Slap_common.trans, then OP(a) = a^T;
- If transa = Slap_common.conjtr, then OP(a) = a^H (the conjugate transpose of a).

parameter diag
default = Slap_common.non_unit
- If diag = Slap_common.unit, then a is unit triangular;
- If diag = Slap_common.non_unit, then a is not unit triangular.

parameter alpha
default = 1.0

val trsm : 
  side:('k, 'm, 'n) Slap_common.side ->
  ?up:[< `U | `L ] Slap_common.uplo ->
  transa:('k * 'k, 'k * 'k, _) trans3 ->
  ?diag:Slap_common.diag ->
  ?alpha:num_type ->
  a:('k, 'k, 'a_cd) mat ->
  ('m, 'n, 'b_cd) mat ->
  unit

trsm ~side ?up ~transa ?diag ?alpha ~a b solves a system of linear equations

OP(a) * x = alpha * b (if side = Slap_common.left) or
x * OP(a) = alpha * b (if side = Slap_common.right)

where a is a triangular matrix, and b is a general matrix. The solution x is returned by b.

parameter side
the side flag to specify direction of multiplication of a and b.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

parameter transa
the transpose flag for a:
- If transa = Slap_common.normal, then OP(a) = a;
- If transa = Slap_common.trans, then OP(a) = a^T;
- If transa = Slap_common.conjtr, then OP(a) = a^H (the conjugate transpose of a).

parameter diag
default = Slap_common.non_unit
- If diag = Slap_common.unit, then a is unit triangular;
- If diag = Slap_common.non_unit, then a is not unit triangular.

parameter alpha
default = 1.0

val syrk : 
  ?up:[< `U | `L ] Slap_common.uplo ->
  ?beta:num_type ->
  ?c:('n, 'n, 'c_cd) mat ->
  trans:('a_n * 'a_k, 'n * 'k, _) Slap_common.trans2 ->
  ?alpha:num_type ->
  ('a_n, 'a_k, 'a_cd) mat ->
  ('n, 'n, 'c_cd) mat

syrk ?up ?beta ?c ~trans ?alpha a executes

c := alpha * a * a^T + beta * c (if trans = Slap_common.normal) or
c := alpha * a^T * a + beta * c (if trans = Slap_common.trans)

where a is a general matrix and c is a symmetric matrix.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

parameter beta
default = 0.0

parameter trans
the transpose flag for a

parameter alpha
default = 1.0

val syr2k : 
  ?up:[< `U | `L ] Slap_common.uplo ->
  ?beta:num_type ->
  ?c:('n, 'n, 'c_cd) mat ->
  trans:('p * 'q, 'n * 'k, _) Slap_common.trans2 ->
  ?alpha:num_type ->
  ('p, 'q, 'a_cd) mat ->
  ('p, 'q, 'b_cd) mat ->
  ('n, 'n, 'c_cd) mat

syr2k ?up ?beta ?c ~trans ?alpha a b computes

c := alpha * a * b^T + alpha * b * a^T + beta * c (if trans = Slap_common.normal) or
c := alpha * a^T * b + alpha * b^T * a + beta * c (if trans = Slap_common.trans)

with symmetric matrix c, and general matrices a and b.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

parameter beta
default = 0.0

parameter trans
the transpose flag for a

parameter alpha
default = 1.0

LAPACK interface

Auxiliary routines

val lacpy : 
  ?uplo:[< `A | `L | `U ] Slap_common.uplo ->
  ?b:('m, 'n, 'b_cd) mat ->
  ('m, 'n, 'a_cd) mat ->
  ('m, 'n, 'b_cd) mat

lacpy ?uplo ?b a copies the matrix a into the matrix b.

returns
b, which is overwritten.

parameter uplo
default = Slap_common.upper_lower
- If uplo = Slap_common.upper, then the upper triangular part of a is copied;
- If uplo = Slap_common.lower, then the lower triangular part of a is copied.

parameter b
default = a fresh matrix.

val lassq : ?scale:float -> ?sumsq:float -> ('n, 'cd) vec -> float * float

lassq ?scale ?sumsq x

returns
(scl, smsq) where scl and smsq satisfy scl^2 * smsq = x1^2 + x2^2 + ... + xn^2 + scale^2 * smsq.

parameter scale
default = 0.0

parameter sumsq
default = 1.0

type larnv_liseed = Slap_size.four

val larnv : 
  ?idist:[ `Normal | `Uniform0 | `Uniform1 ] ->
  ?iseed:(larnv_liseed, Slap_misc.cnt) Slap_common.int32_vec ->
  x:('n, Slap_misc.cnt) vec ->
  unit ->
  ('n, 'cnt) vec

larnv ?idist ?iseed ~x () generates a random vector with the random distribution specified by idist and random seed iseed.

returns
vector x, which is overwritten.

parameter idist
default = `Normal

parameter iseed
a four-dimensional integer vector with all ones.

type ('m, 'a) lange_min_lwork

val lange_min_lwork : 
  'm Slap_size.t ->
  'a Slap_common.norm4 ->
  ('m, 'a) lange_min_lwork Slap_size.t

lange_min_lwork m norm computes the minimum length of workspace for lange routine. m is the number of rows in a matrix, and norm is the sort of matrix norms.

val lange : 
  ?norm:'a Slap_common.norm4 ->
  ?work:('lwork, Slap_misc.cnt) rvec ->
  ('m, 'n, 'cd) mat ->
  float

lange ?norm ?work a

returns
the norm of matrix a.

parameter norm
default = Slap_common.norm_1.
- If norm = Slap_common.norm_1, the one norm is returned;
- If norm = Slap_common.norm_inf, the infinity norm is returned;
- If norm = Slap_common.norm_amax, the largest absolute value of elements in matrix a (not a matrix norm) is returned;
- If norm = Slap_common.norm_frob, the Frobenius norm is returned.

parameter work
default = an optimum-length vector.

val lauum : ?up:[< `U | `L ] Slap_common.uplo -> ('n, 'n, 'cd) mat -> unit

lauum ?up a computes

U * U^T where U is the upper triangular part of matrix a if up is Slap_common.upper.
L^T * L where L is the lower triangular part of matrix a if up is Slap_common.lower.

The upper or lower triangular part is overwritten.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

Linear equations (computational routines)

val getrf : 
  ?ipiv:(('m, 'n) Slap_size.min, Slap_misc.cnt) Slap_common.int32_vec ->
  ('m, 'n, 'cd) mat ->
  (('m, 'n) Slap_size.min, 'cnt) Slap_common.int32_vec

getrf ?ipiv a computes LU factorization of matrix a using partial pivoting with row interchanges: a = P * L * U where P is a permutation matrix, and L and U are lower and upper triangular matrices, respectively. the permutation matrix is returned in ipiv.

returns
vector ipiv, which is overwritten.

raises Failure
if the matrix is singular.

val getrs : 
  ?ipiv:(('n, 'n) Slap_size.min, Slap_misc.cnt) Slap_common.int32_vec ->
  trans:('n * 'n, 'n * 'n, _) trans3 ->
  ('n, 'n, 'a_cd) mat ->
  ('n, 'nrhs, 'b_cd) mat ->
  unit

getrs ?ipiv trans a b solves systems of linear equations OP(a) * x = b where a a 'n-by-'n general matrix, each column of matrix b is the r.h.s. vector, and each column of matrix x is the corresponding solution. The solution x is returned in b.

parameter ipiv
a result of gesv or getrf. It is internally computed by getrf if omitted.

parameter trans
the transpose flag for a:
- If trans = Slap_common.normal, then OP(a) = a;
- If trans = Slap_common.trans, then OP(a) = a^T;
- If trans = Slap_common.conjtr, then OP(a) = a^H (the conjugate transpose of a).

raises Failure
if the matrix is singular.

type 'n getri_min_lwork

val getri_min_lwork : 'n Slap_size.t -> 'n getri_min_lwork Slap_size.t

getri_min_lwork n computes the minimum length of workspace for getri routine. n is the number of columns or rows in a matrix.

val getri_opt_lwork : ('n, 'n, 'cd) mat -> (module Slap_size.SIZE)

getri_opt_lwork a computes the optimal length of workspace for getri routine.

val getri : 
  ?ipiv:(('n, 'n) Slap_size.min, Slap_misc.cnt) Slap_common.int32_vec ->
  ?work:('lwork, Slap_misc.cnt) vec ->
  ('n, 'n, 'cd) mat ->
  unit

getri ?ipiv ?work a computes the inverse of general matrix a by LU-factorization. The inverse matrix is returned in a.

parameter ipiv
a result of gesv or getrf. It is internally computed by getrf if omitted.

parameter work
default = an optimum-length vector.

raises Failure
if the matrix is singular.

type sytrf_min_lwork

val sytrf_min_lwork : unit -> sytrf_min_lwork Slap_size.t

sytrf_min_lwork () computes the minimum length of workspace for sytrf routine.

val sytrf_opt_lwork : 
  ?up:[< `U | `L ] Slap_common.uplo ->
  ('n, 'n, 'cd) mat ->
  (module Slap_size.SIZE)

sytrf_opt_lwork ?up a computes the optimal length of workspace for sytrf routine.

parameter up
default = true
- If up = true, then the upper triangular part of a is used;
- If up = false, then the lower triangular part of a is used.

val sytrf : 
  ?up:[< `U | `L ] Slap_common.uplo ->
  ?ipiv:('n, Slap_misc.cnt) Slap_common.int32_vec ->
  ?work:('lwork, Slap_misc.cnt) vec ->
  ('n, 'n, 'cd) mat ->
  ('n, 'cnt) Slap_common.int32_vec

sytrf ?up ?ipiv ?work a factorizes symmetric matrix a using the Bunch-Kaufman diagonal pivoting method:

a = P * U * D * U^T * P^T if up = true;
a = P * L * D * L^T * P^T if up = false

where P is a permutation matrix, U and L are upper and lower triangular matrices with unit diagonal, and D is a symmetric block-diagonal matrix. The permutation matrix is returned in ipiv.

returns
vector ipiv, which is overwritten.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

parameter work
default = an optimum-length vector.

raises Failure
if a is singular.

val sytrs : 
  ?up:[< `U | `L ] Slap_common.uplo ->
  ?ipiv:('n, Slap_misc.cnt) Slap_common.int32_vec ->
  ('n, 'n, 'a_cd) mat ->
  ('n, 'nrhs, 'b_cd) mat ->
  unit

sytrs ?up ?ipiv a b solves systems of linear equations a * x = b where a is a symmetric matrix, each column of matrix b is the r.h.s. vector, and each column of matrix x is the corresponding solution. The solution x is returned in b.

This routine uses the Bunch-Kaufman diagonal pivoting method:

a = P * U * D * U^T * P^T if up = true;
a = P * L * D * L^T * P^T if up = false

where P is a permutation matrix, U and L are upper and lower triangular matrices with unit diagonal, and D is a symmetric block-diagonal matrix.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

parameter ipiv
a result of sytrf. It is internally computed by sytrf if omitted.

raises Failure
if a is singular.

type 'n sytri_min_lwork

val sytri_min_lwork : 'n Slap_size.t -> 'n sytri_min_lwork Slap_size.t

sytri_min_lwork () computes the minimum length of workspace for sytri routine.

val sytri : 
  ?up:[< `U | `L ] Slap_common.uplo ->
  ?ipiv:('n, Slap_misc.cnt) Slap_common.int32_vec ->
  ?work:('lwork, Slap_misc.cnt) vec ->
  ('n, 'n, 'cd) mat ->
  unit

sytri ?up ?ipiv ?work a computes the inverse of symmetric matrix a using the Bunch-Kaufman diagonal pivoting method:

a = P * U * D * U^T * P^T if up = true;
a = P * L * D * L^T * P^T if up = false

where P is a permutation matrix, U and L are upper and lower triangular matrices with unit diagonal, and D is a symmetric block-diagonal matrix.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

parameter ipiv
a result of sytrf. It is internally computed by sytrf if omitted.

parameter work
default = an optimum-length vector.

raises Failure
if a is singular.

val potrf : 
  ?up:[< `U | `L ] Slap_common.uplo ->
  ?jitter:num_type ->
  ('n, 'n, 'cd) mat ->
  unit

potrf ?up ?jitter a computes the Cholesky factorization of symmetrix (Hermitian) positive-definite matrix a:

a = U^T * U (real) or a = U^H * U (complex) if up = true;
a = L * L^T (real) or a = L * L^H (complex) if up = false

where U and L are upper and lower triangular matrices, respectively. Either of them is returned in the upper or lower triangular part of a, as specified by up.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

parameter jitter
default = nothing

raises Failure
if a is not positive-definite symmetric.

val potrs : 
  ?up:[< `U | `L ] Slap_common.uplo ->
  ('n, 'n, 'a_cd) mat ->
  ?factorize:bool ->
  ?jitter:num_type ->
  ('n, 'nrhs, 'b_cd) mat ->
  unit

potrf ?up a ?jitter b solves systems of linear equations a * x = b using the Cholesky factorization of symmetrix (Hermitian) positive-definite matrix a:

a = U^T * U (real) or a = U^H * U (complex) if up = Slap_common.upper;
a = L * L^T (real) or a = L * L^H (complex) if up = Slap_common.lower

where U and L are upper and lower triangular matrices, respectively.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

parameter factorize
default = true (potrf is called implicitly)

parameter jitter
default = nothing

raises Failure
if a is singular.

val potri : 
  ?up:[< `U | `L ] Slap_common.uplo ->
  ?factorize:bool ->
  ?jitter:num_type ->
  ('n, 'n, 'cd) mat ->
  unit

potrf ?up ?jitter a computes the inverse of symmetrix (Hermitian) positive-definite matrix a using the Cholesky factorization:

a = U^T * U (real) or a = U^H * U (complex) if up = Slap_common.upper;
a = L * L^T (real) or a = L * L^H (complex) if up = Slap_common.lower

where U and L are upper and lower triangular matrices, respectively.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

parameter factorize
default = true (potrf is called implicitly)

parameter jitter
default = nothing

raises Failure
if a is singular.

val trtrs : 
  ?up:[< `U | `L ] Slap_common.uplo ->
  trans:('n * 'n, 'n * 'n, _) trans3 ->
  ?diag:Slap_common.diag ->
  ('n, 'n, 'a_cd) mat ->
  ('n, 'nrhs, 'b_cd) mat ->
  unit

trtrs ?up trans ?diag a b solves systems of linear equations OP(a) * x = b where a is a triangular matrix of order 'n, each column of matrix b is the r.h.s vector, and each column of matrix x is the corresponding solution. The solution x is returned in b.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

parameter trans
the transpose flag for a:
- If trans = Slap_common.normal, then OP(a) = a;
- If trans = Slap_common.trans, then OP(a) = a^T;
- If trans = Slap_common.conjtr, then OP(a) = a^H (the conjugate transpose of a).

parameter diag
default = `N
- If diag = `U, then a is unit triangular;
- If diag = `N, then a is not unit triangular.

raises Failure
if a is singular.

val tbtrs : 
  kd:'kd Slap_size.t ->
  ?up:[< `U | `L ] Slap_common.uplo ->
  trans:('n * 'n, 'n * 'n, _) trans3 ->
  ?diag:Slap_common.diag ->
  (('n, 'kd) Slap_size.syband, 'n, 'a_cd) mat ->
  ('n, 'nrhs, 'b_cd) mat ->
  unit

tbtrs ~kd ?up ~trans ?diag ab b solves systems of linear equations OP(A) * x = b where A is a triangular band matrix with kd subdiagonals, each column of matrix b is the r.h.s vector, and each column of matrix x is the corresponding solution. Matrix A is stored into ab in band storage format. The solution x is returned in b.

parameter kd
the number of subdiagonals or superdiagonals in A.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of A is used;
- If up = Slap_common.lower, then the lower triangular part of A is used.

parameter trans
the transpose flag for A:
- If trans = Slap_common.normal, then OP(A) = A;
- If trans = Slap_common.trans, then OP(A) = A^T;
- If trans = Slap_common.conjtr, then OP(A) = A^H (the conjugate transpose of A).

parameter diag
default = `N
- If diag = `U, then A is unit triangular;
- If diag = `N, then A is not unit triangular.

raises Failure
if the matrix A is singular.

since 0.2.0

val trtri : 
  ?up:[< `U | `L ] Slap_common.uplo ->
  ?diag:Slap_common.diag ->
  ('n, 'n, 'cd) mat ->
  unit

trtri ?up ?diag a computes the inverse of triangular matrix a. The inverse matrix is returned in a.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of A is used;
- If up = Slap_common.lower, then the lower triangular part of A is used.

parameter diag
default = `N
- If diag = `U, then a is unit triangular;
- If diag = `N, then a is not unit triangular.

raises Failure
if the matrix a is singular.

since 0.2.0

type 'n geqrf_min_lwork

val geqrf_min_lwork : n:'n Slap_size.t -> 'n geqrf_min_lwork Slap_size.t

geqrf_min_lwork ~n computes the minimum length of workspace for geqrf routine. n is the number of columns in a matrix.

val geqrf_opt_lwork : ('m, 'n, 'cd) mat -> (module Slap_size.SIZE)

geqrf_opt_lwork a computes the optimum length of workspace for geqrf routine.

val geqrf : 
  ?work:('lwork, Slap_misc.cnt) vec ->
  ?tau:(('m, 'n) Slap_size.min, Slap_misc.cnt) vec ->
  ('m, 'n, 'cd) mat ->
  (('m, 'n) Slap_size.min, 'cnt) vec

geqrf ?work ?tau a computes the QR factorization of general matrix a: a = Q * R where Q is an orthogonal (unitary) matrix and R is an upper triangular matrix. R is returned in a. This routine does not generate Q explicitly. It is generated by orgqr.

returns
vector tau, which is overwritten.

parameter work
default = an optimum-length vector.

Linear equations (simple drivers)

val gesv : 
  ?ipiv:('n, Slap_misc.cnt) Slap_common.int32_vec ->
  ('n, 'n, 'a_cd) mat ->
  ('n, 'nrhs, 'b_cd) mat ->
  unit

gesv ?ipiv a b solves a system of linear equations a * x = b where a is a 'n-by-'n general matrix, each column of matrix b is the r.h.s. vector, and each column of matrix x is the corresponding solution.

This routine uses LU factorization: a = P * L * U with permutation matrix P, a lower triangular matrix L and an upper triangular matrix U. By this function, the upper triangular part of a is replaced by U, the lower triangular part by L, and the solution x is returned in b.

raises Failure
if the matrix is singular.

since 0.2.0

val gbsv : 
  ?ipiv:('n, Slap_misc.cnt) Slap_common.int32_vec ->
  (('n, 'n, 'kl, 'ku) Slap_size.luband, 'n, 'a_cd) mat ->
  'kl Slap_size.t ->
  'ku Slap_size.t ->
  ('n, 'nrhs, 'b_cd) mat ->
  unit

gbsv ?ipiv ab kl ku b solves a system of linear equations A * X = B where A is a 'n-by-'n band matrix, each column of matrix B is the r.h.s. vector, and each column of matrix X is the corresponding solution. The matrix A with kl subdiagonals and ku superdiagonals is stored into ab in band storage format for LU factorizaion.

This routine uses LU factorization: A = P * L * U with permutation matrix P, a lower triangular matrix L and an upper triangular matrix U. By this function, the upper triangular part of A is replaced by U, the lower triangular part by L, and the solution X is returned in B.

raises Failure
if the matrix is singular.

since 0.2.0

val posv : 
  ?up:[< `U | `L ] Slap_common.uplo ->
  ('n, 'n, 'a_cd) mat ->
  ('n, 'nrhs, 'b_cd) mat ->
  unit

posv ?up a b solves systems of linear equations a * x = b where a is a 'n-by-'n symmetric positive-definite matrix, each column of matrix b is the r.h.s vector, and each column of matrix x is the corresponding solution. The solution x is returned in b.

The Cholesky decomposition is used:

If up = Slap_common.upper, then a = U^T * U (real) or a = U^H * U (complex)
If up = Slap_common.lower, then a = L^T * L (real) or a = L^H * L (complex)

where U and L are the upper and lower triangular matrices, respectively.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

raises Failure
if the matrix is singular.

since 0.2.0

val ppsv : 
  ?up:[< `U | `L ] Slap_common.uplo ->
  ('n Slap_size.packed, Slap_misc.cnt) vec ->
  ('n, 'nrhs, 'b_cd) mat ->
  unit

ppsv ?up a b solves systems of linear equations a * x = b where a is a 'n-by-'n symmetric positive-definite matrix stored in packed format, each column of matrix b is the r.h.s vector, and each column of matrix x is the corresponding solution. The solution x is returned in b.

If up = Slap_common.upper, then a = U^T * U (real) or a = U^H * U (complex)
If up = Slap_common.lower, then a = L^T * L (real) or a = L^H * L (complex)

where U and L are the upper and lower triangular matrices, respectively.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

raises Failure
if the matrix is singular.

since 0.2.0

val pbsv : 
  ?up:[< `U | `L ] Slap_common.uplo ->
  kd:'kd Slap_size.t ->
  (('n, 'kd) Slap_size.syband, 'n, 'ab_cd) mat ->
  ('n, 'nrhs, 'b_cd) mat ->
  unit

pbsv ?up ~kd ab b solves systems of linear equations ab * x = b where ab is a 'n-by-'n symmetric positive-definite band matrix with kd subdiangonals, stored in band storage format, each column of matrix b is the r.h.s vector, and each column of matrix x is the corresponding solution. The solution x is returned in b.

This routine uses the Cholesky decomposition:

If up = Slap_common.upper, then a = U^T * U (real) or a = U^H * U (complex)
If up = Slap_common.lower, then a = L^T * L (real) or a = L^H * L (complex)

where U and L are the upper and lower triangular matrices, respectively.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

parameter kd
the number of subdiagonals or superdiagonals in ab.

raises Failure
if the matrix is singular.

since 0.2.0

val ptsv : 
  ('n, Slap_misc.cnt) vec ->
  ('n Slap_size.p, Slap_misc.cnt) vec ->
  ('n, 'nrhs, 'b_cd) mat ->
  unit

ptsv d e b solves systems of linear equations A * x = b where A is a 'n-by-'n symmetric positive-definite tridiagonal matrix with diagonal elements d and subdiagonal elements e, each column of matrix b is the r.h.s vector, and each column of matrix x is the corresponding solution. The solution x is returned in b.

This routine uses the Cholesky decomposition: A = L^T * L (real) or A = L^H * L (complex) where L is a lower triangular matrix.

raises Failure
if the matrix is singular.

since 0.2.0

type sysv_min_lwork

val sysv_min_lwork : unit -> sysv_min_lwork Slap_size.t

sysv_min_lwork () computes the minimum length of workspace for sysv routine.

val sysv_opt_lwork : 
  ?up:[< `U | `L ] Slap_common.uplo ->
  ('n, 'n, 'a_cd) mat ->
  ('n, 'nrhs, 'b_cd) mat ->
  (module Slap_size.SIZE)

sysv_opt_lwork ?up a b computes the optimal length of workspace for sysv routine.

val sysv : 
  ?up:[< `U | `L ] Slap_common.uplo ->
  ?ipiv:('n, Slap_misc.cnt) Slap_common.int32_vec ->
  ?work:('lwork, Slap_misc.cnt) vec ->
  ('n, 'n, 'a_cd) mat ->
  ('n, 'nrhs, 'b_cd) mat ->
  unit

sysv ?up ?ipiv ?work a b solves systems of linear equations a * x = b where a is a 'n-by-'n symmetric matrix, each column of matrix b is the r.h.s. vector, and each column of matrix x is the corresponding solution. The solution x is returned in b.

The diagonal pivoting method is used:

If up = Slap_common.upper, then a = U * D * U^T
If up = Slap_common.lower, then a = L * D * L^T where U and L are the upper and lower triangular matrices, respectively.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

parameter ipiv
a result of sytrf. It is internally computed by sytrf if omitted.

parameter work
default = an optimum-length vector.

raises Failure
if the matrix is singular.

since 0.2.0

val spsv : 
  ?up:[< `U | `L ] Slap_common.uplo ->
  ?ipiv:('n, Slap_misc.cnt) Slap_common.int32_vec ->
  ('n Slap_size.packed, Slap_misc.cnt) vec ->
  ('n, 'nrhs, 'b_cd) mat ->
  unit

spsv ?up a b solves systems of linear equations a * x = b where a is a 'n-by-'n symmetric matrix stored in packed format, each column of matrix b is the r.h.s. vector, and each column of matrix x is the corresponding solution. The solution x is returned in b.

The diagonal pivoting method is used:

If up = Slap_common.upper, then a = U * D * U^T
If up = Slap_common.lower, then a = L * D * L^T where U and L are the upper and lower triangular matrices, respectively.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

parameter ipiv
a result of sytrf. It is internally computed by sytrf if omitted.

raises Failure
if the matrix is singular.

since 0.2.0

Least squares (simple drivers)

type ('m, 'n, 'nrhs) gels_min_lwork

val gels_min_lwork : 
  m:'m Slap_size.t ->
  n:'n Slap_size.t ->
  nrhs:'nrhs Slap_size.t ->
  ('m, 'n, 'nrhs) gels_min_lwork Slap_size.t

gels_min_lwork ~n computes the minimum length of workspace for gels routine.

parameter m
the number of rows in a matrix.

parameter n
the number of columns in a matrix.

parameter nrhs
the number of right hand sides.

val gels_opt_lwork : 
  trans:('am * 'an, 'm * 'n, _) Slap_common.trans2 ->
  ('am, 'an, 'a_cd) mat ->
  ('m, 'nrhs, 'b_cd) mat ->
  (module Slap_size.SIZE)

gels_opt_lwork ~trans a b computes the optimum length of workspace for gels routine.

val gels : 
  ?work:('work, Slap_misc.cnt) vec ->
  trans:('am * 'an, 'm * 'n, _) Slap_common.trans2 ->
  ('am, 'an, 'a_cd) mat ->
  ('m, 'nrhs, 'b_cd) mat ->
  unit

gels ?work ~trans a b solves an overdetermined or underdetermined system of linear equations using QR or LU factorization.

If trans = Slap_common.normal and 'm >= 'n: find the least square solution to an overdetermined system by minimizing ||b - A * x||^2.
If trans = Slap_common.normal and 'm < 'n: find the minimum norm solution to an underdetermined system a * x = b.
If trans = Slap_common.trans, and 'm >= 'n: find the minimum norm solution to an underdetermined system a^H * x = b.
If trans = Slap_common.trans and 'm < 'n: find the least square solution to an overdetermined system by minimizing ||b - A^H * x||^2.

parameter work
default = an optimum-length vector.

parameter trans
the transpose flag for a.

BLAS interface

Level 1

val dot : ('n, 'x_cd) vec -> ('n, 'y_cd) vec -> float

dot x y

returns
the inner product of the vectors x and y.

val asum : ('n, 'x_cd) vec -> float

asum x

returns
the sum of absolute values of elements in the vector x.

Level 2

val sbmv : 
  k:'k Slap_size.t ->
  ?y:('n, 'y_cd) vec ->
  (('n, 'k) Slap_size.syband, 'n, 'a_cd) mat ->
  ?up:[< `U | `L ] Slap_common.uplo ->
  ?alpha:float ->
  ?beta:float ->
  ('n, 'x_cd) vec ->
  ('n, 'y_cd) vec

sbmv ~k ?y a ?up ?alpha ?beta x computes y := alpha * a * x + beta * y where a is a 'n-by-'n symmetric band matrix with k super-(or sub-)diagonals, and x and y are 'n-dimensional vectors.

returns
vector y, which is overwritten.

parameter k
the number of superdiangonals or subdiangonals

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

parameter alpha
default = 1.0

parameter beta
default = 0.0

since 0.2.0

val ger : 
  ?alpha:float ->
  ('m, 'x_cd) vec ->
  ('n, 'y_cd) vec ->
  ('m, 'n, 'a_cd) mat ->
  ('m, 'n, 'a_cd) mat

ger ?alpha x y a computes a := alpha * x * y^T + a with the general matrix a, the vector x and the transposed vector y^T of y.

returns
matrix a, which is overwritten.

parameter alpha
default = 1.0

val syr : 
  ?alpha:float ->
  ?up:[< `U | `L ] Slap_common.uplo ->
  ('n, 'x_cd) vec ->
  ('n, 'n, 'a_cd) mat ->
  ('n, 'n, 'a_cd) mat

syr ?alpha x a computes a := alpha * x * x^T + a with the symmetric matrix a, the vector x and the transposed vector x^T of x.

returns
matrix a, which is overwritten.

parameter alpha
default = 1.0

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

LAPACK interface

Auxiliary routines

lansy

type ('m, 'a) lansy_min_lwork

val lansy_min_lwork : 
  'n Slap_size.t ->
  'a Slap_common.norm4 ->
  ('n, 'a) lansy_min_lwork Slap_size.t

lansy_min_lwork n norm computes the minimum length of workspace for lansy routine. n is the number of rows or columns in a matrix. norm is a matrix norm.

val lansy : 
  ?up:[< `U | `L ] Slap_common.uplo ->
  ?norm:'norm Slap_common.norm4 ->
  ?work:('lwork, Slap_misc.cnt) vec ->
  ('n, 'n, 'cd) mat ->
  float

lansy ?up ?norm ?work a

returns
the norm of matrix a.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

parameter norm
default = Slap_common.norm_1
- If norm = Slap_common.norm_1, the one norm is returned;
- If norm = Slap_common.norm_inf, the infinity norm is returned;
- If norm = Slap_common.norm_amax, the largest absolute value of elements in matrix a (not a matrix norm) is returned;
- If norm = Slap_common.norm_frob, the Frobenius norm is returned.

parameter work
default = an optimum-length vector.

lamch

val lamch : [ `B | `E | `L | `M | `N | `O | `P | `R | `S | `U ] -> float

lamch cmach see LAPACK documentation.

Linear equations (computational routines)

orgqr

type 'n orgqr_min_lwork

val orgqr_min_lwork : n:'n Slap_size.t -> 'n orgqr_min_lwork Slap_size.t

orgqr_min_lwork ~n computes the minimum length of workspace for orgqr routine. n is the number of columns in a matrix.

val orgqr_opt_lwork : 
  tau:('k, Slap_misc.cnt) vec ->
  ('m, 'n, 'cd) mat ->
  (module Slap_size.SIZE)

orgqr_min_lwork ~tau a computes the optimum length of workspace for orgqr routine.

val orgqr_dyn : 
  ?work:('lwork, Slap_misc.cnt) vec ->
  tau:('k, Slap_misc.cnt) vec ->
  ('m, 'n, 'cd) mat ->
  unit

orgqr_dyn ?work ~tau a generates the orthogonal matrix Q of the QR factorization formed by geqrf/geqpf.

parameter work
default = an optimum-length vector

parameter tau
a result of geqrf

raises Invalid_argument
if the following inequality is not satisfied: (Mat.dim1 a) >= (Mat.dim2 a) >= (Vec.dim tau), i.e., 'm >= 'n >= 'k.

ormqr

type ('r, 'm, 'n) ormqr_min_lwork

val ormqr_min_lwork : 
  side:('r, 'm, 'n) Slap_common.side ->
  m:'m Slap_size.t ->
  n:'n Slap_size.t ->
  ('r, 'm, 'n) ormqr_min_lwork Slap_size.t

ormqr_min_lwork ~side ~m ~n computes the minimum length of workspace for ormqr routine.

parameter side
the side flag to specify direction of matrix multiplication.

parameter m
the number of rows in a matrix.

parameter n
the number of columns in a matrix.

val ormqr_opt_lwork : 
  side:('r, 'm, 'n) Slap_common.side ->
  trans:('r * 'r, 'r * 'r, _) Slap_common.trans2 ->
  tau:('k, Slap_misc.cnt) vec ->
  ('r, 'k, 'a_cd) mat ->
  ('m, 'n, 'c_cd) mat ->
  (module Slap_size.SIZE)

ormqr_opt_lwork ~side ~trans ~tau a c computes the optimum length of workspace for ormqr routine.

parameter side
the side flag to specify direction of matrix multiplication.

parameter trans
the transpose flag for orthogonal matrix Q.

parameter tau
a result of geqrf.

val ormqr_dyn : 
  side:('r, 'm, 'n) Slap_common.side ->
  trans:('r * 'r, 'r * 'r, _) Slap_common.trans2 ->
  ?work:('lwork, Slap_misc.cnt) vec ->
  tau:('k, Slap_misc.cnt) vec ->
  ('r, 'k, 'a_cd) mat ->
  ('m, 'n, 'c_cd) mat ->
  unit

ormqr_dyn ~side ~trans ?work ~tau a c multiplies a matrix c by the orthogonal matrix Q of the QR factorization formed by geqrf/geqpf:

Q * c if side = Slap_common.left and trans = Slap_common.normal;
Q^T * c if side = Slap_common.left and trans = Slap_common.trans;
c * Q if side = Slap_common.right and trans = Slap_common.normal;
c * Q^T if side = Slap_common.right and trans = Slap_common.trans.

parameter side
the side flag to specify direction of matrix multiplication of Q and c.

parameter trans
the transpose flag for orthogonal matrix Q.

parameter work
default = an optimum-length vector.

parameter tau
a result of geqrf.

raises Invalid_argument
if the following inequality is not satisfied:
- 'm >= 'k if side = Slap_common.left;
- 'n >= 'k if side = Slap_common.right.

gecon

type 'n gecon_min_lwork

val gecon_min_lwork : 'n Slap_size.t -> 'n gecon_min_lwork Slap_size.t

gecon_min_lwork n computes the minimum length of workspace work for gecon routine. n is the number of rows or columns in a matrix.

type 'n gecon_min_liwork

val gecon_min_liwork : 'n Slap_size.t -> 'n gecon_min_liwork Slap_size.t

gecon_min_liwork n computes the minimum length of workspace iwork for gecon routine. n is the number of rows or columns in a matrix.

val gecon : 
  ?norm:_ Slap_common.norm2 ->
  ?anorm:float ->
  ?work:('lwork, Slap_misc.cnt) vec ->
  ?iwork:('liwork, Slap_misc.cnt) Slap_common.int32_vec ->
  ('n, 'n, 'cd) mat ->
  float

gecon ?norm ?anorm ?work ?iwork a estimates the reciprocal of the condition number of general matrix a.

parameter norm
default = Slap_common.norm_1.
- If norm = Slap_common.norm_1, the one norm is returned;
- If norm = Slap_common.norm_inf, the infinity norm is returned.

parameter anorm
default = the norm of matrix a as returned by lange.

parameter work
default = an optimum-length vector.

parameter iwork
default = an optimum-length vector.

sycon

type 'n sycon_min_lwork

val sycon_min_lwork : 'n Slap_size.t -> 'n sycon_min_lwork Slap_size.t

sycon_min_lwork n computes the minimum length of workspace work for sycon routine. n is the number of rows or columns in a matrix.

type 'n sycon_min_liwork

val sycon_min_liwork : 'n Slap_size.t -> 'n sycon_min_liwork Slap_size.t

sycon_min_liwork n computes the minimum length of workspace iwork for sycon routine. n is the number of rows or columns in a matrix.

val sycon : 
  ?up:[< `U | `L ] Slap_common.uplo ->
  ?ipiv:('n, Slap_misc.cnt) Slap_common.int32_vec ->
  ?anorm:float ->
  ?work:('lwork, Slap_misc.cnt) vec ->
  ?iwork:('liwork, Slap_misc.cnt) Slap_common.int32_vec ->
  ('n, 'n, 'cd) mat ->
  float

sycon ?up ?ipiv ?anorm ?work ?iwork a estimates the reciprocal of the condition number of symmetric matrix a. Since a is symmetric, the 1-norm is equal to the infinity norm.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

parameter ipiv
a result of sytrf. It is internally computed by sytrf if omitted.

parameter anorm
default = the norm of matrix a as returned by lange.

parameter work
default = an optimum-length vector.

parameter iwork
default = an optimum-length vector.

pocon

type 'n pocon_min_lwork

val pocon_min_lwork : 'n Slap_size.t -> 'n pocon_min_lwork Slap_size.t

pocon_min_lwork n computes the minimum length of workspace work for pocon routine. n is the number of rows or columns in a matrix.

type 'n pocon_min_liwork

val pocon_min_liwork : 'n Slap_size.t -> 'n pocon_min_liwork Slap_size.t

pocon_min_liwork n computes the minimum length of workspace iwork for pocon routine. n is the number of rows or columns in a matrix.

val pocon : 
  ?up:[< `U | `L ] Slap_common.uplo ->
  ?anorm:float ->
  ?work:('lwork, Slap_misc.cnt) vec ->
  ?iwork:('liwork, Slap_misc.cnt) Slap_common.int32_vec ->
  ('n, 'n, 'cd) mat ->
  float

pocon ?up ?anorm ?work ?iwork a estimates the reciprocal of the condition number of symmetric positive-definite matrix a. Since a is symmetric, the 1-norm is equal to the infinity norm.

parameter up
default = Slap_common.upper
- If up = Slap_common.upper, then the upper triangular part of a is used;
- If up = Slap_common.lower, then the lower triangular part of a is used.

parameter anorm
default = the norm of matrix a as returned by lange.

parameter work
default = an optimum-length vector.

parameter iwork
default = an optimum-length vector.

Least squares (expert drivers)

gelsy

type ('m, 'n, 'nrhs) gelsy_min_lwork

val gelsy_min_lwork : 
  m:'m Slap_size.t ->
  n:'n Slap_size.t ->
  nrhs:'nrhs Slap_size.t ->
  ('m, 'n, 'nrhs) gelsy_min_lwork Slap_size.t

gelsy_min_lwork ~m ~n ~nrhs computes the minimum length of workspace for gelsy routine.

parameter m
the number of rows in a matrix.

parameter n
the number of columns in a matrix.

parameter nrhs
the number of right hand sides.

val gelsy_opt_lwork : 
  ('m, 'n, 'a_cd) mat ->
  ('n, 'nrhs, 'b_cd) mat ->
  (module Slap_size.SIZE)

gelsy_opt_lwork a b computes the optimum length of workspace for gelsy routine.

val gelsy : 
  ('m, 'n, 'a_cd) mat ->
  ?rcond:float ->
  ?jpvt:('n, Slap_misc.cnt) Slap_common.int32_vec ->
  ?work:('lwork, Slap_misc.cnt) vec ->
  ('n, 'nrhs, 'b_cd) mat ->
  int

gelsy a ?rcond ?jpvt ?work b computes the minimum-norm solution to a linear least square problem (minimize ||b - a * x||) using a complete orthogonal factorization of a.

returns
the effective rank of a.

parameter rcond
default = -1.0 (machine precision)

parameter jpvt
default = a 'n-dimensional vector.

parameter work
default = an optimum-length vector.

gelsd

type ('m, 'n, 'nrhs) gelsd_min_lwork

val gelsd_min_lwork : 
  m:'m Slap_size.t ->
  n:'n Slap_size.t ->
  nrhs:'nrhs Slap_size.t ->
  ('m, 'n, 'nrhs) gelsd_min_lwork Slap_size.t

gelsd_min_lwork ~m ~n ~nrhs computes the minimum length of workspace for gelsd routine.

parameter m
the number of rows in a matrix.

parameter n
the number of columns in a matrix.

parameter nrhs
the number of right hand sides.

val gelsd_opt_lwork : 
  ('m, 'n, 'a_cd) mat ->
  ('n, 'nrhs, 'b_cd) mat ->
  (module Slap_size.SIZE)

gelsd_opt_lwork a b computes the optimum length of workspace for gelsd routine.

type ('m, 'n, 'nrhs) gelsd_min_iwork

val gelsd_min_iwork : 
  'm Slap_size.t ->
  'n Slap_size.t ->
  ('m, 'n, 'nrhs) gelsd_min_iwork Slap_size.t

gelsd_min_iwork ~m ~n ~nrhs computes the minimum length of workspace iwork for gelsd routine.

parameter m
the number of rows in a matrix.

parameter n
the number of columns in a matrix.

val gelsd : 
  ('m, 'n, 'a_cd) mat ->
  ?rcond:float ->
  ?s:(('m, 'n) Slap_size.min, Slap_misc.cnt) vec ->
  ?work:('lwork, Slap_misc.cnt) vec ->
  ?iwork:('liwork, Slap_misc.cnt) vec ->
  ('n, 'nrhs, 'b_cd) mat ->
  int

gelsd a ?rcond ?jpvt ?work b computes the minimum-norm solution to a linear least square problem (minimize ||b - a * x||) using the singular value decomposition (SVD) of a and a divide and conquer method.

returns
the effective rank of a.

parameter rcond
default = -1.0 (machine precision)

parameter s
the singular values of a in decreasing order. They are implicitly computed if omitted.

parameter work
default = an optimum-length vector.

parameter iwork
default = an optimum-length vector.

raises Failure
if the function fails to converge.

gelss

type ('m, 'n, 'nrhs) gelss_min_lwork

val gelss_min_lwork : 
  m:'m Slap_size.t ->
  n:'n Slap_size.t ->
  nrhs:'nrhs Slap_size.t ->
  ('m, 'n, 'nrhs) gelss_min_lwork Slap_size.t

gelss_min_lwork ~m ~n ~nrhs computes the minimum length of workspace for gelss routine.

parameter m
the number of rows in a matrix.

parameter n
the number of columns in a matrix.

parameter nrhs
the number of right hand sides.

val gelss_opt_lwork : 
  ('m, 'n, 'a_cd) mat ->
  ('n, 'nrhs, 'b_cd) mat ->
  (module Slap_size.SIZE)

gelss_min_lwork a b computes the optimum length of workspace for gelss routine.

val gelss : 
  ('m, 'n, 'a_cd) mat ->
  ?rcond:float ->
  ?s:(('m, 'n) Slap_size.min, Slap_misc.cnt) vec ->
  ?work:('lwork, Slap_misc.cnt) vec ->
  ('n, 'nrhs, 'b_cd) mat ->
  int

gelss a ?rcond ?work b computes the minimum-norm solution to a linear least square problem (minimize ||b - a * x||) using the singular value decomposition (SVD) of a.

returns
the effective rank of a.

parameter rcond
default = -1.0 (machine precision)

parameter s
the singular values of a in decreasing order. They are implicitly computed if omitted.

parameter work
default = an optimum-length vector.

raises Failure
if the function fails to converge.

General SVD routines

gesvd

type ('m, 'n) gesvd_min_lwork

val gesvd_min_lwork : 
  m:'m Slap_size.t ->
  n:'n Slap_size.t ->
  ('m, 'n) gesvd_min_lwork Slap_size.t

gesvd_min_lwork ~m ~n computes the minimum length of workspace for gesvd routine.

parameter m
the number of rows in a matrix.

parameter n
the number of columns in a matrix.

val gesvd_opt_lwork : 
  jobu:
    ('u_cols, 'm, ('m, 'n) Slap_size.min, Slap_size.z, Slap_size.z)
      Slap_common.svd_job ->
  jobvt:
    ('vt_rows, 'n, ('m, 'n) Slap_size.min, Slap_size.z, Slap_size.z)
      Slap_common.svd_job ->
  ?s:(('m, 'n) Slap_size.min, Slap_misc.cnt) vec ->
  ?u:('m, 'u_cols, 'u_cd) mat ->
  ?vt:('vt_rows, 'n, 'vt_cd) mat ->
  ('m, 'n, 'a_cd) mat ->
  (module Slap_size.SIZE)

gesvd_opt_lwork ~jobu ~jobvt ?s ?u ?vt computes the optimum length of workspace for gesvd routine.

parameter jobu
the SVD job flag for u.

parameter jobvt
the SVD job flag for vt.

parameter s
a return location for singular values.

parameter u
a return location for left singular vectors.

parameter vt
a return location for (transposed) right singular vectors.

val gesvd : 
  jobu:
    ('u_cols, 'm, ('m, 'n) Slap_size.min, Slap_size.z, Slap_size.z)
      Slap_common.svd_job ->
  jobvt:
    ('vt_rows, 'n, ('m, 'n) Slap_size.min, Slap_size.z, Slap_size.z)
      Slap_common.svd_job ->
  ?s:(('m, 'n) Slap_size.min, Slap_misc.cnt) vec ->
  ?u:('m, 'u_cols, 'u_cd) mat ->
  ?vt:('vt_rows, 'n, 'vt_cd) mat ->
  ?work:('lwork, Slap_misc.cnt) vec ->
  ('m, 'n, 'a_cd) mat ->
  (('m, 'n) Slap_size.min, 'cnt) vec
  * ('m, 'u_cols, 'cnt) mat
  * ('vt_rows, 'n, 'cnt) mat

gesvd ?jobu ?jobvt ?s ?u ?vt ?work a computes the singular value decomposition (SVD) of 'm-by-'n general rectangular matrix a: a = U * D * V^T where

D is an 'm-by-'n matrix (the diagonal elements in D are singular values in descreasing order, and other elements are zeros),
U is an 'm-by-'m orthogonal matrix (the columns in U are left singular vectors), and
V is an 'n-by-'n orthogonal matrix (the columns in V are right singular vectors).

returns
(s, u, vt) with singular values s in descreasing order, left singular vectors u and right singular vectors vt.

parameter jobu
the SVD job flag for u:
- If jobu = Slap_common.svd_all, then all 'm columns of U are returned in u. ('u_cols = 'm.)
- If jobu = Slap_common.svd_top, then the first ('m, 'n) min columns of U are returned in u. ('u_cols = ('m, 'n) min.)
- If jobu = Slap_common.svd_overwrite, then the first ('m, 'n) min columns of U are overwritten on a. ('u_cols = z since u is unused.)
- If jobu = Slap_common.svd_no, then no columns of U are computed. ('u_cols = z.)

parameter jobvt
the SVD job flag for vt:
- If jobvt = Slap_common.svd_all, then all 'n rows of V^T are returned in vt. ('vt_rows = 'n.)
- If jobvt = Slap_common.svd_top, then the first ('m, 'n) min rows of V^T are returned in vt. ('vt_rows = ('m, 'n) min.)
- If jobvt = Slap_common.svd_overwrite, then the first ('m, 'n) min rows of V^T are overwritten on a. ('vt_cols = z since vt is unused.)
- If jobvt = Slap_common.svd_no, then no columns of V^T are computed. ('vt_cols = z.)

parameter s
a return location for singular values. (default = an implicitly allocated vector.)

parameter u
a return location for left singular vectors. (default = an implicitly allocated matrix.)

parameter vt
a return location for (transposed) right singular vectors. (default = an implicitly allocated matrix.)

parameter work
default = an optimum-length vector.

(Note: jobu and jobvt cannot both be Slap_common.svd_overwrite.)

gesdd

type ('m, 'n) gesdd_liwork

val gesdd_liwork : 
  m:'m Slap_size.t ->
  n:'n Slap_size.t ->
  ('m, 'n) gesdd_liwork Slap_size.t

gesdd_liwork ~m ~n computes the length of workspace iwork for gesdd routine.

parameter m
the number of rows in a matrix.

parameter n
the number of columns in a matrix.

type ('m, 'n, 'jobz) gesdd_min_lwork

val gesdd_min_lwork : 
  jobz:
    ('u_cols * 'vt_rows,
      'm * 'n,
      ('m, 'n) Slap_size.min * ('m, 'n) Slap_size.min,
      'm * 'n,
      Slap_size.z * Slap_size.z)
      Slap_common.svd_job ->
  m:'m Slap_size.t ->
  n:'n Slap_size.t ->
  unit ->
  ('m, 'n, 'u_cols * 'vt_rows) gesdd_min_lwork Slap_size.t

gesdd_min_lwork ~m ~n computes the minimum length of workspace work for gesdd routine.

parameter jobz
the SVD job flag.

parameter m
the number of rows in a matrix.

parameter n
the number of columns in a matrix.

val gesdd_opt_lwork : 
  jobz:
    ('u_cols * 'vt_rows,
      'm * 'n,
      ('m, 'n) Slap_size.min * ('m, 'n) Slap_size.min,
      'm * 'n,
      Slap_size.z * Slap_size.z)
      Slap_common.svd_job ->
  ?s:(('m, 'n) Slap_size.min, Slap_misc.cnt) vec ->
  ?u:('m, 'u_cols, 'u_cd) mat ->
  ?vt:('vt_rows, 'n, 'vt_cd) mat ->
  ?iwork:('liwork, Slap_misc.cnt) Slap_common.int32_vec ->
  ('m, 'n, 'a_cd) mat ->
  (module Slap_size.SIZE)

gesdd_opt_lwork ~jobz ?s ?u ?vt ?iwork a computes the optimum length of workspace work for gesdd routine.

parameter jobz
the SVD job flag.

parameter s
a return location for singular values. (default = an implicitly allocated vector.)

parameter u
a return location for left singular vectors. (default = an implicitly allocated matrix.)

parameter vt
a return location for (transposed) right singular vectors. (default = an implicitly allocated matrix.)

parameter iwork
default = an optimum-length vector.

val gesdd : 
  jobz:
    ('u_cols * 'vt_rows,
      'm * 'n,
      ('m, 'n) Slap_size.min * ('m, 'n) Slap_size.min,
      'm * 'n,
      Slap_size.z * Slap_size.z)
      Slap_common.svd_job ->
  ?s:(('m, 'n) Slap_size.min, Slap_misc.cnt) vec ->
  ?u:('m, 'u_cols, 'u_cd) mat ->
  ?vt:('vt_rows, 'n, 'vt_cd) mat ->
  ?work:('lwork, Slap_misc.cnt) vec ->
  ?iwork:('liwork, Slap_misc.cnt) Slap_common.int32_vec ->
  ('m, 'n, 'a_cd) mat ->
  (('m, 'n) Slap_size.min, 'cnt) vec
  * ('m, 'u_cols, 'u_cd) mat option
  * ('vt_rows, 'n, 'vt_cd) mat option

gesdd ~jobz ?s ?u ?vt ?work ?iwork a computes the singular value decomposition (SVD) of general rectangular matrix a using a divide and conquer method: a = U * D * V^T where

D is an 'm-by-'n matrix (the diagonal elements in D are singular values in descreasing order, and other elements are zeros),
U is an 'm-by-'m orthogonal matrix (the columns in U are left singular vectors), and
V is an 'n-by-'n orthogonal matrix (the columns in V are right singular vectors).

returns
(s, u, vt) with singular values s in descreasing order, left singular vectors u and right singular vectors vt. If u (vt) is not needed, None is returned.

parameter jobz
the SVD job flag:
- If jobz is Slap_common.svd_all, all 'm columns of U and all 'n rows of V^T are returned in u and vt. ('u_cols = 'm and 'vt_rows = 'n.)
- If jobz is Slap_common.svd_top, the first ('m, 'n) min columns of U and the first ('m, 'n) min rows of V^T are returned in u and vt. ('u_cols = ('m, 'n) min and 'vt_rows = ('m, 'n) min.)
- If jobz is Slap_common.svd_overwrite, then
  - if 'm >= 'n, a is overwritten with the first ('m, 'n) min columns of U, and all 'n rows of V^T is returned in vt, thus vt is 'n-by-'n and u is not used;
  - if 'm < 'n, a is overwritten with the first ('m, 'n) min rows of V^T, and all 'm columns of U is returned in u; thereby u is 'm-by-'m and vt is not used.
  (In either case, 'u_cols = 'm and 'vt_rows = 'n, but either u or vt should be omitted.)
- If jobz is Slap_common.svd_no, no singular vectors are computed. ('u_cols = z and 'vt_rows = z.)

parameter s
a return location for singular values. (default = an implicitly allocated vector.)

parameter u
a return location for left singular vectors. (default = an implicitly allocated matrix.)

parameter vt
a return location for (transposed) right singular vectors. (default = an implicitly allocated matrix.)

parameter work
default = an optimum-length vector.

parameter iwork
default = an optimum-length vector.

General eigenvalue problem (simple drivers)

geev

val geev_min_lwork : ?vectors:bool -> 'n Slap_size.t -> (module Slap_size.SIZE)

geev_min_lwork ?vectors n computes the minimum length of workspace for geev routine. n is the number of rows or columns of a matrix.

parameter vectors
whether eigenvectors are computed, or not. (default = true, i.e., they are computed.)

val geev_opt_lwork : 
  ?vl:('n, 'n, 'vl_cd) mat option ->
  ?vr:('n, 'n, 'vr_cd) mat option ->
  ?wr:('n, Slap_misc.cnt) vec ->
  ?wi:('n, Slap_misc.cnt) vec ->
  ('n, 'n, 'a_cd) mat ->
  (module Slap_size.SIZE)

geev_opt_lwork ?vl ?vr ?wr ?vi a computes the optimum length of workspace for geev routine.

parameter vl
a return location for left eigenvectors. See LAPACK GEEV documentation for details about storage of complex eigenvectors. (default = an implicitly allocated matrix.)
- If vl = None, left eigenvectors are not computed;
- If vl = Some vl, left eigenvectors are computed.

parameter vr
a return location for right eigenvectors. See LAPACK GEEV documentation for details about storage of complex eigenvectors. (default = an implicitly allocated matrix.)
- If vr = None, right eigenvectors are not computed;
- If vr = Some vr, right eigenvectors are computed.

parameter wr
a return location for real parts of eigenvalues. (default = an implicitly allocated vector.)

parameter wi
a return location for imaginary parts of eigenvalues. (default = an implicitly allocated vector.)

val geev : 
  ?work:('lwork, Slap_misc.cnt) vec ->
  ?vl:('n, 'n, 'vl_cd) mat option ->
  ?vr:('n, 'n, 'vr_cd) mat option ->
  ?wr:('n, Slap_misc.cnt) vec ->
  ?wi:('n, Slap_misc.cnt) vec ->
  ('n, 'n, 'a_cd) mat ->
  ('n, 'n, 'vl_cd) mat option
  * ('n, Slap_misc.cnt) vec
  * ('n, Slap_misc.cnt) vec
  * ('n, 'n, 'vr_cd) mat option

geev ?work ?vl ?vr ?wr ?wi a computes the eigenvalues and the left and right eigenvectors of 'n-by-'n nonsymmetric matrix a:

Let w(j) is the j-th eigenvalue of a. The j-th right eigenvector vr(j) satisfies a * vr(j) = w(j) * vr(j), and the j-th left eigenvector vl(j) satisfies vl(j)^H * a = vl(j)^H * w(j) where vl(j)^H denotes the conjugate transpose of vl(j). The computed eigenvalues are normalized by Euclidian norm.

returns
(vl, wr, wi, vr) where vl and vr are left and right eigenvectors, and wr and wi are the real and imaginary parts of eigenvalues. If vl (vr) is an empty matrix, None is set.

parameter work
default = an optimum-length vector.

parameter vl
a return location for left eigenvectors. See LAPACK GEEV documentation for details about storage of complex eigenvectors. (default = an implicitly allocated matrix.)
- If vl = None, left eigenvectors are not computed;
- If vl = Some vl, left eigenvectors are computed.

parameter vr
a return location for right eigenvectors. See LAPACK GEEV documentation for details about storage of complex eigenvectors. (default = an implicitly allocated matrix.)
- If vr = None, right eigenvectors are not computed;
- If vr = Some vr, right eigenvectors are computed.

parameter wr
a return location for real parts of eigenvalues. (default = an implicitly allocated vector.)

parameter wi
a return location for imaginary parts of eigenvalues. (default = an implicitly allocated vector.)

raises Failure
if the function fails to converge.

Symmetric-matrix eigenvalue and singular value problems (simple drivers)

syev

type 'n syev_min_lwork

val syev_min_lwork : 'n Slap_size.t -> 'n syev_min_lwork Slap_size.t

syev_min_lwork n computes the minimum length of workspace for syev routine. n is the number of rows or columns of a matrix.

val syev_opt_lwork : 
  ?vectors:bool ->
  ?up:bool ->
  ('n, 'n, 'cd) mat ->
  (module Slap_size.SIZE)

syev_opt_lwork ?vectors ?up a computes the optimum length of workspace for syev routine.

parameter vectors
whether eigenvectors are computed, or not. (default = false.)
- If vectors = true, eigenvectors are computed and returned in a.
- If vectors = false, eigenvectors are not computed.

parameter up
default = true
- If up = true, then the upper triangular part of a is used;
- If up = false, then the lower triangular part of a is used.

val syev : 
  ?vectors:bool ->
  ?up:bool ->
  ?work:('lwork, Slap_misc.cnt) vec ->
  ?w:('n, Slap_misc.cnt) vec ->
  ('n, 'n, 'cd) mat ->
  ('n, 'cnt) vec

syev ?vectors ?up ?work ?w a computes the eigenvalues and the eigenvectors of 'n-by-'n symmetric matrix a.

returns
the vector w of eigenvalues in ascending order.

parameter vectors
whether eigenvectors are computed, or not. (default = false.)
- If vectors = true, eigenvectors are computed and returned in a.
- If vectors = false, eigenvectors are not computed.

parameter up
default = true
- If up = true, then the upper triangular part of a is used;
- If up = false, then the lower triangular part of a is used.

parameter work
default = an optimum-length vector.

parameter w
a return location for eigenvalues. (default = an implicitly allocated vector.)

raises Failure
if the function fails to converge.

syevd

val syevd_min_lwork : vectors:bool -> 'n Slap_size.t -> (module Slap_size.SIZE)

syevd_min_lwork ?vectors n computes the minimum length of workspace work for syevd routine. n is the number of rows or columns of a matrix.

parameter vectors
whether eigenvectors are computed, or not. (default = false, i.e., they are not computed.)

val syevd_min_liwork : 
  vectors:bool ->
  'n Slap_size.t ->
  (module Slap_size.SIZE)

syevd_min_liwork ?vectors n computes the minimum length of workspace iwork for syevd routine. n is the number of rows or columns of a matrix.

parameter vectors
whether eigenvectors are computed, or not. (default = false, i.e., they are not computed.)

val syevd_opt_lwork : 
  ?vectors:bool ->
  ?up:bool ->
  ('n, 'n, 'cd) mat ->
  (module Slap_size.SIZE)

syevd_opt_lwork ?vectors ?up a computes the optimum length of workspace work for syevd routine.

parameter vectors
whether eigenvectors are computed, or not. (default = false, i.e., they are not computed.)

parameter up
default = true
- If up = true, then the upper triangular part of a is used;
- If up = false, then the lower triangular part of a is used.

val syevd_opt_liwork : 
  ?vectors:bool ->
  ?up:bool ->
  ('n, 'n, 'cd) mat ->
  (module Slap_size.SIZE)

syevd_opt_liwork ?vectors ?up a computes the optimum length of workspace iwork for syevd routine.

parameter vectors
whether eigenvectors are computed, or not. (default = false, i.e., they are not computed.)

parameter up
default = true
- If up = true, then the upper triangular part of a is used;
- If up = false, then the lower triangular part of a is used.

val syevd : 
  ?vectors:bool ->
  ?up:bool ->
  ?work:('lwork, Slap_misc.cnt) vec ->
  ?iwork:('liwork, Slap_misc.cnt) Slap_common.int32_vec ->
  ?w:('n, Slap_misc.cnt) vec ->
  ('n, 'n, 'a_cd) mat ->
  ('n, 'w_cd) vec

syev ?vectors ?up ?w a computes the eigenvalues and the eigenvectors of 'n-by-'n symmetric matrix a using divide and conquer method.

returns
the vector w of eigenvalues in ascending order.

parameter vectors
whether eigenvectors are computed, or not. (default = false.)
- If vectors = true, eigenvectors are computed and returned in a.
- If vectors = false, eigenvectors are not computed.

parameter up
default = true
- If up = true, then the upper triangular part of a is used;
- If up = false, then the lower triangular part of a is used.

parameter work
default = an optimum-length vector.

parameter iwork
default = an optimum-length vector.

parameter w
a return location for eigenvalues. (default = an implicitly allocated vector.)

raises Failure
if the function fails to converge.

sbev

type 'n sbev_min_lwork

val sbev_min_lwork : 'n Slap_size.t -> 'n sbev_min_lwork Slap_size.t

sbev_min_lwork n computes the minimum length of workspace work for sbev routine. n is the number of rows or columns of a matrix.

val sbev : 
  kd:'kd Slap_size.t ->
  ?z:('n, 'n, 'z_cd) mat ->
  ?up:bool ->
  ?work:('lwork, Slap_misc.cnt) vec ->
  ?w:('n, Slap_misc.cnt) vec ->
  (('n, 'kd) Slap_size.syband, 'n, 'a_cd) mat ->
  ('n, 'cnt) vec

sbev ~kd ?z ?up ?work ?w ab computes all eigenvalues and, optionally, eigenvectors of real symmetric band matrix ab store in band storage format.

returns
vector w, which is overwritten.

parameter kd
the number of subdiagonals or superdiagonals.

parameter z
The eigenvectors are returned in z if it is given. They are not computed if omitted.

parameter up
default = true
- If up = true, then the upper triangular part of ab is used;
- If up = false, then the lower triangular part of ab is used.

parameter work
workspace for sbev

parameter w
w is replaced by eigenvalues if it is given, or newly allocated if omitted.

raises Failure
if the function fails to converge.

since 0.2.0

Symmetric-matrix eigenvalue and singular value problems (expert & RRR drivers)

syevr

type 'n syevr_min_lwork

val syevr_min_lwork : 'n Slap_size.t -> 'n syevr_min_lwork Slap_size.t

sbevr_min_lwork n computes the minimum length of workspace work for syevr routine. n is the number of rows or columns of a matrix.

type 'n syevr_min_liwork

val syevr_min_liwork : 'n Slap_size.t -> 'n syevr_min_liwork Slap_size.t

sbevr_min_liwork n computes the minimum length of workspace iwork for syevr routine. n is the number of rows or columns of a matrix.

val syevr_opt_lwork : 
  ?vectors:bool ->
  ?range:[ `A | `I of int * int | `V of float * float ] ->
  ?up:bool ->
  ?abstol:float ->
  ('n, 'n, 'a_cd) mat ->
  (module Slap_size.SIZE)

sbevr_opt_lwork ?vectors ?range ?up ?abstol a computes the optimum length of workspace work for syevr routine.

parameter vectors
whether eigenvectors are computed, or not. (default = false, i.e., they are not computed.)

parameter range
default = `A.

parameter up
default = true.

parameter abstol
The absolute error tolerance to which each eigenvalue or eigenvector is required. (default = lamch `S.)

val syevr_opt_liwork : 
  ?vectors:bool ->
  ?range:[ `A | `I of int * int | `V of float * float ] ->
  ?up:bool ->
  ?abstol:float ->
  ('n, 'n, 'a_cd) mat ->
  (module Slap_size.SIZE)

sbevr_opt_liwork ?vectors ?range ?up ?abstol a computes the optimum length of workspace iwork for sbevr routine.

parameter vectors
whether eigenvectors are computed, or not. (default = false, i.e., they are not computed.)

parameter range
default = `A.

parameter up
default = true.

parameter abstol
The absolute error tolerance to which each eigenvalue or eigenvector is required. (default = lamch `S.)

module type SYEVR_RESULT = sig ... end

The signature of returned modules of syevr_dyn.

val syevr_dyn : 
  ?vectors:bool ->
  ?range:[ `A | `I of int * int | `V of float * float ] ->
  ?up:bool ->
  ?abstol:float ->
  ?work:('lwork, Slap_misc.cnt) vec ->
  ?iwork:('liwork, Slap_misc.cnt) Slap_common.int32_vec ->
  ?w:('n, Slap_misc.cnt) vec ->
  ?z:('n, 'k, 'z_cd) mat ->
  ?isuppz:(('k, 'k) Slap_size.add, Slap_misc.cnt) Slap_common.int32_vec ->
  ('n, 'n, 'a_cd) mat ->
  (module SYEVR_RESULT
  with type n = 'n)

syevr_dyn ?vectors ?range ?up ?abstol ?work ?iwork ?w ?z ?isuppz a computes selected eigenvalues w and, optionally, eigenvectors z of a real symmetric matrix a using the Relatively Robust Representations.

Usage:

let f (type nn) ... =
  ...
  let (a : (nn, nn, _) mat) = ... in
  let module X = (val syevr_dyn ?vectors ?range ?up ?abstol
                      ?work ?iwork ?w ?z ?isuppz a
                   : SYEVR_RESULT with type n = nn) in
  let (m, w, z, isuppz) = X.value in
  ...

where type nn is the size of symmetric matrix a. The returned module X contains tuple X.value = (m, w, z, isuppz) and type X.m for representation of the number of computed eigenvalues:

Size m : X.m Slap_size.t is the number of eigenvalues.
Vector w : (X.n, _) vec contains the m eigenvalues in ascending order.
Matrix z : (X.n, X.m, _) mat contains the m eigenvectors of dimension n in the same order.
2*m-dimensional vector isuppz : ((m, m) Slap.Slap_size.add, _) Slap_common.int32_vec indicates the nonzero elements in z.

returns
the above-mentioned module X.

parameter vectors
whether eigenvectors are computed, or not. (default = false.)
- If vectors = true, eigenvectors are computed and returned in a.
- If vectors = false, eigenvectors are not computed.

parameter range
default = `A
- If range = `A, all eigenvalues are computed.
- If range = `I (il, iu), eigenvalues with indices il to iu are computed.
- If range = `V (vl, vu), the routine computes eigenvalues w(i) in the half-open interval: vl < w(i) <= vu where vl <= vu.

parameter up
default = true
- If up = true, then the upper triangular part of a is used;
- If up = false, then the lower triangular part of a is used.

parameter abstol
The absolute error tolerance to which each eigenvalue or eigenvector is required. (default = lamch `S.)

parameter work
default = an optimum-length vector.

parameter iwork
default = an optimum-length vector.

parameter w
a return location for eigenvalues. (default = an implicitly allocated vector of the minimum required dimension.)

parameter z
a return location for eigenvectors. (default = an implicitly allocated matrix of the minimum required dimension.)

parameter isuppz
a return location for a vector to indicate the nonzero elements in z. (default = an implicitly allocated matrix of the minimum required dimension.)

raises Invalid_argument
if not X.m <= 'k

sygv

val sygv_opt_lwork : 
  ?vectors:bool ->
  ?up:bool ->
  ?itype:[ `AB | `A_B | `BA ] ->
  ('n, 'n, 'a_cd) mat ->
  ('n, 'n, 'b_cd) mat ->
  (module Slap_size.SIZE)

sygv_opt_lwork ?vectors ?up ?itype a b computes the optimum length of workspace work for sbevr routine.

parameter vectors
whether eigenvectors are computed, or not. (default = false, i.e., they are not computed.)

parameter up
default = true.

parameter itype
the behavior of this routine.

val sygv : 
  ?vectors:bool ->
  ?up:bool ->
  ?work:('lwork, Slap_misc.cnt) vec ->
  ?w:('n, Slap_misc.cnt) vec ->
  ?itype:[ `AB | `A_B | `BA ] ->
  ('n, 'n, 'a_cd) mat ->
  ('n, 'n, 'b_cd) mat ->
  ('n, 'cnt) vec

sygv ?vectors ?up ?work ?w ?itype a b solves a real generalized symmetric definite eigenproblem:

a * x = lambda * b * x if itype is `A_B;
a * b * x = lambda * x if itype is `AB;
b * a * x = lambda * x if itype is `BA

where a is a 'n-by-'n symmetric matrix, and b is a 'n-by-'n symmetric positive definite matrix.

raises Failure
if the function fails to converge.

returns
vector w of eigenvalues in ascending order.

parameter vectors
whether eigenvectors are computed, or not. (default = false.)
- If vectors = true, eigenvectors are computed and returned in a.
- If vectors = false, eigenvectors are not computed.

parameter up
default = true.
- If up = true, then the upper triangular part of a is used;
- If up = false, then the lower triangular part of a is used.

parameter work
default = an optimum-length workspace.

parameter w
a return location for eigenvalues. (default = an implicitly allocated vector.)

parameter itype
the behavior of this routine.

raises Failure
if the function fails to converge.

sbgv

val sbgv : 
  ka:'ka Slap_size.t ->
  kb:'kb Slap_size.t ->
  ?z:('n, 'n, 'z_cd) mat ->
  ?up:bool ->
  ?work:('lwork, Slap_misc.cnt) vec ->
  ?w:('n, Slap_misc.cnt) vec ->
  (('n, 'ka) Slap_size.syband, 'n, 'ab_cd) mat ->
  (('n, 'kb) Slap_size.syband, 'n, 'bb_cd) mat ->
  ('n, 'cnt) vec

sbgv ~ka ~kb ?z ?up ?work ?w ab bb solves a general eigenvalue problem ab * z = (lambda) * bb * z where ab is a 'n-by-'n symmetric band matrix with ka subdiagonals, and bb is a 'n-by-'n symmetric positive-definite band matrix with kb subdiagonals. Both ab and bb are stored in band storage format.

returns
vector w, which is overwritten.

parameter ka
the number of subdiagonals or superdiagonals of ab.

parameter kb
the number of subdiagonals or superdiagonals of bb.

parameter z
The eigenvectors are returned in z if it is given. They are not computed if omitted.

parameter up
default = true
- If up = true, then the upper triangular part of ab is used;
- If up = false, then the lower triangular part of ab is used.

parameter work
workspace for sbgv

parameter w
w is replaced by eigenvalues if it is given, or newly allocated if omitted.

raises Failure
if the function fails to converge.

since 0.2.0

On This Page

BLAS interface
1. Level 1
2. Level 2
3. Level 3
LAPACK interface
BLAS interface
1. Level 1
2. Level 2
LAPACK interface

package slap

Install

dune-project Dependency

Authors

Maintainers

Sources

doc/slap/Slap_D/index.html

Module Slap_D

BLAS interface

Level 1

Level 2

Level 3

LAPACK interface

Auxiliary routines

Linear equations (computational routines)

Linear equations (simple drivers)

Least squares (simple drivers)

BLAS interface

Level 1

Level 2

LAPACK interface

Auxiliary routines

lansy

lamch

Linear equations (computational routines)

orgqr

ormqr

gecon

sycon

pocon

Least squares (expert drivers)

gelsy

gelsd

gelss

General SVD routines

gesvd

gesdd

General eigenvalue problem (simple drivers)

geev

Symmetric-matrix eigenvalue and singular value problems (simple drivers)

syev

syevd

sbev

Symmetric-matrix eigenvalue and singular value problems (expert & RRR drivers)

syevr

sygv

sbgv

dune-project
Dependency

Module `Slap_D`