Index of values


(|<) [Bitpath_prereq]

A
abs_compl [Bitpath_cover]
abs_compl s is the absolute complement ∁ s.
add [Bitpath_cover_map.Make]
add [Bitpath_cover]
add p s is the union s ∪ of_prefix p.
appose [Bitpath_cover_map.Make]
appose [Bitpath_cover]
appose sA sB is the set whose lower and upper halves are sA and sB shrunk to half their size by prefixing their elements by 0 and 1, respectively.

B
bitnot [Bitpath]
bitnot s is the string s' such that get i s = not (get i s').

C
c0 [Bitpath]
The constant const 1 false.
c1 [Bitpath]
The constant const 1 true.
cat [Bitpath]
cat s0 s1 is the concatenation of s0 and s1.
compare [Bitpath]
compare sA sB returns -1, 0, or 1 when sA is less, equal, or greater than sB, respectively, according to lexicographical ordering of bits.
compl_decomp [Bitpath_cover]
compl_decomp s returns a pair (sC, sA) such that s equals sA ∖ sC.
const [Bitpath_cover_map.Make]
const [Bitpath_cover_map.Poly]
const [Bitpath]
const n x is the n-bit string of x.
coprefix [Bitpath]
coprefix_length [Bitpath]
coprefix_length sA sB is the largest n such that get i sA = get i sB for i < n.
coslice_length [Bitpath]
coslice_length iA sA iB sB is the largest n such that get (iA + i) sA = get (iB + i) sB for i < n.
cover_card [Bitpath_cover_map.Make]
cover_card [Bitpath_cover_map.Poly]
cover_card [Bitpath_cover]
cover_card s is the cardinality of the minimal set of prefixes which cover of s.
cover_find [Bitpath_cover_map.Make]
cover_find [Bitpath_cover_map.Poly]
cover_find [Bitpath_cover]
cover_find p s returns the cover of p in s or raises Not_found is no such cover exist in s.

D
default [Bitpath_prereq.Option]
disjoint [Bitpath_cover_map.Make]
disjoint [Bitpath_cover]
disjoint sA sB is true iff sA ∩ sB is the empty set.

E
empty [Bitpath_cover_map.Make]
empty [Bitpath_cover_map.Poly]
empty [Bitpath_cover]
The empty set.
empty [Bitpath]
The empty bit-string.
equal [Bitpath_cover_map.Equatable]
equal [Bitpath_cover_map.Make]
equal [Bitpath_cover]
equal sA sB is true iff sA and sB contain the same members.
equal [Bitpath]
equal sA sB is true iff sA and sB are bitwise equal.

F
fold [Bitpath_cover_map.Make]
fold [Bitpath_cover_map.Poly]
fold [Bitpath_cover]
fold f s is the function f p_(n-1) ∘ ⋯ ∘ f p_0 where {p_i} is the minimal set of prefixes which cover s.
fold [Bitpath]
Given a string s of length n, fold f s returns f (get (n - 1) s) ∘ ⋯ ∘ f (get 0 s).
foldi [Bitpath_cover_map.Make]
foldi [Bitpath_cover_map.Poly]
foldi [Bitpath]
Given a string s of length n, foldi f s is the function f (n - 1) (get (n - 1) s) ∘ ⋯ ∘ f 0 (get 0 s).
foldi16 [Bitpath]
Given a string s of length n, foldi16 f s is the function f (⌈n/16⌉ - 1) (get (⌈n/16⌉ - 1) s) ∘ ⋯ ∘ f 0 (get 0 s).
foldi8 [Bitpath]
Given a string s of length n, foldi8 f s is the function f (⌈n/8⌉ - 1) (get (⌈n/8⌉ - 1) s) ∘ ⋯ ∘ f 0 (get 0 s).

G
get [Bitpath]
get i s is true iff the ith bit of s is set.
get16 [Bitpath]
get16 i s is the integer with bit number 15 - j equal to bit number 16*i + j of s.
get8 [Bitpath]
get8 i s is the integer with bit number 7 - j equal to bit number 8*i + j of s.

H
has_prefix [Bitpath]
has_prefix s0 s is true iff s starts with s0.
has_slice [Bitpath]
has_slice s0 i s is true iff s contains a substring equal to s0 starting at bit number i.
has_suffix [Bitpath]
has_suffix s0 s is true iff s ends with s0.
hexdigit_of_int [Bitpath_prereq.Char]
hexdigit_to_int [Bitpath_prereq.Char]

