sig
  type (+'n, 'num, 'prec, +'cnt_or_dsc) t
  val cnt :
    ('n, 'num, 'prec, Slap_misc.cnt) Slap_vec.t ->
    ('n, 'num, 'prec, 'cnt) Slap_vec.t
  val create :
    ('num, 'prec) Bigarray.kind ->
    'n Slap_size.t -> ('n, 'num, 'prec, 'cnt) Slap_vec.t
  val make :
    ('num, 'prec) Bigarray.kind ->
    'n Slap_size.t -> 'num -> ('n, 'num, 'prec, 'cnt) Slap_vec.t
  val init :
    ('a, 'b) Bigarray.kind ->
    'n Slap_size.t -> (int -> 'a) -> ('n, 'a, 'b, 'cnt) Slap_vec.t
  val kind : ('n, 'num, 'prec, 'cd) Slap_vec.t -> ('num, 'prec) Bigarray.kind
  val dim : ('n, 'num, 'prec, 'cd) Slap_vec.t -> 'n Slap_size.t
  val get_dyn : ('n, 'num, 'prec, 'cd) Slap_vec.t -> int -> 'num
  val set_dyn : ('n, 'num, 'prec, 'cd) Slap_vec.t -> int -> 'num -> unit
  val unsafe_get : ('n, 'num, 'prec, 'cd) Slap_vec.t -> int -> 'num
  val unsafe_set : ('n, 'num, 'prec, 'cd) Slap_vec.t -> int -> 'num -> unit
  val replace_dyn :
    ('n, 'num, 'prec, 'cd) Slap_vec.t -> int -> ('num -> 'num) -> unit
  val map :
    ('y_num, 'y_prec) Bigarray.kind ->
    ('x_num -> 'y_num) ->
    ?y:('n, 'y_num, 'y_prec, 'y_cd) Slap_vec.t ->
    ('n, 'x_num, 'x_prec, 'x_cd) Slap_vec.t ->
    ('n, 'y_num, 'y_prec, 'y_cd) Slap_vec.t
  val mapi :
    ('y_num, 'y_prec) Bigarray.kind ->
    (int -> 'x_num -> 'y_num) ->
    ?y:('n, 'y_num, 'y_prec, 'y_cd) Slap_vec.t ->
    ('n, 'x_num, 'x_prec, 'x_cd) Slap_vec.t ->
    ('n, 'y_num, 'y_prec, 'y_cd) Slap_vec.t
  val fold_left :
    ('accum -> 'x_num -> 'accum) ->
    'accum -> ('n, 'x_num, 'prec, 'cd) Slap_vec.t -> 'accum
  val fold_lefti :
    (int -> 'accum -> 'num -> 'accum) ->
    'accum -> ('n, 'num, 'prec, 'cd) Slap_vec.t -> 'accum
  val fold_right :
    ('num -> 'accum -> 'accum) ->
    ('n, 'num, 'prec, 'cd) Slap_vec.t -> 'accum -> 'accum
  val fold_righti :
    (int -> 'num -> 'accum -> 'accum) ->
    ('n, 'num, 'prec, 'cd) Slap_vec.t -> 'accum -> 'accum
  val replace_all :
    ('n, 'num, 'prec, 'cd) Slap_vec.t -> ('num -> 'num) -> unit
  val replace_alli :
    ('n, 'num, 'prec, 'cd) Slap_vec.t -> (int -> 'num -> 'num) -> unit
  val iter : ('num -> unit) -> ('n, 'num, 'prec, 'cd) Slap_vec.t -> unit
  val iteri :
    (int -> 'num -> unit) -> ('n, 'num, 'prec, 'cd) Slap_vec.t -> unit
  val map2 :
    ('z_num, 'z_prec) Bigarray.kind ->
    ('x_num -> 'y_num -> 'z_num) ->
    ?z:('n, 'z_num, 'z_prec, 'z_cd) Slap_vec.t ->
    ('n, 'x_num, 'x_prec, 'x_cd) Slap_vec.t ->
    ('n, 'y_num, 'y_prec, 'y_cd) Slap_vec.t ->
    ('n, 'z_num, 'z_prec, 'z_cd) Slap_vec.t
  val mapi2 :
    ('z_num, 'z_prec) Bigarray.kind ->
    (int -> 'x_num -> 'y_num -> 'z_num) ->
    ?z:('n, 'z_num, 'z_prec, 'z_cd) Slap_vec.t ->
    ('n, 'x_num, 'x_prec, 'x_cd) Slap_vec.t ->
    ('n, 'y_num, 'y_prec, 'y_cd) Slap_vec.t ->
    ('n, 'z_num, 'z_prec, 'z_cd) Slap_vec.t
  val fold_left2 :
    ('accum -> 'x_num -> 'y_num -> 'accum) ->
    'accum ->
    ('n, 'x_num, 'x_prec, 'x_cd) Slap_vec.t ->
    ('n, 'y_num, 'y_prec, 'y_cd) Slap_vec.t -> 'accum
  val fold_lefti2 :
    (int -> 'accum -> 'x_num -> 'y_num -> 'accum) ->
    'accum ->
    ('n, 'x_num, 'x_prec, 'x_cd) Slap_vec.t ->
    ('n, 'y_num, 'y_prec, 'y_cd) Slap_vec.t -> 'accum
  val fold_right2 :
    ('x_num -> 'y_num -> 'accum -> 'accum) ->
    ('n, 'x_num, 'x_prec, 'x_cd) Slap_vec.t ->
    ('n, 'y_num, 'y_prec, 'y_cd) Slap_vec.t -> 'accum -> 'accum
  val fold_righti2 :
    (int -> 'x_num -> 'y_num -> 'accum -> 'accum) ->
    ('n, 'x_num, 'x_prec, 'x_cd) Slap_vec.t ->
    ('n, 'y_num, 'y_prec, 'y_cd) Slap_vec.t -> 'accum -> 'accum
  val iter2 :
    ('x_num -> 'y_num -> unit) ->
    ('n, 'x_num, 'x_prec, 'x_cd) Slap_vec.t ->
    ('n, 'y_num, 'y_prec, 'y_cd) Slap_vec.t -> unit
  val iteri2 :
    (int -> 'x_num -> 'y_num -> unit) ->
    ('n, 'x_num, 'x_prec, 'x_cd) Slap_vec.t ->
    ('n, 'y_num, 'y_prec, 'y_cd) Slap_vec.t -> unit
  val map3 :
    ('w_num, 'w_prec) Bigarray.kind ->
    ('x_num -> 'y_num -> 'z_num -> 'w_num) ->
    ?w:('n, 'w_num, 'w_prec, 'w_cd) Slap_vec.t ->
    ('n, 'x_num, 'x_prec, 'x_cd) Slap_vec.t ->
    ('n, 'y_num, 'y_prec, 'y_cd) Slap_vec.t ->
    ('n, 'z_num, 'z_prec, 'z_cd) Slap_vec.t ->
    ('n, 'w_num, 'w_prec, 'w_cd) Slap_vec.t
  val mapi3 :
    ('w_num, 'w_prec) Bigarray.kind ->
    (int -> 'x_num -> 'y_num -> 'z_num -> 'w_num) ->
    ?w:('n, 'w_num, 'w_prec, 'w_cd) Slap_vec.t ->
    ('n, 'x_num, 'x_prec, 'x_cd) Slap_vec.t ->
    ('n, 'y_num, 'y_prec, 'y_cd) Slap_vec.t ->
    ('n, 'z_num, 'z_prec, 'z_cd) Slap_vec.t ->
    ('n, 'w_num, 'w_prec, 'w_cd) Slap_vec.t
  val fold_left3 :
    ('accum -> 'x_num -> 'y_num -> 'z_num -> 'accum) ->
    'accum ->
    ('n, 'x_num, 'x_prec, 'x_cd) Slap_vec.t ->
    ('n, 'y_num, 'y_prec, 'y_cd) Slap_vec.t ->
    ('n, 'z_num, 'z_prec, 'z_cd) Slap_vec.t -> 'accum
  val fold_lefti3 :
    (int -> 'accum -> 'x_num -> 'y_num -> 'z_num -> 'accum) ->
    'accum ->
    ('n, 'x_num, 'x_prec, 'x_cd) Slap_vec.t ->
    ('n, 'y_num, 'y_prec, 'y_cd) Slap_vec.t ->
    ('n, 'z_num, 'z_prec, 'z_cd) Slap_vec.t -> 'accum
  val fold_right3 :
    ('x_num -> 'y_num -> 'z_num -> 'accum -> 'accum) ->
    ('n, 'x_num, 'x_prec, 'x_cd) Slap_vec.t ->
    ('n, 'y_num, 'y_prec, 'y_cd) Slap_vec.t ->
    ('n, 'z_num, 'z_prec, 'z_cd) Slap_vec.t -> 'accum -> 'accum
  val fold_righti3 :
    (int -> 'x_num -> 'y_num -> 'z_num -> 'accum -> 'accum) ->
    ('n, 'x_num, 'x_prec, 'x_cd) Slap_vec.t ->
    ('n, 'y_num, 'y_prec, 'y_cd) Slap_vec.t ->
    ('n, 'z_num, 'z_prec, 'z_cd) Slap_vec.t -> 'accum -> 'accum
  val iter3 :
    ('x_num -> 'y_num -> 'z_num -> unit) ->
    ('n, 'x_num, 'x_prec, 'x_cd) Slap_vec.t ->
    ('n, 'y_num, 'y_prec, 'y_cd) Slap_vec.t ->
    ('n, 'z_num, 'z_prec, 'z_cd) Slap_vec.t -> unit
  val iteri3 :
    (int -> 'x_num -> 'y_num -> 'z_num -> unit) ->
    ('n, 'x_num, 'x_prec, 'x_cd) Slap_vec.t ->
    ('n, 'y_num, 'y_prec, 'y_cd) Slap_vec.t ->
    ('n, 'z_num, 'z_prec, 'z_cd) Slap_vec.t -> unit
  val for_all : ('num -> bool) -> ('n, 'num, 'prec, 'cd) Slap_vec.t -> bool
  val exists : ('num -> bool) -> ('n, 'num, 'prec, 'cd) Slap_vec.t -> bool
  val for_all2 :
    ('x_num -> 'y_num -> bool) ->
    ('n, 'x_num, 'x_prec, 'x_cd) Slap_vec.t ->
    ('n, 'y_num, 'y_prec, 'y_cd) Slap_vec.t -> bool
  val exists2 :
    ('x_num -> 'y_num -> bool) ->
    ('n, 'x_num, 'x_prec, 'x_cd) Slap_vec.t ->
    ('n, 'y_num, 'y_prec, 'y_cd) Slap_vec.t -> bool
  val mem :
    ?equal:('num -> 'num -> bool) ->
    'num -> ('n, 'num, 'prec, 'cd) Slap_vec.t -> bool
  val cons :
    ?y:('n Slap_size.s, 'num, 'prec, 'y_cd) Slap_vec.t ->
    'num ->
    ('n, 'num, 'prec, 'x_cd) Slap_vec.t ->
    ('n Slap_size.s, 'num, 'prec, 'y_cd) Slap_vec.t
  val hd : ('n Slap_size.s, 'num, 'prec, 'x_cd) Slap_vec.t -> 'num
  val hd_dyn : ('n, 'num, 'prec, 'x_cd) Slap_vec.t -> 'num
  val last : ('n Slap_size.s, 'num, 'prec, 'x_cd) Slap_vec.t -> 'num
  val last_dyn : ('n, 'num, 'prec, 'x_cd) Slap_vec.t -> 'num
  val tl :
    ?y:('n, 'num, 'prec, 'y_cd) Slap_vec.t ->
    ('n Slap_size.s, 'num, 'prec, 'x_cd) Slap_vec.t ->
    ('n, 'num, 'prec, 'x_cd) Slap_vec.t
  val tl_dyn :
    ?y:('n Slap_size.p, 'num, 'prec, 'y_cd) Slap_vec.t ->
    ('n, 'num, 'prec, 'x_cd) Slap_vec.t ->
    ('n Slap_size.p, 'num, 'prec, 'x_cd) Slap_vec.t
  val inits :
    ?y:('n, 'num, 'prec, 'y_cd) Slap_vec.t ->
    ('n Slap_size.s, 'num, 'prec, 'x_cd) Slap_vec.t ->
    ('n, 'num, 'prec, 'x_cd) Slap_vec.t
  val inits_dyn :
    ?y:('n Slap_size.p, 'num, 'prec, 'y_cd) Slap_vec.t ->
    ('n, 'num, 'prec, 'x_cd) Slap_vec.t ->
    ('n Slap_size.p, 'num, 'prec, 'x_cd) Slap_vec.t
  val copy :
    ?y:('n, 'num, 'prec, 'y_cd) Slap_vec.t ->
    ('n, 'num, 'prec, 'x_cd) Slap_vec.t ->
    ('n, 'num, 'prec, 'y_cd) Slap_vec.t
  val fill : ('n, 'num, 'prec, 'cd) Slap_vec.t -> 'num -> unit
  val append :
    ('m, 'num, 'prec, 'x_cd) Slap_vec.t ->
    ('n, 'num, 'prec, 'y_cd) Slap_vec.t ->
    (('m, 'n) Slap_size.add, 'num, 'prec, 'cnt) Slap_vec.t
  val shared_rev :
    ('n, 'num, 'prec, 'cd) Slap_vec.t -> ('n, 'num, 'prec, 'cd) Slap_vec.t
  val rev :
    ('n, 'num, 'prec, 'cd) Slap_vec.t -> ('n, 'num, 'prec, 'cd) Slap_vec.t
  val to_array : ('n, 'num, 'prec, 'cd) Slap_vec.t -> 'num array
  val of_array_dyn :
    ('num, 'prec) Bigarray.kind ->
    'n Slap_size.t -> 'num array -> ('n, 'num, 'prec, 'cnt) Slap_vec.t
  val unsafe_of_array :
    ('num, 'prec) Bigarray.kind ->
    'n Slap_size.t -> 'num array -> ('n, 'num, 'prec, 'cnt) Slap_vec.t
  val to_list : ('n, 'num, 'prec, 'cd) Slap_vec.t -> 'num list
  val of_list_dyn :
    ('num, 'prec) Bigarray.kind ->
    'n Slap_size.t -> 'num list -> ('n, 'num, 'prec, 'cnt) Slap_vec.t
  val unsafe_of_list :
    ('num, 'prec) Bigarray.kind ->
    'n Slap_size.t -> 'num list -> ('n, 'num, 'prec, 'cnt) Slap_vec.t
  val to_bigarray :
    ('n, 'num, 'prec, 'cd) Slap_vec.t ->
    ('num, 'prec, Bigarray.fortran_layout) Bigarray.Array1.t
  val of_bigarray_dyn :
    ?share:bool ->
    'n Slap_size.t ->
    ('num, 'prec, Bigarray.fortran_layout) Bigarray.Array1.t ->
    ('n, 'num, 'prec, 'cnt) Slap_vec.t
  val unsafe_of_bigarray :
    ?share:bool ->
    'n Slap_size.t ->
    ('num, 'prec, Bigarray.fortran_layout) Bigarray.Array1.t ->
    ('n, 'num, 'prec, 'cnt) Slap_vec.t
  type ('num, 'prec, 'cnt_or_dsc) dyn =
      VEC :
        ('n, 'num, 'prec, 'cnt_or_dsc) Slap_vec.t -> ('num, 'prec,
                                                      'cnt_or_dsc)
                                                     Slap_vec.dyn
  val of_array_c :
    ('num, 'prec) Bigarray.kind ->
    'num array -> ('num, 'prec, 'cnt) Slap_vec.dyn
  val of_list_c :
    ('num, 'prec) Bigarray.kind ->
    'num list -> ('num, 'prec, 'cnt) Slap_vec.dyn
  val of_bigarray_c :
    ?share:bool ->
    ('num, 'prec, Bigarray.fortran_layout) Bigarray.Array1.t ->
    ('num, 'prec, 'cnt) Slap_vec.dyn
  val subcntvec_dyn :
    'm Slap_size.t ->
    ?ofsx:int ->
    ('n, 'num, 'prec, Slap_misc.cnt) Slap_vec.t ->
    ('m, 'num, 'prec, 'cnt) Slap_vec.t
  val subdscvec_dyn :
    'm Slap_size.t ->
    ?ofsx:int ->
    ?incx:int ->
    ('n, 'num, 'prec, 'cd) Slap_vec.t ->
    ('m, 'num, 'prec, Slap_misc.dsc) Slap_vec.t
  val subvec_dyn :
    'm Slap_size.t ->
    ?ofsx:int ->
    ?incx:int ->
    ('n, 'num, 'prec, 'cd) Slap_vec.t ->
    ('m, 'num, 'prec, Slap_misc.dsc) Slap_vec.t
  val check_cnt : ('n, 'num, 'prec, Slap_misc.cnt) Slap_vec.t -> bool
  val opt_work :
    ('n, 'num, 'prec, Slap_misc.cnt) Slap_vec.t option ->
    ('num, 'prec, Bigarray.fortran_layout) Bigarray.Array1.t option
  val opt_cnt_vec :
    'n Slap_size.t ->
    ('n, 'num, 'prec, Slap_misc.cnt) Slap_vec.t option ->
    ('num, 'prec, Bigarray.fortran_layout) Bigarray.Array1.t option
  val opt_cnt_vec_alloc :
    ('num, 'prec) Bigarray.kind ->
    'n Slap_size.t ->
    ('n, 'num, 'prec, Slap_misc.cnt) Slap_vec.t option ->
    ('num, 'prec, Bigarray.fortran_layout) Bigarray.Array1.t
  val opt_vec :
    'n Slap_size.t ->
    ('n, 'num, 'prec, 'cd) Slap_vec.t option ->
    int option *
    ('num, 'prec, Bigarray.fortran_layout) Bigarray.Array1.t option
  val opt_vec_alloc :
    ('num, 'prec) Bigarray.kind ->
    'n Slap_size.t ->
    ('n, 'num, 'prec, 'cd) Slap_vec.t option ->
    int * ('num, 'prec, Bigarray.fortran_layout) Bigarray.Array1.t
  val __expose :
    ('n, 'num, 'prec, 'cnt_or_dsc) Slap_vec.t ->
    'n Slap_size.t * int *
    ('num, 'prec, Bigarray.fortran_layout) Bigarray.Array1.t
  val __unexpose :
    'n Slap_size.t ->
    int ->
    ('num, 'prec, Bigarray.fortran_layout) Bigarray.Array1.t ->
    ('n, 'num, 'prec, 'cnt_or_dsc) Slap_vec.t
  val __unexpose_with_ofs :
    'n Slap_size.t ->
    int ->
    int ->
    ('num, 'prec, Bigarray.fortran_layout) Bigarray.Array1.t ->
    ('n, 'num, 'prec, 'cnt_or_dsc) Slap_vec.t
  val __alloc_work :
    loc:string ->
    min_lwork:'a Slap_size.t ->
    opt_lwork:'b Slap_size.t ->
    ('num, 'prec) Bigarray.kind ->
    ('k, 'num, 'prec, Slap_misc.cnt) Slap_vec.t option ->
    int * ('num, 'prec, Bigarray.fortran_layout) Bigarray.Array1.t
end