type prec = Bigarray.complex64_elttype num_type = Complex.ttype (+'indim, +'outdim, +'tag) trans3 =
('indim, 'outdim, 'tag) Slap_common.trans3A type of transpose parameters (Slap_common.normal, Slap_common.trans or Slap_common.conjtr).
type (+'n, +'cnt_or_dsc) vec = ('n, num_type, prec, 'cnt_or_dsc) Slap_vec.tVectors.
type (+'m, +'n, +'cnt_or_dsc) mat =
('m, 'n, num_type, prec, 'cnt_or_dsc) Slap_mat.tMatrices.
type rprec = Bigarray.float64_elttype (+'n, +'cnt_or_dsc) rvec = ('n, float, rprec, 'cnt_or_dsc) Slap_vec.tval prec : (num_type, prec) Bigarray.kindval rprec : (float, rprec) Bigarray.kindmodule Vec : sig ... endmodule Mat : sig ... endval pp_num : Format.formatter -> num_type -> unitA pretty-printer for elements in vectors and matrices.
val pp_vec : Format.formatter -> ('n, 'cnt_or_dsc) vec -> unitA pretty-printer for column vectors.
val pp_mat : Format.formatter -> ('m, 'n, 'cnt_or_dsc) mat -> unitA pretty-printer for matrices.
scal c x multiplies all elements in x by scalar value c, and destructively assigns the result to x.
val nrm2 : ('n, 'cd) vec -> floatnrm2 x retruns the L2 norm of vector x: ||x||.
axpy ?alpha x y executes y := alpha * x + y with scalar value alpha, and vectors x and y.
val iamax : ('n, 'cd) vec -> intiamax x returns the index of the maximum value of all elements in x.
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) vecgemv ?beta ?y ~trans ?alpha a x executes y := alpha * OP(a) * x + beta * y.
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) vecgbmv ~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.
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) vecsymv ?beta ?y ?up ?alpha a x executes y := alpha * a * x + beta * y.
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 ->
unittrmv ~trans ?diag ?up a x executes x := OP(a) * x.
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 ->
unittrmv ~trans ?diag ?up a b solves linear system OP(a) * x = b and destructively assigns x to b.
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 ->
unittpmv ~trans ?diag ?up a x executes x := OP(a) * x where a is a packed triangular matrix.
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 ->
unittpsv ~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.
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) matgemm ?beta ?c ~transa ?alpha a ~transb b executes c := alpha * OP(a) * OP(b) + beta * c.
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) matsymm ~side ?up ?beta ?c ?alpha a b executes
c := alpha * a * b + beta * c (if side = Slap_common.left) orc := alpha * b * a + beta * c (if side = Slap_common.right)where a is a symmterix matrix, and b and c are general matrices.
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 ->
unittrmm ~side ?up ~transa ?diag ?alpha ~a b executes
b := alpha * OP(a) * b (if side = Slap_common.left) orb := alpha * b * OP(a) (if side = Slap_common.right)where a is a triangular matrix, and b is a general matrix.
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 ->
unittrsm ~side ?up ~transa ?diag ?alpha ~a b solves a system of linear equations
OP(a) * x = alpha * b (if side = Slap_common.left) orx * 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.
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) matsyrk ?up ?beta ?c ~trans ?alpha a executes
c := alpha * a * a^T + beta * c (if trans = Slap_common.normal) orc := alpha * a^T * a + beta * c (if trans = Slap_common.trans)where a is a general matrix and c is a symmetric matrix.
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) matsyr2k ?up ?beta ?c ~trans ?alpha a b computes
c := alpha * a * b^T + alpha * b * a^T + beta * c (if trans = Slap_common.normal) orc := 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.
val lacpy :
?uplo:[< `A | `L | `U ] Slap_common.uplo ->
?b:('m, 'n, 'b_cd) mat ->
('m, 'n, 'a_cd) mat ->
('m, 'n, 'b_cd) matlacpy ?uplo ?b a copies the matrix a into the matrix b.
val lassq : ?scale:float -> ?sumsq:float -> ('n, 'cd) vec -> float * floatlassq ?scale ?sumsq x
type larnv_liseed = Slap_size.fourval larnv :
?idist:[ `Normal | `Uniform0 | `Uniform1 ] ->
?iseed:(larnv_liseed, Slap_misc.cnt) Slap_common.int32_vec ->
x:('n, Slap_misc.cnt) vec ->
unit ->
('n, 'cnt) veclarnv ?idist ?iseed ~x () generates a random vector with the random distribution specified by idist and random seed iseed.
val lange_min_lwork :
'm Slap_size.t ->
'a Slap_common.norm4 ->
('m, 'a) lange_min_lwork Slap_size.tlange_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 ->
floatlange ?norm ?work a
val lauum : ?up:[< `U | `L ] Slap_common.uplo -> ('n, 'n, 'cd) mat -> unitlauum ?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.
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_vecgetrf ?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.
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 ->
unitgetrs ?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.
val getri_min_lwork : 'n Slap_size.t -> 'n getri_min_lwork Slap_size.tgetri_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 ->
unitgetri ?ipiv ?work a computes the inverse of general matrix a by LU-factorization. The inverse matrix is returned in a.
val sytrf_min_lwork : unit -> sytrf_min_lwork Slap_size.tsytrf_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.
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_vecsytrf ?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 = falsewhere 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.
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 ->
unitsytrs ?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 = falsewhere 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.
val sytri_min_lwork : 'n Slap_size.t -> 'n sytri_min_lwork Slap_size.tsytri_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 ->
unitsytri ?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 = falsewhere 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.
val potrf :
?up:[< `U | `L ] Slap_common.uplo ->
?jitter:num_type ->
('n, 'n, 'cd) mat ->
unitpotrf ?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 = falsewhere 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.
val potrs :
?up:[< `U | `L ] Slap_common.uplo ->
('n, 'n, 'a_cd) mat ->
?factorize:bool ->
?jitter:num_type ->
('n, 'nrhs, 'b_cd) mat ->
unitpotrf ?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.lowerwhere U and L are upper and lower triangular matrices, respectively.
val potri :
?up:[< `U | `L ] Slap_common.uplo ->
?factorize:bool ->
?jitter:num_type ->
('n, 'n, 'cd) mat ->
unitpotrf ?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.lowerwhere U and L are upper and lower triangular matrices, respectively.
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 ->
unittrtrs ?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.
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 ->
unittbtrs ~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.
val trtri :
?up:[< `U | `L ] Slap_common.uplo ->
?diag:Slap_common.diag ->
('n, 'n, 'cd) mat ->
unittrtri ?up ?diag a computes the inverse of triangular matrix a. The inverse matrix is returned in a.
val geqrf_min_lwork : n:'n Slap_size.t -> 'n geqrf_min_lwork Slap_size.tgeqrf_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) vecgeqrf ?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.
val gesv :
?ipiv:('n, Slap_misc.cnt) Slap_common.int32_vec ->
('n, 'n, 'a_cd) mat ->
('n, 'nrhs, 'b_cd) mat ->
unitgesv ?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.
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 ->
unitgbsv ?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.
val posv :
?up:[< `U | `L ] Slap_common.uplo ->
('n, 'n, 'a_cd) mat ->
('n, 'nrhs, 'b_cd) mat ->
unitposv ?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:
up = Slap_common.upper, then a = U^T * U (real) or a = U^H * U (complex)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.
val ppsv :
?up:[< `U | `L ] Slap_common.uplo ->
('n Slap_size.packed, Slap_misc.cnt) vec ->
('n, 'nrhs, 'b_cd) mat ->
unitppsv ?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.
up = Slap_common.upper, then a = U^T * U (real) or a = U^H * U (complex)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.
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 ->
unitpbsv ?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:
up = Slap_common.upper, then a = U^T * U (real) or a = U^H * U (complex)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.
val ptsv :
('n, Slap_misc.cnt) vec ->
('n Slap_size.p, Slap_misc.cnt) vec ->
('n, 'nrhs, 'b_cd) mat ->
unitptsv 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.
val sysv_min_lwork : unit -> sysv_min_lwork Slap_size.tsysv_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 ->
unitsysv ?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:
up = Slap_common.upper, then a = U * D * U^Tup = Slap_common.lower, then a = L * D * L^T where U and L are the upper and lower triangular matrices, respectively.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 ->
unitspsv ?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:
up = Slap_common.upper, then a = U * D * U^Tup = Slap_common.lower, then a = L * D * L^T where U and L are the upper and lower triangular matrices, respectively.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.tgels_min_lwork ~n computes the minimum length of workspace for gels routine.
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 ->
unitgels ?work ~trans a b solves an overdetermined or underdetermined system of linear equations using QR or LU factorization.
trans = Slap_common.normal and 'm >= 'n: find the least square solution to an overdetermined system by minimizing ||b - A * x||^2.trans = Slap_common.normal and 'm < 'n: find the minimum norm solution to an underdetermined system a * x = b.trans = Slap_common.trans, and 'm >= 'n: find the minimum norm solution to an underdetermined system a^H * x = b.trans = Slap_common.trans and 'm < 'n: find the least square solution to an overdetermined system by minimizing ||b - A^H * x||^2.