Module Lacaml.Utils

module Utils: Lacaml__utils

Utility functions

val empty_int32_vec : Lacaml__common.int32_vec

val get_norm_char : [< `F | `I | `M | `O ] -> char

val get_uplo_char : bool -> char

val get_trans_char : [< `C | `N | `T ] -> char

val get_side_char : [< `L | `R ] -> char

val get_diag_char : [< `N | `U ] -> char

val get_s_d_job_char : [< `A | `N | `O | `S ] -> char

val get_job_char : bool -> char

val job_char_true : char

val job_char_false : char

Preallocated strings (names)

val a_str : string

val ab_str : string

val alphas_str : string

val ap_str : string

val b_str : string

val br_str : string

val bc_str : string

val c_str : string

val cr_str : string

val cc_str : string

val d_str : string

val dl_str : string

val du_str : string

val e_str : string

val ipiv_str : string

val iseed_str : string

val k_str : string

val ka_str : string

val kb_str : string

val work_str : string

val lwork_str : string

val liwork_str : string

val k1_str : string

val k2_str : string

val kd_str : string

val kl_str : string

val ku_str : string

val m_str : string

val n_str : string

val nrhs_str : string

val ofs_str : string

val r_str : string

val s_str : string

val tau_str : string

val u_str : string

val um_str : string

val un_str : string

val vm_str : string

val vn_str : string

val vs_str : string

val vsr_str : string

val vsc_str : string

val vt_str : string

val w_str : string

val wi_str : string

val wr_str : string

val x_str : string

val y_str : string

val z_str : string

Range checking

val raise_var_lt0 : loc:string -> name:string -> int -> 'a

raise_var_lt0 ~loc ~name var

Raises Invalid_argument to indicate that integer variable var with name name at location loc is lower than 0.

val check_var_lt0 : loc:string -> name:string -> int -> unit

check_var_lt0 ~loc ~name var checks whether integer variable var with name name at location loc is lower than 0.

Raises Invalid_argument in that case.

val check_var_within : string -> string -> 'a -> 'a -> 'a -> ('a -> string) -> unit

Valueless vector checking and allocation functions (do not require a vector value as argument

val calc_vec_min_dim : n:int -> ofs:int -> inc:int -> int

calc_vec_min_dim ~n ~ofs ~inc

Returns minimum vector dimension given offset ofs, increment inc, and operation size n for a vector.

val raise_vec_min_dim : loc:string -> vec_name:string -> dim:int -> min_dim:int -> 'a

raise_vec_min_dim ~loc ~vec_name ~dim ~min_dim

Raises Invalid_argument to indicate that dimension dim of a vector with name vec_name exceeds the minimum min_dim at location loc.

val check_vec_min_dim : loc:string -> vec_name:string -> dim:int -> min_dim:int -> unit

check_vec_min_dim ~loc ~vec_name ~dim ~min_dim checks whether vector with name vec_name and dimension dim satisfies minimum dimension min_dim.

Raises Invalid_argument otherwise.

val raise_vec_bad_ofs : loc:string -> vec_name:string -> ofs:int -> max_ofs:int -> 'a

raise_vec_bad_ofs ~loc ~vec_name ~ofs ~max_ofs

Raises Invalid_argument to indicate that vector offset ofs is invalid (i.e. is outside of 1..max_ofs).

val bad_n : n:int -> max_n:int -> bool

bad_n ~n ~max_n

Returns true iff n is smaller than zero or larger than max_n.

val bad_ofs : ofs:int -> max_ofs:int -> bool

bad_ofs ~ofs ~max_ofs

Returns true iff ofs is smaller than one or exceeds max_ofs.

val bad_inc : int -> bool

bad_inc inc

Returns true iff inc is illegal.

val check_vec_ofs : loc:string -> vec_name:string -> ofs:int -> max_ofs:int -> unit

check_vec_ofs ~loc ~vec_name ~ofs ~max_ofs checks whether vector offset ofs for vector of name vec_name is invalid (i.e. outside of 1..max_ofs).

Raises Invalid_argument in that case.

val check_vec_inc : loc:string -> vec_name:string -> int -> unit

check_vec_inc ~loc ~vec_name inc checks whether vector increment inc for vector of name vec_name is invalid (i.e. 0).

Raises Invalid_argument in that case.

val calc_vec_max_n : dim:int -> ofs:int -> inc:int -> int

calc_vec_max_n ~dim ~ofs ~inc

Returns maximum operation length n for a vector given the dimension dim of the vector, the offset ofs, and increment inc. Assumes that the offset has already been validated to not exceed dim, i.e. the returned max_n is at least 1.

val calc_vec_opt_max_n : ?ofs:int -> ?inc:int -> int -> int

calc_vec_opt_max_n ?ofs ?inc dim

Returns maximum operation length n for a vector given the dimension dim of the vector, the optional offset ofs, and optional increment inc. Assumes that the offset has already been validated to not exceed dim, i.e. the returned max_n is at least 1.

val raise_max_len : loc:string -> len_name:string -> len:int -> max_len:int -> 'a

raise_max_len ~loc ~len_name ~len ~max_len

Raises Invalid_argument that the maximum operation size (e.g. m or n for vectors and matrices) has been exceeded.

val check_vec_dim : loc:string ->
       vec_name:string ->
       dim:int -> ofs:int -> inc:int -> n_name:string -> n:int -> unit

check_vec_dim ~loc ~vec_name ~dim ~ofs ~inc ~n_name ~n checks the vector operation length in parameter n with name n_name at location loc for vector with name vec_name and dimension dim given the operation offset ofs and increment inc.

Raises Invalid_argument if any arguments are invalid.

val get_vec_n : loc:string ->
       vec_name:string ->
       dim:int -> ofs:int -> inc:int -> n_name:string -> int option -> int

get_vec_n ~loc ~vec_name ~dim ~ofs ~inc ~n_name n checks or infers the vector operation length in the option parameter n with name n_name at location loc for vector with name vec_name and dimension dim given the operation offset ofs and increment inc.

Raises Invalid_argument if any arguments are invalid.

val get_vec_min_dim : loc:string -> vec_name:string -> ofs:int -> inc:int -> n:int -> int

get_vec_min_dim ~loc ~vec_name ~ofs ~inc ~n

Raises Invalid_argument if any of the parameters are illegal.
Returns minimum vector dimension given offset ofs, increment inc, and operation size n for a vector named vec_name at location loc.

val get_vec_start_stop : ofsx:int -> incx:int -> n:int -> int * int

get_vec_start_stop ~ofsx ~incx ~n

Returns (start, stop) where start and stop reflect the start and stop of an iteration respectively.

Valueless matrix checking and allocation functions (do not require a matrix value as argument

val raise_bad_mat_ofs : loc:string -> name:string -> ofs_name:string -> ofs:int -> max_ofs:int -> 'a

raise_bad_mat_ofs ~loc ~name ~ofs_name ~ofs ~max_ofs

Raises Invalid_argument to indicate that a matrix offset ofs named ofs_name for a matrix having name is invalid (i.e. is outside of 1..max_ofs).

val raise_mat_bad_r : loc:string -> mat_name:string -> r:int -> max_r:int -> 'a

raise_mat_bad_r ~loc ~mat_name ~r ~max_r

Raises Invalid_argument to indicate that matrix row offset r is invalid (i.e. is outside of 1..max_r).

val raise_mat_bad_c : loc:string -> mat_name:string -> c:int -> max_c:int -> 'a

raise_mat_bad_c ~loc ~mat_name ~c ~max_c

Raises Invalid_argument to indicate that matrix column offset c is invalid (i.e. is outside of 1..max_c).

val check_mat_r : loc:string -> mat_name:string -> r:int -> max_r:int -> unit

check_mat_r ~loc ~vec_name ~r ~max_r checks whether matrix row offset r for vector of name vec_name is invalid (i.e. outside of 1..max_r).

Raises Invalid_argument in that case.

val check_mat_c : loc:string -> mat_name:string -> c:int -> max_c:int -> unit

check_mat_c ~loc ~vec_name ~c ~max_c checks whether matrix column offset c for vector of name vec_name is invalid (i.e. outside of 1..max_c).

Raises Invalid_argument in that case.

val calc_mat_max_rows : dim1:int -> r:int -> int

calc_mat_max_rows ~dim1 ~r

Returns maximum row operation length m for a matrix given the dimension dim1 of the matrix and the start row r.

val calc_mat_opt_max_rows : ?r:int -> int -> int

calc_mat_opt_max_rows ?r dim1

Returns maximum row operation length m for a matrix given the dimension dim1 of the matrix and the optional start row r. Assumes that the offset has already been validated to not exceed dim1, i.e. the returned max_m is at least 1.

val calc_mat_max_cols : dim2:int -> c:int -> int

calc_mat_max_cols ~dim2 ~c

Returns maximum column operation length n for a matrix given the dimension dim1 of the matrix and the start column c.

val calc_mat_opt_max_cols : ?c:int -> int -> int

calc_mat_opt_max_cols ?c dim1

Returns maximum column operation length m for a matrix given the dimension dim2 of the matrix and the optional start column c. Assumes that the offset has already been validated to not exceed dim2, i.e. the returned max_n is at least 1.

val check_mat_rows : loc:string ->
       mat_name:string -> dim1:int -> r:int -> p:int -> param_name:string -> unit

check_mat_rows ~loc ~mat_name ~dim1 ~r ~p ~param_name checks the matrix row operation length in parameter p with name param_name at location loc for matrix with name mat_name and dimension dim1 given the operation row r.

Raises Invalid_argument if any arguments are invalid.

val check_mat_m : loc:string -> mat_name:string -> dim1:int -> r:int -> m:int -> unit

check_mat_m ~loc ~mat_name ~dim1 ~r ~m checks the matrix row operation length in parameter m at location loc for matrix with name mat_name and dimension dim1 given the operation row r.

Raises Invalid_argument if any arguments are invalid.

val check_mat_cols : loc:string ->
       mat_name:string -> dim2:int -> c:int -> p:int -> param_name:string -> unit

check_mat_cols ~loc ~mat_name ~dim2 ~c ~p ~param_name checks the matrix column operation length in parameter p with name param_name at location loc for matrix with name mat_name and dimension dim2 given the operation column c.

Raises Invalid_argument if any arguments are invalid.

val check_mat_n : loc:string -> mat_name:string -> dim2:int -> c:int -> n:int -> unit

check_mat_n ~loc ~mat_name ~dim2 ~c ~n checks the matrix column operation length in parameter n at location loc for matrix with name mat_name and dimension dim2 given the operation column c.

Raises Invalid_argument if any arguments are invalid.

val check_mat_mn : loc:string ->
       mat_name:string ->
       dim1:int -> dim2:int -> r:int -> c:int -> m:int -> n:int -> unit

check_mat_mn ~loc ~mat_name ~dim1 ~dim2 ~r ~c ~m ~n checks the matrix operation lengths in parameters m and n at location loc for matrix with name mat_name and dimensions dim1 and dim2 given the operation row r and column c.

Raises Invalid_argument if any arguments are invalid.

val get_mat_rows : loc:string ->
       mat_name:string ->
       dim1:int -> r:int -> p:int option -> param_name:string -> int

get_mat_rows ~loc ~mat_name ~dim1 ~r p ~param_name checks or infers the matrix row operation length in the option parameter p with name param_name at location loc for matrix with name mat_name and dimension dim1 given the row operation offset r.

Raises Invalid_argument if any arguments are invalid.

val get_mat_dim1 : loc:string ->
       mat_name:string -> dim1:int -> r:int -> m:int option -> m_name:string -> int

get_mat_dim1 ~loc ~mat_name ~dim1 ~r ~m ~m_name checks or infers the matrix row operation length in the option parameter m with name m_name at location loc for matrix with name mat_name and dimension dim1 given the row operation offset r.

Raises Invalid_argument if any arguments are invalid.

val get_mat_m : loc:string -> mat_name:string -> dim1:int -> r:int -> m:int option -> int

get_mat_m ~loc ~mat_name ~dim1 ~r ~m checks or infers the matrix row operation length in the option parameter m at location loc for matrix with name mat_name and dimension dim1 given the row operation offset r.

Raises Invalid_argument if any arguments are invalid.

val get_mat_cols : loc:string ->
       mat_name:string ->
       dim2:int -> c:int -> p:int option -> param_name:string -> int

get_mat_cols ~loc ~mat_name ~dim2 ~c ~param_name p checks or infers the matrix column operation length in the option parameter p with name param_name at location loc for matrix with name mat_name and dimension dim2 given the column operation offset c.

Raises Invalid_argument if any arguments are invalid.

val get_mat_dim2 : loc:string ->
       mat_name:string -> dim2:int -> c:int -> n:int option -> n_name:string -> int

get_mat_dim2 ~loc ~mat_name ~dim2 ~c ~n ~n_name checks or infers the matrix column operation length in the option parameter n with name n_name at location loc for matrix with name mat_name and dimension dim2 given the column operation offset c.

Raises Invalid_argument if any arguments are invalid.

val get_mat_n : loc:string -> mat_name:string -> dim2:int -> c:int -> n:int option -> int

get_mat_n ~loc ~mat_name ~dim2 ~c ~n checks or infers the matrix column operation length in the option parameter n at location loc for matrix with name mat_name and dimension dim2 given the column operation offset c.

Raises Invalid_argument if any arguments are invalid.

val get_mat_min_dim1 : loc:string -> mat_name:string -> r:int -> m:int -> int

get_mat_min_dim1 ~loc ~mat_name ~r ~m

Raises Invalid_argument if any arguments are invalid.
Returns the minimum row dimension of a matrix with name mat_name at location loc given row r and row operation length m.

val get_mat_min_dim2 : loc:string -> mat_name:string -> c:int -> n:int -> int

get_mat_min_dim2 ~loc ~mat_name ~c ~n

Raises Invalid_argument if any arguments are invalid.
Returns the minimum column dimension of a matrix with name mat_name at location loc given column c and row operation length n.

val check_mat_min_dim1 : loc:string -> mat_name:string -> dim1:int -> min_dim1:int -> unit

check_mat_min_dim1 ~loc ~mat_name ~dim1 ~min_dim1 checks the minimum row dimension min_dim1 of a matrix with name mat_name at location loc given its row dimension dim1.

Raises Invalid_argument if any arguments are invalid.

val check_mat_min_dim2 : loc:string -> mat_name:string -> dim2:int -> min_dim2:int -> unit

check_mat_min_dim2 ~loc ~mat_name ~dim2 ~min_dim2 checks the minimum column dimension min_dim2 of a matrix with name mat_name at location loc given its column dimension dim2.

Raises Invalid_argument if any arguments are invalid.

val check_mat_min_dims : loc:string ->
       mat_name:string ->
       dim1:int -> dim2:int -> min_dim1:int -> min_dim2:int -> unit

check_mat_min_dim2 ~loc ~mat_name ~dim2 ~min_dim2 checks the minimum column dimension min_dim2 of a matrix with name mat_name at location loc given its column dimension dim2.

Raises Invalid_argument if any arguments are invalid.

(Old) Vector checking and allocation functions

val check_vec : string -> string -> ('a, 'b, 'c) Bigarray.Array1.t -> int -> unit

val check_vec_is_perm : string -> string -> (int32, 'a, 'b) Bigarray.Array1.t -> int -> unit

check_vec_is_perm loc vec_name vec n checks whether vec is a valid permutation vector.

val get_vec : string ->
       string ->
       ('a, 'b, 'c) Bigarray.Array1.t option ->
       int ->
       int ->
       int ->
       (int -> ('a, 'b, 'c) Bigarray.Array1.t) -> ('a, 'b, 'c) Bigarray.Array1.t

val get_dim_vec : string ->
       string ->
       int -> int -> ('a, 'b, 'c) Bigarray.Array1.t -> string -> int option -> int

get_dim_vec loc vec_name ofs inc vec n_name n if the dimension n is given, check that the vector vec is big enough, otherwise return the maximal n for the given vector vec.

val check_vec_empty : loc:string -> vec_name:string -> dim:int -> unit

(Old) Matrix checking and allocation functions

val get_mat : string ->
       string ->
       (int -> int -> ('a, 'b, 'c) Bigarray.Array2.t) ->
       int ->
       int ->
       ('a, 'b, 'c) Bigarray.Array2.t option ->
       int -> int -> ('a, 'b, 'c) Bigarray.Array2.t

val check_dim1_mat : string ->
       string -> ('a, 'b, 'c) Bigarray.Array2.t -> int -> string -> int -> unit

val check_dim2_mat : string ->
       string -> ('a, 'b, 'c) Bigarray.Array2.t -> int -> string -> int -> unit

val check_dim_mat : string ->
       string -> int -> int -> ('a, 'b, 'c) Bigarray.Array2.t -> int -> int -> unit

val get_dim1_mat : string ->
       string ->
       ('a, 'b, 'c) Bigarray.Array2.t -> int -> string -> int option -> int

val get_dim2_mat : string ->
       string ->
       ('a, 'b, 'c) Bigarray.Array2.t -> int -> string -> int option -> int

val check_mat_empty : loc:string -> mat_name:string -> dim1:int -> dim2:int -> unit

val get_vec_inc : string -> string -> int option -> int

val get_vec_ofs : string -> string -> int option -> int

val ilaenv : int -> string -> string -> int -> int -> int -> int -> int

val get_work : string ->
       (int -> ('a, 'b, 'c) Bigarray.Array1.t) ->
       ('a, 'b, 'c) Bigarray.Array1.t option ->
       int -> int -> string -> ('a, 'b, 'c) Bigarray.Array1.t * int

val calc_unpacked_dim : string -> int -> int

val get_unpacked_dim : string -> ?n:int -> int -> int

val get_vec_geom : string -> string -> int option -> int option -> int * int

val get_k_mat_sb : string ->
       string ->
       ('a, 'b, 'c) Bigarray.Array2.t -> int -> string -> int option -> int

val get_dim_mat_packed : string ->
       string ->
       int -> ('a, 'b, 'c) Bigarray.Array1.t -> string -> int option -> int

val get_n_of_square : string ->
       string -> int -> int -> ('a, 'b, 'c) Bigarray.Array2.t -> int option -> int

val get_n_of_a : string -> int -> int -> ('a, 'b, 'c) Bigarray.Array2.t -> int option -> int

val get_nrhs_of_b : string ->
       int -> int -> int -> ('a, 'b, 'c) Bigarray.Array2.t -> int option -> int

val orgqr_err : loc:string ->
       m:int ->
       n:int ->
       k:int ->
       work:('a, 'b, 'c) Bigarray.Array1.t ->
       a:('d, 'e, 'f) Bigarray.Array2.t -> err:int -> 'g

val orgqr_get_params : string ->
       ?m:int ->
       ?n:int ->
       ?k:int ->
       tau:('a, 'b, 'c) Bigarray.Array1.t ->
       ar:int -> ac:int -> ('d, 'e, 'f) Bigarray.Array2.t -> int * int * int

val ormqr_err : loc:string ->
       side:[< `L | `R ] ->
       m:int ->
       n:int ->
       k:int ->
       lwork:int ->
       a:('a, 'b, 'c) Bigarray.Array2.t ->
       c:('d, 'e, 'f) Bigarray.Array2.t -> err:int -> 'g

val ormqr_get_params : string ->
       side:[< `L | `R ] ->
       ?m:int ->
       ?n:int ->
       ?k:int ->
       tau:('a, 'b, 'c) Bigarray.Array1.t ->
       ar:int ->
       ac:int ->
       ('d, 'e, 'f) Bigarray.Array2.t ->
       cr:int -> cc:int -> ('g, 'h, 'i) Bigarray.Array2.t -> int * int * int

val gelsX_err : string ->
       (m:int -> n:int -> nrhs:int -> int) ->
       int ->
       ('a, 'b, 'c) Bigarray.Array2.t ->
       int ->
       int -> int -> int -> int -> ('d, 'e, 'f) Bigarray.Array2.t -> int -> 'g

val gelsX_get_s : (int -> ('a, 'b, 'c) Bigarray.Array1.t) ->
       string ->
       int ->
       int ->
       ('a, 'b, 'c) Bigarray.Array1.t option -> ('a, 'b, 'c) Bigarray.Array1.t

val gelsX_get_params : string ->
       int ->
       int ->
       ('a, 'b, 'c) Bigarray.Array2.t ->
       int option ->
       int option ->
       int option -> int -> int -> ('d, 'e, 'f) Bigarray.Array2.t -> int * int * int

val xxev_get_params : string ->
       int ->
       int ->
       ('a, 'b, 'c) Bigarray.Array2.t ->
       int option -> bool -> bool -> int * char * char

val xxev_get_wx : (int -> ('a, 'b, 'c) Bigarray.Array1.t) ->
       string ->
       string ->
       int ->
       ('a, 'b, 'c) Bigarray.Array1.t option ->
       int -> int * ('a, 'b, 'c) Bigarray.Array1.t

val geev_get_job_side : string ->
       ('a, 'b, 'c) Bigarray.Array2.t ->
       (int -> int -> ('a, 'b, 'c) Bigarray.Array2.t) ->
       string ->
       int ->
       int ->
       int ->
       ('a, 'b, 'c) Bigarray.Array2.t option option ->
       int * int * ('a, 'b, 'c) Bigarray.Array2.t * char * bool

val geev_gen_get_params : string ->
       ('a, 'b, 'c) Bigarray.Array2.t ->
       (int -> int -> ('a, 'b, 'c) Bigarray.Array2.t) ->
       int ->
       int ->
       ('d, 'e, 'f) Bigarray.Array2.t ->
       int option ->
       int ->
       int ->
       ('a, 'b, 'c) Bigarray.Array2.t option option ->
       int ->
       int ->
       ('a, 'b, 'c) Bigarray.Array2.t option option ->
       int * int * int * ('a, 'b, 'c) Bigarray.Array2.t * char * int * int *
       ('a, 'b, 'c) Bigarray.Array2.t * char * bool

val gXmv_get_params : string ->
       (int -> ('a, 'b, 'c) Bigarray.Array1.t) ->
       int ->
       int ->
       int option ->
       int option ->
       ('d, 'e, 'f) Bigarray.Array1.t ->
       int option ->
       int option ->
       ('a, 'b, 'c) Bigarray.Array1.t option ->
       [< `C | `N | `T > `N ] ->
       int * int * int * int * ('a, 'b, 'c) Bigarray.Array1.t * char

val symv_get_params : string ->
       (int -> ('a, 'b, 'c) Bigarray.Array1.t) ->
       int ->
       int ->
       ('d, 'e, 'f) Bigarray.Array2.t ->
       int option ->
       int option ->
       int option ->
       ('g, 'h, 'i) Bigarray.Array1.t ->
       int option ->
       int option ->
       ('a, 'b, 'c) Bigarray.Array1.t option ->
       bool -> int * int * int * int * int * ('a, 'b, 'c) Bigarray.Array1.t * char

val trXv_get_params : string ->
       int ->
       int ->
       ('a, 'b, 'c) Bigarray.Array2.t ->
       int option ->
       int option ->
       int option ->
       ('d, 'e, 'f) Bigarray.Array1.t ->
       bool ->
       [< `C | `N | `T ] -> [< `N | `U ] -> int * int * int * char * char * char

