Core__Interval (core.Core_

Module for simple closed intervals over arbitrary types that are ordered correctly using polymorphic compare.

Sexps are () for empty interval and (3 5) for an interval containing 3, 4, and 5.

include S1

type 'a t

include sig ... end

val t_of_sexp : (Sexplib.Sexp.t ‑> 'a) ‑> Sexplib.Sexp.t ‑> 'a t

val sexp_of_t : ('a ‑> Sexplib.Sexp.t) ‑> 'a t ‑> Sexplib.Sexp.t

val bin_t : 'a Bin_prot.Type_class.t ‑> 'a t Bin_prot.Type_class.t

val bin_read_t : 'a Bin_prot.Read.reader ‑> 'a t Bin_prot.Read.reader

val __bin_read_t__ : 'a Bin_prot.Read.reader ‑> (int ‑> 'a t) Bin_prot.Read.reader

val bin_reader_t : 'a Bin_prot.Type_class.reader ‑> 'a t Bin_prot.Type_class.reader

val bin_size_t : 'a Bin_prot.Size.sizer ‑> 'a t Bin_prot.Size.sizer

val bin_write_t : 'a Bin_prot.Write.writer ‑> 'a t Bin_prot.Write.writer

val bin_writer_t : 'a Bin_prot.Type_class.writer ‑> 'a t Bin_prot.Type_class.writer

val bin_shape_t : Bin_prot.Shape.t ‑> Bin_prot.Shape.t

type 'a bound_ = 'a

include Core__.Interval_intf.Gen with type a t := a t with type a bound := a bound_

type 'a t

type 'a bound

bound 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.

val create : 'a bound ‑> 'a bound ‑> 'a t

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 t

val intersect : 'a t ‑> 'a t ‑> 'a t

val is_empty : 'a t ‑> bool

val is_empty_or_singleton : 'a t ‑> bool

val bounds : 'a t ‑> ('a bound * 'a bound) option

val lbound : 'a t ‑> 'a bound option

val ubound : 'a t ‑> 'a bound option

val bounds_exn : 'a t ‑> 'a bound * 'a bound

val lbound_exn : 'a t ‑> 'a bound

val ubound_exn : 'a t ‑> 'a bound

val convex_hull : 'a t list ‑> 'a t

convex_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.

val contains : 'a t ‑> 'a bound ‑> bool

val compare_value : 'a t ‑> 'a bound ‑> [ `Below | `Within | `Above | `Interval_is_empty ]

val bound : 'a t ‑> 'a bound ‑> 'a bound option

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

val is_superset : 'a t ‑> of_:'a t ‑> bool

is_superset i1 of_:i2 is whether i1 contains i2. The empty interval is contained in every interval.

val is_subset : 'a t ‑> of_:'a t ‑> bool

val map : 'a t ‑> f:('a bound ‑> 'b bound) ‑> 'b t

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]

 [1,1]

, not to

 [0,1]

val are_disjoint : 'a t list ‑> bool

are_disjoint ts returns true iff the intervals in ts are pairwise disjoint.

val are_disjoint_as_open_intervals : 'a t list ‑> bool

Returns 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.

val list_intersect : 'a t list ‑> 'a t list ‑> 'a t list

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 ‑> bool

Returns 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.

module Set : sig ... end with type a bound := a bound_ with type a interval := a t