| (|<) [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}.
|