sig
  module type CNTMAT =
    sig
      type m
      type n
      val value : (Slap_C.Mat.CNTMAT.m, Slap_C.Mat.CNTMAT.n, 'cnt) Slap_C.mat
    end
  module type DSCMAT =
    sig
      type m
      type n
      val value :
        (Slap_C.Mat.DSCMAT.m, Slap_C.Mat.DSCMAT.n, Slap_misc.dsc) Slap_C.mat
    end
  val cnt : ('m, 'n, Slap_misc.cnt) Slap_C.mat -> ('m, 'n, 'cnt) Slap_C.mat
  val empty : (Slap_size.z, Slap_size.z, 'cnt) Slap_C.mat
  val create : 'm Slap_size.t -> 'n Slap_size.t -> ('m, 'n, 'cnt) Slap_C.mat
  val make :
    'm Slap_size.t ->
    'n Slap_size.t -> Slap_C.num_type -> ('m, 'n, 'cnt) Slap_C.mat
  val make0 : 'm Slap_size.t -> 'n Slap_size.t -> ('m, 'n, 'cnt) Slap_C.mat
  val make1 : 'm Slap_size.t -> 'n Slap_size.t -> ('m, 'n, 'cnt) Slap_C.mat
  val identity : 'n Slap_size.t -> ('n, 'n, 'cnt) Slap_C.mat
  val init :
    'm Slap_size.t ->
    'n Slap_size.t ->
    (int -> int -> Slap_C.num_type) -> ('m, 'n, 'cnt) Slap_C.mat
  val init_cols :
    'm Slap_size.t ->
    'n Slap_size.t ->
    (int -> int -> Slap_C.num_type) -> ('m, 'n, 'cnt) Slap_C.mat
  val init_rows :
    'm Slap_size.t ->
    'n Slap_size.t ->
    (int -> int -> Slap_C.num_type) -> ('m, 'n, 'cnt) Slap_C.mat
  val dim : ('m, 'n, 'cd) Slap_C.mat -> 'm Slap_size.t * 'n Slap_size.t
  val dim1 : ('m, 'n, 'cd) Slap_C.mat -> 'm Slap_size.t
  val dim2 : ('m, 'n, 'cd) Slap_C.mat -> 'n Slap_size.t
  val get_dyn : ('m, 'n, 'cd) Slap_C.mat -> int -> int -> Slap_C.num_type
  val set_dyn :
    ('m, 'n, 'cd) Slap_C.mat -> int -> int -> Slap_C.num_type -> unit
  val unsafe_get : ('m, 'n, 'cd) Slap_C.mat -> int -> int -> Slap_C.num_type
  val unsafe_set :
    ('m, 'n, 'cd) Slap_C.mat -> int -> int -> Slap_C.num_type -> unit
  val col_dyn : ('m, 'n, 'cd) Slap_C.mat -> int -> ('m, 'cnt) Slap_C.vec
  val row_dyn :
    ('m, 'n, 'cd) Slap_C.mat -> int -> ('n, Slap_misc.dsc) Slap_C.vec
  val copy_row_dyn : ('m, 'n, 'cd) Slap_C.mat -> int -> ('n, 'cnt) Slap_C.vec
  val diag : ('n, 'n, 'cd) Slap_C.mat -> ('n, Slap_misc.dsc) Slap_C.vec
  val diag_rect :
    ('m, 'n, 'cd) Slap_C.mat ->
    (('m, 'n) Slap_size.min, Slap_misc.dsc) Slap_C.vec
  val copy_diag : ('n, 'n, 'cd) Slap_C.mat -> ('n, 'cnt) Slap_C.vec
  val copy_diag_rect :
    ('m, 'n, 'cd) Slap_C.mat -> (('m, 'n) Slap_size.min, 'cnt) Slap_C.vec
  val as_vec :
    ('m, 'n, Slap_misc.cnt) Slap_C.mat ->
    (('m, 'n) Slap_size.mul, 'cnt) Slap_C.vec
  val fill : ('m, 'n, 'cd) Slap_C.mat -> Slap_C.num_type -> unit
  val copy :
    ?uplo:[ `L | `U ] ->
    ?b:('m, 'n, 'b_cd) Slap_C.mat ->
    ('m, 'n, 'a_cd) Slap_C.mat -> ('m, 'n, 'b_cd) Slap_C.mat
  val of_col_vecs_dyn :
    'm Slap_size.t ->
    'n Slap_size.t ->
    ('m, Slap_misc.cnt) Slap_C.vec array -> ('m, 'n, 'cnt) Slap_C.mat
  val to_array : ('m, 'n, 'cd) Slap_C.mat -> Slap_C.num_type array array
  val of_array_dyn :
    'm Slap_size.t ->
    'n Slap_size.t ->
    Slap_C.num_type array array -> ('m, 'n, 'cnt) Slap_C.mat
  val of_array : Slap_C.num_type array array -> (module Slap_C.Mat.CNTMAT)
  module Of_array :
    functor (X : sig val value : Slap_C.num_type array array end) -> CNTMAT
  val unsafe_of_array :
    'm Slap_size.t ->
    'n Slap_size.t ->
    Slap_C.num_type array array -> ('m, 'n, 'cnt) Slap_C.mat
  val to_list : ('m, 'n, 'cd) Slap_C.mat -> Slap_C.num_type list list
  val of_list_dyn :
    'm Slap_size.t ->
    'n Slap_size.t -> Slap_C.num_type list list -> ('m, 'n, 'cnt) Slap_C.mat
  val of_list : Slap_C.num_type list list -> (module Slap_C.Mat.CNTMAT)
  module Of_list :
    functor (X : sig val value : Slap_C.num_type list list end) -> CNTMAT
  val unsafe_of_list :
    'm Slap_size.t ->
    'n Slap_size.t -> Slap_C.num_type list list -> ('m, 'n, 'cnt) Slap_C.mat
  val to_bigarray :
    ('m, 'n, 'cd) Slap_C.mat ->
    (Slap_C.num_type, Slap_C.prec, Bigarray.fortran_layout) Bigarray.Array2.t
  val of_bigarray_dyn :
    ?share:bool ->
    'm Slap_size.t ->
    'n Slap_size.t ->
    (Slap_C.num_type, Slap_C.prec, Bigarray.fortran_layout) Bigarray.Array2.t ->
    ('m, 'n, 'cnt) Slap_C.mat
  val of_bigarray :
    (Slap_C.num_type, Slap_C.prec, Bigarray.fortran_layout) Bigarray.Array2.t ->
    (module Slap_C.Mat.CNTMAT)
  module Of_bigarray :
    functor
      (X : sig
             val value :
               (Slap_C.num_type, Slap_C.prec, Bigarray.fortran_layout)
               Bigarray.Array2.t
           end) ->
      CNTMAT
  val unsafe_of_bigarray :
    ?share:bool ->
    'm Slap_size.t ->
    'n Slap_size.t ->
    (Slap_C.num_type, Slap_C.prec, Bigarray.fortran_layout) Bigarray.Array2.t ->
    ('m, 'n, 'cnt) Slap_C.mat
  val of_array_c :
    Slap_C.num_type array array ->
    (Slap_C.num_type, Slap_C.prec, 'cnt) Slap_mat.dyn
  val of_list_c :
    Slap_C.num_type list list ->
    (Slap_C.num_type, Slap_C.prec, 'cnt) Slap_mat.dyn
  val of_bigarray_c :
    ?share:bool ->
    (Slap_C.num_type, Slap_C.prec, Bigarray.fortran_layout) Bigarray.Array2.t ->
    (Slap_C.num_type, Slap_C.prec, 'cnt) Slap_mat.dyn
  val map :
    (Slap_C.num_type -> Slap_C.num_type) ->
    ?b:('m, 'n, 'b_cd) Slap_C.mat ->
    ('m, 'n, 'a_cd) Slap_C.mat -> ('m, 'n, 'b_cd) Slap_C.mat
  val mapi :
    (int -> int -> Slap_C.num_type -> Slap_C.num_type) ->
    ?b:('m, 'n, 'b_cd) Slap_C.mat ->
    ('m, 'n, 'a_cd) Slap_C.mat -> ('m, 'n, 'b_cd) Slap_C.mat
  val fold_left :
    ('accum -> ('m, 'x_cd) Slap_C.vec -> 'accum) ->
    'accum -> ('m, 'n, 'a_cd) Slap_C.mat -> 'accum
  val fold_lefti :
    (int -> 'accum -> ('m, 'x_cd) Slap_C.vec -> 'accum) ->
    'accum -> ('m, 'n, 'a_cd) Slap_C.mat -> 'accum
  val fold_right :
    (('m, 'x_cd) Slap_C.vec -> 'accum -> 'accum) ->
    ('m, 'n, 'a_cd) Slap_C.mat -> 'accum -> 'accum
  val fold_righti :
    (int -> ('m, 'x_cd) Slap_C.vec -> 'accum -> 'accum) ->
    ('m, 'n, 'a_cd) Slap_C.mat -> 'accum -> 'accum
  val fold_top :
    ('accum -> ('n, Slap_misc.dsc) Slap_C.vec -> 'accum) ->
    'accum -> ('m, 'n, 'a_cd) Slap_C.mat -> 'accum
  val fold_topi :
    (int -> 'accum -> ('n, Slap_misc.dsc) Slap_C.vec -> 'accum) ->
    'accum -> ('m, 'n, 'a_cd) Slap_C.mat -> 'accum
  val fold_bottom :
    (('n, Slap_misc.dsc) Slap_C.vec -> 'accum -> 'accum) ->
    ('m, 'n, 'a_cd) Slap_C.mat -> 'accum -> 'accum
  val fold_bottomi :
    (int -> ('n, Slap_misc.dsc) Slap_C.vec -> 'accum -> 'accum) ->
    ('m, 'n, 'a_cd) Slap_C.mat -> 'accum -> 'accum
  val replace_all :
    ('m, 'n, 'cd) Slap_C.mat -> (Slap_C.num_type -> Slap_C.num_type) -> unit
  val replace_alli :
    ('m, 'n, 'cd) Slap_C.mat ->
    (int -> int -> Slap_C.num_type -> Slap_C.num_type) -> unit
  val transpose_copy :
    ?b:('n, 'm, 'b_cd) Slap_C.mat ->
    ('m, 'n, 'a_cd) Slap_C.mat -> ('n, 'm, 'b_cd) Slap_C.mat
  val detri : ?up:bool -> ('n, 'n, 'cd) Slap_C.mat -> unit
  val packed :
    ?up:bool ->
    ?x:('n Slap_size.packed, Slap_misc.cnt) Slap_C.vec ->
    ('n, 'n, 'cd) Slap_C.mat -> ('n Slap_size.packed, 'cnt) Slap_C.vec
  val unpacked :
    ?up:bool ->
    ?fill_num:Slap_C.num_type option ->
    ?a:('n, 'n, 'cd) Slap_C.mat ->
    ('n Slap_size.packed, Slap_misc.cnt) Slap_C.vec ->
    ('n, 'n, 'cd) Slap_C.mat
  val geband_dyn :
    'kl Slap_size.t ->
    'ku Slap_size.t ->
    ?b:(('m, 'n, 'kl, 'ku) Slap_size.geband, 'n, 'b_cd) Slap_C.mat ->
    ('m, 'n, 'a_cd) Slap_C.mat ->
    (('m, 'n, 'kl, 'ku) Slap_size.geband, 'n, 'b_cd) Slap_C.mat
  val ungeband :
    'm Slap_size.t ->
    'kl Slap_size.t ->
    'ku Slap_size.t ->
    ?fill_num:Slap_C.num_type option ->
    ?a:('m, 'n, 'a_cd) Slap_C.mat ->
    (('m, 'n, 'kl, 'ku) Slap_size.geband, 'n, 'b_cd) Slap_C.mat ->
    ('m, 'n, 'a_cd) Slap_C.mat
  val syband_dyn :
    'kd Slap_size.t ->
    ?up:bool ->
    ?b:(('n, 'kd) Slap_size.syband, 'n, 'b_cd) Slap_C.mat ->
    ('n, 'n, 'a_cd) Slap_C.mat ->
    (('n, 'kd) Slap_size.syband, 'n, 'b_cd) Slap_C.mat
  val unsyband :
    'kd Slap_size.t ->
    ?up:bool ->
    ?fill_num:Slap_C.num_type option ->
    ?a:('n, 'n, 'a_cd) Slap_C.mat ->
    (('n, 'kd) Slap_size.syband, 'n, 'b_cd) Slap_C.mat ->
    ('n, 'n, 'a_cd) Slap_C.mat
  val luband_dyn :
    'kl Slap_size.t ->
    'ku Slap_size.t ->
    ?ab:(('m, 'n, 'kl, 'ku) Slap_size.luband, 'n, 'b_cd) Slap_C.mat ->
    ('m, 'n, 'a_cd) Slap_C.mat ->
    (('m, 'n, 'kl, 'ku) Slap_size.luband, 'n, 'b_cd) Slap_C.mat
  val unluband :
    'm Slap_size.t ->
    'kl Slap_size.t ->
    'ku Slap_size.t ->
    ?fill_num:Slap_C.num_type option ->
    ?a:('m, 'n, 'a_cd) Slap_C.mat ->
    (('m, 'n, 'kl, 'ku) Slap_size.luband, 'n, 'b_cd) Slap_C.mat ->
    ('m, 'n, 'a_cd) Slap_C.mat
  val add_const :
    Slap_C.num_type ->
    ?b:('m, 'n, 'b_cd) Slap_C.mat ->
    ('m, 'n, 'a_cd) Slap_C.mat -> ('m, 'n, 'b_cd) Slap_C.mat
  val sum : ('m, 'n, 'cd) Slap_C.mat -> Slap_C.num_type
  val trace : ('m, 'n, 'cd) Slap_C.mat -> Slap_C.num_type
  val scal : Slap_C.num_type -> ('m, 'n, 'cd) Slap_C.mat -> unit
  val scal_cols :
    ('m, 'n, 'cd) Slap_C.mat -> ('n, Slap_misc.cnt) Slap_C.vec -> unit
  val scal_rows :
    ('m, Slap_misc.cnt) Slap_C.vec -> ('m, 'n, 'cd) Slap_C.mat -> unit
  val axpy :
    ?alpha:Slap_C.num_type ->
    ('m, 'n, 'x_cd) Slap_C.mat -> ('m, 'n, 'y_cd) Slap_C.mat -> unit
  val gemm_diag :
    ?beta:Slap_C.num_type ->
    ?y:('n, Slap_misc.cnt) Slap_C.vec ->
    transa:('a_n * 'a_k, 'n * 'k, [< `C | `N | `T ]) Slap_C.trans3 ->
    ?alpha:Slap_C.num_type ->
    ('a_n, 'a_k, 'a_cd) Slap_C.mat ->
    transb:('b_k * 'b_n, 'k * 'n, [< `C | `N | `T ]) Slap_C.trans3 ->
    ('b_k, 'b_n, 'b_cd) Slap_C.mat -> ('n, 'cnt) Slap_C.vec
  val syrk_diag :
    ?beta:Slap_C.num_type ->
    ?y:('n, Slap_misc.cnt) Slap_C.vec ->
    trans:('a_n * 'a_k, 'n * 'k, [< `N | `T ]) Slap_common.trans2 ->
    ?alpha:Slap_C.num_type ->
    ('a_n, 'a_k, 'a_cd) Slap_C.mat -> ('n, 'cnt) Slap_C.vec
  val gemm_trace :
    transa:('a_n * 'a_k, 'n * 'k, [< `C | `N | `T ]) Slap_C.trans3 ->
    ('a_n, 'a_k, 'a_cd) Slap_C.mat ->
    transb:('b_k * 'b_n, 'k * 'n, [< `C | `N | `T ]) Slap_C.trans3 ->
    ('b_k, 'b_n, 'b_cd) Slap_C.mat -> Slap_C.num_type
  val syrk_trace : ('n, 'k, 'cd) Slap_C.mat -> Slap_C.num_type
  val symm2_trace :
    ?upa:bool ->
    ('n, 'n, 'a_cd) Slap_C.mat ->
    ?upb:bool -> ('n, 'n, 'b_cd) Slap_C.mat -> Slap_C.num_type
  val submat_dyn :
    'm Slap_size.t ->
    'n Slap_size.t ->
    ?ar:int ->
    ?ac:int -> ('a, 'b, 'cd) Slap_C.mat -> ('m, 'n, Slap_misc.dsc) Slap_C.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_C.mat
end