package core_unix

  1. Overview
  2. Docs
package core_unix
Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module Interval.IntSource

include S with type bound = Core.Int.t
Sourcetype t
include Core.Bin_prot.Binable.S with type t := t
include Bin_prot.Binable.S_only_functions with type t := t
Sourceval bin_size_t : t Bin_prot.Size.sizer
Sourceval bin_write_t : t Bin_prot.Write.writer
Sourceval bin_read_t : t Bin_prot.Read.reader
Sourceval __bin_read_t__ : (int -> t) Bin_prot.Read.reader

This function only needs implementation if t exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant t afterwards.

Sourceval bin_shape_t : Bin_prot.Shape.t
include Sexplib0.Sexpable.S with type t := t
Sourceval t_of_sexp : Sexplib0.Sexp.t -> t
Sourceval sexp_of_t : t -> Sexplib0.Sexp.t
include Ppx_compare_lib.Comparable.S with type t := t
Sourceval compare : t Base__Ppx_compare_lib.compare
include Ppx_hash_lib.Hashable.S with type t := t
Sourceval hash_fold_t : t Base__Ppx_hash_lib.hash_fold
Sourceval hash : t -> Base__Ppx_hash_lib.Std.Hash.hash_value
Sourcetype bound = Core.Int.t
Sourceval empty : t
Sourceval intersect : t -> t -> t
Sourceval is_empty_or_singleton : t -> bool
Sourceval bounds : t -> (bound * bound) option
Sourceval lbound : t -> bound option
Sourceval ubound : t -> bound option
Sourceval bounds_exn : t -> bound * bound
Sourceval lbound_exn : t -> bound
Sourceval ubound_exn : t -> bound
Sourceval convex_hull : t list -> 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.

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.

Sourceval contains : t -> bound -> bool
Sourceval compare_value : t -> bound -> [ `Below | `Within | `Above | `Interval_is_empty ]
Sourceval bound : t -> bound -> 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
Sourceval is_superset : t -> of_:t -> bool

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

Sourceval is_subset : t -> of_:t -> bool
Sourceval map : t -> f:(bound -> bound) -> 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 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].

Sourceval are_disjoint : t list -> bool

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

Sourceval are_disjoint_as_open_intervals : t 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.

Sourceval list_intersect : t list -> t list -> t 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.

Sourceval half_open_intervals_are_a_partition : 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.

Sourceval create : bound -> bound -> t

create has the same type as in Gen, but adding it here prevents a type-checker issue with nongeneralizable type variables.

Sourceval to_poly : t -> bound t
Sourcemodule Set : sig ... end
include Core.Container.S0 with type t := t with type elt := bound
Sourceval mem : t -> bound -> bool
Sourceval length : t -> int
Sourceval is_empty : t -> bool
Sourceval iter : t -> f:(bound -> unit) -> unit
Sourceval fold : t -> init:'accum -> f:('accum -> bound -> 'accum) -> 'accum
Sourceval fold_result : t -> init:'accum -> f:('accum -> bound -> ('accum, 'e) Base__.Result.t) -> ('accum, 'e) Base__.Result.t
Sourceval fold_until : t -> init:'accum -> f: ('accum -> bound -> ('accum, 'final) Base__Container_intf.Continue_or_stop.t) -> finish:('accum -> 'final) -> 'final
Sourceval exists : t -> f:(bound -> bool) -> bool
Sourceval for_all : t -> f:(bound -> bool) -> bool
Sourceval count : t -> f:(bound -> bool) -> int
Sourceval sum : (module Base__Container_intf.Summable with type t = 'sum) -> t -> f:(bound -> 'sum) -> 'sum
Sourceval find : t -> f:(bound -> bool) -> bound option
Sourceval find_map : t -> f:(bound -> 'a option) -> 'a option
Sourceval to_list : t -> bound list
Sourceval to_array : t -> bound array
Sourceval min_elt : t -> compare:(bound -> bound -> int) -> bound option
Sourceval max_elt : t -> compare:(bound -> bound -> int) -> bound option
include Core.Binary_searchable.S with type t := t with type elt := bound
Sourceval binary_search_segmented : (t, bound) Base__Binary_searchable_intf.binary_search_segmented