val tpXv_get_params : string ->
       int option ->
       ('a, 'b, 'c) Bigarray.Array1.t ->
       ?n:int ->
       int option ->
       int option ->
       ('d, 'e, 'f) Bigarray.Array1.t ->
       bool ->
       [< `C | `N | `T ] ->
       [< `N | `U ] -> int * int * int * int * char * char * char

val get_c : string ->
       (int -> int -> ('a, 'b, 'c) Bigarray.Array2.t) ->
       int ->
       int ->
       ('a, 'b, 'c) Bigarray.Array2.t option ->
       int -> int -> ('a, 'b, 'c) Bigarray.Array2.t

val get_rows_mat_tr : string ->
       string ->
       ('a, 'b, 'c) Bigarray.Array2.t ->
       int -> int -> [> `N ] -> string -> int option -> int

val get_cols_mat_tr : string ->
       string ->
       ('a, 'b, 'c) Bigarray.Array2.t ->
       int -> int -> [> `N ] -> string -> int option -> int

val get_inner_dim : string ->
       string ->
       ('a, 'b, 'c) Bigarray.Array2.t ->
       int ->
       int ->
       [> `N ] ->
       string ->
       ('d, 'e, 'f) Bigarray.Array2.t ->
       int -> int -> [> `N ] -> string -> int option -> int

val gemm_get_params : string ->
       (int -> int -> ('a, 'b, 'c) Bigarray.Array2.t) ->
       int ->
       int ->
       ('d, 'e, 'f) Bigarray.Array2.t ->
       [< `C | `N | `T > `N ] ->
       int ->
       int ->
       ('g, 'h, 'i) Bigarray.Array2.t ->
       int ->
       [< `C | `N | `T > `N ] ->
       int ->
       ('a, 'b, 'c) Bigarray.Array2.t option ->
       int option ->
       int option ->
       int option -> int * int * int * char * char * ('a, 'b, 'c) Bigarray.Array2.t

val check_mat_square : string ->
       string -> ('a, 'b, 'c) Bigarray.Array2.t -> int -> int -> int -> unit

val symm_get_params : string ->
       (int -> int -> ('a, 'b, 'c) Bigarray.Array2.t) ->
       int ->
       int ->
       ('d, 'e, 'f) Bigarray.Array2.t ->
       int ->
       int ->
       ('g, 'h, 'i) Bigarray.Array2.t ->
       int ->
       int ->
       ('a, 'b, 'c) Bigarray.Array2.t option ->
       int option ->
       int option ->
       [< `L | `R > `L ] ->
       bool -> int * int * char * char * ('a, 'b, 'c) Bigarray.Array2.t

val trXm_get_params : string ->
       int ->
       int ->
       ('a, 'b, 'c) Bigarray.Array2.t ->
       int ->
       int ->
       ('d, 'e, 'f) Bigarray.Array2.t ->
       int option ->
       int option ->
       [< `L | `R > `L ] ->
       bool ->
       [< `C | `N | `T ] -> [< `N | `U ] -> int * int * char * char * char * char

val syrk_get_params : string ->
       (int -> int -> ('a, 'b, 'c) Bigarray.Array2.t) ->
       int ->
       int ->
       ('d, 'e, 'f) Bigarray.Array2.t ->
       int ->
       int ->
       ('a, 'b, 'c) Bigarray.Array2.t option ->
       int option ->
       int option ->
       bool ->
       [< `C | `N | `T > `N ] ->
       int * int * char * char * ('a, 'b, 'c) Bigarray.Array2.t

val syr2k_get_params : string ->
       (int -> int -> ('a, 'b, 'c) Bigarray.Array2.t) ->
       int ->
       int ->
       ('d, 'e, 'f) Bigarray.Array2.t ->
       int ->
       int ->
       ('g, 'h, 'i) Bigarray.Array2.t ->
       int ->
       int ->
       ('a, 'b, 'c) Bigarray.Array2.t option ->
       int option ->
       int option ->
       bool ->
       [< `C | `N | `T > `N ] ->
       int * int * char * char * ('a, 'b, 'c) Bigarray.Array2.t

val xlange_get_params : string ->
       int option ->
       int option -> int -> int -> ('a, 'b, 'c) Bigarray.Array2.t -> int * int

val xxtrs_get_params : string ->
       int ->
       int ->
       ('a, 'b, 'c) Bigarray.Array2.t ->
       int option ->
       int -> int -> ('d, 'e, 'f) Bigarray.Array2.t -> int option -> int * int

val xxtrs_err : string ->
       int ->
       int ->
       ('a, 'b, 'c) Bigarray.Array2.t -> ('d, 'e, 'f) Bigarray.Array2.t -> int -> 'g

val xxtri_singular_err : string -> int -> 'a

val xxtri_err : string -> int -> ('a, 'b, 'c) Bigarray.Array2.t -> int -> 'd

val xxcon_err : string -> int -> ('a, 'b, 'c) Bigarray.Array2.t -> int -> 'd

val geXrf_get_params : string ->
       int option ->
       int option -> int -> int -> ('a, 'b, 'c) Bigarray.Array2.t -> int * int

val getrf_err : string -> int -> int -> ('a, 'b, 'c) Bigarray.Array2.t -> int -> 'd

val getrf_lu_err : string -> int -> 'a

val getrf_get_ipiv : string ->
       (int32, Stdlib.Bigarray.int32_elt, Stdlib.Bigarray.fortran_layout)
       Bigarray.Array1.t option -> int -> int -> Lacaml__common.int32_vec

val sytrf_get_ipiv : string ->
       (int32, Stdlib.Bigarray.int32_elt, Stdlib.Bigarray.fortran_layout)
       Bigarray.Array1.t option -> int -> Lacaml__common.int32_vec

val sytrf_err : string -> int -> ('a, 'b, 'c) Bigarray.Array2.t -> int -> 'd

val sytrf_fact_err : string -> int -> 'a

val potrf_chol_err : string -> int -> 'a

val potrf_err : string -> int -> ('a, 'b, 'c) Bigarray.Array2.t -> int -> 'd

val potrs_err : string ->
       int ->
       int ->
       ('a, 'b, 'c) Bigarray.Array2.t -> ('d, 'e, 'f) Bigarray.Array2.t -> int -> 'g

val trtrs_err : string ->
       int ->
       int ->
       ('a, 'b, 'c) Bigarray.Array2.t -> ('d, 'e, 'f) Bigarray.Array2.t -> int -> 'g

val tbtrs_err : string ->
       int ->
       int ->
       int ->
       ('a, 'b, 'c) Bigarray.Array2.t -> ('d, 'e, 'f) Bigarray.Array2.t -> int -> 'g

val getri_err : string ->
       (int -> int) -> int -> ('a, 'b, 'c) Bigarray.Array2.t -> int -> int -> 'd

val trtri_err : string -> int -> ('a, 'b, 'c) Bigarray.Array2.t -> int -> 'd

val geqrf_err : string -> int -> int -> ('a, 'b, 'c) Bigarray.Array2.t -> int -> 'd

val gecon_err : string -> char -> int -> ('a, 'b, 'c) Bigarray.Array2.t -> int -> 'd

val gees_err : string -> int -> int -> char -> char -> 'a

val dummy_select_fun : 'a -> bool

val gees_get_params_generic : string ->
       (int -> int -> ('a, 'b, 'c) Bigarray.Array2.t) ->
       ('a, 'b, 'c) Bigarray.Array2.t ->
       [< `Compute_Schur_vectors | `No_Schur_vectors ] ->
       [< `No_sort
        | `Select_custom of 'd -> bool
        | `Select_exterior_disk
        | `Select_interior_disk
        | `Select_left_plane
        | `Select_right_plane ] ->
       int option ->
       int ->
       int ->
       ('e, 'f, 'g) Bigarray.Array2.t ->
       int ->
       int ->
       ('a, 'b, 'c) Bigarray.Array2.t option ->
       char * char * int * ('d -> bool) * int * ('a, 'b, 'c) Bigarray.Array2.t

val gees_get_params_real : string ->
       (int -> ('a, 'b, 'c) Bigarray.Array1.t) ->
       (int -> int -> ('d, 'e, 'f) Bigarray.Array2.t) ->
       ('d, 'e, 'f) Bigarray.Array2.t ->
       [< `Compute_Schur_vectors | `No_Schur_vectors ] ->
       [< `No_sort
        | `Select_custom of 'g -> bool
        | `Select_exterior_disk
        | `Select_interior_disk
        | `Select_left_plane
        | `Select_right_plane ] ->
       int option ->
       int ->
       int ->
       ('h, 'i, 'j) Bigarray.Array2.t ->
       ('a, 'b, 'c) Bigarray.Array1.t option ->
       ('a, 'b, 'c) Bigarray.Array1.t option ->
       int ->
       int ->
       ('d, 'e, 'f) Bigarray.Array2.t option ->
       char * char * int * ('g -> bool) * int * ('d, 'e, 'f) Bigarray.Array2.t *
       ('a, 'b, 'c) Bigarray.Array1.t * ('a, 'b, 'c) Bigarray.Array1.t

val gees_get_params_complex : string ->
       (int -> ('a, 'b, 'c) Bigarray.Array1.t) ->
       (int -> int -> ('d, 'e, 'f) Bigarray.Array2.t) ->
       ('d, 'e, 'f) Bigarray.Array2.t ->
       [< `Compute_Schur_vectors | `No_Schur_vectors ] ->
       [< `No_sort
        | `Select_custom of 'g -> bool
        | `Select_exterior_disk
        | `Select_interior_disk
        | `Select_left_plane
        | `Select_right_plane ] ->
       int option ->
       int ->
       int ->
       ('h, 'i, 'j) Bigarray.Array2.t ->
       ('a, 'b, 'c) Bigarray.Array1.t option ->
       int ->
       int ->
       ('d, 'e, 'f) Bigarray.Array2.t option ->
       char * char * int * ('g -> bool) * int * ('d, 'e, 'f) Bigarray.Array2.t *
       ('a, 'b, 'c) Bigarray.Array1.t

val gesvd_err : string ->
       char ->
       char ->
       int ->
       int ->
       ('a, 'b, 'c) Bigarray.Array2.t ->
       ('d, 'e, 'f) Bigarray.Array2.t ->
       ('g, 'h, 'i) Bigarray.Array2.t -> int -> int -> 'j

val gesvd_get_params : string ->
       (int -> ('a, 'b, 'c) Bigarray.Array1.t) ->
       (int -> int -> ('d, 'e, 'f) Bigarray.Array2.t) ->
       [< `A | `N | `O | `S ] ->
       [< `A | `N | `O | `S ] ->
       int option ->
       int option ->
       int ->
       int ->
       ('g, 'h, 'i) Bigarray.Array2.t ->
       ('a, 'b, 'c) Bigarray.Array1.t option ->
       int ->
       int ->
       ('d, 'e, 'f) Bigarray.Array2.t option ->
       int ->
       int ->
       ('d, 'e, 'f) Bigarray.Array2.t option ->
       char * char * int * int * ('a, 'b, 'c) Bigarray.Array1.t *
       ('d, 'e, 'f) Bigarray.Array2.t * ('d, 'e, 'f) Bigarray.Array2.t

val gesdd_err : string ->
       char ->
       int ->
       int ->
       ('a, 'b, 'c) Bigarray.Array2.t ->
       ('d, 'e, 'f) Bigarray.Array2.t ->
       ('g, 'h, 'i) Bigarray.Array2.t -> int -> int -> 'j

val gesdd_get_params : string ->
       (int -> ('a, 'b, 'c) Bigarray.Array1.t) ->
       (int -> int -> ('d, 'e, 'f) Bigarray.Array2.t) ->
       [< `A | `N | `O | `S ] ->
       int option ->
       int option ->
       int ->
       int ->
       ('g, 'h, 'i) Bigarray.Array2.t ->
       ('a, 'b, 'c) Bigarray.Array1.t option ->
       int ->
       int ->
       ('d, 'e, 'f) Bigarray.Array2.t option ->
       int ->
       int ->
       ('d, 'e, 'f) Bigarray.Array2.t option ->
       char * int * int * ('a, 'b, 'c) Bigarray.Array1.t *
       ('d, 'e, 'f) Bigarray.Array2.t * ('d, 'e, 'f) Bigarray.Array2.t

val xxsv_err : string -> int -> int -> ('a, 'b, 'c) Bigarray.Array2.t -> int -> 'd

val xxsv_lu_err : string -> int -> 'a

val xxsv_pos_err : string -> int -> 'a

val xxsv_ind_err : string -> int -> 'a

val xxsv_a_err : string -> ('a, 'b, 'c) Bigarray.Array2.t -> int -> 'd

val xxsv_work_err : string -> int -> 'a

val xxsv_get_ipiv : string ->
       (int32, Stdlib.Bigarray.int32_elt, Stdlib.Bigarray.fortran_layout)
       Bigarray.Array1.t option -> int -> Lacaml__common.int32_vec

val xxsv_get_params : string ->
       int ->
       int ->
       ('a, 'b, 'c) Bigarray.Array2.t ->
       int option ->
       int -> int -> ('d, 'e, 'f) Bigarray.Array2.t -> int option -> int * int