I
ident [Bitpath_prereq]
init [Bitpath_prereq.String]
init [Bitpath]
init n f turns the predicate f into a bit-string s of length n such that f i = get f i for 0 ≤ i < n.
init16 [Bitpath]
init16 n f is the n-bit string s such that get (16*i + j) s is true iff bit number 15 - j of f i is set.
init8 [Bitpath]
init8 n f is the n-bit string s such that get (8*i + j) s is true iff bit number 7 - j of f i is set.
intersect [Bitpath_cover_map.Make]
intersect [Bitpath_cover_map.Poly]
intersect [Bitpath_cover]
intersect p s is the intersection s ∩ of_prefix p.
is_const [Bitpath_cover_map.Make]
is_const [Bitpath_cover_map.Poly]
is_empty [Bitpath_cover_map.Make]
is_empty [Bitpath_cover_map.Poly]
is_empty [Bitpath_cover]
True on the empty set, false elsewhere.
is_empty [Bitpath]
True on the empty path, elsewhere false.
is_prefix [Bitpath_cover]
True for sets s such that equal s (of_prefix p) for some p.
is_universe [Bitpath_cover]
is_universe s is true iff equal s universe.
isecn [Bitpath_cover]
isecn sA sB is the intersection sA ∩ sB.
iter [Bitpath_cover_map.Make]
iter [Bitpath_cover_map.Poly]
iter [Bitpath_cover]
iter f s calls f for each prefix in the minimal cover for s.
iter [Bitpath]
iter f s calls f on each element of s in order.
iteri [Bitpath_cover_map.Make]
iteri [Bitpath_cover_map.Poly]
iteri [Bitpath]
iteri f s calls f i (get i s) for 0 ≤ i < length s in order.

K
konst [Bitpath_prereq]

L
length [Bitpath]
length s is the number of bits contained in s.
length16 [Bitpath]
length16 s = ⌈length s / 16⌉.
length8 [Bitpath]
length8 s = ⌈length s / 8⌉.
lower_half [Bitpath_cover_map.Make]
lower_half [Bitpath_cover_map.Poly]
lower_half [Bitpath_cover]
lower_half s is the set {p | 0·p ∈ s}.

M
map [Bitpath_cover_map.Make]
map [Bitpath]
Given s of length n, then map f s is the n-bit string s' such that get i s' = f (get i s) for 0 ≤ i < n.
mapi [Bitpath_cover_map.Make]
mapi [Bitpath]
Given s of length n, then mapi f s is the n-bit string s' such that get i s' = f i (get i s) for 0 ≤ i < n.
modify [Bitpath_cover_map.Make]
modify [Bitpath_cover]
modify f p s is the set s ∖ of_prefix p ∪ unzoom (f (zoom s)).

O
of_array16 [Bitpath]
of_array16 xa forms a bitpath by composing hexadecatets of xa, staring with the most significant.
of_array8 [Bitpath]
of_array8 xa forms a bitpath by composing the octets from xa, starting with the most significant.
of_bin_string [Bitpath]
of_bin_string ~n s8 converts an octet string s8 to a bit string s1, where get (8*i + j) s1 equals bit number 7 - j of String.get i s8.
of_hex_string [Bitpath]
of_hex_string ~n str returns the bitstring described by the hexadecimal string str, clipped to n bits if specified.
of_prefix [Bitpath_cover]
of_prefix p is the set of all strings starting with p.
of_string [Bitpath]
of_string s interprets a string s of '0' and '1' characters as a bit string.

P
pick_first [Bitpath_cover]
pick_first s returns the lexicographically lowest prefix describing a cover in s.
pick_random [Bitpath_cover]
pick_random s returns a random prefix of s, using the PRNG from the Random module.
picki_first [Bitpath_cover_map.Make]
picki_first [Bitpath_cover_map.Poly]
picki_random [Bitpath_cover_map.Make]
picki_random [Bitpath_cover_map.Poly]
prefix [Bitpath]
prefix i s is the substring containing the i first bits of s.

R
rel_compl [Bitpath_cover]
rel_compl sC sA is the relative complement sA ∖ sC.
remove [Bitpath_cover_map.Make]
remove [Bitpath_cover_map.Poly]
remove [Bitpath_cover]
remove p s is the relative complement s ∖ of_prefix p.
right_isecn [Bitpath_cover_map.Make]
right_union [Bitpath_cover_map.Make]

S
slice [Bitpath]
slice i j s is the sub-string of bit i to j - 1 of s.
suffix [Bitpath]
suffix i s is the substring containing all but the i first bits of s.

T
to_bin_string [Bitpath]
to_bin_string ~n s converts a bit string to an octet string using the same representation as of_bit_string.
to_const [Bitpath_cover_map.Make]
to_const [Bitpath_cover_map.Poly]
to_hex_string [Bitpath]
to_hex_string ~n s is the hexadecimal encoding of s padded with zeros to the next quartet, or clipped or padded to n bits if specified.
to_prefix [Bitpath_cover]
If is_prefix s, then to_prefix s returns the p such that equal s (of_prefix p), otherwise it raises Invalid_argument.
to_string [Bitpath]
to_string s turns s to a textual representation of '0' and '1' characters, starting with the lowest index.

U
union [Bitpath_cover]
union sA sB is the union sA ∪ sB.
universe [Bitpath_cover]
The set containing all infinite bit-strings.
unzoom [Bitpath_cover_map.Make]
unzoom [Bitpath_cover_map.Poly]
unzoom [Bitpath_cover]
unzoom p s is the set {p·p' | p' ∈ s}.
upper_half [Bitpath_cover_map.Make]
upper_half [Bitpath_cover_map.Poly]
upper_half [Bitpath_cover]
upper_half s is the set {p | 1·p ∈ s}.

V
valid [Bitpath_cover_map.Make]

Z
zoom [Bitpath_cover_map.Make]
zoom [Bitpath_cover_map.Poly]
zoom [Bitpath_cover]
zoom p s is the set {p' | p·p' ∈ s}.