Legend:
Library
Module
Module type
Parameter
Class
Class type
Interval.Make is a functor that takes a type that you'd like to create intervals for and returns a module with functions over intervals of that type.
For example, suppose you had a Percent.t type and wanted to work with intervals over it, i.e., inclusive ranges like 40-50% or 0-100%. You would create your Percent_interval module by calling:
module Percent_interval = Interval.Make(Percent)
You now have a module with lots of functionality ready to use. For instance you could call Percent_interval.empty to create an empty interval, or:
to get an actual interval that ranges from 3% to 30%. You can then ask questions of this interval, like whether it's a subset of another interval or whether it contains a particular value.
NB. In order to use the Interval.Make functor, your type must satisfy Comparable and support bin-io and s-expression conversion. At a minimum, then, Percent must look like this:
module Percent = struct
module T = struct
type t = float [@@deriving bin_io, compare, sexp]
end
include T
include Comparable.Make_binable(T)
end
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.
Suppose you had three intervals a, b, and c:
a: ( )
b: ( )
c: ( )
hull: ( )
In this case the hull goes from lbound_exn a to ubound_exn c.
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 you think 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, map ~f:(fun x -> x * x) maps the interval [-1,1] to [1,1], not to [0,1].
are_disjoint ts returns true iff the intervals in ts are pairwise disjoint.
val are_disjoint_as_open_intervals : 'at_ list-> bool
Returns true iff a given set of intervals would be disjoint if considered as open intervals, e.g., (3,4) and (4,5) would count as disjoint according to this function.
val list_intersect : 'at_ list->'at_ list->'at_ list
Assuming that ilist1 and ilist2 are lists of disjoint intervals, list_intersect
ilist1 ilist2 considers the intersection (intersect i1 i2) of every pair of intervals (i1, i2), with i1 drawn from ilist1 and i2 from ilist2, returning just the non-empty intersections. By construction these intervals will be disjoint, too. For example:
let i = Interval.create;;
list_intersect [i 4 7; i 9 15] [i 2 4; i 5 10; i 14 20];;
[(4, 4), (5, 7), (9, 10), (14, 15)]
Raises an exception if either input list is non-disjoint.
val half_open_intervals_are_a_partition : 'at_ 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.