sig
  type (+'m, +'n, 'num, 'prec, +'cnt_or_dsc) t
  val cnt :
    ('m, 'n, 'num, 'prec, Slap_misc.cnt) Slap_mat.t ->
    ('m, 'n, 'num, 'prec, 'cnt) Slap_mat.t
  val create :
    ('num, 'prec) Bigarray.kind ->
    'm Slap_size.t ->
    'n Slap_size.t -> ('m, 'n, 'num, 'prec, 'cnt) Slap_mat.t
  val make :
    ('num, 'prec) Bigarray.kind ->
    'm Slap_size.t ->
    'n Slap_size.t -> 'num -> ('m, 'n, 'num, 'prec, 'cnt) Slap_mat.t
  val init :
    ('num, 'prec) Bigarray.kind ->
    'm Slap_size.t ->
    'n Slap_size.t ->
    (int -> int -> 'num) -> ('m, 'n, 'num, 'prec, 'cnt) Slap_mat.t
  val init_cols :
    ('num, 'prec) Bigarray.kind ->
    'm Slap_size.t ->
    'n Slap_size.t ->
    (int -> int -> 'num) -> ('m, 'n, 'num, 'prec, 'cnt) Slap_mat.t
  val init_rows :
    ('num, 'prec) Bigarray.kind ->
    'm Slap_size.t ->
    'n Slap_size.t ->
    (int -> int -> 'num) -> ('m, 'n, 'num, 'prec, 'cnt) Slap_mat.t
  val kind :
    ('m, 'n, 'num, 'prec, 'cd) Slap_mat.t -> ('num, 'prec) Bigarray.kind
  val dim :
    ('m, 'n, 'num, 'prec, 'cd) Slap_mat.t -> 'm Slap_size.t * 'n Slap_size.t
  val dim1 : ('m, 'n, 'num, 'prec, 'cd) Slap_mat.t -> 'm Slap_size.t
  val dim2 : ('m, 'n, 'num, 'prec, 'cd) Slap_mat.t -> 'n Slap_size.t
  val get_dyn : ('m, 'n, 'num, 'prec, 'cd) Slap_mat.t -> int -> int -> 'num
  val set_dyn :
    ('m, 'n, 'num, 'prec, 'cd) Slap_mat.t -> int -> int -> 'num -> unit
  val unsafe_get :
    ('m, 'n, 'num, 'prec, 'cd) Slap_mat.t -> int -> int -> 'num
  val unsafe_set :
    ('m, 'n, 'num, 'prec, 'cd) Slap_mat.t -> int -> int -> 'num -> unit
  val replace_dyn :
    ('m, 'n, 'num, 'prec, 'cd) Slap_mat.t ->
    int -> int -> ('num -> 'num) -> unit
  val col_dyn :
    ('m, 'n, 'num, 'prec, 'cd) Slap_mat.t ->
    int -> ('m, 'num, 'prec, 'cnt) Slap_vec.t
  val row_dyn :
    ('m, 'n, 'num, 'prec, 'cd) Slap_mat.t ->
    int -> ('n, 'num, 'prec, Slap_misc.dsc) Slap_vec.t
  val diag :
    ('n, 'n, 'num, 'prec, 'cd) Slap_mat.t ->
    ('n, 'num, 'prec, Slap_misc.dsc) Slap_vec.t
  val diag_rect :
    ('m, 'n, 'num, 'prec, 'cd) Slap_mat.t ->
    (('m, 'n) Slap_size.min, 'num, 'prec, Slap_misc.dsc) Slap_vec.t
  val as_vec :
    ('m, 'n, 'num, 'prec, Slap_misc.cnt) Slap_mat.t ->
    (('m, 'n) Slap_size.mul, 'num, 'prec, 'cnt) Slap_vec.t
  val fill : ('m, 'n, 'num, 'prec, 'cd) Slap_mat.t -> 'num -> unit
  val copy :
    ?b:('m, 'n, 'num, 'prec, 'b_cd) Slap_mat.t ->
    ('m, 'n, 'num, 'prec, 'a_cd) Slap_mat.t ->
    ('m, 'n, 'num, 'prec, 'b_cd) Slap_mat.t
  val packed :
    ?up:bool ->
    ?x:('n Slap_size.packed, 'num, 'prec, Slap_misc.cnt) Slap_vec.t ->
    ('n, 'n, 'num, 'prec, 'cd) Slap_mat.t ->
    ('n Slap_size.packed, 'num, 'prec, 'cnt) Slap_vec.t
  val unpacked :
    ?up:bool ->
    ?fill_num:'num option ->
    ?a:('n, 'n, 'num, 'prec, 'cd) Slap_mat.t ->
    ('n Slap_size.packed, 'num, 'prec, Slap_misc.cnt) Slap_vec.t ->
    ('n, 'n, 'num, 'prec, 'cd) Slap_mat.t
  val geband_dyn :
    'kl Slap_size.t ->
    'ku Slap_size.t ->
    ?b:(('m, 'n, 'kl, 'ku) Slap_size.geband, 'n, 'num, 'prec, 'b_cd)
       Slap_mat.t ->
    ('m, 'n, 'num, 'prec, 'a_cd) Slap_mat.t ->
    (('m, 'n, 'kl, 'ku) Slap_size.geband, 'n, 'num, 'prec, 'b_cd) Slap_mat.t
  val ungeband :
    'm Slap_size.t ->
    'kl Slap_size.t ->
    'ku Slap_size.t ->
    ?fill_num:'num option ->
    ?a:('m, 'n, 'num, 'prec, 'a_cd) Slap_mat.t ->
    (('m, 'n, 'kl, 'ku) Slap_size.geband, 'n, 'num, 'prec, 'b_cd) Slap_mat.t ->
    ('m, 'n, 'num, 'prec, 'a_cd) Slap_mat.t
  val syband_dyn :
    'kd Slap_size.t ->
    ?up:bool ->
    ?b:(('n, 'kd) Slap_size.syband, 'n, 'num, 'prec, 'b_cd) Slap_mat.t ->
    ('n, 'n, 'num, 'prec, 'a_cd) Slap_mat.t ->
    (('n, 'kd) Slap_size.syband, 'n, 'num, 'prec, 'b_cd) Slap_mat.t
  val unsyband :
    'kd Slap_size.t ->
    ?up:bool ->
    ?fill_num:'num option ->
    ?a:('n, 'n, 'num, 'prec, 'a_cd) Slap_mat.t ->
    (('n, 'kd) Slap_size.syband, 'n, 'num, 'prec, 'b_cd) Slap_mat.t ->
    ('n, 'n, 'num, 'prec, 'a_cd) Slap_mat.t
  val luband_dyn :
    'kl Slap_size.t ->
    'ku Slap_size.t ->
    ?ab:(('m, 'n, 'kl, 'ku) Slap_size.luband, 'n, 'num, 'prec, 'b_cd)
        Slap_mat.t ->
    ('m, 'n, 'num, 'prec, 'a_cd) Slap_mat.t ->
    (('m, 'n, 'kl, 'ku) Slap_size.luband, 'n, 'num, 'prec, 'b_cd) Slap_mat.t
  val unluband :
    'm Slap_size.t ->
    'kl Slap_size.t ->
    'ku Slap_size.t ->
    ?fill_num:'num option ->
    ?a:('m, 'n, 'num, 'prec, 'a_cd) Slap_mat.t ->
    (('m, 'n, 'kl, 'ku) Slap_size.luband, 'n, 'num, 'prec, 'b_cd) Slap_mat.t ->
    ('m, 'n, 'num, 'prec, 'a_cd) Slap_mat.t
  val map :
    ('b_num, 'b_prec) Bigarray.kind ->
    ('a_num -> 'b_num) ->
    ?b:('m, 'n, 'b_num, 'b_prec, 'b_cd) Slap_mat.t ->
    ('m, 'n, 'a_num, 'a_prec, 'a_cd) Slap_mat.t ->
    ('m, 'n, 'b_num, 'b_prec, 'b_cd) Slap_mat.t
  val mapi :
    ('b_num, 'b_prec) Bigarray.kind ->
    (int -> int -> 'a_num -> 'b_num) ->
    ?b:('m, 'n, 'b_num, 'b_prec, 'b_cd) Slap_mat.t ->
    ('m, 'n, 'a_num, 'a_prec, 'a_cd) Slap_mat.t ->
    ('m, 'n, 'b_num, 'b_prec, 'b_cd) Slap_mat.t
  val fold_left :
    ('accum -> ('m, 'num, 'prec, 'x_cd) Slap_vec.t -> 'accum) ->
    'accum -> ('m, 'n, 'num, 'prec, 'a_cd) Slap_mat.t -> 'accum
  val fold_lefti :
    (int -> 'accum -> ('m, 'num, 'prec, 'x_cd) Slap_vec.t -> 'accum) ->
    'accum -> ('m, 'n, 'num, 'prec, 'a_cd) Slap_mat.t -> 'accum
  val fold_right :
    (('m, 'num, 'prec, 'x_cd) Slap_vec.t -> 'accum -> 'accum) ->
    ('m, 'n, 'num, 'prec, 'a_cd) Slap_mat.t -> 'accum -> 'accum
  val fold_righti :
    (int -> ('m, 'num, 'prec, 'x_cd) Slap_vec.t -> 'accum -> 'accum) ->
    ('m, 'n, 'num, 'prec, 'a_cd) Slap_mat.t -> 'accum -> 'accum
  val fold_top :
    ('accum -> ('n, 'num, 'prec, Slap_misc.dsc) Slap_vec.t -> 'accum) ->
    'accum -> ('m, 'n, 'num, 'prec, 'a_cd) Slap_mat.t -> 'accum
  val fold_topi :
    (int -> 'accum -> ('n, 'num, 'prec, Slap_misc.dsc) Slap_vec.t -> 'accum) ->
    'accum -> ('m, 'n, 'num, 'prec, 'a_cd) Slap_mat.t -> 'accum
  val fold_bottom :
    (('n, 'num, 'prec, Slap_misc.dsc) Slap_vec.t -> 'accum -> 'accum) ->
    ('m, 'n, 'num, 'prec, 'a_cd) Slap_mat.t -> 'accum -> 'accum
  val fold_bottomi :
    (int -> ('n, 'num, 'prec, Slap_misc.dsc) Slap_vec.t -> 'accum -> 'accum) ->
    ('m, 'n, 'num, 'prec, 'a_cd) Slap_mat.t -> 'accum -> 'accum
  val replace_all :
    ('m, 'n, 'num, 'prec, 'cd) Slap_mat.t -> ('num -> 'num) -> unit
  val replace_alli :
    ('m, 'n, 'num, 'prec, 'cd) Slap_mat.t ->
    (int -> int -> 'num -> 'num) -> unit
  val to_array : ('m, 'n, 'num, 'prec, 'cd) Slap_mat.t -> 'num array array
  val of_array_dyn :
    ('num, 'prec) Bigarray.kind ->
    'm Slap_size.t ->
    'n Slap_size.t ->
    'num array array -> ('m, 'n, 'num, 'prec, 'cnt) Slap_mat.t
  val unsafe_of_array :
    ('num, 'prec) Bigarray.kind ->
    'm Slap_size.t ->
    'n Slap_size.t ->
    'num array array -> ('m, 'n, 'num, 'prec, 'cnt) Slap_mat.t
  val to_list : ('m, 'n, 'num, 'prec, 'cd) Slap_mat.t -> 'num list list
  val of_list_dyn :
    ('num, 'prec) Bigarray.kind ->
    'm Slap_size.t ->
    'n Slap_size.t ->
    'num list list -> ('m, 'n, 'num, 'prec, 'cnt) Slap_mat.t
  val unsafe_of_list :
    ('num, 'prec) Bigarray.kind ->
    'm Slap_size.t ->
    'n Slap_size.t ->
    'num list list -> ('m, 'n, 'num, 'prec, 'cnt) Slap_mat.t
  val to_bigarray :
    ('m, 'n, 'num, 'prec, 'cd) Slap_mat.t ->
    ('num, 'prec, Bigarray.fortran_layout) Bigarray.Array2.t
  val of_bigarray_dyn :
    ?share:bool ->
    'm Slap_size.t ->
    'n Slap_size.t ->
    ('num, 'prec, Bigarray.fortran_layout) Bigarray.Array2.t ->
    ('m, 'n, 'num, 'prec, 'cnt) Slap_mat.t
  val unsafe_of_bigarray :
    ?share:bool ->
    'm Slap_size.t ->
    'n Slap_size.t ->
    ('num, 'prec, Bigarray.fortran_layout) Bigarray.Array2.t ->
    ('m, 'n, 'num, 'prec, 'cnt) Slap_mat.t
  type ('num, 'prec, 'cnt_or_dsc) dyn =
      MAT :
        ('m, 'n, 'num, 'prec, 'cnt_or_dsc) Slap_mat.t -> ('num, 'prec,
                                                          'cnt_or_dsc)
                                                         Slap_mat.dyn
  val of_array_c :
    ('num, 'prec) Bigarray.kind ->
    'num array array -> ('num, 'prec, 'cnt) Slap_mat.dyn
  val of_list_c :
    ('num, 'prec) Bigarray.kind ->
    'num list list -> ('num, 'prec, 'cnt) Slap_mat.dyn
  val of_bigarray_c :
    ?share:bool ->
    ('num, 'prec, Bigarray.fortran_layout) Bigarray.Array2.t ->
    ('num, 'prec, 'cnt) Slap_mat.dyn
  val submat_dyn :
    'm Slap_size.t ->
    'n Slap_size.t ->
    ?ar:int ->
    ?ac:int ->
    ('a, 'b, 'num, 'prec, 'cd) Slap_mat.t ->
    ('m, 'n, 'num, 'prec, Slap_misc.dsc) Slap_mat.t
  val dim_array_array : 'a array array -> (int * int) option
  val dim_list_list : 'a list list -> (int * int) option
  val check_cnt : ('m, 'n, 'num, 'prec, Slap_misc.cnt) Slap_mat.t -> bool
  val create_array2 :
    ('a, 'b) Bigarray.kind ->
    'm Slap_size.t ->
    'n Slap_size.t -> ('a, 'b, Bigarray.fortran_layout) Bigarray.Array2.t
  val opt_mat :
    'm Slap_size.t ->
    'n Slap_size.t ->
    ('m, 'n, 'num, 'prec, 'cd) Slap_mat.t option ->
    int option * int option *
    ('num, 'prec, Bigarray.fortran_layout) Bigarray.Array2.t option
  val opt_mat_alloc :
    ('num, 'prec) Bigarray.kind ->
    'm Slap_size.t ->
    'n Slap_size.t ->
    ('m, 'n, 'num, 'prec, 'cd) Slap_mat.t option ->
    int * int * ('num, 'prec, Bigarray.fortran_layout) Bigarray.Array2.t
  val __expose :
    ('m, 'n, 'num, 'prec, 'cnt_or_dsc) Slap_mat.t ->
    'm Slap_size.t * 'n Slap_size.t * int * int *
    ('num, 'prec, Bigarray.fortran_layout) Bigarray.Array2.t
  val __unexpose :
    'm Slap_size.t ->
    'n Slap_size.t ->
    int ->
    int ->
    ('num, 'prec, Bigarray.fortran_layout) Bigarray.Array2.t ->
    ('m, 'n, 'num, 'prec, 'cnt_or_dsc) Slap_mat.t
end