Up

Module Time

Signature

include S with type bound = Time.t
type t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
type bound = Time.t
type 'a t_ = t
type 'a bound_ = bound
include Interval_intf.Gen with type 'a t := 'a t_ with type 'a bound := 'a bound_
type 'a t
type 'a bound

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 upperbound is the greatest upperbound of the intervals in the list, and whose lowerbound is the least lowerbound 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]

to 

 [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
val create : bound -> bound -> t
type 'a poly_t
val to_poly : t -> bound poly_t
type 'a poly_set
module Set : sig .. end
val create_ending_after : ?zone:Zone.t -> Ofday.t * Ofday.t -> now:Time.t -> t

create_ending_after ?zone (od1, od2) ~now returns the smallest interval (t1 t2) with minimum t2 such that t2 >= now, to_ofday t1 = od1, and to_ofday t2 = od2. If zone is specified, it is used to translate od1 and od2 into times, otherwise the machine's time zone is used. It is not guaranteed that contains (t1 t2) now, which will be false iff there is no interval containing now with to_ofday t1 = od1 and to_ofday t2 = od1 .

val create_ending_before : ?zone:Zone.t -> Ofday.t * Ofday.t -> ubound:Time.t -> t

create_ending_before ?zone (od1, od2) ~ubound returns the smallest interval (t1 t2) with maximum t2 such that t2 <= ubound, to_ofday t1 = od1, and to_ofday t2 = od2. If zone is specified, it is used to translate od1 and od2 into times, otherwise the machine's time zone is used.