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