Module Lacaml.S

Single precision real BLAS and LAPACK functions.

This module Lacaml.S contains linear algebra routines for real numbers (precision: float32). It is recommended to use this module by writing

    open Lacaml.S

at the top of your file.

type prec = Bigarray.float32_elt
type num_type = float
type vec = (float, Bigarray.float32_elt, Bigarray.fortran_layout) Bigarray.Array1.t

Vectors (precision: float32).

type rvec = vec
type mat = (float, Bigarray.float32_elt, Bigarray.fortran_layout) Bigarray.Array2.t

Matrices (precision: float32).

type trans3 = [
| `N
| `T
]

Transpose parameter (normal or transposed). For complex matrices, conjugate transpose is also offered, hence the name.

val prec : (float, Bigarray.float32_elt) Bigarray.kind

Precision for this submodule S. Allows to write precision independent code.

module Vec : sig ... end
module Mat : sig ... end
val pp_num : Format.formatter ‑> float ‑> unit

pp_num ppf el is equivalent to fprintf ppf "%G" el.

val pp_vec : (float, 'aIo.pp_vec

Pretty-printer for column vectors.

val pp_mat : (float, 'aIo.pp_mat

Pretty-printer for matrices.

BLAS-1 interface
val dot : ?⁠n:int ‑> ?⁠ofsx:int ‑> ?⁠incx:int ‑> vec ‑> ?⁠ofsy:int ‑> ?⁠incy:int ‑> vec ‑> float

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

val asum : ?⁠n:int ‑> ?⁠ofsx:int ‑> ?⁠incx:int ‑> vec ‑> float

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

BLAS-2 interface
val sbmv : ?⁠n:int ‑> ?⁠k:int ‑> ?⁠ofsy:int ‑> ?⁠incy:int ‑> ?⁠y:vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠up:bool ‑> ?⁠alpha:float ‑> ?⁠beta:float ‑> ?⁠ofsx:int ‑> ?⁠incx:int ‑> vec ‑> vec

sbmv ?n ?k ?ofsy ?incy ?y ?ar ?ac a ?up ?alpha ?beta ?ofsx ?incx x see BLAS documentation!

val ger : ?⁠m:int ‑> ?⁠n:int ‑> ?⁠alpha:float ‑> ?⁠ofsx:int ‑> ?⁠incx:int ‑> vec ‑> ?⁠ofsy:int ‑> ?⁠incy:int ‑> vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> unit

ger ?m ?n ?alpha ?ofsx ?incx x ?ofsy ?incy y n ?ar ?ac a see BLAS documentation!

val syr : ?⁠n:int ‑> ?⁠alpha:float ‑> ?⁠up:bool ‑> ?⁠ofsx:int ‑> ?⁠incx:int ‑> vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> unit

syr ?n ?alpha ?up ?ofsx ?incx x ?ar ?ac a see BLAS documentation!

LAPACK interface
Auxiliary routines
val lansy_min_lwork : int ‑> Common.norm4 ‑> int

lansy_min_lwork m norm

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

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

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

lamch cmach see LAPACK documentation!

Linear equations (computational routines)
val orgqr_min_lwork : n:int ‑> int

orgqr_min_lwork ~n

val orgqr_opt_lwork : ?⁠m:int ‑> ?⁠n:int ‑> ?⁠k:int ‑> tau:vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> int

orgqr_opt_lwork ?m ?n ?k ~tau ?ar ?ac a

val orgqr : ?⁠m:int ‑> ?⁠n:int ‑> ?⁠k:int ‑> ?⁠work:vec ‑> tau:vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> unit

orgqr ?m ?n ?k ?work ~tau ?ar ?ac a see LAPACK documentation!

val ormqr_opt_lwork : ?⁠side:Common.side ‑> ?⁠trans:Common.trans2 ‑> ?⁠m:int ‑> ?⁠n:int ‑> ?⁠k:int ‑> tau:vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠cr:int ‑> ?⁠cc:int ‑> mat ‑> int

ormqr_opt_lwork ?side ?trans ?m ?n ?k ~tau ?ar ?ac a ?cr ?cc c

val ormqr : ?⁠side:Common.side ‑> ?⁠trans:Common.trans2 ‑> ?⁠m:int ‑> ?⁠n:int ‑> ?⁠k:int ‑> ?⁠work:vec ‑> tau:vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠cr:int ‑> ?⁠cc:int ‑> mat ‑> unit

ormqr ?side ?trans ?m ?n ?k ?work ~tau ?ar ?ac a ?cr ?cc c see LAPACK documentation!

val gecon_min_lwork : int ‑> int

gecon_min_lwork n

val gecon_min_liwork : int ‑> int

gecon_min_liwork n

val gecon : ?⁠n:int ‑> ?⁠norm:Common.norm2 ‑> ?⁠anorm:float ‑> ?⁠work:vec ‑> ?⁠iwork:Common.int32_vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> float

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

val sycon_min_lwork : int ‑> int

sycon_min_lwork n

val sycon_min_liwork : int ‑> int

sycon_min_liwork n

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

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

val pocon_min_lwork : int ‑> int

pocon_min_lwork n

val pocon_min_liwork : int ‑> int

pocon_min_liwork n

val pocon : ?⁠n:int ‑> ?⁠up:bool ‑> ?⁠anorm:float ‑> ?⁠work:vec ‑> ?⁠iwork:Common.int32_vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> float

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

Least squares (expert drivers)
val gelsy_min_lwork : m:int ‑> n:int ‑> nrhs:int ‑> int

gelsy_min_lwork ~m ~n ~nrhs

val gelsy_opt_lwork : ?⁠m:int ‑> ?⁠n:int ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠nrhs:int ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> int

gelsy_opt_lwork ?m ?n ?ar ?ac a ?nrhs ?br ?bc b

val gelsy : ?⁠m:int ‑> ?⁠n:int ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠rcond:float ‑> ?⁠jpvt:Common.int32_vec ‑> ?⁠work:vec ‑> ?⁠nrhs:int ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> int

gelsy ?m ?n ?ar ?ac a ?rcond ?jpvt ?ofswork ?work ?nrhs b see LAPACK documentation!

val gelsd_min_lwork : m:int ‑> n:int ‑> nrhs:int ‑> int

gelsd_min_lwork ~m ~n ~nrhs

val gelsd_opt_lwork : ?⁠m:int ‑> ?⁠n:int ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠nrhs:int ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> int

gelsd_opt_lwork ?m ?n ?ar ?ac a ?nrhs b

val gelsd_min_iwork : int ‑> int ‑> int

gelsd_min_iwork m n

val gelsd : ?⁠m:int ‑> ?⁠n:int ‑> ?⁠rcond:float ‑> ?⁠ofss:int ‑> ?⁠s:vec ‑> ?⁠work:vec ‑> ?⁠iwork:vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠nrhs:int ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> int

gelsd ?m ?n ?rcond ?ofss ?s ?ofswork ?work ?ar ?ac a ?nrhs b see LAPACK documentation!

val gelss_min_lwork : m:int ‑> n:int ‑> nrhs:int ‑> int

gelss_min_lwork ~m ~n ~nrhs

val gelss_opt_lwork : ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠m:int ‑> ?⁠n:int ‑> ?⁠nrhs:int ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> int

gelss_opt_lwork ?ar ?ac a ?m ?n ?nrhs ?br ?bc b

val gelss : ?⁠m:int ‑> ?⁠n:int ‑> ?⁠rcond:float ‑> ?⁠ofss:int ‑> ?⁠s:vec ‑> ?⁠work:vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠nrhs:int ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> int

gelss ?m ?n ?rcond ?ofss ?s ?ofswork ?work ?ar ?ac a ?nrhs ?br ?bc b see LAPACK documentation!

General Schur factorization
val gees : ?⁠n:int ‑> ?⁠jobvs:Common.schur_vectors ‑> ?⁠sort:Common.eigen_value_sort ‑> ?⁠wr:vec ‑> ?⁠wi:vec ‑> ?⁠vsr:int ‑> ?⁠vsc:int ‑> ?⁠vs:mat ‑> ?⁠work:vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> int * vec * vec * mat

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

General SVD routines
val gesvd_min_lwork : m:int ‑> n:int ‑> int

gesvd_min_lwork ~m ~n

val gesvd_opt_lwork : ?⁠m:int ‑> ?⁠n:int ‑> ?⁠jobu:Common.svd_job ‑> ?⁠jobvt:Common.svd_job ‑> ?⁠s:vec ‑> ?⁠ur:int ‑> ?⁠uc:int ‑> ?⁠u:mat ‑> ?⁠vtr:int ‑> ?⁠vtc:int ‑> ?⁠vt:mat ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> int
val gesvd : ?⁠m:int ‑> ?⁠n:int ‑> ?⁠jobu:Common.svd_job ‑> ?⁠jobvt:Common.svd_job ‑> ?⁠s:vec ‑> ?⁠ur:int ‑> ?⁠uc:int ‑> ?⁠u:mat ‑> ?⁠vtr:int ‑> ?⁠vtc:int ‑> ?⁠vt:mat ‑> ?⁠work:vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> vec * mat * mat
val gesdd_liwork : m:int ‑> n:int ‑> int
val gesdd_min_lwork : ?⁠jobz:Common.svd_job ‑> m:int ‑> n:int ‑> unit ‑> int

gesdd_min_lwork ?jobz ~m ~n

val gesdd_opt_lwork : ?⁠m:int ‑> ?⁠n:int ‑> ?⁠jobz:Common.svd_job ‑> ?⁠s:vec ‑> ?⁠ur:int ‑> ?⁠uc:int ‑> ?⁠u:mat ‑> ?⁠vtr:int ‑> ?⁠vtc:int ‑> ?⁠vt:mat ‑> ?⁠iwork:Common.int32_vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> int
val gesdd : ?⁠m:int ‑> ?⁠n:int ‑> ?⁠jobz:Common.svd_job ‑> ?⁠s:vec ‑> ?⁠ur:int ‑> ?⁠uc:int ‑> ?⁠u:mat ‑> ?⁠vtr:int ‑> ?⁠vtc:int ‑> ?⁠vt:mat ‑> ?⁠work:vec ‑> ?⁠iwork:Common.int32_vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> vec * mat * mat
General eigenvalue problem (simple drivers)
val geev_min_lwork : ?⁠vectors:bool ‑> int ‑> int

geev_min_lwork vectors n

val geev_opt_lwork : ?⁠n:int ‑> ?⁠vlr:int ‑> ?⁠vlc:int ‑> ?⁠vl:mat option ‑> ?⁠vrr:int ‑> ?⁠vrc:int ‑> ?⁠vr:mat option ‑> ?⁠ofswr:int ‑> ?⁠wr:vec ‑> ?⁠ofswi:int ‑> ?⁠wi:vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> int

geev_opt_lwork ?n ?vlr ?vlc ?vl ?vrr ?vrc ?vr ?ofswr wr ?ofswi wi ?ar ?ac a See geev-function for details about arguments.

val geev : ?⁠n:int ‑> ?⁠work:vec ‑> ?⁠vlr:int ‑> ?⁠vlc:int ‑> ?⁠vl:mat option ‑> ?⁠vrr:int ‑> ?⁠vrc:int ‑> ?⁠vr:mat option ‑> ?⁠ofswr:int ‑> ?⁠wr:vec ‑> ?⁠ofswi:int ‑> ?⁠wi:vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> mat * vec * vec * mat

geev ?work ?n ?vlr ?vlc ?vl ?vrr ?vrc ?vr ?ofswr ?wr ?ofswi ?wi ?ar ?ac a

Symmetric-matrix eigenvalue and singular value problems (simple drivers)
val syev_min_lwork : int ‑> int

syev_min_lwork n

val syev_opt_lwork : ?⁠n:int ‑> ?⁠vectors:bool ‑> ?⁠up:bool ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> int

syev_opt_lwork ?n ?vectors ?up ?ar ?ac a

val syev : ?⁠n:int ‑> ?⁠vectors:bool ‑> ?⁠up:bool ‑> ?⁠work:vec ‑> ?⁠ofsw:int ‑> ?⁠w:vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> vec

syev ?n ?vectors ?up ?ofswork ?work ?ofsw ?w ?ar ?ac a computes all eigenvalues and, optionally, eigenvectors of the real symmetric matrix a.

val syevd_min_lwork : vectors:bool ‑> int ‑> int

syevd_min_lwork vectors n

val syevd_min_liwork : vectors:bool ‑> int ‑> int

syevd_min_liwork vectors n

val syevd_opt_lwork : ?⁠n:int ‑> ?⁠vectors:bool ‑> ?⁠up:bool ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> int

syevd_opt_lwork ?n ?vectors ?up ?ar ?ac a

val syevd_opt_liwork : ?⁠n:int ‑> ?⁠vectors:bool ‑> ?⁠up:bool ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> int

syevd_opt_liwork ?n ?vectors ?up ?ar ?ac a

val syevd_opt_l_li_work : ?⁠n:int ‑> ?⁠vectors:bool ‑> ?⁠up:bool ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> int * int

syevd_opt_l_li_iwork ?n ?vectors ?up ?ar ?ac a

val syevd : ?⁠n:int ‑> ?⁠vectors:bool ‑> ?⁠up:bool ‑> ?⁠work:vec ‑> ?⁠iwork:Common.int32_vec ‑> ?⁠ofsw:int ‑> ?⁠w:vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> vec

syevd ?n ?vectors ?up ?ofswork ?work ?iwork ?ofsw ?w ?ar ?ac a computes all eigenvalues and, optionally, eigenvectors of the real symmetric matrix a. If eigenvectors are desired, it uses a divide and conquer algorithm.

val sbev_min_lwork : int ‑> int

sbev_min_lwork n

val sbev : ?⁠n:int ‑> ?⁠kd:int ‑> ?⁠zr:int ‑> ?⁠zc:int ‑> ?⁠z:mat ‑> ?⁠up:bool ‑> ?⁠work:vec ‑> ?⁠ofsw:int ‑> ?⁠w:vec ‑> ?⁠abr:int ‑> ?⁠abc:int ‑> mat ‑> vec

sbev ?n ?vectors ?zr ?zc ?z ?up ?ofswork ?work ?ofsw ?w ?abr ?abc ab computes all the eigenvalues and, optionally, eigenvectors of the real symmetric band matrix ab.

Symmetric-matrix eigenvalue and singular value problems (expert & RRR drivers)
val syevr_min_lwork : int ‑> int

syevr_min_lwork n

val syevr_min_liwork : int ‑> int

syevr_min_liwork n

val syevr_opt_lwork : ?⁠n:int ‑> ?⁠vectors:bool ‑> ?⁠range:[ `A | `V of float * float | `I of int * int ] ‑> ?⁠up:bool ‑> ?⁠abstol:float ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> int

syevr_opt_lwork ?n ?vectors ?range ?up ?abstol ?ar ?ac a

val syevr_opt_liwork : ?⁠n:int ‑> ?⁠vectors:bool ‑> ?⁠range:[ `A | `V of float * float | `I of int * int ] ‑> ?⁠up:bool ‑> ?⁠abstol:float ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> int

syevr_opt_liwork ?n ?vectors ?range ?up ?abstol ?ar ?ac a

val syevr_opt_l_li_work : ?⁠n:int ‑> ?⁠vectors:bool ‑> ?⁠range:[ `A | `V of float * float | `I of int * int ] ‑> ?⁠up:bool ‑> ?⁠abstol:float ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> int * int

syevr_opt_l_li_iwork ?n ?vectors ?range ?up ?abstol ?ar ?ac a

val syevr : ?⁠n:int ‑> ?⁠vectors:bool ‑> ?⁠range:[ `A | `V of float * float | `I of int * int ] ‑> ?⁠up:bool ‑> ?⁠abstol:float ‑> ?⁠work:vec ‑> ?⁠iwork:Common.int32_vec ‑> ?⁠ofsw:int ‑> ?⁠w:vec ‑> ?⁠zr:int ‑> ?⁠zc:int ‑> ?⁠z:mat ‑> ?⁠isuppz:Common.int32_vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> int * vec * mat * Common.int32_vec

syevr ?n ?vectors ?range ?up ?abstol ?work ?iwork ?ofsw ?w ?zr ?zc ?z ?isuppz ?ar ?ac arange is either `A for computing all eigenpairs, `V (vl, vu) defines the lower and upper range of computed eigenvalues, `I (il, iu) defines the indexes of the computed eigenpairs, which are sorted in ascending order.

val sygv_opt_lwork : ?⁠n:int ‑> ?⁠vectors:bool ‑> ?⁠up:bool ‑> ?⁠itype:[ `A_B | `AB | `BA ] ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> int

sygv_opt_lwork ?n ?vectors ?up ?ar ?ac a ?br ?bc b

val sygv : ?⁠n:int ‑> ?⁠vectors:bool ‑> ?⁠up:bool ‑> ?⁠work:vec ‑> ?⁠ofsw:int ‑> ?⁠w:vec ‑> ?⁠itype:[ `A_B | `AB | `BA ] ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> vec

sygv ?n ?vectors ?up ?ofswork ?work ?ofsw ?w ?ar ?ac a ?br ?bc b computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form a*x=(lambda)*b*x, a*b*x=(lambda)*x, or b*a*x=(lambda)*x. Here a and b are assumed to be symmetric and b is also positive definite.

val sbgv : ?⁠n:int ‑> ?⁠ka:int ‑> ?⁠kb:int ‑> ?⁠zr:int ‑> ?⁠zc:int ‑> ?⁠z:mat ‑> ?⁠up:bool ‑> ?⁠work:vec ‑> ?⁠ofsw:int ‑> ?⁠w:vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> vec

sbgv ?n ?ka ?kb ?zr ?zc ?z ?up ?work ?ofsw ?w ?ar ?ac a ?br ?bc b computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form a*x=(lambda)*b*x. Here a and b are assumed to be symmetric and banded, and b is also positive definite.

BLAS-1 interface
val swap : ?⁠n:int ‑> ?⁠ofsx:int ‑> ?⁠incx:int ‑> vec ‑> ?⁠ofsy:int ‑> ?⁠incy:int ‑> vec ‑> unit

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

val scal : ?⁠n:int ‑> float ‑> ?⁠ofsx:int ‑> ?⁠incx:int ‑> vec ‑> unit

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

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

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

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

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

val axpy : ?⁠alpha:float ‑> ?⁠n:int ‑> ?⁠ofsx:int ‑> ?⁠incx:int ‑> vec ‑> ?⁠ofsy:int ‑> ?⁠incy:int ‑> vec ‑> unit

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

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

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

val amax : ?⁠n:int ‑> ?⁠ofsx:int ‑> ?⁠incx:int ‑> vec ‑> float

amax ?n ?ofsx ?incx x

BLAS-2 interface
val gemv : ?⁠m:int ‑> ?⁠n:int ‑> ?⁠beta:float ‑> ?⁠ofsy:int ‑> ?⁠incy:int ‑> ?⁠y:vec ‑> ?⁠trans:trans3 ‑> ?⁠alpha:float ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠ofsx:int ‑> ?⁠incx:int ‑> vec ‑> vec

gemv ?m ?n ?beta ?ofsy ?incy ?y ?trans ?alpha ?ar ?ac a ?ofsx ?incx x performs the operation y := alpha * op(a) * x + beta * y where op(a) = a or aᵀ according to the value of trans. See BLAS documentation for more information. BEWARE that the 1988 BLAS-2 specification mandates that this function has no effect when n=0 while the mathematically expected behavior is y ← beta * y.

val gbmv : ?⁠m:int ‑> ?⁠n:int ‑> ?⁠beta:float ‑> ?⁠ofsy:int ‑> ?⁠incy:int ‑> ?⁠y:vec ‑> ?⁠trans:trans3 ‑> ?⁠alpha:float ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> int ‑> int ‑> ?⁠ofsx:int ‑> ?⁠incx:int ‑> vec ‑> vec

gbmv ?m ?n ?beta ?ofsy ?incy ?y ?trans ?alpha ?ar ?ac a kl ku ?ofsx ?incx x see BLAS documentation!

val symv : ?⁠n:int ‑> ?⁠beta:float ‑> ?⁠ofsy:int ‑> ?⁠incy:int ‑> ?⁠y:vec ‑> ?⁠up:bool ‑> ?⁠alpha:float ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠ofsx:int ‑> ?⁠incx:int ‑> vec ‑> vec

symv ?n ?beta ?ofsy ?incy ?y ?up ?alpha ?ar ?ac a ?ofsx ?incx x see BLAS documentation!

val trmv : ?⁠n:int ‑> ?⁠trans:trans3 ‑> ?⁠diag:Common.diag ‑> ?⁠up:bool ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠ofsx:int ‑> ?⁠incx:int ‑> vec ‑> unit

trmv ?n ?trans ?diag ?up ?ar ?ac a ?ofsx ?incx x see BLAS documentation!

val trsv : ?⁠n:int ‑> ?⁠trans:trans3 ‑> ?⁠diag:Common.diag ‑> ?⁠up:bool ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠ofsx:int ‑> ?⁠incx:int ‑> vec ‑> unit

trsv ?n ?trans ?diag ?up ?ar ?ac a ?ofsx ?incx x see BLAS documentation!

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

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

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

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

BLAS-3 interface
val gemm : ?⁠m:int ‑> ?⁠n:int ‑> ?⁠k:int ‑> ?⁠beta:float ‑> ?⁠cr:int ‑> ?⁠cc:int ‑> ?⁠c:mat ‑> ?⁠transa:trans3 ‑> ?⁠alpha:float ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠transb:trans3 ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> mat

gemm ?m ?n ?k ?beta ?cr ?cc ?c ?transa ?alpha ?ar ?ac a ?transb ?br ?bc b performs the operation c := alpha * op(a) * op(b) + beta * c where op(x) = x or xᵀ depending on transx. See BLAS documentation for more information.

val symm : ?⁠m:int ‑> ?⁠n:int ‑> ?⁠side:Common.side ‑> ?⁠up:bool ‑> ?⁠beta:float ‑> ?⁠cr:int ‑> ?⁠cc:int ‑> ?⁠c:mat ‑> ?⁠alpha:float ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> mat

symm ?m ?n ?side ?up ?beta ?cr ?cc ?c ?alpha ?ar ?ac a ?br ?bc b see BLAS documentation!

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

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

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

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

val syrk : ?⁠n:int ‑> ?⁠k:int ‑> ?⁠up:bool ‑> ?⁠beta:float ‑> ?⁠cr:int ‑> ?⁠cc:int ‑> ?⁠c:mat ‑> ?⁠trans:Common.trans2 ‑> ?⁠alpha:float ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> mat

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

val syr2k : ?⁠n:int ‑> ?⁠k:int ‑> ?⁠up:bool ‑> ?⁠beta:float ‑> ?⁠cr:int ‑> ?⁠cc:int ‑> ?⁠c:mat ‑> ?⁠trans:Common.trans2 ‑> ?⁠alpha:float ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> mat

syr2k ?n ?k ?up ?beta ?cr ?cc ?c ?trans ?alpha ?ar ?ac a ?br ?bc b see BLAS documentation!

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

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

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

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

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

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

val lassq : ?⁠n:int ‑> ?⁠scale:float ‑> ?⁠sumsq:float ‑> ?⁠ofsx:int ‑> ?⁠incx:int ‑> vec ‑> float * float

lassq ?n ?ofsx ?incx ?scale ?sumsq

val larnv : ?⁠idist:[ `Uniform0 | `Uniform1 | `Normal ] ‑> ?⁠iseed:Common.int32_vec ‑> ?⁠n:int ‑> ?⁠ofsx:int ‑> ?⁠x:vec ‑> unit ‑> vec

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

val lange_min_lwork : int ‑> Common.norm4 ‑> int

lange_min_lwork m norm

val lange : ?⁠m:int ‑> ?⁠n:int ‑> ?⁠norm:Common.norm4 ‑> ?⁠work:rvec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> float

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

val lauum : ?⁠n:int ‑> ?⁠up:bool ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> unit

lauum ?n ?up ?ar ?ac a computes the product U * U**T or L**T * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array a. The upper or lower part of a is overwritten.

Linear equations (computational routines)
val getrf : ?⁠m:int ‑> ?⁠n:int ‑> ?⁠ipiv:Common.int32_vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> Common.int32_vec

getrf ?m ?n ?ipiv ?ar ?ac a computes an LU factorization of a general m-by-n matrix a using partial pivoting with row interchanges. See LAPACK documentation.

val getrs : ?⁠n:int ‑> ?⁠ipiv:Common.int32_vec ‑> ?⁠trans:trans3 ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠nrhs:int ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> unit

getrs ?n ?ipiv ?trans ?ar ?ac a ?nrhs ?br ?bc b solves a system of linear equations a * X = b or a' * X = b with a general n-by-n matrix a using the LU factorization computed by getrf. Note that matrix a will be passed to getrf if ipiv was not provided.

val getri_min_lwork : int ‑> int

getri_min_lwork n

val getri_opt_lwork : ?⁠n:int ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> int

getri_opt_lwork ?n ?ar ?ac a

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

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

val sytrf_min_lwork : unit ‑> int

sytrf_min_lwork ()

val sytrf_opt_lwork : ?⁠n:int ‑> ?⁠up:bool ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> int

sytrf_opt_lwork ?n ?up ?ar ?ac a

val sytrf : ?⁠n:int ‑> ?⁠up:bool ‑> ?⁠ipiv:Common.int32_vec ‑> ?⁠work:vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> Common.int32_vec

sytrf ?n ?up ?ipiv ?work ?ar ?ac a computes the factorization of the real symmetric matrix a using the Bunch-Kaufman diagonal pivoting method.

val sytrs : ?⁠n:int ‑> ?⁠up:bool ‑> ?⁠ipiv:Common.int32_vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠nrhs:int ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> unit

sytrs ?n ?up ?ipiv ?ar ?ac a ?nrhs ?br ?bc b solves a system of linear equations a*X = b with a real symmetric matrix a using the factorization a = U*D*U**T or a = L*D*L**T computed by sytrf. Note that matrix a will be passed to sytrf if ipiv was not provided.

val sytri_min_lwork : int ‑> int

sytri_min_lwork n

val sytri : ?⁠n:int ‑> ?⁠up:bool ‑> ?⁠ipiv:Common.int32_vec ‑> ?⁠work:vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> unit

sytri ?n ?up ?ipiv ?work ?ar ?ac a computes the inverse of the real symmetric indefinite matrix a using the factorization a = U*D*U**T or a = L*D*L**T computed by sytrf. Note that matrix a will be passed to sytrf if ipiv was not provided.

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

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

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

potrs ?n ?up ?ar ?ac a ?nrhs ?br ?bc b solves a system of linear equations a*X = b, where a is symmetric positive definite matrix, using the Cholesky factorization a = U**T*U or a = L*L**T computed by potrf.

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

potri ?n ?up ?ar ?ac a computes the inverse of the real symmetric positive definite matrix a using the Cholesky factorization a = U**T*U or a = L*L**T computed by potrf.

val trtrs : ?⁠n:int ‑> ?⁠up:bool ‑> ?⁠trans:trans3 ‑> ?⁠diag:Common.diag ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠nrhs:int ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> unit

trtrs ?n ?up ?trans ?diag ?ar ?ac a ?nrhs ?br ?bc b solves a triangular system of the form a * X = b or a**T * X = n, where a is a triangular matrix of order n, and b is an n-by-nrhs matrix.

val tbtrs : ?⁠n:int ‑> ?⁠kd:int ‑> ?⁠up:bool ‑> ?⁠trans:trans3 ‑> ?⁠diag:Common.diag ‑> ?⁠abr:int ‑> ?⁠abc:int ‑> mat ‑> ?⁠nrhs:int ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> unit

tbtrs ?n ?kd ?up ?trans ?diag ?abr ?abc ab ?nrhs ?br ?bc b solves a triangular system of the form a * X = b or a**T * X = b, where a is a triangular band matrix of order n, and b is an n-by-nrhs matrix.

val trtri : ?⁠n:int ‑> ?⁠up:bool ‑> ?⁠diag:Common.diag ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> unit

trtri ?n ?up ?diag ?ar ?ac a computes the inverse of a real upper or lower triangular matrix a.

val geqrf_opt_lwork : ?⁠m:int ‑> ?⁠n:int ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> int

geqrf_opt_lwork ?m ?n ?ar ?ac a

val geqrf_min_lwork : n:int ‑> int

geqrf_min_lwork ~n

val geqrf : ?⁠m:int ‑> ?⁠n:int ‑> ?⁠work:vec ‑> ?⁠tau:vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> vec

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

Linear equations (simple drivers)
val gesv : ?⁠n:int ‑> ?⁠ipiv:Common.int32_vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠nrhs:int ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> unit

gesv ?n ?ipiv ?ar ?ac a ?nrhs ?br ?bc b computes the solution to a real system of linear equations a * X = b, where a is an n-by-n matrix and X and b are n-by-nrhs matrices. The LU decomposition with partial pivoting and row interchanges is used to factor a as a = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of a is then used to solve the system of equations a * X = b. On exit, b contains the solution matrix X.

val gbsv : ?⁠n:int ‑> ?⁠ipiv:Common.int32_vec ‑> ?⁠abr:int ‑> ?⁠abc:int ‑> mat ‑> int ‑> int ‑> ?⁠nrhs:int ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> unit

gbsv ?n ?ipiv ?abr ?abc ab kl ku ?nrhs ?br ?bc b computes the solution to a real system of linear equations a * X = b, where a is a band matrix of order n with kl subdiagonals and ku superdiagonals, and X and b are n-by-nrhs matrices. The LU decomposition with partial pivoting and row interchanges is used to factor a as a = L * U, where L is a product of permutation and unit lower triangular matrices with kl subdiagonals, and U is upper triangular with kl+ku superdiagonals. The factored form of a is then used to solve the system of equations a * X = b.

val gtsv : ?⁠n:int ‑> ?⁠ofsdl:int ‑> vec ‑> ?⁠ofsd:int ‑> vec ‑> ?⁠ofsdu:int ‑> vec ‑> ?⁠nrhs:int ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> unit

gtsv ?n ?ofsdl dl ?ofsd d ?ofsdu du ?nrhs ?br ?bc b solves the equation a * X = b where a is an n-by-n tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation A'*X = b may be solved by interchanging the order of the arguments du and dl.

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

posv ?n ?up ?ar ?ac a ?nrhs ?br ?bc b computes the solution to a real system of linear equations a * X = b, where a is an n-by-n symmetric positive definite matrix and X and b are n-by-nrhs matrices. The Cholesky decomposition is used to factor a as a = U**T * U, if up = true, or a = L * L**T, if up = false, where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of a is then used to solve the system of equations a * X = b.

val ppsv : ?⁠n:int ‑> ?⁠up:bool ‑> ?⁠ofsap:int ‑> vec ‑> ?⁠nrhs:int ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> unit

ppsv ?n ?up ?ofsap ap ?nrhs ?br ?bc b computes the solution to the real system of linear equations a * X = b, where a is an n-by-n symmetric positive definite matrix stored in packed format and X and b are n-by-nrhs matrices. The Cholesky decomposition is used to factor a as a = U**T * U, if up = true, or a = L * L**T, if up = false, where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of a is then used to solve the system of equations a * X = b.

val pbsv : ?⁠n:int ‑> ?⁠up:bool ‑> ?⁠kd:int ‑> ?⁠abr:int ‑> ?⁠abc:int ‑> mat ‑> ?⁠nrhs:int ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> unit

pbsv ?n ?up ?kd ?abr ?abc ab ?nrhs ?br ?bc b computes the solution to a real system of linear equations a * X = b, where a is an n-by-n symmetric positive definite band matrix and X and b are n-by-nrhs matrices. The Cholesky decomposition is used to factor a as a = U**T * U, if up = true, or a = L * L**T, if up = false, where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as a. The factored form of a is then used to solve the system of equations a * X = b.

val ptsv : ?⁠n:int ‑> ?⁠ofsd:int ‑> vec ‑> ?⁠ofse:int ‑> vec ‑> ?⁠nrhs:int ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> unit

ptsv ?n ?ofsd d ?ofse e ?nrhs ?br ?bc b computes the solution to the real system of linear equations a*X = b, where a is an n-by-n symmetric positive definite tridiagonal matrix, and X and b are n-by-nrhs matrices. A is factored as a = L*D*L**T, and the factored form of a is then used to solve the system of equations.

val sysv_opt_lwork : ?⁠n:int ‑> ?⁠up:bool ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠nrhs:int ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> int

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

val sysv : ?⁠n:int ‑> ?⁠up:bool ‑> ?⁠ipiv:Common.int32_vec ‑> ?⁠work:vec ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠nrhs:int ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> unit

sysv ?n ?up ?ipiv ?work ?ar ?ac a ?nrhs ?br ?bc b computes the solution to a real system of linear equations a * X = b, where a is an N-by-N symmetric matrix and X and b are n-by-nrhs matrices. The diagonal pivoting method is used to factor a as a = U * D * U**T, if up = true, or a = L * D * L**T, if up = false, where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of a is then used to solve the system of equations a * X = b.

val spsv : ?⁠n:int ‑> ?⁠up:bool ‑> ?⁠ipiv:Common.int32_vec ‑> ?⁠ofsap:int ‑> vec ‑> ?⁠nrhs:int ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> unit

spsv ?n ?up ?ipiv ?ofsap ap ?nrhs ?br ?bc b computes the solution to the real system of linear equations a * X = b, where a is an n-by-n symmetric matrix stored in packed format and X and b are n-by-nrhs matrices. The diagonal pivoting method is used to factor a as a = U * D * U**T, if up = true, or a = L * D * L**T, if up = false, where U (or L) is a product of permutation and unit upper (lower) triangular matrices, D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of a is then used to solve the system of equations a * X = b.

Least squares (simple drivers)
val gels_min_lwork : m:int ‑> n:int ‑> nrhs:int ‑> int

gels_min_lwork ~m ~n ~nrhs

val gels_opt_lwork : ?⁠m:int ‑> ?⁠n:int ‑> ?⁠trans:Common.trans2 ‑> ?⁠ar:int ‑> ?⁠ac:int ‑> mat ‑> ?⁠nrhs:int ‑> ?⁠br:int ‑> ?⁠bc:int ‑> mat ‑> int

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

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

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