module Floats:Nopres_intf.T
with module Strategy = DefStrat and type el = float
Resizable float array using the default reallocation strategy.
module Strategy:Strat.T
Module implementing the reallocation strategy
typestrategy =
Strategy.t
Type of reallocation strategy
type
t
Type of resizable arrays
type
el
Type of the elements in the resizable array
val length : t -> int
length ra
ra
excluding the reserved space.val lix : t -> int
lix ra
ra
excluding the reserved
space.val real_length : t -> int
real_length ra
ra
including the reserved space.val real_lix : t -> int
real_lix ra
ra
including the reserved space.val get : t -> int -> el
get ra n
Invalid_argument
if index out of bounds.n
th element of ra
.val set : t -> int -> el -> unit
set ra n
sets the n
th element of ra
.
Invalid_argument
if index out of bounds.val sempty : strategy -> t
sempty s
s
.val empty : unit -> t
empty ()
same as sempty
but uses default strategy.
val screate : strategy -> int -> t
screate s n
s
containing n
arbitrary
elements.
Attention: the contents is not specified!val create : int -> t
create n
same as screate
but uses default strategy.
val smake : strategy -> int -> el -> t
smake s n el
n
containing element el
only using
strategy s
.val make : int -> el -> t
make n el
same as smake
but uses default strategy.
val sinit : strategy -> int -> (int -> el) -> t
sinit s n f
n
containing elements that were created by applying
function f
to the index, using strategy s
.val init : int -> (int -> el) -> t
init n f
sames as sinit
but uses default strategy.
val get_strategy : t -> strategy
get_strategy ra
ra
.val set_strategy : t -> strategy -> unit
set_strategy ra s
sets the reallocation strategy of resizable array ra
to s
, possibly causing an immediate reallocation.
val put_strategy : t -> strategy -> unit
put_strategy ra s
sets the reallocation strategy of resizable array ra
to s
. Reallocation is only done at later changes in size.
val enforce_strategy : t -> unit
enforce_strategy ra
forces a reallocation if necessary (e.g. after a
put_strategy
).
val copy : t -> t
copy ra
ra
. The two arrays share the same strategy!val sub : t -> int -> int -> t
sub ra ofs len
Invalid_argument
if parameters do not denote a correct subarray.len
from resizable array ra
starting
at offset ofs
using the default strategy.val fill : t -> int -> int -> el -> unit
fill ra ofs len el
fills resizable array ra
from offset ofs
with
len
elements el
, possibly adding elements at the end. Raises
Invalid_argument
if offset ofs
is larger than the length of the array.
val blit : t -> int -> t -> int -> int -> unit
blit ra1 ofs1 ra2 ofs2 len
blits resizable array ra1
onto ra2
reading len
elements from offset ofs1
and writing them to ofs2
,
possibly adding elements at the end of ra2. Raises Invalid_argument
if
ofs1
and len
do not designate a valid subarray of ra1
or if ofs2
is larger than the length of ra2
.
val append : t -> t -> t
append ra1 ra2
ra1
and
ra2
in this order onto it.val concat : t list -> t
concat l
l
in their respective order onto it.val add_one : t -> el -> unit
add_one ra el
adds element el
to resizable array ra
, possibly
causing a reallocation.
val remove_one : t -> unit
remove_one ra
removes the last element of resizable array ra
, possibly
causing a reallocation.
Failure
if the array is empty.val remove_n : t -> int -> unit
remove_n ra n
removes the last n elements of resizable array ra
,
possibly causing a reallocation.
Invalid_argument
if there are not enough elements or n < 0
.val remove_range : t -> int -> int -> unit
remove_range ra ofs len
removes len
elements from resizable array ra
starting at ofs
and possibly causing a reallocation.
Invalid_argument
if range is invalid.val clear : t -> unit
clear ra
removes all elements from resizable array ra
, possibly
causing a reallocation.
val swap : t -> int -> int -> unit
swap ra n m
swaps elements at indices n
and m
.
Invalid_argument
if any index is out of range.val swap_in_last : t -> int -> unit
swap_in_last ra n
swaps the last element with the one at position n
.
Invalid_argument
if index n
is out of range.val to_array : t -> el array
to_array ra
converts a resizable array to a standard one.
val sof_array : strategy -> el array -> t
sof_array s ar
converts a standard array to a resizable one, using
strategy s
.
val of_array : el array -> t
of_array ar
converts a standard array to a resizable one using the
default strategy.
val to_list : t -> el list
to_list ra
converts resizable array ra
to a list.
val sof_list : strategy -> el list -> t
sof_list s l
creates a resizable array using strategy s
and the
elements in list l
.
val of_list : el list -> t
of_list l
creates a resizable array using the default strategy and the
elements in list l
.
val iter : (el -> unit) -> t -> unit
iter f ra
applies the unit-function f
to each element in resizable
array ra
.
val map : (el -> el) -> t -> t
map f ra
ra
and mapping each element in
ra
to its corresponding position in the new array using function f
.val iteri : (int -> el -> unit) -> t -> unit
iteri f ra
applies the unit-function f
to each index and element in
resizable array ra
.
val mapi : (int -> el -> el) ->
t -> t
mapi f ra
ra
and mapping each element in
ra
to its corresponding position in the new array using function f
and the index position.val fold_left : ('a -> el -> 'a) -> 'a -> t -> 'a
fold_left f a ra
left-folds values in resizable array ra
using
function f
and start accumulator a
.
val fold_right : (el -> 'a -> 'a) -> t -> 'a -> 'a
fold_right f a ra
right-folds values in resizable array ra
using
function f
and start accumulator a
.
val for_all : (el -> bool) -> t -> bool
for_all p ra
true
if all elements in resizable array ra
satisfy the predicate
p
, false
otherwise.val exists : (el -> bool) -> t -> bool
exists p ra
true
if at least one element in resizable array ra
satisfies the
predicate p
, false
otherwise.val mem : el -> t -> bool
mem el ra
true
if element el
is logically equal to any element in resizable
array ra
, false
otherwise.val memq : el -> t -> bool
memq el ra
true
if element el
is physically equal to any element in resizable
array ra
, false
otherwise.val pos : el -> t -> int option
pos el ra
Some index
if el
is logically equal to the element at index
in
ra
, None
otherwise. index
is the index of the first element that
matches.val posq : el -> t -> int option
posq el ra
Some index
if el
is physically equal to the element at index
in
ra
, None
otherwise. index
is the index of the first element that
matches.val find : (el -> bool) -> t -> el
find p ra
Not_found
if there is no such element.ra
that satisfies predicate p
.val find_index : (el -> bool) -> t -> int -> int
find_index p ra pos
Not_found
if there is no such element or if pos
is larger than the highest
index.Invalid_argument
if pos
is negative.p
in resizable
array ra
, starting search at index pos
.val filter : (el -> bool) -> t -> t
filter p ra
ra
that satisfy
predicate p
using the same strategy as ra
.val find_all : (el -> bool) -> t -> t
find_all p ra
is the same as filter
val filter_in_place : (el -> bool) -> t -> unit
filter_in_place p ra
as filter
, but filters in place.
val partition : (el -> bool) ->
t -> t * t
partition p ra
ra
that satisfy predicate p
, the right one only those that do not
satisfy it. Both returned arrays are created using the strategy of ra
.val unsafe_get : t -> int -> el
val unsafe_set : t -> int -> el -> unit
val unsafe_sub : t -> int -> int -> t
val unsafe_fill : t -> int -> int -> el -> unit
val unsafe_blit : t -> int -> t -> int -> int -> unit
val unsafe_remove_one : t -> unit
val unsafe_remove_n : t -> int -> unit
val unsafe_swap : t -> int -> int -> unit
val unsafe_swap_in_last : t -> int -> unit