sig
  type prec = Bigarray.float64_elt
  type num_type = float
  type ('indim, 'outdim, +'a) trans3 =
      ('indim, 'outdim, 'a) Slap_common.trans2
    constraint 'a = [< `N | `T ]
  type ('n, 'cnt_or_dsc) vec =
      ('n, Slap_D.num_type, Slap_D.prec, 'cnt_or_dsc) Slap_vec.t
  type ('m, 'n, 'cnt_or_dsc) mat =
      ('m, 'n, Slap_D.num_type, Slap_D.prec, 'cnt_or_dsc) Slap_mat.t
  type rprec = Bigarray.float64_elt
  type ('n, 'cnt_or_dsc) rvec =
      ('n, float, Slap_D.rprec, 'cnt_or_dsc) Slap_vec.t
  val prec : (Slap_D.num_type, Slap_D.prec) Bigarray.kind
  val rprec : (float, Slap_D.rprec) Bigarray.kind
  module Vec :
    sig
      module type CNTVEC =
        sig type n val value : (Slap_D.Vec.CNTVEC.n, 'cnt) Slap_D.vec end
      module type DSCVEC =
        sig
          type n
          val value : (Slap_D.Vec.DSCVEC.n, Slap_misc.dsc) Slap_D.vec
        end
      val cnt : ('n, Slap_misc.cnt) Slap_D.vec -> ('n, 'cnt) Slap_D.vec
      val empty : (Slap_size.z, 'cnt) Slap_D.vec
      val create : 'n Slap_size.t -> ('n, 'cnt) Slap_D.vec
      val make : 'n Slap_size.t -> Slap_D.num_type -> ('n, 'cnt) Slap_D.vec
      val make0 : 'n Slap_size.t -> ('n, 'cnt) Slap_D.vec
      val make1 : 'n Slap_size.t -> ('n, 'cnt) Slap_D.vec
      val init :
        'n Slap_size.t -> (int -> Slap_D.num_type) -> ('n, 'cnt) Slap_D.vec
      val dim : ('n, 'cd) Slap_D.vec -> 'n Slap_size.t
      val get_dyn : ('n, 'cd) Slap_D.vec -> int -> Slap_D.num_type
      val set_dyn : ('n, 'cd) Slap_D.vec -> int -> Slap_D.num_type -> unit
      val unsafe_get : ('n, 'cd) Slap_D.vec -> int -> Slap_D.num_type
      val unsafe_set : ('n, 'cd) Slap_D.vec -> int -> Slap_D.num_type -> unit
      val replace_dyn :
        ('n, 'cd) Slap_D.vec ->
        int -> (Slap_D.num_type -> Slap_D.num_type) -> unit
      val cons :
        ?y:('n Slap_size.s, 'y_cd) Slap_D.vec ->
        Slap_D.num_type ->
        ('n, 'x_cd) Slap_D.vec -> ('n Slap_size.s, 'y_cd) Slap_D.vec
      val hd : ('n Slap_size.s, 'x_cd) Slap_D.vec -> Slap_D.num_type
      val hd_dyn : ('n, 'x_cd) Slap_D.vec -> Slap_D.num_type
      val last : ('n Slap_size.s, 'x_cd) Slap_D.vec -> Slap_D.num_type
      val last_dyn : ('n, 'x_cd) Slap_D.vec -> Slap_D.num_type
      val tl :
        ?y:('n, 'y_cd) Slap_D.vec ->
        ('n Slap_size.s, 'x_cd) Slap_D.vec -> ('n, 'x_cd) Slap_D.vec
      val tl_dyn :
        ?y:('n Slap_size.p, 'y_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec -> ('n Slap_size.p, 'x_cd) Slap_D.vec
      val inits :
        ?y:('n, 'y_cd) Slap_D.vec ->
        ('n Slap_size.s, 'x_cd) Slap_D.vec -> ('n, 'x_cd) Slap_D.vec
      val inits_dyn :
        ?y:('n Slap_size.p, 'y_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec -> ('n Slap_size.p, 'x_cd) Slap_D.vec
      val copy :
        ?y:('n, 'y_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec
      val fill : ('n, 'cd) Slap_D.vec -> Slap_D.num_type -> unit
      val append :
        ('m, 'x_cd) Slap_D.vec ->
        ('n, 'y_cd) Slap_D.vec -> (('m, 'n) Slap_size.add, 'cnt) Slap_D.vec
      val shared_rev : ('n, 'cd) Slap_D.vec -> ('n, 'cd) Slap_D.vec
      val rev : ('n, 'cd) Slap_D.vec -> ('n, 'cd) Slap_D.vec
      val to_array : ('n, 'cd) Slap_D.vec -> Slap_D.num_type array
      val of_array_dyn :
        'n Slap_size.t -> Slap_D.num_type array -> ('n, 'cnt) Slap_D.vec
      val of_array : Slap_D.num_type array -> (module Slap_D.Vec.CNTVEC)
      module Of_array :
        functor (X : sig val value : Slap_D.num_type array end) -> CNTVEC
      val unsafe_of_array :
        'n Slap_size.t -> Slap_D.num_type array -> ('n, 'cnt) Slap_D.vec
      val to_list : ('n, 'cd) Slap_D.vec -> Slap_D.num_type list
      val of_list_dyn :
        'n Slap_size.t -> Slap_D.num_type list -> ('n, 'cnt) Slap_D.vec
      val of_list : Slap_D.num_type list -> (module Slap_D.Vec.CNTVEC)
      module Of_list :
        functor (X : sig val value : Slap_D.num_type list end) -> CNTVEC
      val unsafe_of_list :
        'n Slap_size.t -> Slap_D.num_type list -> ('n, 'cnt) Slap_D.vec
      val to_bigarray :
        ('n, 'cd) Slap_D.vec ->
        (Slap_D.num_type, Slap_D.prec, Bigarray.fortran_layout)
        Bigarray.Array1.t
      val of_bigarray_dyn :
        ?share:bool ->
        'n Slap_size.t ->
        (Slap_D.num_type, Slap_D.prec, Bigarray.fortran_layout)
        Bigarray.Array1.t -> ('n, 'cnt) Slap_D.vec
      val of_bigarray :
        ?share:bool ->
        (Slap_D.num_type, Slap_D.prec, Bigarray.fortran_layout)
        Bigarray.Array1.t -> (module Slap_D.Vec.CNTVEC)
      module Of_bigarray :
        functor
          (X : sig
                 val share : bool
                 val value :
                   (Slap_D.num_type, Slap_D.prec, Bigarray.fortran_layout)
                   Bigarray.Array1.t
               end) ->
          CNTVEC
      val unsafe_of_bigarray :
        ?share:bool ->
        'n Slap_size.t ->
        (Slap_D.num_type, Slap_D.prec, Bigarray.fortran_layout)
        Bigarray.Array1.t -> ('n, 'cnt) Slap_D.vec
      val of_array_c :
        Slap_D.num_type array ->
        (Slap_D.num_type, Slap_D.prec, 'cnt) Slap_vec.dyn
      val of_list_c :
        Slap_D.num_type list ->
        (Slap_D.num_type, Slap_D.prec, 'cnt) Slap_vec.dyn
      val of_bigarray_c :
        ?share:bool ->
        (Slap_D.num_type, Slap_D.prec, Bigarray.fortran_layout)
        Bigarray.Array1.t ->
        (Slap_D.num_type, Slap_D.prec, 'cnt) Slap_vec.dyn
      val map :
        (Slap_D.num_type -> Slap_D.num_type) ->
        ?y:('n, 'y_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec
      val mapi :
        (int -> Slap_D.num_type -> Slap_D.num_type) ->
        ?y:('n, 'y_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec
      val fold_left :
        ('accum -> Slap_D.num_type -> 'accum) ->
        'accum -> ('n, 'cd) Slap_D.vec -> 'accum
      val fold_lefti :
        (int -> 'accum -> Slap_D.num_type -> 'accum) ->
        'accum -> ('n, 'cd) Slap_D.vec -> 'accum
      val fold_right :
        (Slap_D.num_type -> 'accum -> 'accum) ->
        ('n, 'cd) Slap_D.vec -> 'accum -> 'accum
      val fold_righti :
        (int -> Slap_D.num_type -> 'accum -> 'accum) ->
        ('n, 'cd) Slap_D.vec -> 'accum -> 'accum
      val replace_all :
        ('n, 'cd) Slap_D.vec -> (Slap_D.num_type -> Slap_D.num_type) -> unit
      val replace_alli :
        ('n, 'cd) Slap_D.vec ->
        (int -> Slap_D.num_type -> Slap_D.num_type) -> unit
      val iter : (Slap_D.num_type -> unit) -> ('n, 'cd) Slap_D.vec -> unit
      val iteri :
        (int -> Slap_D.num_type -> unit) -> ('n, 'cd) Slap_D.vec -> unit
      val map2 :
        (Slap_D.num_type -> Slap_D.num_type -> Slap_D.num_type) ->
        ?z:('n, 'z_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec ->
        ('n, 'y_cd) Slap_D.vec -> ('n, 'z_cd) Slap_D.vec
      val mapi2 :
        (int -> Slap_D.num_type -> Slap_D.num_type -> Slap_D.num_type) ->
        ?z:('n, 'z_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec ->
        ('n, 'y_cd) Slap_D.vec -> ('n, 'z_cd) Slap_D.vec
      val fold_left2 :
        ('accum -> Slap_D.num_type -> Slap_D.num_type -> 'accum) ->
        'accum -> ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec -> 'accum
      val fold_lefti2 :
        (int -> 'accum -> Slap_D.num_type -> Slap_D.num_type -> 'accum) ->
        'accum -> ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec -> 'accum
      val fold_right2 :
        (Slap_D.num_type -> Slap_D.num_type -> 'accum -> 'accum) ->
        ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec -> 'accum -> 'accum
      val fold_righti2 :
        (int -> Slap_D.num_type -> Slap_D.num_type -> 'accum -> 'accum) ->
        ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec -> 'accum -> 'accum
      val iter2 :
        (Slap_D.num_type -> Slap_D.num_type -> unit) ->
        ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec -> unit
      val iteri2 :
        (int -> Slap_D.num_type -> Slap_D.num_type -> unit) ->
        ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec -> unit
      val map3 :
        (Slap_D.num_type ->
         Slap_D.num_type -> Slap_D.num_type -> Slap_D.num_type) ->
        ?w:('n, 'w_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec ->
        ('n, 'y_cd) Slap_D.vec ->
        ('n, 'z_cd) Slap_D.vec -> ('n, 'w_cd) Slap_D.vec
      val mapi3 :
        (int ->
         Slap_D.num_type ->
         Slap_D.num_type -> Slap_D.num_type -> Slap_D.num_type) ->
        ?w:('n, 'w_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec ->
        ('n, 'y_cd) Slap_D.vec ->
        ('n, 'z_cd) Slap_D.vec -> ('n, 'w_cd) Slap_D.vec
      val fold_left3 :
        ('accum ->
         Slap_D.num_type -> Slap_D.num_type -> Slap_D.num_type -> 'accum) ->
        'accum ->
        ('n, 'x_cd) Slap_D.vec ->
        ('n, 'y_cd) Slap_D.vec -> ('n, 'z_cd) Slap_D.vec -> 'accum
      val fold_lefti3 :
        (int ->
         'accum ->
         Slap_D.num_type -> Slap_D.num_type -> Slap_D.num_type -> 'accum) ->
        'accum ->
        ('n, 'x_cd) Slap_D.vec ->
        ('n, 'y_cd) Slap_D.vec -> ('n, 'z_cd) Slap_D.vec -> 'accum
      val fold_right3 :
        (Slap_D.num_type ->
         Slap_D.num_type -> Slap_D.num_type -> 'accum -> 'accum) ->
        ('n, 'x_cd) Slap_D.vec ->
        ('n, 'y_cd) Slap_D.vec -> ('n, 'z_cd) Slap_D.vec -> 'accum -> 'accum
      val fold_righti3 :
        (int ->
         Slap_D.num_type ->
         Slap_D.num_type -> Slap_D.num_type -> 'accum -> 'accum) ->
        ('n, 'x_cd) Slap_D.vec ->
        ('n, 'y_cd) Slap_D.vec -> ('n, 'z_cd) Slap_D.vec -> 'accum -> 'accum
      val iter3 :
        (Slap_D.num_type -> Slap_D.num_type -> Slap_D.num_type -> unit) ->
        ('n, 'x_cd) Slap_D.vec ->
        ('n, 'y_cd) Slap_D.vec -> ('n, 'z_cd) Slap_D.vec -> unit
      val iteri3 :
        (int -> Slap_D.num_type -> Slap_D.num_type -> Slap_D.num_type -> unit) ->
        ('n, 'x_cd) Slap_D.vec ->
        ('n, 'y_cd) Slap_D.vec -> ('n, 'z_cd) Slap_D.vec -> unit
      val for_all : (Slap_D.num_type -> bool) -> ('n, 'cd) Slap_D.vec -> bool
      val exists : (Slap_D.num_type -> bool) -> ('n, 'cd) Slap_D.vec -> bool
      val for_all2 :
        (Slap_D.num_type -> Slap_D.num_type -> bool) ->
        ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec -> bool
      val exists2 :
        (Slap_D.num_type -> Slap_D.num_type -> bool) ->
        ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec -> bool
      val max : ('n, 'cd) Slap_D.vec -> Slap_D.num_type
      val min : ('n, 'cd) Slap_D.vec -> Slap_D.num_type
      val sum : ('n, 'cd) Slap_D.vec -> Slap_D.num_type
      val prod : ('n, 'cd) Slap_D.vec -> Slap_D.num_type
      val add_const :
        Slap_D.num_type ->
        ?y:('n, 'y_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec
      val sqr_nrm2 : ?stable:bool -> ('n, 'cd) Slap_D.vec -> float
      val ssqr :
        ?c:Slap_D.num_type -> ('n, 'cd) Slap_D.vec -> Slap_D.num_type
      val sort :
        ?cmp:(Slap_D.num_type -> Slap_D.num_type -> int) ->
        ?decr:bool ->
        ?p:('n, 'p_cd) Slap_common.int_vec -> ('n, 'x_cd) Slap_D.vec -> unit
      val neg :
        ?y:('n, 'y_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec
      val reci :
        ?y:('n, 'y_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec
      val add :
        ?z:('n, 'z_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec ->
        ('n, 'y_cd) Slap_D.vec -> ('n, 'z_cd) Slap_D.vec
      val sub :
        ?z:('n, 'z_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec ->
        ('n, 'y_cd) Slap_D.vec -> ('n, 'z_cd) Slap_D.vec
      val mul :
        ?z:('n, 'z_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec ->
        ('n, 'y_cd) Slap_D.vec -> ('n, 'z_cd) Slap_D.vec
      val div :
        ?z:('n, 'z_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec ->
        ('n, 'y_cd) Slap_D.vec -> ('n, 'z_cd) Slap_D.vec
      val zpxy :
        ('n, 'z_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec ->
        ('n, 'y_cd) Slap_D.vec -> ('n, 'z_cd) Slap_D.vec
      val zmxy :
        ('n, 'z_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec ->
        ('n, 'y_cd) Slap_D.vec -> ('n, 'z_cd) Slap_D.vec
      val ssqr_diff :
        ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec -> Slap_D.num_type
      val subcntvec_dyn :
        'm Slap_size.t ->
        ?ofsx:int -> ('n, Slap_misc.cnt) Slap_D.vec -> ('m, 'cnt) Slap_D.vec
      val subdscvec_dyn :
        'm Slap_size.t ->
        ?ofsx:int ->
        ?incx:int -> ('n, 'cd) Slap_D.vec -> ('m, Slap_misc.dsc) Slap_D.vec
      val subvec_dyn :
        'm Slap_size.t ->
        ?ofsx:int ->
        ?incx:int -> ('n, 'cd) Slap_D.vec -> ('m, Slap_misc.dsc) Slap_D.vec
      val random :
        ?rnd_state:Random.State.t ->
        ?from:float ->
        ?range:float -> 'n Slap_size.t -> ('n, 'cnt) Slap_D.vec
      val sqr :
        ?y:('n, 'y_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec
      val sqrt :
        ?y:('n, 'y_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec
      val exp :
        ?y:('n, 'y_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec
      val log :
        ?y:('n, 'y_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec
      val sin :
        ?y:('n, 'y_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec
      val cos :
        ?y:('n, 'y_cd) Slap_D.vec ->
        ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec
    end
  module Mat :
    sig
      module type CNTMAT =
        sig
          type m
          type n
          val value :
            (Slap_D.Mat.CNTMAT.m, Slap_D.Mat.CNTMAT.n, 'cnt) Slap_D.mat
        end
      module type DSCMAT =
        sig
          type m
          type n
          val value :
            (Slap_D.Mat.DSCMAT.m, Slap_D.Mat.DSCMAT.n, Slap_misc.dsc)
            Slap_D.mat
        end
      val cnt :
        ('m, 'n, Slap_misc.cnt) Slap_D.mat -> ('m, 'n, 'cnt) Slap_D.mat
      val empty : (Slap_size.z, Slap_size.z, 'cnt) Slap_D.mat
      val create :
        'm Slap_size.t -> 'n Slap_size.t -> ('m, 'n, 'cnt) Slap_D.mat
      val make :
        'm Slap_size.t ->
        'n Slap_size.t -> Slap_D.num_type -> ('m, 'n, 'cnt) Slap_D.mat
      val make0 :
        'm Slap_size.t -> 'n Slap_size.t -> ('m, 'n, 'cnt) Slap_D.mat
      val make1 :
        'm Slap_size.t -> 'n Slap_size.t -> ('m, 'n, 'cnt) Slap_D.mat
      val identity : 'n Slap_size.t -> ('n, 'n, 'cnt) Slap_D.mat
      val init :
        'm Slap_size.t ->
        'n Slap_size.t ->
        (int -> int -> Slap_D.num_type) -> ('m, 'n, 'cnt) Slap_D.mat
      val init_cols :
        'm Slap_size.t ->
        'n Slap_size.t ->
        (int -> int -> Slap_D.num_type) -> ('m, 'n, 'cnt) Slap_D.mat
      val init_rows :
        'm Slap_size.t ->
        'n Slap_size.t ->
        (int -> int -> Slap_D.num_type) -> ('m, 'n, 'cnt) Slap_D.mat
      val dim : ('m, 'n, 'cd) Slap_D.mat -> 'm Slap_size.t * 'n Slap_size.t
      val dim1 : ('m, 'n, 'cd) Slap_D.mat -> 'm Slap_size.t
      val dim2 : ('m, 'n, 'cd) Slap_D.mat -> 'n Slap_size.t
      val get_dyn : ('m, 'n, 'cd) Slap_D.mat -> int -> int -> Slap_D.num_type
      val set_dyn :
        ('m, 'n, 'cd) Slap_D.mat -> int -> int -> Slap_D.num_type -> unit
      val unsafe_get :
        ('m, 'n, 'cd) Slap_D.mat -> int -> int -> Slap_D.num_type
      val unsafe_set :
        ('m, 'n, 'cd) Slap_D.mat -> int -> int -> Slap_D.num_type -> unit
      val col_dyn : ('m, 'n, 'cd) Slap_D.mat -> int -> ('m, 'cnt) Slap_D.vec
      val row_dyn :
        ('m, 'n, 'cd) Slap_D.mat -> int -> ('n, Slap_misc.dsc) Slap_D.vec
      val copy_row_dyn :
        ('m, 'n, 'cd) Slap_D.mat -> int -> ('n, 'cnt) Slap_D.vec
      val diag : ('n, 'n, 'cd) Slap_D.mat -> ('n, Slap_misc.dsc) Slap_D.vec
      val diag_rect :
        ('m, 'n, 'cd) Slap_D.mat ->
        (('m, 'n) Slap_size.min, Slap_misc.dsc) Slap_D.vec
      val copy_diag : ('n, 'n, 'cd) Slap_D.mat -> ('n, 'cnt) Slap_D.vec
      val copy_diag_rect :
        ('m, 'n, 'cd) Slap_D.mat -> (('m, 'n) Slap_size.min, 'cnt) Slap_D.vec
      val as_vec :
        ('m, 'n, Slap_misc.cnt) Slap_D.mat ->
        (('m, 'n) Slap_size.mul, 'cnt) Slap_D.vec
      val fill : ('m, 'n, 'cd) Slap_D.mat -> Slap_D.num_type -> unit
      val copy :
        ?uplo:[ `L | `U ] ->
        ?b:('m, 'n, 'b_cd) Slap_D.mat ->
        ('m, 'n, 'a_cd) Slap_D.mat -> ('m, 'n, 'b_cd) Slap_D.mat
      val of_col_vecs_dyn :
        'm Slap_size.t ->
        'n Slap_size.t ->
        ('m, Slap_misc.cnt) Slap_D.vec array -> ('m, 'n, 'cnt) Slap_D.mat
      val to_array : ('m, 'n, 'cd) Slap_D.mat -> Slap_D.num_type array array
      val of_array_dyn :
        'm Slap_size.t ->
        'n Slap_size.t ->
        Slap_D.num_type array array -> ('m, 'n, 'cnt) Slap_D.mat
      val of_array :
        Slap_D.num_type array array -> (module Slap_D.Mat.CNTMAT)
      module Of_array :
        functor (X : sig val value : Slap_D.num_type array array end) ->
          CNTMAT
      val unsafe_of_array :
        'm Slap_size.t ->
        'n Slap_size.t ->
        Slap_D.num_type array array -> ('m, 'n, 'cnt) Slap_D.mat
      val to_list : ('m, 'n, 'cd) Slap_D.mat -> Slap_D.num_type list list
      val of_list_dyn :
        'm Slap_size.t ->
        'n Slap_size.t ->
        Slap_D.num_type list list -> ('m, 'n, 'cnt) Slap_D.mat
      val of_list : Slap_D.num_type list list -> (module Slap_D.Mat.CNTMAT)
      module Of_list :
        functor (X : sig val value : Slap_D.num_type list list end) -> CNTMAT
      val unsafe_of_list :
        'm Slap_size.t ->
        'n Slap_size.t ->
        Slap_D.num_type list list -> ('m, 'n, 'cnt) Slap_D.mat
      val to_bigarray :
        ('m, 'n, 'cd) Slap_D.mat ->
        (Slap_D.num_type, Slap_D.prec, Bigarray.fortran_layout)
        Bigarray.Array2.t
      val of_bigarray_dyn :
        ?share:bool ->
        'm Slap_size.t ->
        'n Slap_size.t ->
        (Slap_D.num_type, Slap_D.prec, Bigarray.fortran_layout)
        Bigarray.Array2.t -> ('m, 'n, 'cnt) Slap_D.mat
      val of_bigarray :
        (Slap_D.num_type, Slap_D.prec, Bigarray.fortran_layout)
        Bigarray.Array2.t -> (module Slap_D.Mat.CNTMAT)
      module Of_bigarray :
        functor
          (X : sig
                 val value :
                   (Slap_D.num_type, Slap_D.prec, Bigarray.fortran_layout)
                   Bigarray.Array2.t
               end) ->
          CNTMAT
      val unsafe_of_bigarray :
        ?share:bool ->
        'm Slap_size.t ->
        'n Slap_size.t ->
        (Slap_D.num_type, Slap_D.prec, Bigarray.fortran_layout)
        Bigarray.Array2.t -> ('m, 'n, 'cnt) Slap_D.mat
      val of_array_c :
        Slap_D.num_type array array ->
        (Slap_D.num_type, Slap_D.prec, 'cnt) Slap_mat.dyn
      val of_list_c :
        Slap_D.num_type list list ->
        (Slap_D.num_type, Slap_D.prec, 'cnt) Slap_mat.dyn
      val of_bigarray_c :
        ?share:bool ->
        (Slap_D.num_type, Slap_D.prec, Bigarray.fortran_layout)
        Bigarray.Array2.t ->
        (Slap_D.num_type, Slap_D.prec, 'cnt) Slap_mat.dyn
      val map :
        (Slap_D.num_type -> Slap_D.num_type) ->
        ?b:('m, 'n, 'b_cd) Slap_D.mat ->
        ('m, 'n, 'a_cd) Slap_D.mat -> ('m, 'n, 'b_cd) Slap_D.mat
      val mapi :
        (int -> int -> Slap_D.num_type -> Slap_D.num_type) ->
        ?b:('m, 'n, 'b_cd) Slap_D.mat ->
        ('m, 'n, 'a_cd) Slap_D.mat -> ('m, 'n, 'b_cd) Slap_D.mat
      val fold_left :
        ('accum -> ('m, 'x_cd) Slap_D.vec -> 'accum) ->
        'accum -> ('m, 'n, 'a_cd) Slap_D.mat -> 'accum
      val fold_lefti :
        (int -> 'accum -> ('m, 'x_cd) Slap_D.vec -> 'accum) ->
        'accum -> ('m, 'n, 'a_cd) Slap_D.mat -> 'accum
      val fold_right :
        (('m, 'x_cd) Slap_D.vec -> 'accum -> 'accum) ->
        ('m, 'n, 'a_cd) Slap_D.mat -> 'accum -> 'accum
      val fold_righti :
        (int -> ('m, 'x_cd) Slap_D.vec -> 'accum -> 'accum) ->
        ('m, 'n, 'a_cd) Slap_D.mat -> 'accum -> 'accum
      val fold_top :
        ('accum -> ('n, Slap_misc.dsc) Slap_D.vec -> 'accum) ->
        'accum -> ('m, 'n, 'a_cd) Slap_D.mat -> 'accum
      val fold_topi :
        (int -> 'accum -> ('n, Slap_misc.dsc) Slap_D.vec -> 'accum) ->
        'accum -> ('m, 'n, 'a_cd) Slap_D.mat -> 'accum
      val fold_bottom :
        (('n, Slap_misc.dsc) Slap_D.vec -> 'accum -> 'accum) ->
        ('m, 'n, 'a_cd) Slap_D.mat -> 'accum -> 'accum
      val fold_bottomi :
        (int -> ('n, Slap_misc.dsc) Slap_D.vec -> 'accum -> 'accum) ->
        ('m, 'n, 'a_cd) Slap_D.mat -> 'accum -> 'accum
      val replace_all :
        ('m, 'n, 'cd) Slap_D.mat ->
        (Slap_D.num_type -> Slap_D.num_type) -> unit
      val replace_alli :
        ('m, 'n, 'cd) Slap_D.mat ->
        (int -> int -> Slap_D.num_type -> Slap_D.num_type) -> unit
      val transpose_copy :
        ?b:('n, 'm, 'b_cd) Slap_D.mat ->
        ('m, 'n, 'a_cd) Slap_D.mat -> ('n, 'm, 'b_cd) Slap_D.mat
      val detri : ?up:bool -> ('n, 'n, 'cd) Slap_D.mat -> unit
      val packed :
        ?up:bool ->
        ?x:('n Slap_size.packed, Slap_misc.cnt) Slap_D.vec ->
        ('n, 'n, 'cd) Slap_D.mat -> ('n Slap_size.packed, 'cnt) Slap_D.vec
      val unpacked :
        ?up:bool ->
        ?fill_num:Slap_D.num_type option ->
        ?a:('n, 'n, 'cd) Slap_D.mat ->
        ('n Slap_size.packed, Slap_misc.cnt) Slap_D.vec ->
        ('n, 'n, 'cd) Slap_D.mat
      val geband_dyn :
        'kl Slap_size.t ->
        'ku Slap_size.t ->
        ?b:(('m, 'n, 'kl, 'ku) Slap_size.geband, 'n, 'b_cd) Slap_D.mat ->
        ('m, 'n, 'a_cd) Slap_D.mat ->
        (('m, 'n, 'kl, 'ku) Slap_size.geband, 'n, 'b_cd) Slap_D.mat
      val ungeband :
        'm Slap_size.t ->
        'kl Slap_size.t ->
        'ku Slap_size.t ->
        ?fill_num:Slap_D.num_type option ->
        ?a:('m, 'n, 'a_cd) Slap_D.mat ->
        (('m, 'n, 'kl, 'ku) Slap_size.geband, 'n, 'b_cd) Slap_D.mat ->
        ('m, 'n, 'a_cd) Slap_D.mat
      val syband_dyn :
        'kd Slap_size.t ->
        ?up:bool ->
        ?b:(('n, 'kd) Slap_size.syband, 'n, 'b_cd) Slap_D.mat ->
        ('n, 'n, 'a_cd) Slap_D.mat ->
        (('n, 'kd) Slap_size.syband, 'n, 'b_cd) Slap_D.mat
      val unsyband :
        'kd Slap_size.t ->
        ?up:bool ->
        ?fill_num:Slap_D.num_type option ->
        ?a:('n, 'n, 'a_cd) Slap_D.mat ->
        (('n, 'kd) Slap_size.syband, 'n, 'b_cd) Slap_D.mat ->
        ('n, 'n, 'a_cd) Slap_D.mat
      val luband_dyn :
        'kl Slap_size.t ->
        'ku Slap_size.t ->
        ?ab:(('m, 'n, 'kl, 'ku) Slap_size.luband, 'n, 'b_cd) Slap_D.mat ->
        ('m, 'n, 'a_cd) Slap_D.mat ->
        (('m, 'n, 'kl, 'ku) Slap_size.luband, 'n, 'b_cd) Slap_D.mat
      val unluband :
        'm Slap_size.t ->
        'kl Slap_size.t ->
        'ku Slap_size.t ->
        ?fill_num:Slap_D.num_type option ->
        ?a:('m, 'n, 'a_cd) Slap_D.mat ->
        (('m, 'n, 'kl, 'ku) Slap_size.luband, 'n, 'b_cd) Slap_D.mat ->
        ('m, 'n, 'a_cd) Slap_D.mat
      val add_const :
        Slap_D.num_type ->
        ?b:('m, 'n, 'b_cd) Slap_D.mat ->
        ('m, 'n, 'a_cd) Slap_D.mat -> ('m, 'n, 'b_cd) Slap_D.mat
      val sum : ('m, 'n, 'cd) Slap_D.mat -> Slap_D.num_type
      val trace : ('m, 'n, 'cd) Slap_D.mat -> Slap_D.num_type
      val scal : Slap_D.num_type -> ('m, 'n, 'cd) Slap_D.mat -> unit
      val scal_cols :
        ('m, 'n, 'cd) Slap_D.mat -> ('n, Slap_misc.cnt) Slap_D.vec -> unit
      val scal_rows :
        ('m, Slap_misc.cnt) Slap_D.vec -> ('m, 'n, 'cd) Slap_D.mat -> unit
      val axpy :
        ?alpha:Slap_D.num_type ->
        ('m, 'n, 'x_cd) Slap_D.mat -> ('m, 'n, 'y_cd) Slap_D.mat -> unit
      val gemm_diag :
        ?beta:Slap_D.num_type ->
        ?y:('n, Slap_misc.cnt) Slap_D.vec ->
        transa:('a_n * 'a_k, 'n * 'k, [< `N | `T ]) Slap_D.trans3 ->
        ?alpha:Slap_D.num_type ->
        ('a_n, 'a_k, 'a_cd) Slap_D.mat ->
        transb:('b_k * 'b_n, 'k * 'n, [< `N | `T ]) Slap_D.trans3 ->
        ('b_k, 'b_n, 'b_cd) Slap_D.mat -> ('n, 'cnt) Slap_D.vec
      val syrk_diag :
        ?beta:Slap_D.num_type ->
        ?y:('n, Slap_misc.cnt) Slap_D.vec ->
        trans:('a_n * 'a_k, 'n * 'k, [< `N | `T ]) Slap_common.trans2 ->
        ?alpha:Slap_D.num_type ->
        ('a_n, 'a_k, 'a_cd) Slap_D.mat -> ('n, 'cnt) Slap_D.vec
      val gemm_trace :
        transa:('a_n * 'a_k, 'n * 'k, [< `N | `T ]) Slap_D.trans3 ->
        ('a_n, 'a_k, 'a_cd) Slap_D.mat ->
        transb:('b_k * 'b_n, 'k * 'n, [< `N | `T ]) Slap_D.trans3 ->
        ('b_k, 'b_n, 'b_cd) Slap_D.mat -> Slap_D.num_type
      val syrk_trace : ('n, 'k, 'cd) Slap_D.mat -> Slap_D.num_type
      val symm2_trace :
        ?upa:bool ->
        ('n, 'n, 'a_cd) Slap_D.mat ->
        ?upb:bool -> ('n, 'n, 'b_cd) Slap_D.mat -> Slap_D.num_type
      val submat_dyn :
        'm Slap_size.t ->
        'n Slap_size.t ->
        ?ar:int ->
        ?ac:int ->
        ('a, 'b, 'cd) Slap_D.mat -> ('m, 'n, Slap_misc.dsc) Slap_D.mat
      val random :
        ?rnd_state:Random.State.t ->
        ?from:float ->
        ?range:float ->
        'm Slap_size.t -> 'n Slap_size.t -> ('m, 'n, 'cnt) Slap_D.mat
    end
  val pp_num : Format.formatter -> Slap_D.num_type -> unit
  val pp_vec : Format.formatter -> ('n, 'cnt_or_dsc) Slap_D.vec -> unit
  val pp_mat : Format.formatter -> ('m, 'n, 'cnt_or_dsc) Slap_D.mat -> unit
  val swap : ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec -> unit
  val scal : Slap_D.num_type -> ('n, 'cd) Slap_D.vec -> unit
  val copy :
    ?y:('n, 'y_cd) Slap_D.vec ->
    ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec
  val nrm2 : ('n, 'cd) Slap_D.vec -> float
  val axpy :
    ?alpha:Slap_D.num_type ->
    ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec -> unit
  val iamax : ('n, 'cd) Slap_D.vec -> int
  val amax : ('n, 'cd) Slap_D.vec -> Slap_D.num_type
  val gemv :
    ?beta:Slap_D.num_type ->
    ?y:('m, 'y_cd) Slap_D.vec ->
    trans:('a_m * 'a_n, 'm * 'n, [< `N | `T ]) Slap_D.trans3 ->
    ?alpha:Slap_D.num_type ->
    ('a_m, 'a_n, 'a_cd) Slap_D.mat ->
    ('n, 'x_cd) Slap_D.vec -> ('m, 'y_cd) Slap_D.vec
  val gbmv :
    m:'a_m Slap_size.t ->
    ?beta:Slap_D.num_type ->
    ?y:('m, 'y_cd) Slap_D.vec ->
    trans:('a_m * 'a_n, 'm * 'n, [< `N | `T ]) Slap_D.trans3 ->
    ?alpha:Slap_D.num_type ->
    (('a_m, 'a_n, 'kl, 'ku) Slap_size.geband, 'a_n, 'a_cd) Slap_D.mat ->
    'kl Slap_size.t ->
    'ku Slap_size.t -> ('n, 'x_cd) Slap_D.vec -> ('m, 'y_cd) Slap_D.vec
  val symv :
    ?beta:Slap_D.num_type ->
    ?y:('n, 'y_cd) Slap_D.vec ->
    ?up:[< `L | `U ] Slap_common.uplo ->
    ?alpha:Slap_D.num_type ->
    ('n, 'n, 'a_cd) Slap_D.mat ->
    ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec
  val trmv :
    trans:('n * 'n, 'n * 'n, [< `N | `T ]) Slap_D.trans3 ->
    ?diag:Slap_common.diag ->
    ?up:[< `L | `U ] Slap_common.uplo ->
    ('n, 'n, 'a_cd) Slap_D.mat -> ('n, 'x_cd) Slap_D.vec -> unit
  val trsv :
    trans:('n * 'n, 'n * 'n, [< `N | `T ]) Slap_D.trans3 ->
    ?diag:Slap_common.diag ->
    ?up:[< `L | `U ] Slap_common.uplo ->
    ('n, 'n, 'a_cd) Slap_D.mat -> ('n, 'b_cd) Slap_D.vec -> unit
  val tpmv :
    trans:('n * 'n, 'n * 'n, [< `N | `T ]) Slap_D.trans3 ->
    ?diag:Slap_common.diag ->
    ?up:[< `L | `U ] Slap_common.uplo ->
    ('n Slap_size.packed, Slap_misc.cnt) Slap_D.vec ->
    ('n, 'x_cd) Slap_D.vec -> unit
  val tpsv :
    trans:('n * 'n, 'n * 'n, [< `N | `T ]) Slap_D.trans3 ->
    ?diag:Slap_common.diag ->
    ?up:[< `L | `U ] Slap_common.uplo ->
    ('n Slap_size.packed, Slap_misc.cnt) Slap_D.vec ->
    ('n, 'x_cd) Slap_D.vec -> unit
  val gemm :
    ?beta:Slap_D.num_type ->
    ?c:('m, 'n, 'c_cd) Slap_D.mat ->
    transa:('a_m * 'a_k, 'm * 'k, [< `N | `T ]) Slap_D.trans3 ->
    ?alpha:Slap_D.num_type ->
    ('a_m, 'a_k, 'a_cd) Slap_D.mat ->
    transb:('b_k * 'b_n, 'k * 'n, [< `N | `T ]) Slap_D.trans3 ->
    ('b_k, 'b_n, 'b_cd) Slap_D.mat -> ('m, 'n, 'c_cd) Slap_D.mat
  val symm :
    side:('k, 'm, 'n) Slap_common.side ->
    ?up:[< `L | `U ] Slap_common.uplo ->
    ?beta:Slap_D.num_type ->
    ?c:('m, 'n, 'c_cd) Slap_D.mat ->
    ?alpha:Slap_D.num_type ->
    ('k, 'k, 'a_cd) Slap_D.mat ->
    ('m, 'n, 'b_cd) Slap_D.mat -> ('m, 'n, 'c_cd) Slap_D.mat
  val trmm :
    side:('k, 'm, 'n) Slap_common.side ->
    ?up:[< `L | `U ] Slap_common.uplo ->
    transa:('k * 'k, 'k * 'k, [< `N | `T ]) Slap_D.trans3 ->
    ?diag:Slap_common.diag ->
    ?alpha:Slap_D.num_type ->
    a:('k, 'k, 'a_cd) Slap_D.mat -> ('m, 'n, 'b_cd) Slap_D.mat -> unit
  val trsm :
    side:('k, 'm, 'n) Slap_common.side ->
    ?up:[< `L | `U ] Slap_common.uplo ->
    transa:('k * 'k, 'k * 'k, [< `N | `T ]) Slap_D.trans3 ->
    ?diag:Slap_common.diag ->
    ?alpha:Slap_D.num_type ->
    a:('k, 'k, 'a_cd) Slap_D.mat -> ('m, 'n, 'b_cd) Slap_D.mat -> unit
  val syrk :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ?beta:Slap_D.num_type ->
    ?c:('n, 'n, 'c_cd) Slap_D.mat ->
    trans:('a_n * 'a_k, 'n * 'k, [< `N | `T ]) Slap_common.trans2 ->
    ?alpha:Slap_D.num_type ->
    ('a_n, 'a_k, 'a_cd) Slap_D.mat -> ('n, 'n, 'c_cd) Slap_D.mat
  val syr2k :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ?beta:Slap_D.num_type ->
    ?c:('n, 'n, 'c_cd) Slap_D.mat ->
    trans:('p * 'q, 'n * 'k, [< `N | `T ]) Slap_common.trans2 ->
    ?alpha:Slap_D.num_type ->
    ('p, 'q, 'a_cd) Slap_D.mat ->
    ('p, 'q, 'b_cd) Slap_D.mat -> ('n, 'n, 'c_cd) Slap_D.mat
  val lacpy :
    ?uplo:[< `A | `L | `U ] Slap_common.uplo ->
    ?b:('m, 'n, 'b_cd) Slap_D.mat ->
    ('m, 'n, 'a_cd) Slap_D.mat -> ('m, 'n, 'b_cd) Slap_D.mat
  val lassq :
    ?scale:float -> ?sumsq:float -> ('n, 'cd) Slap_D.vec -> float * float
  type larnv_liseed = Slap_size.four
  val larnv :
    ?idist:[ `Normal | `Uniform0 | `Uniform1 ] ->
    ?iseed:(Slap_D.larnv_liseed, Slap_misc.cnt) Slap_common.int32_vec ->
    x:('n, Slap_misc.cnt) Slap_D.vec -> unit -> ('n, 'cnt) Slap_D.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_D.lange_min_lwork Slap_size.t
  val lange :
    ?norm:[< `F | `I | `M | `O ] Slap_common.norm4 ->
    ?work:('lwork, Slap_misc.cnt) Slap_D.rvec ->
    ('m, 'n, 'cd) Slap_D.mat -> float
  val lauum :
    ?up:[< `L | `U ] Slap_common.uplo -> ('n, 'n, 'cd) Slap_D.mat -> unit
  val getrf :
    ?ipiv:(('m, 'n) Slap_size.min, Slap_misc.cnt) Slap_common.int32_vec ->
    ('m, 'n, 'cd) Slap_D.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, [< `N | `T ]) Slap_D.trans3 ->
    ('n, 'n, 'a_cd) Slap_D.mat -> ('n, 'n, 'b_cd) Slap_D.mat -> unit
  type 'n getri_min_lwork
  val getri_min_lwork :
    'n Slap_size.t -> 'n Slap_D.getri_min_lwork Slap_size.t
  val getri_opt_lwork : ('n, 'n, 'cd) Slap_D.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_D.vec ->
    ('n, 'n, 'cd) Slap_D.mat -> unit
  type sytrf_min_lwork
  val sytrf_min_lwork : unit -> Slap_D.sytrf_min_lwork Slap_size.t
  val sytrf_opt_lwork :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ('n, 'n, 'cd) Slap_D.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_D.vec ->
    ('n, 'n, 'cd) Slap_D.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_D.mat -> ('n, 'nrhs, 'b_cd) Slap_D.mat -> unit
  type 'n sytri_min_lwork
  val sytri_min_lwork :
    'n Slap_size.t -> 'n Slap_D.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_D.vec ->
    ('n, 'n, 'cd) Slap_D.mat -> unit
  val potrf :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ?jitter:Slap_D.num_type -> ('n, 'n, 'cd) Slap_D.mat -> unit
  val potrs :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ('n, 'n, 'a_cd) Slap_D.mat ->
    ?factorize:bool ->
    ?jitter:Slap_D.num_type -> ('n, 'nrhs, 'b_cd) Slap_D.mat -> unit
  val potri :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ?factorize:bool ->
    ?jitter:Slap_D.num_type -> ('n, 'n, 'cd) Slap_D.mat -> unit
  val trtrs :
    ?up:[< `L | `U ] Slap_common.uplo ->
    trans:('n * 'n, 'n * 'n, [< `N | `T ]) Slap_D.trans3 ->
    ?diag:Slap_common.diag ->
    ('n, 'n, 'a_cd) Slap_D.mat -> ('n, 'nrhs, 'b_cd) Slap_D.mat -> unit
  val tbtrs :
    kd:'kd Slap_size.t ->
    ?up:[< `L | `U ] Slap_common.uplo ->
    trans:('n * 'n, 'n * 'n, [< `N | `T ]) Slap_D.trans3 ->
    ?diag:Slap_common.diag ->
    (('n, 'kd) Slap_size.syband, 'n, 'a_cd) Slap_D.mat ->
    ('n, 'nrhs, 'b_cd) Slap_D.mat -> unit
  val trtri :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ?diag:Slap_common.diag -> ('n, 'n, 'cd) Slap_D.mat -> unit
  type 'n geqrf_min_lwork
  val geqrf_min_lwork :
    n:'n Slap_size.t -> 'n Slap_D.geqrf_min_lwork Slap_size.t
  val geqrf_opt_lwork : ('m, 'n, 'cd) Slap_D.mat -> (module Slap_size.SIZE)
  val geqrf :
    ?work:('lwork, Slap_misc.cnt) Slap_D.vec ->
    ?tau:(('m, 'n) Slap_size.min, Slap_misc.cnt) Slap_D.vec ->
    ('m, 'n, 'cd) Slap_D.mat -> (('m, 'n) Slap_size.min, 'cnt) Slap_D.vec
  val gesv :
    ?ipiv:('n, Slap_misc.cnt) Slap_common.int32_vec ->
    ('n, 'n, 'a_cd) Slap_D.mat -> ('n, 'nrhs, 'b_cd) Slap_D.mat -> unit
  val gbsv :
    ?ipiv:('n, Slap_misc.cnt) Slap_common.int32_vec ->
    (('n, 'n, 'kl, 'ku) Slap_size.luband, 'n, 'a_cd) Slap_D.mat ->
    'kl Slap_size.t ->
    'ku Slap_size.t -> ('n, 'nrhs, 'b_cd) Slap_D.mat -> unit
  val posv :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ('n, 'n, 'a_cd) Slap_D.mat -> ('n, 'nrhs, 'b_cd) Slap_D.mat -> unit
  val ppsv :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ('n Slap_size.packed, Slap_misc.cnt) Slap_D.vec ->
    ('n, 'nrhs, 'b_cd) Slap_D.mat -> unit
  val pbsv :
    ?up:[< `L | `U ] Slap_common.uplo ->
    kd:'kd Slap_size.t ->
    (('n, 'kd) Slap_size.syband, 'n, 'ab_cd) Slap_D.mat ->
    ('n, 'nrhs, 'b_cd) Slap_D.mat -> unit
  val ptsv :
    ('n, Slap_misc.cnt) Slap_D.vec ->
    ('n Slap_size.p, Slap_misc.cnt) Slap_D.vec ->
    ('n, 'nrhs, 'b_cd) Slap_D.mat -> unit
  type sysv_min_lwork
  val sysv_min_lwork : unit -> Slap_D.sysv_min_lwork Slap_size.t
  val sysv_opt_lwork :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ('n, 'n, 'a_cd) Slap_D.mat ->
    ('n, 'nrhs, 'b_cd) Slap_D.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_D.vec ->
    ('n, 'n, 'a_cd) Slap_D.mat -> ('n, 'nrhs, 'b_cd) Slap_D.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_D.vec ->
    ('n, 'nrhs, 'b_cd) Slap_D.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_D.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_D.mat ->
    ('m, 'nrhs, 'b_cd) Slap_D.mat -> (module Slap_size.SIZE)
  val gels :
    ?work:('work, Slap_misc.cnt) Slap_D.vec ->
    trans:('am * 'an, 'm * 'n, [< `N | `T ]) Slap_common.trans2 ->
    ('am, 'an, 'a_cd) Slap_D.mat -> ('m, 'nrhs, 'b_cd) Slap_D.mat -> unit
  val dot : ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec -> float
  val asum : ('n, 'x_cd) Slap_D.vec -> float
  val sbmv :
    k:'k Slap_size.t ->
    ?y:('n, 'y_cd) Slap_D.vec ->
    (('n, 'k) Slap_size.syband, 'n, 'a_cd) Slap_D.mat ->
    ?up:[< `L | `U ] Slap_common.uplo ->
    ?alpha:float ->
    ?beta:float -> ('n, 'x_cd) Slap_D.vec -> ('n, 'y_cd) Slap_D.vec
  val ger :
    ?alpha:float ->
    ('m, 'x_cd) Slap_D.vec ->
    ('n, 'y_cd) Slap_D.vec ->
    ('m, 'n, 'a_cd) Slap_D.mat -> ('m, 'n, 'a_cd) Slap_D.mat
  val syr :
    ?alpha:float ->
    ?up:[< `L | `U ] Slap_common.uplo ->
    ('n, 'x_cd) Slap_D.vec ->
    ('n, 'n, 'a_cd) Slap_D.mat -> ('n, 'n, 'a_cd) Slap_D.mat
  type ('m, 'a) lansy_min_lwork
  val lansy_min_lwork :
    'n Slap_size.t ->
    ([< `F | `I | `M | `O ] as 'a) Slap_common.norm4 ->
    ('n, 'a) Slap_D.lansy_min_lwork Slap_size.t
  val lansy :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ?norm:[< `F | `I | `M | `O ] Slap_common.norm4 ->
    ?work:('lwork, Slap_misc.cnt) Slap_D.vec ->
    ('n, 'n, 'cd) Slap_D.mat -> float
  val lamch : [ `B | `E | `L | `M | `N | `O | `P | `R | `S | `U ] -> float
  type 'n orgqr_min_lwork
  val orgqr_min_lwork :
    n:'n Slap_size.t -> 'n Slap_D.orgqr_min_lwork Slap_size.t
  val orgqr_opt_lwork :
    tau:('k, Slap_misc.cnt) Slap_D.vec ->
    ('m, 'n, 'cd) Slap_D.mat -> (module Slap_size.SIZE)
  val orgqr_dyn :
    ?work:('lwork, Slap_misc.cnt) Slap_D.vec ->
    tau:('k, Slap_misc.cnt) Slap_D.vec -> ('m, 'n, 'cd) Slap_D.mat -> unit
  type ('r, 'm, 'n) ormqr_min_lwork
  val ormqr_min_lwork :
    side:('r, 'm, 'n) Slap_common.side ->
    m:'m Slap_size.t ->
    n:'n Slap_size.t -> ('r, 'm, 'n) Slap_D.ormqr_min_lwork Slap_size.t
  val ormqr_opt_lwork :
    side:('r, 'm, 'n) Slap_common.side ->
    trans:('r * 'r, 'r * 'r, [< `N | `T ]) Slap_common.trans2 ->
    tau:('k, Slap_misc.cnt) Slap_D.vec ->
    ('r, 'k, 'a_cd) Slap_D.mat ->
    ('m, 'n, 'c_cd) Slap_D.mat -> (module Slap_size.SIZE)
  val ormqr_dyn :
    side:('r, 'm, 'n) Slap_common.side ->
    trans:('r * 'r, 'r * 'r, [< `N | `T ]) Slap_common.trans2 ->
    ?work:('lwork, Slap_misc.cnt) Slap_D.vec ->
    tau:('k, Slap_misc.cnt) Slap_D.vec ->
    ('r, 'k, 'a_cd) Slap_D.mat -> ('m, 'n, 'c_cd) Slap_D.mat -> unit
  type 'n gecon_min_lwork
  val gecon_min_lwork :
    'n Slap_size.t -> 'n Slap_D.gecon_min_lwork Slap_size.t
  type 'n gecon_min_liwork
  val gecon_min_liwork :
    'n Slap_size.t -> 'n Slap_D.gecon_min_liwork Slap_size.t
  val gecon :
    ?norm:[< `I | `O ] Slap_common.norm2 ->
    ?anorm:float ->
    ?work:('lwork, Slap_misc.cnt) Slap_D.vec ->
    ?iwork:('liwork, Slap_misc.cnt) Slap_common.int32_vec ->
    ('n, 'n, 'cd) Slap_D.mat -> float
  type 'n sycon_min_lwork
  val sycon_min_lwork :
    'n Slap_size.t -> 'n Slap_D.sycon_min_lwork Slap_size.t
  type 'n sycon_min_liwork
  val sycon_min_liwork :
    'n Slap_size.t -> 'n Slap_D.sycon_min_liwork Slap_size.t
  val sycon :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ?ipiv:('n, Slap_misc.cnt) Slap_common.int32_vec ->
    ?anorm:float ->
    ?work:('lwork, Slap_misc.cnt) Slap_D.vec ->
    ?iwork:('liwork, Slap_misc.cnt) Slap_common.int32_vec ->
    ('n, 'n, 'cd) Slap_D.mat -> float
  type 'n pocon_min_lwork
  val pocon_min_lwork :
    'n Slap_size.t -> 'n Slap_D.pocon_min_lwork Slap_size.t
  type 'n pocon_min_liwork
  val pocon_min_liwork :
    'n Slap_size.t -> 'n Slap_D.pocon_min_liwork Slap_size.t
  val pocon :
    ?up:[< `L | `U ] Slap_common.uplo ->
    ?anorm:float ->
    ?work:('lwork, Slap_misc.cnt) Slap_D.vec ->
    ?iwork:('liwork, Slap_misc.cnt) Slap_common.int32_vec ->
    ('n, 'n, 'cd) Slap_D.mat -> float
  type ('m, 'n, 'nrhs) gelsy_min_lwork
  val gelsy_min_lwork :
    m:'m Slap_size.t ->
    n:'n Slap_size.t ->
    nrhs:'nrhs Slap_size.t ->
    ('m, 'n, 'nrhs) Slap_D.gelsy_min_lwork Slap_size.t
  val gelsy_opt_lwork :
    ('m, 'n, 'a_cd) Slap_D.mat ->
    ('n, 'nrhs, 'b_cd) Slap_D.mat -> (module Slap_size.SIZE)
  val gelsy :
    ('m, 'n, 'a_cd) Slap_D.mat ->
    ?rcond:float ->
    ?jpvt:('n, Slap_misc.cnt) Slap_common.int32_vec ->
    ?work:('lwork, Slap_misc.cnt) Slap_D.vec ->
    ('n, 'nrhs, 'b_cd) Slap_D.mat -> int
  type ('m, 'n, 'nrhs) gelsd_min_lwork
  val gelsd_min_lwork :
    m:'m Slap_size.t ->
    n:'n Slap_size.t ->
    nrhs:'nrhs Slap_size.t ->
    ('m, 'n, 'nrhs) Slap_D.gelsd_min_lwork Slap_size.t
  val gelsd_opt_lwork :
    ('m, 'n, 'a_cd) Slap_D.mat ->
    ('n, 'nrhs, 'b_cd) Slap_D.mat -> (module Slap_size.SIZE)
  type ('m, 'n, 'nrhs) gelsd_min_iwork
  val gelsd_min_iwork :
    'm Slap_size.t ->
    'n Slap_size.t -> ('m, 'n, 'nrhs) Slap_D.gelsd_min_iwork Slap_size.t
  val gelsd :
    ('m, 'n, 'a_cd) Slap_D.mat ->
    ?rcond:float ->
    ?s:(('m, 'n) Slap_size.min, Slap_misc.cnt) Slap_D.vec ->
    ?work:('lwork, Slap_misc.cnt) Slap_D.vec ->
    ?iwork:('liwork, Slap_misc.cnt) Slap_D.vec ->
    ('n, 'nrhs, 'b_cd) Slap_D.mat -> int
  type ('m, 'n, 'nrhs) gelss_min_lwork
  val gelss_min_lwork :
    m:'m Slap_size.t ->
    n:'n Slap_size.t ->
    nrhs:'nrhs Slap_size.t ->
    ('m, 'n, 'nrhs) Slap_D.gelss_min_lwork Slap_size.t
  val gelss_opt_lwork :
    ('m, 'n, 'a_cd) Slap_D.mat ->
    ('n, 'nrhs, 'b_cd) Slap_D.mat -> (module Slap_size.SIZE)
  val gelss :
    ('m, 'n, 'a_cd) Slap_D.mat ->
    ?rcond:float ->
    ?s:(('m, 'n) Slap_size.min, Slap_misc.cnt) Slap_D.vec ->
    ?work:('lwork, Slap_misc.cnt) Slap_D.vec ->
    ('n, 'nrhs, 'b_cd) Slap_D.mat -> int
  type ('m, 'n) gesvd_min_lwork
  val gesvd_min_lwork :
    m:'m Slap_size.t ->
    n:'n Slap_size.t -> ('m, 'n) Slap_D.gesvd_min_lwork Slap_size.t
  val gesvd_opt_lwork :
    jobu:('u_cols, 'm, ('m, 'n) Slap_size.min, Slap_size.z, Slap_size.z)
         Slap_common.svd_job ->
    jobvt:('vt_rows, 'n, ('m, 'n) Slap_size.min, Slap_size.z, Slap_size.z)
          Slap_common.svd_job ->
    ?s:(('m, 'n) Slap_size.min, Slap_misc.cnt) Slap_D.vec ->
    ?u:('m, 'u_cols, 'u_cd) Slap_D.mat ->
    ?vt:('vt_rows, 'n, 'vt_cd) Slap_D.mat ->
    ('m, 'n, 'a_cd) Slap_D.mat -> (module Slap_size.SIZE)
  val gesvd :
    jobu:('u_cols, 'm, ('m, 'n) Slap_size.min, Slap_size.z, Slap_size.z)
         Slap_common.svd_job ->
    jobvt:('vt_rows, 'n, ('m, 'n) Slap_size.min, Slap_size.z, Slap_size.z)
          Slap_common.svd_job ->
    ?s:(('m, 'n) Slap_size.min, Slap_misc.cnt) Slap_D.vec ->
    ?u:('m, 'u_cols, 'u_cd) Slap_D.mat ->
    ?vt:('vt_rows, 'n, 'vt_cd) Slap_D.mat ->
    ?work:('lwork, Slap_misc.cnt) Slap_D.vec ->
    ('m, 'n, 'a_cd) Slap_D.mat ->
    (('m, 'n) Slap_size.min, 'cnt) Slap_D.vec *
    ('m, 'u_cols, 'cnt) Slap_D.mat * ('vt_rows, 'n, 'cnt) Slap_D.mat
  type ('m, 'n) gesdd_liwork
  val gesdd_liwork :
    m:'m Slap_size.t ->
    n:'n Slap_size.t -> ('m, 'n) Slap_D.gesdd_liwork Slap_size.t
  type ('m, 'n, 'jobz) gesdd_min_lwork
  val gesdd_min_lwork :
    jobz:('u_cols * 'vt_rows, 'm * 'n,
          ('m, 'n) Slap_size.min * ('m, 'n) Slap_size.min, 'm * 'n,
          Slap_size.z * Slap_size.z)
         Slap_common.svd_job ->
    m:'m Slap_size.t ->
    n:'n Slap_size.t ->
    unit -> ('m, 'n, 'u_cols * 'vt_rows) Slap_D.gesdd_min_lwork Slap_size.t
  val gesdd_opt_lwork :
    jobz:('u_cols * 'vt_rows, 'm * 'n,
          ('m, 'n) Slap_size.min * ('m, 'n) Slap_size.min, 'm * 'n,
          Slap_size.z * Slap_size.z)
         Slap_common.svd_job ->
    ?s:(('m, 'n) Slap_size.min, Slap_misc.cnt) Slap_D.vec ->
    ?u:('m, 'u_cols, 'u_cd) Slap_D.mat ->
    ?vt:('vt_rows, 'n, 'vt_cd) Slap_D.mat ->
    ?iwork:('liwork, Slap_misc.cnt) Slap_common.int32_vec ->
    ('m, 'n, 'a_cd) Slap_D.mat -> (module Slap_size.SIZE)
  val gesdd :
    jobz:('u_cols * 'vt_rows, 'm * 'n,
          ('m, 'n) Slap_size.min * ('m, 'n) Slap_size.min, 'm * 'n,
          Slap_size.z * Slap_size.z)
         Slap_common.svd_job ->
    ?s:(('m, 'n) Slap_size.min, Slap_misc.cnt) Slap_D.vec ->
    ?u:('m, 'u_cols, 'u_cd) Slap_D.mat ->
    ?vt:('vt_rows, 'n, 'vt_cd) Slap_D.mat ->
    ?work:('lwork, Slap_misc.cnt) Slap_D.vec ->
    ?iwork:('liwork, Slap_misc.cnt) Slap_common.int32_vec ->
    ('m, 'n, 'a_cd) Slap_D.mat ->
    (('m, 'n) Slap_size.min, 'cnt) Slap_D.vec *
    ('m, 'u_cols, 'u_cd) Slap_D.mat option *
    ('vt_rows, 'n, 'vt_cd) Slap_D.mat option
  val geev_min_lwork :
    ?vectors:bool -> 'n Slap_size.t -> (module Slap_size.SIZE)
  val geev_opt_lwork :
    ?vl:('n, 'n, 'vl_cd) Slap_D.mat option ->
    ?vr:('n, 'n, 'vr_cd) Slap_D.mat option ->
    ?wr:('n, Slap_misc.cnt) Slap_D.vec ->
    ?wi:('n, Slap_misc.cnt) Slap_D.vec ->
    ('n, 'n, 'a_cd) Slap_D.mat -> (module Slap_size.SIZE)
  val geev :
    ?work:('lwork, Slap_misc.cnt) Slap_D.vec ->
    ?vl:('n, 'n, 'vl_cd) Slap_D.mat option ->
    ?vr:('n, 'n, 'vr_cd) Slap_D.mat option ->
    ?wr:('n, Slap_misc.cnt) Slap_D.vec ->
    ?wi:('n, Slap_misc.cnt) Slap_D.vec ->
    ('n, 'n, 'a_cd) Slap_D.mat ->
    ('n, 'n, 'vl_cd) Slap_D.mat option * ('n, Slap_misc.cnt) Slap_D.vec *
    ('n, Slap_misc.cnt) Slap_D.vec * ('n, 'n, 'vr_cd) Slap_D.mat option
  type 'n syev_min_lwork
  val syev_min_lwork : 'n Slap_size.t -> 'n Slap_D.syev_min_lwork Slap_size.t
  val syev_opt_lwork :
    ?vectors:bool ->
    ?up:bool -> ('n, 'n, 'cd) Slap_D.mat -> (module Slap_size.SIZE)
  val syev :
    ?vectors:bool ->
    ?up:bool ->
    ?work:('lwork, Slap_misc.cnt) Slap_D.vec ->
    ?w:('n, Slap_misc.cnt) Slap_D.vec ->
    ('n, 'n, 'cd) Slap_D.mat -> ('n, 'cnt) Slap_D.vec
  val syevd_min_lwork :
    vectors:bool -> 'n Slap_size.t -> (module Slap_size.SIZE)
  val syevd_min_liwork :
    vectors:bool -> 'n Slap_size.t -> (module Slap_size.SIZE)
  val syevd_opt_lwork :
    ?vectors:bool ->
    ?up:bool -> ('n, 'n, 'cd) Slap_D.mat -> (module Slap_size.SIZE)
  val syevd_opt_liwork :
    ?vectors:bool ->
    ?up:bool -> ('n, 'n, 'cd) Slap_D.mat -> (module Slap_size.SIZE)
  val syevd :
    ?vectors:bool ->
    ?up:bool ->
    ?work:('lwork, Slap_misc.cnt) Slap_D.vec ->
    ?iwork:('liwork, Slap_misc.cnt) Slap_common.int32_vec ->
    ?w:('n, Slap_misc.cnt) Slap_D.vec ->
    ('n, 'n, 'a_cd) Slap_D.mat -> ('n, 'w_cd) Slap_D.vec
  type 'n sbev_min_lwork
  val sbev_min_lwork : 'n Slap_size.t -> 'n Slap_D.sbev_min_lwork Slap_size.t
  val sbev :
    kd:'kd Slap_size.t ->
    ?z:('n, 'n, 'z_cd) Slap_D.mat ->
    ?up:bool ->
    ?work:('lwork, Slap_misc.cnt) Slap_D.vec ->
    ?w:('n, Slap_misc.cnt) Slap_D.vec ->
    (('n, 'kd) Slap_size.syband, 'n, 'a_cd) Slap_D.mat ->
    ('n, 'cnt) Slap_D.vec
  type 'n syevr_min_lwork
  val syevr_min_lwork :
    'n Slap_size.t -> 'n Slap_D.syevr_min_lwork Slap_size.t
  type 'n syevr_min_liwork
  val syevr_min_liwork :
    'n Slap_size.t -> 'n Slap_D.syevr_min_liwork Slap_size.t
  val syevr_opt_lwork :
    ?vectors:bool ->
    ?range:[ `A | `I of int * int | `V of float * float ] ->
    ?up:bool ->
    ?abstol:float -> ('n, 'n, 'a_cd) Slap_D.mat -> (module Slap_size.SIZE)
  val syevr_opt_liwork :
    ?vectors:bool ->
    ?range:[ `A | `I of int * int | `V of float * float ] ->
    ?up:bool ->
    ?abstol:float -> ('n, 'n, 'a_cd) Slap_D.mat -> (module Slap_size.SIZE)
  module type SYEVR_RESULT =
    sig
      type m
      type n
      val value :
        Slap_D.SYEVR_RESULT.m Slap_size.t *
        (Slap_D.SYEVR_RESULT.n, 'cnt) Slap_D.vec *
        (Slap_D.SYEVR_RESULT.n, Slap_D.SYEVR_RESULT.m, 'cnt) Slap_D.mat *
        ((Slap_D.SYEVR_RESULT.m, Slap_D.SYEVR_RESULT.m) Slap_size.add, 'cnt)
        Slap_common.int32_vec
    end
  val syevr_dyn :
    ?vectors:bool ->
    ?range:[ `A | `I of int * int | `V of float * float ] ->
    ?up:bool ->
    ?abstol:float ->
    ?work:('lwork, Slap_misc.cnt) Slap_D.vec ->
    ?iwork:('liwork, Slap_misc.cnt) Slap_common.int32_vec ->
    ?w:('n, Slap_misc.cnt) Slap_D.vec ->
    ?z:('n, 'k, 'z_cd) Slap_D.mat ->
    ?isuppz:(('k, 'k) Slap_size.add, Slap_misc.cnt) Slap_common.int32_vec ->
    ('n, 'n, 'a_cd) Slap_D.mat ->
    (module Slap_D.SYEVR_RESULT with type n = 'n)
  val sygv_opt_lwork :
    ?vectors:bool ->
    ?up:bool ->
    ?itype:[ `AB | `A_B | `BA ] ->
    ('n, 'n, 'a_cd) Slap_D.mat ->
    ('n, 'n, 'b_cd) Slap_D.mat -> (module Slap_size.SIZE)
  val sygv :
    ?vectors:bool ->
    ?up:bool ->
    ?work:('lwork, Slap_misc.cnt) Slap_D.vec ->
    ?w:('n, Slap_misc.cnt) Slap_D.vec ->
    ?itype:[ `AB | `A_B | `BA ] ->
    ('n, 'n, 'a_cd) Slap_D.mat ->
    ('n, 'n, 'b_cd) Slap_D.mat -> ('n, 'cnt) Slap_D.vec
  val sbgv :
    ka:'ka Slap_size.t ->
    kb:'kb Slap_size.t ->
    ?z:('n, 'n, 'z_cd) Slap_D.mat ->
    ?up:bool ->
    ?work:('lwork, Slap_misc.cnt) Slap_D.vec ->
    ?w:('n, Slap_misc.cnt) Slap_D.vec ->
    (('n, 'ka) Slap_size.syband, 'n, 'ab_cd) Slap_D.mat ->
    (('n, 'kb) Slap_size.syband, 'n, 'bb_cd) Slap_D.mat ->
    ('n, 'cnt) Slap_D.vec
end