sig
  type prec = Bigarray.complex64_elt
  type num_type = Complex.t
  type ('indim, 'outdim, +'a) trans3 =
      ('indim, 'outdim, 'a) Slap_common.trans3
    constraint 'a = [< `C | `N | `T ]
  type ('n, 'cnt_or_dsc) vec =
      ('n, Slap_Z.num_type, Slap_Z.prec, 'cnt_or_dsc) Slap_vec.t
  type ('m, 'n, 'cnt_or_dsc) mat =
      ('m, 'n, Slap_Z.num_type, Slap_Z.prec, 'cnt_or_dsc) Slap_mat.t
  type rprec = Bigarray.float64_elt
  type ('n, 'cnt_or_dsc) rvec =
      ('n, float, Slap_Z.rprec, 'cnt_or_dsc) Slap_vec.t
  val prec : (Slap_Z.num_type, Slap_Z.prec) Bigarray.kind
  val rprec : (float, Slap_Z.rprec) Bigarray.kind
  module Vec :
    sig
      module type CNTVEC =
        sig type n val value : (Slap_Z.Vec.CNTVEC.n, 'cnt) Slap_Z.vec end
      module type DSCVEC =
        sig
          type n
          val value : (Slap_Z.Vec.DSCVEC.n, Slap_misc.dsc) Slap_Z.vec
        end
      val cnt : ('n, Slap_misc.cnt) Slap_Z.vec -> ('n, 'cnt) Slap_Z.vec
      val empty : (Slap_size.z, 'cnt) Slap_Z.vec
      val create : 'n Slap_size.t -> ('n, 'cnt) Slap_Z.vec
      val make : 'n Slap_size.t -> Slap_Z.num_type -> ('n, 'cnt) Slap_Z.vec
      val make0 : 'n Slap_size.t -> ('n, 'cnt) Slap_Z.vec
      val make1 : 'n Slap_size.t -> ('n, 'cnt) Slap_Z.vec
      val init :
        'n Slap_size.t -> (int -> Slap_Z.num_type) -> ('n, 'cnt) Slap_Z.vec
      val dim : ('n, 'cd) Slap_Z.vec -> 'n Slap_size.t
      val get_dyn : ('n, 'cd) Slap_Z.vec -> int -> Slap_Z.num_type
      val set_dyn : ('n, 'cd) Slap_Z.vec -> int -> Slap_Z.num_type -> unit
      val unsafe_get : ('n, 'cd) Slap_Z.vec -> int -> Slap_Z.num_type
      val unsafe_set : ('n, 'cd) Slap_Z.vec -> int -> Slap_Z.num_type -> unit
      val replace_dyn :
        ('n, 'cd) Slap_Z.vec ->
        int -> (Slap_Z.num_type -> Slap_Z.num_type) -> unit
      val cons :
        ?y:('n Slap_size.s, 'y_cd) Slap_Z.vec ->
        Slap_Z.num_type ->
        ('n, 'x_cd) Slap_Z.vec -> ('n Slap_size.s, 'y_cd) Slap_Z.vec
      val hd : ('n Slap_size.s, 'x_cd) Slap_Z.vec -> Slap_Z.num_type
      val hd_dyn : ('n, 'x_cd) Slap_Z.vec -> Slap_Z.num_type
      val last : ('n Slap_size.s, 'x_cd) Slap_Z.vec -> Slap_Z.num_type
      val last_dyn : ('n, 'x_cd) Slap_Z.vec -> Slap_Z.num_type
      val tl :
        ?y:('n, 'y_cd) Slap_Z.vec ->
        ('n Slap_size.s, 'x_cd) Slap_Z.vec -> ('n, 'x_cd) Slap_Z.vec
      val tl_dyn :
        ?y:('n Slap_size.p, 'y_cd) Slap_Z.vec ->
        ('n, 'x_cd) Slap_Z.vec -> ('n Slap_size.p, 'x_cd) Slap_Z.vec
      val inits :
        ?y:('n, 'y_cd) Slap_Z.vec ->
        ('n Slap_size.s, 'x_cd) Slap_Z.vec -> ('n, 'x_cd) Slap_Z.vec
      val inits_dyn :
        ?y:('n Slap_size.p, 'y_cd) Slap_Z.vec ->
        ('n, 'x_cd) Slap_Z.vec -> ('n Slap_size.p, 'x_cd) Slap_Z.vec
      val copy :
        ?y:('n, 'y_cd) Slap_Z.vec ->
        ('n, 'x_cd) Slap_Z.vec -> ('n, 'y_cd) Slap_Z.vec
      val fill : ('n, 'cd) Slap_Z.vec -> Slap_Z.num_type -> unit
      val append :
        ('m, 'x_cd) Slap_Z.vec ->
        ('n, 'y_cd) Slap_Z.vec -> (('m, 'n) Slap_size.add, 'cnt) Slap_Z.vec
      val shared_rev : ('n, 'cd) Slap_Z.vec -> ('n, 'cd) Slap_Z.vec
      val rev : ('n, 'cd) Slap_Z.vec -> ('n, 'cd) Slap_Z.vec
      val to_array : ('n, 'cd) Slap_Z.vec -> Slap_Z.num_type array
      val of_array_dyn :
        'n Slap_size.t -> Slap_Z.num_type array -> ('n, 'cnt) Slap_Z.vec
      val of_array : Slap_Z.num_type array -> (module Slap_Z.Vec.CNTVEC)
      module Of_array :
        functor (X : sig val value : Slap_Z.num_type array end) -> CNTVEC
      val unsafe_of_array :
        'n Slap_size.t -> Slap_Z.num_type array -> ('n, 'cnt) Slap_Z.vec
      val to_list : ('n, 'cd) Slap_Z.vec -> Slap_Z.num_type list
      val of_list_dyn :
        'n Slap_size.t -> Slap_Z.num_type list -> ('n, 'cnt) Slap_Z.vec
      val of_list : Slap_Z.num_type list -> (module Slap_Z.Vec.CNTVEC)
      module Of_list :
        functor (X : sig val value : Slap_Z.num_type list end) -> CNTVEC
      val unsafe_of_list :
        'n Slap_size.t -> Slap_Z.num_type list -> ('n, 'cnt) Slap_Z.vec
      val to_bigarray :
        ('n, 'cd) Slap_Z.vec ->
        (Slap_Z.num_type, Slap_Z.prec, Bigarray.fortran_layout)
        Bigarray.Array1.t
      val of_bigarray_dyn :
        ?share:bool ->
        'n Slap_size.t ->
        (Slap_Z.num_type, Slap_Z.prec, Bigarray.fortran_layout)
        Bigarray.Array1.t -> ('n, 'cnt) Slap_Z.vec
      val of_bigarray :
        ?share:bool ->
        (Slap_Z.num_type, Slap_Z.prec, Bigarray.fortran_layout)
        Bigarray.Array1.t -> (module Slap_Z.Vec.CNTVEC)
      module Of_bigarray :
        functor
          (X : sig
                 val share : bool
                 val value :
                   (Slap_Z.num_type, Slap_Z.prec, Bigarray.fortran_layout)
                   Bigarray.Array1.t
               end) ->
          CNTVEC
      val unsafe_of_bigarray :
        ?share:bool ->
        'n Slap_size.t ->
        (Slap_Z.num_type, Slap_Z.prec, Bigarray.fortran_layout)
        Bigarray.Array1.t -> ('n, 'cnt) Slap_Z.vec
      val of_array_c :
        Slap_Z.num_type array ->
        (Slap_Z.num_type, Slap_Z.prec, 'cnt) Slap_vec.dyn
      val of_list_c :
        Slap_Z.num_type list ->
        (Slap_Z.num_type, Slap_Z.prec, 'cnt) Slap_vec.dyn
      val of_bigarray_c :
        ?share:bool ->
        (Slap_Z.num_type, Slap_Z.prec, Bigarray.fortran_layout)
        Bigarray.Array1.t ->
        (Slap_Z.num_type, Slap_Z.prec, 'cnt) Slap_vec.dyn
      val map :
        (Slap_Z.num_type -> Slap_Z.num_type) ->
        ?y:('n, 'y_cd) Slap_Z.vec ->
        ('n, 'x_cd) Slap_Z.vec -> ('n, 'y_cd) Slap_Z.vec
      val mapi :
        (int -> Slap_Z.num_type -> Slap_Z.num_type) ->
        ?y:('n, 'y_cd) Slap_Z.vec ->
        ('n, 'x_cd) Slap_Z.vec -> ('n, 'y_cd) Slap_Z.vec
      val fold_left :
        ('accum -> Slap_Z.num_type -> 'accum) ->
        'accum -> ('n, 'cd) Slap_Z.vec -> 'accum
      val fold_lefti :
        (int -> 'accum -> Slap_Z.num_type -> 'accum) ->
        'accum -> ('n, 'cd) Slap_Z.vec -> 'accum
      val fold_right :
        (Slap_Z.num_type -> 'accum -> 'accum) ->
        ('n, 'cd) Slap_Z.vec -> 'accum -> 'accum
      val fold_righti :
        (int -> Slap_Z.num_type -> 'accum -> 'accum) ->
        ('n, 'cd) Slap_Z.vec -> 'accum -> 'accum
      val replace_all :
        ('n, 'cd) Slap_Z.vec -> (Slap_Z.num_type -> Slap_Z.num_type) -> unit
      val replace_alli :
        ('n, 'cd) Slap_Z.vec ->
        (int -> Slap_Z.num_type -> Slap_Z.num_type) -> unit
      val iter : (Slap_Z.num_type -> unit) -> ('n, 'cd) Slap_Z.vec -> unit
      val iteri :
        (int -> Slap_Z.num_type -> unit) -> ('n, 'cd) Slap_Z.vec -> unit
      val map2 :
        (Slap_Z.num_type -> Slap_Z.num_type -> Slap_Z.num_type) ->
        ?z:('n, 'z_cd) Slap_Z.vec ->
        ('n, 'x_cd) Slap_Z.vec ->
        ('n, 'y_cd) Slap_Z.vec -> ('n, 'z_cd) Slap_Z.vec
      val mapi2 :
        (int -> Slap_Z.num_type -> Slap_Z.num_type -> Slap_Z.num_type) ->
        ?z:('n, 'z_cd) Slap_Z.vec ->
        ('n, 'x_cd) Slap_Z.vec ->
        ('n, 'y_cd) Slap_Z.vec -> ('n, 'z_cd) Slap_Z.vec
      val fold_left2 :
        ('accum -> Slap_Z.num_type -> Slap_Z.num_type -> 'accum) ->
        'accum -> ('n, 'x_cd) Slap_Z.vec -> ('n, 'y_cd) Slap_Z.vec -> 'accum
      val fold_lefti2 :
        (int -> 'accum -> Slap_Z.num_type -> Slap_Z.num_type -> 'accum) ->
        'accum -> ('n, 'x_cd) Slap_Z.vec -> ('n, 'y_cd) Slap_Z.vec -> 'accum
      val fold_right2 :
        (Slap_Z.num_type -> Slap_Z.num_type -> 'accum -> 'accum) ->
        ('n, 'x_cd) Slap_Z.vec -> ('n, 'y_cd) Slap_Z.vec -> 'accum -> 'accum
      val fold_righti2 :
        (int -> Slap_Z.num_type -> Slap_Z.num_type -> 'accum -> 'accum) ->
        ('n, 'x_cd) Slap_Z.vec -> ('n, 'y_cd) Slap_Z.vec -> 'accum -> 'accum
      val iter2 :
        (Slap_Z.num_type -> Slap_Z.num_type -> unit) ->
        ('n, 'x_cd) Slap_Z.vec -> ('n, 'y_cd) Slap_Z.vec -> unit
      val iteri2 :
        (int -> Slap_Z.num_type -> Slap_Z.num_type -> unit) ->
        ('n, 'x_cd) Slap_Z.vec -> ('n, 'y_cd) Slap_Z.vec -> unit
      val map3 :
        (Slap_Z.num_type ->
         Slap_Z.num_type -> Slap_Z.num_type -> Slap_Z.num_type) ->
        ?w:('n, 'w_cd) Slap_Z.vec ->
        ('n, 'x_cd) Slap_Z.vec ->
        ('n, 'y_cd) Slap_Z.vec ->
        ('n, 'z_cd) Slap_Z.vec -> ('n, 'w_cd) Slap_Z.vec
      val mapi3 :
        (int ->
         Slap_Z.num_type ->
         Slap_Z.num_type -> Slap_Z.num_type -> Slap_Z.num_type) ->
        ?w:('n, 'w_cd) Slap_Z.vec ->
        ('n, 'x_cd) Slap_Z.vec ->
        ('n, 'y_cd) Slap_Z.vec ->
        ('n, 'z_cd) Slap_Z.vec -> ('n, 'w_cd) Slap_Z.vec
      val fold_left3 :
        ('accum ->
         Slap_Z.num_type -> Slap_Z.num_type -> Slap_Z.num_type -> 'accum) ->
        'accum ->
        ('n, 'x_cd) Slap_Z.vec ->
        ('n, 'y_cd) Slap_Z.vec -> ('n, 'z_cd) Slap_Z.vec -> 'accum
      val fold_lefti3 :
        (int ->
         'accum ->
         Slap_Z.num_type -> Slap_Z.num_type -> Slap_Z.num_type -> 'accum) ->
        'accum ->
        ('n, 'x_cd) Slap_Z.vec ->
        ('n, 'y_cd) Slap_Z.vec -> ('n, 'z_cd) Slap_Z.vec -> 'accum
      val fold_right3 :
        (Slap_Z.num_type ->
         Slap_Z.num_type -> Slap_Z.num_type -> 'accum -> 'accum) ->
        ('n, 'x_cd) Slap_Z.vec ->
        ('n, 'y_cd) Slap_Z.vec -> ('n, 'z_cd) Slap_Z.vec -> 'accum -> 'accum
      val fold_righti3 :
        (int ->
         Slap_Z.num_type ->
         Slap_Z.num_type -> Slap_Z.num_type -> 'accum -> 'accum) ->
        ('n, 'x_cd) Slap_Z.vec ->
        ('n, 'y_cd) Slap_Z.vec -> ('n, 'z_cd) Slap_Z.vec -> 'accum -> 'accum
      val iter3 :
        (Slap_Z.num_type -> Slap_Z.num_type -> Slap_Z.num_type -> unit) ->
        ('n, 'x_cd) Slap_Z.vec ->
        ('n, 'y_cd) Slap_Z.vec -> ('n, 'z_cd) Slap_Z.vec -> unit
      val iteri3 :
        (int -> Slap_Z.num_type -> Slap_Z.num_type -> Slap_Z.num_type -> unit) ->
        ('n, 'x_cd) Slap_Z.vec ->
        ('n, 'y_cd) Slap_Z.vec -> ('n, 'z_cd) Slap_Z.vec -> unit
      val for_all : (Slap_Z.num_type -> bool) -> ('n, 'cd) Slap_Z.vec -> bool
      val exists : (Slap_Z.num_type -> bool) -> ('n, 'cd) Slap_Z.vec -> bool
      val for_all2 :
        (Slap_Z.num_type -> Slap_Z.num_type -> bool) ->
        ('n, 'x_cd) Slap_Z.vec -> ('n, 'y_cd) Slap_Z.vec -> bool
      val exists2 :
        (Slap_Z.num_type -> Slap_Z.num_type -> bool) ->
        ('n, 'x_cd) Slap_Z.vec -> ('n, 'y_cd) Slap_Z.vec -> bool
      val max : ('n, 'cd) Slap_Z.vec -> Slap_Z.num_type
      val min : ('n, 'cd) Slap_Z.vec -> Slap_Z.num_type
      val sum : ('n, 'cd) Slap_Z.vec -> Slap_Z.num_type
      val prod : ('n, 'cd) Slap_Z.vec -> Slap_Z.num_type
      val add_const :
        Slap_Z.num_type ->
        ?y:('n, 'y_cd) Slap_Z.vec ->
        ('n, 'x_cd) Slap_Z.vec -> ('n, 'y_cd) Slap_Z.vec
      val sqr_nrm2 : ?stable:bool -> ('n, 'cd) Slap_Z.vec -> float
      val ssqr :
        ?c:Slap_Z.num_type -> ('n, 'cd) Slap_Z.vec -> Slap_Z.num_type
      val sort :
        ?cmp:(Slap_Z.num_type -> Slap_Z.num_type -> int) ->
        ?decr:bool ->
        ?p:('n, 'p_cd) Slap_common.int_vec -> ('n, 'x_cd) Slap_Z.vec -> unit
      val neg :
        ?y:('n, 'y_cd) Slap_Z.vec ->
        ('n, 'x_cd) Slap_Z.vec -> ('n, 'y_cd) Slap_Z.vec
      val reci :
        ?y:('n, 'y_cd) Slap_Z.vec ->
        ('n, 'x_cd) Slap_Z.vec -> ('n, 'y_cd) Slap_Z.vec
      val add :
        ?z:('n, 'z_cd) Slap_Z.vec ->
        ('n, 'x_cd) Slap_Z.vec ->
        ('n, 'y_cd) Slap_Z.vec -> ('n, 'z_cd) Slap_Z.vec
      val sub :
        ?z:('n, 'z_cd) Slap_Z.vec ->
        ('n, 'x_cd) Slap_Z.vec ->
        ('n, 'y_cd) Slap_Z.vec -> ('n, 'z_cd) Slap_Z.vec
      val mul :
        ?z:('n, 'z_cd) Slap_Z.vec ->
        ('n, 'x_cd) Slap_Z.vec ->
        ('n, 'y_cd) Slap_Z.vec -> ('n, 'z_cd) Slap_Z.vec
      val div :
        ?z:('n, 'z_cd) Slap_Z.vec ->
        ('n, 'x_cd) Slap_Z.vec ->
        ('n, 'y_cd) Slap_Z.vec -> ('n, 'z_cd) Slap_Z.vec
      val zpxy :
        ('n, 'z_cd) Slap_Z.vec ->
        ('n, 'x_cd) Slap_Z.vec ->
        ('n, 'y_cd) Slap_Z.vec -> ('n, 'z_cd) Slap_Z.vec
      val zmxy :
        ('n, 'z_cd) Slap_Z.vec ->
        ('n, 'x_cd) Slap_Z.vec ->
        ('n, 'y_cd) Slap_Z.vec -> ('n, 'z_cd) Slap_Z.vec
      val ssqr_diff :
        ('n, 'x_cd) Slap_Z.vec -> ('n, 'y_cd) Slap_Z.vec -> Slap_Z.num_type
      val subcntvec_dyn :
        'm Slap_size.t ->
        ?ofsx:int -> ('n, Slap_misc.cnt) Slap_Z.vec -> ('m, 'cnt) Slap_Z.vec
      val subdscvec_dyn :
        'm Slap_size.t ->
        ?ofsx:int ->
        ?incx:int -> ('n, 'cd) Slap_Z.vec -> ('m, Slap_misc.dsc) Slap_Z.vec
      val subvec_dyn :
        'm Slap_size.t ->
        ?ofsx:int ->
        ?incx:int -> ('n, 'cd) Slap_Z.vec -> ('m, Slap_misc.dsc) Slap_Z.vec
      val random :
        ?rnd_state:Random.State.t ->
        ?re_from:float ->
        ?re_range:float ->
        ?im_from:float ->
        ?im_range:float -> 'n Slap_size.t -> ('n, 'cnt) Slap_Z.vec
    end
  module Mat :
    sig
      module type CNTMAT =
        sig
          type m
          type n
          val value :
            (Slap_Z.Mat.CNTMAT.m, Slap_Z.Mat.CNTMAT.n, 'cnt) Slap_Z.mat
        end
      module type DSCMAT =
        sig
          type m
          type n
          val value :
            (Slap_Z.Mat.DSCMAT.m, Slap_Z.Mat.DSCMAT.n, Slap_misc.dsc)
            Slap_Z.mat
        end
      val cnt :
        ('m, 'n, Slap_misc.cnt) Slap_Z.mat -> ('m, 'n, 'cnt) Slap_Z.mat
      val empty : (Slap_size.z, Slap_size.z, 'cnt) Slap_Z.mat
      val create :
        'm Slap_size.t -> 'n Slap_size.t -> ('m, 'n, 'cnt) Slap_Z.mat
      val make :
        'm Slap_size.t ->
        'n Slap_size.t -> Slap_Z.num_type -> ('m, 'n, 'cnt) Slap_Z.mat
      val make0 :
        'm Slap_size.t -> 'n Slap_size.t -> ('m, 'n, 'cnt) Slap_Z.mat
      val make1 :
        'm Slap_size.t -> 'n Slap_size.t -> ('m, 'n, 'cnt) Slap_Z.mat
      val identity : 'n Slap_size.t -> ('n, 'n, 'cnt) Slap_Z.mat
      val init :
        'm Slap_size.t ->
        'n Slap_size.t ->
        (int -> int -> Slap_Z.num_type) -> ('m, 'n, 'cnt) Slap_Z.mat
      val init_cols :
        'm Slap_size.t ->
        'n Slap_size.t ->
        (int -> int -> Slap_Z.num_type) -> ('m, 'n, 'cnt) Slap_Z.mat
      val init_rows :
        'm Slap_size.t ->
        'n Slap_size.t ->
        (int -> int -> Slap_Z.num_type) -> ('m, 'n, 'cnt) Slap_Z.mat
      val dim : ('m, 'n, 'cd) Slap_Z.mat -> 'm Slap_size.t * 'n Slap_size.t
      val dim1 : ('m, 'n, 'cd) Slap_Z.mat -> 'm Slap_size.t
      val dim2 : ('m, 'n, 'cd) Slap_Z.mat -> 'n Slap_size.t
      val get_dyn : ('m, 'n, 'cd) Slap_Z.mat -> int -> int -> Slap_Z.num_type
      val set_dyn :
        ('m, 'n, 'cd) Slap_Z.mat -> int -> int -> Slap_Z.num_type -> unit
      val unsafe_get :
        ('m, 'n, 'cd) Slap_Z.mat -> int -> int -> Slap_Z.num_type
      val unsafe_set :
        ('m, 'n, 'cd) Slap_Z.mat -> int -> int -> Slap_Z.num_type -> unit
      val col_dyn : ('m, 'n, 'cd) Slap_Z.mat -> int -> ('m, 'cnt) Slap_Z.vec
      val row_dyn :
        ('m, 'n, 'cd) Slap_Z.mat -> int -> ('n, Slap_misc.dsc) Slap_Z.vec
      val copy_row_dyn :
        ('m, 'n, 'cd) Slap_Z.mat -> int -> ('n, 'cnt) Slap_Z.vec
      val diag : ('n, 'n, 'cd) Slap_Z.mat -> ('n, Slap_misc.dsc) Slap_Z.vec
      val diag_rect :
        ('m, 'n, 'cd) Slap_Z.mat ->
        (('m, 'n) Slap_size.min, Slap_misc.dsc) Slap_Z.vec
      val copy_diag : ('n, 'n, 'cd) Slap_Z.mat -> ('n, 'cnt) Slap_Z.vec
      val copy_diag_rect :
        ('m, 'n, 'cd) Slap_Z.mat -> (('m, 'n) Slap_size.min, 'cnt) Slap_Z.vec
      val as_vec :
        ('m, 'n, Slap_misc.cnt) Slap_Z.mat ->
        (('m, 'n) Slap_size.mul, 'cnt) Slap_Z.vec
      val fill : ('m, 'n, 'cd) Slap_Z.mat -> Slap_Z.num_type -> unit
      val copy :
        ?uplo:[ `L | `U ] ->
        ?b:('m, 'n, 'b_cd) Slap_Z.mat ->
        ('m, 'n, 'a_cd) Slap_Z.mat -> ('m, 'n, 'b_cd) Slap_Z.mat
      val of_col_vecs_dyn :
        'm Slap_size.t ->
        'n Slap_size.t ->
        ('m, Slap_misc.cnt) Slap_Z.vec array -> ('m, 'n, 'cnt) Slap_Z.mat
      val to_array : ('m, 'n, 'cd) Slap_Z.mat -> Slap_Z.num_type array array
      val of_array_dyn :
        'm Slap_size.t ->
        'n Slap_size.t ->
        Slap_Z.num_type array array -> ('m, 'n, 'cnt) Slap_Z.mat
      val of_array :
        Slap_Z.num_type array array -> (module Slap_Z.Mat.CNTMAT)
      module Of_array :
        functor (X : sig val value : Slap_Z.num_type array array end) ->
          CNTMAT
      val unsafe_of_array :
        'm Slap_size.t ->
        'n Slap_size.t ->
        Slap_Z.num_type array array -> ('m, 'n, 'cnt) Slap_Z.mat
      val to_list : ('m, 'n, 'cd) Slap_Z.mat -> Slap_Z.num_type list list
      val of_list_dyn :
        'm Slap_size.t ->
        'n Slap_size.t ->
        Slap_Z.num_type list list -> ('m, 'n, 'cnt) Slap_Z.mat
      val of_list : Slap_Z.num_type list list -> (module Slap_Z.Mat.CNTMAT)
      module Of_list :
        functor (X : sig val value : Slap_Z.num_type list list end) -> CNTMAT
      val unsafe_of_list :
        'm Slap_size.t ->
        'n Slap_size.t ->
        Slap_Z.num_type list list -> ('m, 'n, 'cnt) Slap_Z.mat
      val to_bigarray :
        ('m, 'n, 'cd) Slap_Z.mat ->
        (Slap_Z.num_type, Slap_Z.prec, Bigarray.fortran_layout)
        Bigarray.Array2.t
      val of_bigarray_dyn :
        ?share:bool ->
        'm Slap_size.t ->
        'n Slap_size.t ->
        (Slap_Z.num_type, Slap_Z.prec, Bigarray.fortran_layout)
        Bigarray.Array2.t -> ('m, 'n, 'cnt) Slap_Z.mat
      val of_bigarray :
        (Slap_Z.num_type, Slap_Z.prec, Bigarray.fortran_layout)
        Bigarray.Array2.t -> (module Slap_Z.Mat.CNTMAT)
      module Of_bigarray :
        functor
          (X : sig
                 val value :
                   (Slap_Z.num_type, Slap_Z.prec, Bigarray.fortran_layout)
                   Bigarray.Array2.t
               end) ->
          CNTMAT
      val unsafe_of_bigarray :
        ?share:bool ->
        'm Slap_size.t ->
        'n Slap_size.t ->
        (Slap_Z.num_type, Slap_Z.prec, Bigarray.fortran_layout)
        Bigarray.Array2.t -> ('m, 'n, 'cnt) Slap_Z.mat
      val of_array_c :
        Slap_Z.num_type array array ->
        (Slap_Z.num_type, Slap_Z.prec, 'cnt) Slap_mat.dyn
      val of_list_c :
        Slap_Z.num_type list list ->
        (Slap_Z.num_type, Slap_Z.prec, 'cnt) Slap_mat.dyn
      val of_bigarray_c :
        ?share:bool ->
        (Slap_Z.num_type, Slap_Z.prec, Bigarray.fortran_layout)
        Bigarray.Array2.t ->
        (Slap_Z.num_type, Slap_Z.prec, 'cnt) Slap_mat.dyn
      val map :
        (Slap_Z.num_type -> Slap_Z.num_type) ->
        ?b:('m, 'n, 'b_cd) Slap_Z.mat ->
        ('m, 'n, 'a_cd) Slap_Z.mat -> ('m, 'n, 'b_cd) Slap_Z.mat
      val mapi :
        (int -> int -> Slap_Z.num_type -> Slap_Z.num_type) ->
        ?b:('m, 'n, 'b_cd) Slap_Z.mat ->
        ('m, 'n, 'a_cd) Slap_Z.mat -> ('m, 'n, 'b_cd) Slap_Z.mat
      val fold_left :
        ('accum -> ('m, 'x_cd) Slap_Z.vec -> 'accum) ->
        'accum -> ('m, 'n, 'a_cd) Slap_Z.mat -> 'accum
      val fold_lefti :
        (int -> 'accum -> ('m, 'x_cd) Slap_Z.vec -> 'accum) ->
        'accum -> ('m, 'n, 'a_cd) Slap_Z.mat -> 'accum
      val fold_right :
        (('m, 'x_cd) Slap_Z.vec -> 'accum -> 'accum) ->
        ('m, 'n, 'a_cd) Slap_Z.mat -> 'accum -> 'accum
      val fold_righti :
        (int -> ('m, 'x_cd) Slap_Z.vec -> 'accum -> 'accum) ->
        ('m, 'n, 'a_cd) Slap_Z.mat -> 'accum -> 'accum
      val fold_top :
        ('accum -> ('n, Slap_misc.dsc) Slap_Z.vec -> 'accum) ->
        'accum -> ('m, 'n, 'a_cd) Slap_Z.mat -> 'accum
      val fold_topi :
        (int -> 'accum -> ('n, Slap_misc.dsc) Slap_Z.vec -> 'accum) ->
        'accum -> ('m, 'n, 'a_cd) Slap_Z.mat -> 'accum
      val fold_bottom :
        (('n, Slap_misc.dsc) Slap_Z.vec -> 'accum -> 'accum) ->
        ('m, 'n, 'a_cd) Slap_Z.mat -> 'accum -> 'accum
      val fold_bottomi :
        (int -> ('n, Slap_misc.dsc) Slap_Z.vec -> 'accum -> 'accum) ->
        ('m, 'n, 'a_cd) Slap_Z.mat -> 'accum -> 'accum
      val replace_all :
        ('m, 'n, 'cd) Slap_Z.mat ->
        (Slap_Z.num_type -> Slap_Z.num_type) -> unit
      val replace_alli :
        ('m, 'n, 'cd) Slap_Z.mat ->
        (int -> int -> Slap_Z.num_type -> Slap_Z.num_type) -> unit
      val transpose_copy :
        ?b:('n, 'm, 'b_cd) Slap_Z.mat ->
        ('m, 'n, 'a_cd) Slap_Z.mat -> ('n, 'm, 'b_cd) Slap_Z.mat
      val detri : ?up:bool -> ('n, 'n, 'cd) Slap_Z.mat -> unit
      val packed :
        ?up:bool ->
        ?x:('n Slap_size.packed, Slap_misc.cnt) Slap_Z.vec ->
        ('n, 'n, 'cd) Slap_Z.mat -> ('n Slap_size.packed, 'cnt) Slap_Z.vec
      val unpacked :
        ?up:bool ->
        ?fill_num:Slap_Z.num_type option ->
        ?a:('n, 'n, 'cd) Slap_Z.mat ->
        ('n Slap_size.packed, Slap_misc.cnt) Slap_Z.vec ->
        ('n, 'n, 'cd) Slap_Z.mat
      val geband_dyn :
        'kl Slap_size.t ->
        'ku Slap_size.t ->
        ?b:(('m, 'n, 'kl, 'ku) Slap_size.geband, 'n, 'b_cd) Slap_Z.mat ->
        ('m, 'n, 'a_cd) Slap_Z.mat ->
        (('m, 'n, 'kl, 'ku) Slap_size.geband, 'n, 'b_cd) Slap_Z.mat
      val ungeband :
        'm Slap_size.t ->
        'kl Slap_size.t ->
        'ku Slap_size.t ->
        ?fill_num:Slap_Z.num_type option ->
        ?a:('m, 'n, 'a_cd) Slap_Z.mat ->
        (('m, 'n, 'kl, 'ku) Slap_size.geband, 'n, 'b_cd) Slap_Z.mat ->
        ('m, 'n, 'a_cd) Slap_Z.mat
      val syband_dyn :
        'kd Slap_size.t ->
        ?up:bool ->
        ?b:(('n, 'kd) Slap_size.syband, 'n, 'b_cd) Slap_Z.mat ->
        ('n, 'n, 'a_cd) Slap_Z.mat ->
        (('n, 'kd) Slap_size.syband, 'n, 'b_cd) Slap_Z.mat
      val unsyband :
        'kd Slap_size.t ->
        ?up:bool ->
        ?fill_num:Slap_Z.num_type option ->
        ?a:('n, 'n, 'a_cd) Slap_Z.mat ->
        (('n, 'kd) Slap_size.syband, 'n, 'b_cd) Slap_Z.mat ->
        ('n, 'n, 'a_cd) Slap_Z.mat
      val luband_dyn :
        'kl Slap_size.t ->
        'ku Slap_size.t ->
        ?ab:(('m, 'n, 'kl, 'ku) Slap_size.luband, 'n, 'b_cd) Slap_Z.mat ->
        ('m, 'n, 'a_cd) Slap_Z.mat ->
        (('m, 'n, 'kl, 'ku) Slap_size.luband, 'n, 'b_cd) Slap_Z.mat
      val unluband :
        'm Slap_size.t ->
        'kl Slap_size.t ->
        'ku Slap_size.t ->
        ?fill_num:Slap_Z.num_type option ->
        ?a:('m, 'n, 'a_cd) Slap_Z.mat ->
        (('m, 'n, 'kl, 'ku) Slap_size.luband, 'n, 'b_cd) Slap_Z.mat ->
        ('m, 'n, 'a_cd) Slap_Z.mat
      val add_const :
        Slap_Z.num_type ->
        ?b:('m, 'n, 'b_cd) Slap_Z.mat ->
        ('m, 'n, 'a_cd) Slap_Z.mat -> ('m, 'n, 'b_cd) Slap_Z.mat
      val sum : ('m, 'n, 'cd) Slap_Z.mat -> Slap_Z.num_type
      val trace : ('m, 'n, 'cd) Slap_Z.mat -> Slap_Z.num_type
      val scal : Slap_Z.num_type -> ('m, 'n, 'cd) Slap_Z.mat -> unit
      val scal_cols :
        ('m, 'n, 'cd) Slap_Z.mat -> ('n, Slap_misc.cnt) Slap_Z.vec -> unit
      val scal_rows :
        ('m, Slap_misc.cnt) Slap_Z.vec -> ('m, 'n, 'cd) Slap_Z.mat -> unit
      val axpy :
        ?alpha:Slap_Z.num_type ->
        ('m, 'n, 'x_cd) Slap_Z.mat -> ('m, 'n, 'y_cd) Slap_Z.mat -> unit
      val gemm_diag :
        ?beta:Slap_Z.num_type ->
        ?y:('n, Slap_misc.cnt) Slap_Z.vec ->
        transa:('a_n * 'a_k, 'n * 'k, [< `C | `N | `T ]) Slap_Z.trans3 ->
        ?alpha:Slap_Z.num_type ->
        ('a_n, 'a_k, 'a_cd) Slap_Z.mat ->
        transb:('b_k * 'b_n, 'k * 'n, [< `C | `N | `T ]) Slap_Z.trans3 ->
        ('b_k, 'b_n, 'b_cd) Slap_Z.mat -> ('n, 'cnt) Slap_Z.vec
      val syrk_diag :
        ?beta:Slap_Z.num_type ->
        ?y:('n, Slap_misc.cnt) Slap_Z.vec ->
        trans:('a_n * 'a_k, 'n * 'k, [< `N | `T ]) Slap_common.trans2 ->
        ?alpha:Slap_Z.num_type ->
        ('a_n, 'a_k, 'a_cd) Slap_Z.mat -> ('n, 'cnt) Slap_Z.vec
      val gemm_trace :
        transa:('a_n * 'a_k, 'n * 'k, [< `C | `N | `T ]) Slap_Z.trans3 ->
        ('a_n, 'a_k, 'a_cd) Slap_Z.mat ->
        transb:('b_k * 'b_n, 'k * 'n, [< `C | `N | `T ]) Slap_Z.trans3 ->
        ('b_k, 'b_n, 'b_cd) Slap_Z.mat -> Slap_Z.num_type
      val syrk_trace : ('n, 'k, 'cd) Slap_Z.mat -> Slap_Z.num_type
      val symm2_trace :
        ?upa:bool ->
        ('n, 'n, 'a_cd) Slap_Z.mat ->
        ?upb:bool -> ('n, 'n, 'b_cd) Slap_Z.mat -> Slap_Z.num_type
      val submat_dyn :
        'm Slap_size.t ->
        'n Slap_size.t ->
        ?ar:int ->
        ?ac:int ->
        ('a, 'b, 'cd) Slap_Z.mat -> ('m, 'n, Slap_misc.dsc) Slap_Z.mat
      val random :
        ?rnd_state:Random.State.t ->
        ?re_from:float ->
        ?re_range:float ->
        ?im_from:float ->
        ?im_range:float ->
        'm Slap_size.t -> 'n Slap_size.t -> ('m, 'n, 'cnt) Slap_Z.mat
    end
  val pp_num : Format.formatter -> Slap_Z.num_type -> unit
  val pp_vec : Format.formatter -> ('n, 'cnt_or_dsc) Slap_Z.vec -> unit
  val pp_mat : Format.formatter -> ('m, 'n, 'cnt_or_dsc) Slap_Z.mat -> unit
  val swap : ('n, 'x_cd) Slap_Z.vec -> ('n, 'y_cd) Slap_Z.vec -> unit
  val scal : Slap_Z.num_type -> ('n, 'cd) Slap_Z.vec -> unit
  val copy :
    ?y:('n, 'y_cd) Slap_Z.vec ->
    ('n, 'x_cd) Slap_Z.vec -> ('n, 'y_cd) Slap_Z.vec
  val nrm2 : ('n, 'cd) Slap_Z.vec -> float
  val axpy :
    ?alpha:Slap_Z.num_type ->
    ('n, 'x_cd) Slap_Z.vec -> ('n, 'y_cd) Slap_Z.vec -> unit
  val iamax : ('n, 'cd) Slap_Z.vec -> int
  val amax : ('n, 'cd) Slap_Z.vec -> Slap_Z.num_type
  val gemv :
    ?beta:Slap_Z.num_type ->
    ?y:('m, 'y_cd) Slap_Z.vec ->
    trans:('a_m * 'a_n, 'm * 'n, [< `C | `N | `T ]) Slap_Z.trans3 ->
    ?alpha:Slap_Z.num_type ->
    ('a_m, 'a_n, 'a_cd) Slap_Z.mat ->
    ('n, 'x_cd) Slap_Z.vec -> ('m, 'y_cd) Slap_Z.vec
  val gbmv :
    m:'a_m Slap_size.t ->
    ?beta:Slap_Z.num_type ->
    ?y:('m, 'y_cd) Slap_Z.vec ->
    trans:('a_m * 'a_n, 'm * 'n, [< `C | `N | `T ]) Slap_Z.trans3 ->
    ?alpha:Slap_Z.num_type ->
    (('a_m, 'a_n, 'kl, 'ku) Slap_size.geband, 'a_n, 'a_cd) Slap_Z.mat ->
    'kl Slap_size.t ->
    'ku Slap_size.t -> ('n, 'x_cd) Slap_Z.vec -> ('m, 'y_cd) Slap_Z.vec
  val symv :
    ?beta:Slap_Z.num_type ->
    ?y:('n, 'y_cd) Slap_Z.vec ->
    ?up:[< `L | `U ] Slap_common.uplo ->
    ?alpha:Slap_Z.num_type ->
    ('n, 'n, 'a_cd) Slap_Z.mat ->
    ('n, 'x_cd) Slap_Z.vec -> ('n, 'y_cd) Slap_Z.vec
  val trmv :
    trans:('n * 'n, 'n * 'n, [< `C | `N | `T ]) Slap_Z.trans3 ->
    ?diag:Slap_common.diag ->
    ?up:[< `L | `U ] Slap_common.uplo ->
    ('n, 'n, 'a_cd) Slap_Z.mat -> ('n, 'x_cd) Slap_Z.vec -> unit
  val trsv :
    trans:('n * 'n, 'n * 'n, [< `C | `N | `T ]) Slap_Z.trans3 ->
    ?diag:Slap_common.diag ->
    ?up:[< `L | `U ] Slap_common.uplo ->
    ('n, 'n, 'a_cd) Slap_Z.mat -> ('n, 'b_cd) Slap_Z.vec -> unit
  val tpmv :
    trans:('n * 'n, 'n * 'n, [< `C | `N | `T ]) Slap_Z.trans3 ->
    ?diag:Slap_common.diag ->
    ?up:[< `L | `U ] Slap_common.uplo ->
    ('n Slap_size.packed, Slap_misc.cnt) Slap_Z.vec ->
    ('n, 'x_cd) Slap_Z.vec -> unit
  val tpsv :
    trans:('n * 'n, 'n * 'n, [< `C | `N | `T ]) Slap_Z.trans3 ->
    ?diag:Slap_common.diag ->
    ?up:[< `L | `U ] Slap_common.uplo ->
    ('n Slap_size.packed, Slap_misc.cnt) Slap_Z.vec ->
    ('n, 'x_cd) Slap_Z.vec -> unit
  val gemm :
    ?beta:Slap_Z.num_type ->
    ?c:('m, 'n, 'c_cd) Slap_Z.mat ->
    transa:('a_m * 'a_k, 'm * 'k, [< `C | `N | `T ]) Slap_Z.trans3 ->
    ?alpha:Slap_Z.num_type ->
    ('a_m, 'a_k, 'a_cd) Slap_Z.mat ->
    transb:('b_k * 'b_n, 'k * 'n, [< `C | `N | `T ]) Slap_Z.trans3 ->
    ('b_k, 'b_n, 'b_cd) Slap_Z.mat -> ('m, 'n, 'c_cd) Slap_Z.mat
  val symm :
    side:('k, 'm, 'n) Slap_common.side ->
    ?up:[< `L | `U ] Slap_common.uplo ->
    ?beta:Slap_Z.num_type ->
    ?c:('m, 'n, 'c_cd) Slap_Z.mat ->
    ?alpha:Slap_Z.num_type ->
    ('k, 'k, 'a_cd) Slap_Z.mat ->
    ('m, 'n, 'b_cd) Slap_Z.mat -> ('m, 'n, 'c_cd) Slap_Z.mat
  val trmm :
    side:('k, 'm, 'n) Slap_common.side ->
    ?up:[< `L | `U ] Slap_common.uplo ->
    transa:('k * 'k, 'k * 'k, [< `C | `N | `T ]) Slap_Z.trans3 ->
    ?diag:Slap_common.diag ->
    ?alpha:Slap_Z.num_type ->
    a:('k, 'k, 'a_cd) Slap_Z.mat -> ('m, 'n, 'b_cd) Slap_Z.mat -> unit
  val trsm :
    side:('k, 'm, 'n) Slap_common.side ->
    ?up:[< `L | `U ] Slap_common.uplo ->
    transa:('k * 'k, 'k * 'k, [< `C | `N | `T ]) Slap_Z.trans3 ->
    ?diag:Slap_common.diag ->
    ?alpha:Slap_Z.num_type ->
    a:('k, 'k, 'a_cd) Slap_Z.mat -> ('m, 'n, 'b_cd) Slap_Z.mat -> unit
  val syrk :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ?beta:Slap_Z.num_type ->
    ?c:('n, 'n, 'c_cd) Slap_Z.mat ->
    trans:('a_n * 'a_k, 'n * 'k, [< `N | `T ]) Slap_common.trans2 ->
    ?alpha:Slap_Z.num_type ->
    ('a_n, 'a_k, 'a_cd) Slap_Z.mat -> ('n, 'n, 'c_cd) Slap_Z.mat
  val syr2k :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ?beta:Slap_Z.num_type ->
    ?c:('n, 'n, 'c_cd) Slap_Z.mat ->
    trans:('p * 'q, 'n * 'k, [< `N | `T ]) Slap_common.trans2 ->
    ?alpha:Slap_Z.num_type ->
    ('p, 'q, 'a_cd) Slap_Z.mat ->
    ('p, 'q, 'b_cd) Slap_Z.mat -> ('n, 'n, 'c_cd) Slap_Z.mat
  val lacpy :
    ?uplo:[< `A | `L | `U ] Slap_common.uplo ->
    ?b:('m, 'n, 'b_cd) Slap_Z.mat ->
    ('m, 'n, 'a_cd) Slap_Z.mat -> ('m, 'n, 'b_cd) Slap_Z.mat
  val lassq :
    ?scale:float -> ?sumsq:float -> ('n, 'cd) Slap_Z.vec -> float * float
  type larnv_liseed = Slap_size.four
  val larnv :
    ?idist:[ `Normal | `Uniform0 | `Uniform1 ] ->
    ?iseed:(Slap_Z.larnv_liseed, Slap_misc.cnt) Slap_common.int32_vec ->
    x:('n, Slap_misc.cnt) Slap_Z.vec -> unit -> ('n, 'cnt) Slap_Z.vec
  type ('m, 'a) lange_min_lwork
  val lange_min_lwork :
    'm Slap_size.t ->
    ([< `F | `I | `M | `O ] as 'a) Slap_common.norm4 ->
    ('m, 'a) Slap_Z.lange_min_lwork Slap_size.t
  val lange :
    ?norm:[< `F | `I | `M | `O ] Slap_common.norm4 ->
    ?work:('lwork, Slap_misc.cnt) Slap_Z.rvec ->
    ('m, 'n, 'cd) Slap_Z.mat -> float
  val lauum :
    ?up:[< `L | `U ] Slap_common.uplo -> ('n, 'n, 'cd) Slap_Z.mat -> unit
  val getrf :
    ?ipiv:(('m, 'n) Slap_size.min, Slap_misc.cnt) Slap_common.int32_vec ->
    ('m, 'n, 'cd) Slap_Z.mat ->
    (('m, 'n) Slap_size.min, 'cnt) Slap_common.int32_vec
  val getrs :
    ?ipiv:(('n, 'n) Slap_size.min, Slap_misc.cnt) Slap_common.int32_vec ->
    trans:('n * 'n, 'n * 'n, [< `C | `N | `T ]) Slap_Z.trans3 ->
    ('n, 'n, 'a_cd) Slap_Z.mat -> ('n, 'n, 'b_cd) Slap_Z.mat -> unit
  type 'n getri_min_lwork
  val getri_min_lwork :
    'n Slap_size.t -> 'n Slap_Z.getri_min_lwork Slap_size.t
  val getri_opt_lwork : ('n, 'n, 'cd) Slap_Z.mat -> (module Slap_size.SIZE)
  val getri :
    ?ipiv:(('n, 'n) Slap_size.min, Slap_misc.cnt) Slap_common.int32_vec ->
    ?work:('lwork, Slap_misc.cnt) Slap_Z.vec ->
    ('n, 'n, 'cd) Slap_Z.mat -> unit
  type sytrf_min_lwork
  val sytrf_min_lwork : unit -> Slap_Z.sytrf_min_lwork Slap_size.t
  val sytrf_opt_lwork :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ('n, 'n, 'cd) Slap_Z.mat -> (module Slap_size.SIZE)
  val sytrf :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ?ipiv:('n, Slap_misc.cnt) Slap_common.int32_vec ->
    ?work:('lwork, Slap_misc.cnt) Slap_Z.vec ->
    ('n, 'n, 'cd) Slap_Z.mat -> ('n, 'cnt) Slap_common.int32_vec
  val sytrs :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ?ipiv:('n, Slap_misc.cnt) Slap_common.int32_vec ->
    ('n, 'n, 'a_cd) Slap_Z.mat -> ('n, 'nrhs, 'b_cd) Slap_Z.mat -> unit
  type 'n sytri_min_lwork
  val sytri_min_lwork :
    'n Slap_size.t -> 'n Slap_Z.sytri_min_lwork Slap_size.t
  val sytri :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ?ipiv:('n, Slap_misc.cnt) Slap_common.int32_vec ->
    ?work:('lwork, Slap_misc.cnt) Slap_Z.vec ->
    ('n, 'n, 'cd) Slap_Z.mat -> unit
  val potrf :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ?jitter:Slap_Z.num_type -> ('n, 'n, 'cd) Slap_Z.mat -> unit
  val potrs :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ('n, 'n, 'a_cd) Slap_Z.mat ->
    ?factorize:bool ->
    ?jitter:Slap_Z.num_type -> ('n, 'nrhs, 'b_cd) Slap_Z.mat -> unit
  val potri :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ?factorize:bool ->
    ?jitter:Slap_Z.num_type -> ('n, 'n, 'cd) Slap_Z.mat -> unit
  val trtrs :
    ?up:[< `L | `U ] Slap_common.uplo ->
    trans:('n * 'n, 'n * 'n, [< `C | `N | `T ]) Slap_Z.trans3 ->
    ?diag:Slap_common.diag ->
    ('n, 'n, 'a_cd) Slap_Z.mat -> ('n, 'nrhs, 'b_cd) Slap_Z.mat -> unit
  val tbtrs :
    kd:'kd Slap_size.t ->
    ?up:[< `L | `U ] Slap_common.uplo ->
    trans:('n * 'n, 'n * 'n, [< `C | `N | `T ]) Slap_Z.trans3 ->
    ?diag:Slap_common.diag ->
    (('n, 'kd) Slap_size.syband, 'n, 'a_cd) Slap_Z.mat ->
    ('n, 'nrhs, 'b_cd) Slap_Z.mat -> unit
  val trtri :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ?diag:Slap_common.diag -> ('n, 'n, 'cd) Slap_Z.mat -> unit
  type 'n geqrf_min_lwork
  val geqrf_min_lwork :
    n:'n Slap_size.t -> 'n Slap_Z.geqrf_min_lwork Slap_size.t
  val geqrf_opt_lwork : ('m, 'n, 'cd) Slap_Z.mat -> (module Slap_size.SIZE)
  val geqrf :
    ?work:('lwork, Slap_misc.cnt) Slap_Z.vec ->
    ?tau:(('m, 'n) Slap_size.min, Slap_misc.cnt) Slap_Z.vec ->
    ('m, 'n, 'cd) Slap_Z.mat -> (('m, 'n) Slap_size.min, 'cnt) Slap_Z.vec
  val gesv :
    ?ipiv:('n, Slap_misc.cnt) Slap_common.int32_vec ->
    ('n, 'n, 'a_cd) Slap_Z.mat -> ('n, 'nrhs, 'b_cd) Slap_Z.mat -> unit
  val gbsv :
    ?ipiv:('n, Slap_misc.cnt) Slap_common.int32_vec ->
    (('n, 'n, 'kl, 'ku) Slap_size.luband, 'n, 'a_cd) Slap_Z.mat ->
    'kl Slap_size.t ->
    'ku Slap_size.t -> ('n, 'nrhs, 'b_cd) Slap_Z.mat -> unit
  val posv :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ('n, 'n, 'a_cd) Slap_Z.mat -> ('n, 'nrhs, 'b_cd) Slap_Z.mat -> unit
  val ppsv :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ('n Slap_size.packed, Slap_misc.cnt) Slap_Z.vec ->
    ('n, 'nrhs, 'b_cd) Slap_Z.mat -> unit
  val pbsv :
    ?up:[< `L | `U ] Slap_common.uplo ->
    kd:'kd Slap_size.t ->
    (('n, 'kd) Slap_size.syband, 'n, 'ab_cd) Slap_Z.mat ->
    ('n, 'nrhs, 'b_cd) Slap_Z.mat -> unit
  val ptsv :
    ('n, Slap_misc.cnt) Slap_Z.vec ->
    ('n Slap_size.p, Slap_misc.cnt) Slap_Z.vec ->
    ('n, 'nrhs, 'b_cd) Slap_Z.mat -> unit
  type sysv_min_lwork
  val sysv_min_lwork : unit -> Slap_Z.sysv_min_lwork Slap_size.t
  val sysv_opt_lwork :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ('n, 'n, 'a_cd) Slap_Z.mat ->
    ('n, 'nrhs, 'b_cd) Slap_Z.mat -> (module Slap_size.SIZE)
  val sysv :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ?ipiv:('n, Slap_misc.cnt) Slap_common.int32_vec ->
    ?work:('lwork, Slap_misc.cnt) Slap_Z.vec ->
    ('n, 'n, 'a_cd) Slap_Z.mat -> ('n, 'nrhs, 'b_cd) Slap_Z.mat -> unit
  val spsv :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ?ipiv:('n, Slap_misc.cnt) Slap_common.int32_vec ->
    ('n Slap_size.packed, Slap_misc.cnt) Slap_Z.vec ->
    ('n, 'nrhs, 'b_cd) Slap_Z.mat -> unit
  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) Slap_Z.gels_min_lwork Slap_size.t
  val gels_opt_lwork :
    trans:('am * 'an, 'm * 'n, [< `N | `T ]) Slap_common.trans2 ->
    ('am, 'an, 'a_cd) Slap_Z.mat ->
    ('m, 'nrhs, 'b_cd) Slap_Z.mat -> (module Slap_size.SIZE)
  val gels :
    ?work:('work, Slap_misc.cnt) Slap_Z.vec ->
    trans:('am * 'an, 'm * 'n, [< `N | `T ]) Slap_common.trans2 ->
    ('am, 'an, 'a_cd) Slap_Z.mat -> ('m, 'nrhs, 'b_cd) Slap_Z.mat -> unit
  val dotu :
    ('n, 'x_cd) Slap_Z.vec -> ('n, 'y_cd) Slap_Z.vec -> Slap_Z.num_type
  val dotc :
    ('n, 'x_cd) Slap_Z.vec -> ('n, 'y_cd) Slap_Z.vec -> Slap_Z.num_type
end