include S with type bound = Core__.Import.Int.tinclude sig ... endval t_of_sexp : Sexplib.Sexp.t ‑> tval sexp_of_t : t ‑> Sexplib.Sexp.tval bin_t : t Bin_prot.Type_class.tval bin_read_t : t Bin_prot.Read.readerval __bin_read_t__ : (int ‑> t) Bin_prot.Read.readerval bin_reader_t : t Bin_prot.Type_class.readerval bin_size_t : t Bin_prot.Size.sizerval bin_write_t : t Bin_prot.Write.writerval bin_writer_t : t Bin_prot.Type_class.writerval bin_shape_t : Bin_prot.Shape.tinclude Core__.Interval_intf.Gen with type a t := a t_ with type a bound := a bound_type 'a boundbound is the type of points in the interval (and also of the bounds, which are
points; hence the name). bound is instantiated in two different ways below: in
module type S as a monotype and in module type S1 as 'a.
Module for simple closed intervals over arbitrary types that are ordered correctly using polymorphic compare.
create l u returns the interval with lower bound l and upper bound u, unless
l > u, in which case create returns the empty interval.
val empty : 'a tval is_empty : 'a t ‑> boolval is_empty_or_singleton : 'a t ‑> boolconvex_hull ts returns an interval whose upper bound is the greatest upper bound
of the intervals in the list, and whose lower bound is the least lower bound of the
list.
bound t x returns None iff is_empty t. If bounds t = Some (a, b), then
bound returns Some y where y is the element of t closest to x. I.e.:
| y = a if x < a | y = x if a <= x <= b | y = b if x > b
map t ~f returns create (f l) (f u) if bounds t = Some (l, u), and empty if
t is empty. Note that if f l > f u, the result of map is empty, by the
definition of create.
If one thinks of an interval as a set of points, rather than a pair of its bounds,
then map is not the same as the usual mathematical notion of mapping f over that
set. For example, ~f:(fun x -> x * x) maps the interval
[-1,1]
to
[1,1]
, not to
[0,1]
.
val are_disjoint : 'a t list ‑> boolare_disjoint ts returns true iff the intervals in ts are pairwise disjoint.
val are_disjoint_as_open_intervals : 'a t list ‑> boolReturns true iff a given set of intervals would be disjoint if considered as open intervals. i.e., (3,4) and (4,5) would count as disjoint.
Assuming that ilist1 and ilist2 are lists of (disjoint) intervals,
list_intersect ilist1 ilist2 returns the list of disjoint intervals that
correspond to the intersection of ilist1 with ilist2.
val half_open_intervals_are_a_partition : 'a t list ‑> boolReturns true if the intervals, when considered as half-open-intervals, nestle up cleanly one to the next. i.e., if you sort the intervals by the lower bound, then the upper bound of the nth interval is equal to the lower bound of the n+1th interval. The intervals do not need to partition the entire space, they just need to partition their union.
include Core__.Import.Container.S0 with type t := t with type elt := boundval length : t ‑> intval is_empty : t ‑> booliter must allow exceptions raised in f to escape, terminating the iteration
cleanly. The same holds for all functions below taking an f.
val fold_result : t ‑> init:'accum ‑> f:('accum ‑> elt ‑> ('accum, 'e) Base.Result.t) ‑> ('accum, 'e) Base.Result.tfold_result t ~init ~f is a short-circuiting version of fold that runs in the
Result monad. If f returns an Error _, that value is returned without any
additional invocations of f.
val fold_until : t ‑> init:'accum ‑> f:('accum ‑> elt ‑> ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ‑> ('accum, 'stop) Base.Container_intf.Finished_or_stopped_early.tfold_until t ~init ~f is a short-circuiting version of fold. If f
returns Stop _ the computation ceases and results in that value. If f returns
Continue _, the fold will proceed.
Returns true if and only if there exists an element for which the provided
function evaluates to true. This is a short-circuiting operation.
Returns true if and only if the provided function evaluates to true for all
elements. This is a short-circuiting operation.
val sum : (module Base.Commutative_group.S with type t = 'sum) ‑> t ‑> f:(elt ‑> 'sum) ‑> 'sumReturns the sum of f i for i in the container
include Core__.Import.Binary_searchable.S with type t := t with type elt := boundval binary_search : (t, elt) Base.Binary_searchable_intf.binary_searchSee Binary_search.binary_search in binary_search.ml
val binary_search_segmented : (t, elt) Base.Binary_searchable_intf.binary_search_segmentedSee Binary_search.binary_search_segmented in binary_search.ml