Index of values

A
add [Expr1.O.Bint]
add [Expr1.Bint]
add [Expr0.O.Bint]
add [Expr0.Bint]
add [Int]
add [Reg]	Addition; returns the new registerm, the carry, and the overflow (for signed integers).
add_typ [Env]
add_typ_with [Env]	Declaration of a new type
add_var_with [Env]	Addition without normalization (internal)
add_vars [Env]
add_vars_with [Env]	Add the set of variables, possibly normalize the environment and return the applied permutation (that should also be applied to expressions defined in this environment)
apply_change [Domain0.O]
assign_lexpr [Domain1.O]
assign_lexpr [Domain1]
assign_lexpr [Domain0.O]	Assignement
assign_lexpr [Domain0]	Assignement
assign_listexpr [Domain1.O]	Assignement
assign_listexpr [Domain1]	Assignement
B
bddsupport [Expr0.O]
bool_of_tbool [Expr0.O.Expr]
bottom [Domain1.O]
bottom [Domain1]
bottom [Domain0.O]
bottom [Domain0]
C
change_environment [Domain1.O]
change_environment [Domain1]
check_lvalue [Domain1.O]
check_lvalue [Env]
check_lvar [Env]
check_lvarvalue [Env]
check_normalized [Cond]
check_normalized [Env]	Prints error message and returns `false` if not normalized
check_ovalue [Env]
check_value [Domain1.O]
check_value [Env]
check_value2 [Env]
check_value3 [Env]
check_var [Env]
clear [Cond]	Clear all the conditions (results in a normalized environments)
code_of_label [Enum]	Return the code associated to the label
cofactor [Expr1.O.Benum]
cofactor [Expr1.O.Bint]
cofactor [Expr1.O.Bool]
cofactor [Expr1.O]	Evaluate the expression.
cofactor [Expr1.Benum]
cofactor [Expr1.Bint]
cofactor [Expr1.Bool]
cofactor [Expr1]	Evaluate the expression.
cofactor [Expr0.O.Benum]
cofactor [Expr0.O.Bint]
cofactor [Expr0.O.Bool]
cofactor [Expr0.Benum]
cofactor [Expr0.Bint]
cofactor [Expr0.Bool]
cofactor [Expr0]	Evaluate the expression.
cofactor [Enum]
cofactor [Int]	Evaluation
cofactor [Reg]
compare_idb [Env]	Comparison
compose [Expr0.O]
compose_opermutation [Env]
compose_permutation [Env]
composition_of_lvarexpr [Expr0.O]
composition_of_lvarlexpr [Expr0.O]
compute_careset [Cond]
compute_change [Env]
cond_of_idb [Cond]
conjunction_of_minterm [Expr0.O.Expr]
copy [Cond]
copy [Env]	Copy
cube_of_bdd [Expr0.O]	Same as `Cudd.Bdd.cube_of_bdd`, but keep only the the values of variables having a determinated value.
cube_of_bdd [Expr0]	Same as `Cudd.Bdd.cube_of_bdd`, but keep only the the values of variables having a determinated value.
D
dand [Expr1.O.Bool]
dand [Expr1.Bool]
dand [Expr0.O.Bool]
dand [Expr0.Bool]
dfalse [Expr1.O.Bool]
dfalse [Expr1.Bool]
dfalse [Expr0.O.Bool]
dfalse [Expr0.Bool]
disjunction_of_bdd [Expr0.O.Expr]
dnot [Expr1.O.Bool]
dnot [Expr1.Bool]
dnot [Expr0.O.Bool]
dnot [Expr0.Bool]
dor [Expr1.O.Bool]	`not`, `and` and `or` (use of 'd' prefix because of conflict with OCaml keywords)
dor [Expr1.Bool]	`not`, `and` and `or` (use of 'd' prefix because of conflict with OCaml keywords)
dor [Expr0.O.Bool]	`not`, `and` and `or` (use of 'd' prefix because of conflict with OCaml keywords)
dor [Expr0.Bool]	`not`, `and` and `or` (use of 'd' prefix because of conflict with OCaml keywords)
dtrue [Expr1.O.Bool]
dtrue [Expr1.Bool]
dtrue [Expr0.O.Bool]
dtrue [Expr0.Bool]
E
eq [Expr1.O.Benum]
eq [Expr1.O.Bint]
eq [Expr1.O.Bool]	Same as `nxor`
eq [Expr1.O]	Equality operation
eq [Expr1.Benum]
eq [Expr1.Bint]
eq [Expr1.Bool]	Same as `nxor`
eq [Expr1]	Equality operation
eq [Expr0.O.Benum]
eq [Expr0.O.Bint]
eq [Expr0.O.Bool]	Same as `nxor`
eq [Expr0.O]	Equality operation
eq [Expr0.Benum]
eq [Expr0.Bint]
eq [Expr0.Bool]	Same as `nxor`
eq [Expr0]	Equality operation
eq_int [Expr1.O.Bint]
eq_int [Expr1.Bint]
eq_int [Expr0.O.Bint]
eq_int [Expr0.Bint]
eq_label [Expr1.O.Benum]
eq_label [Expr1.Benum]
eq_label [Expr0.O.Benum]
eq_label [Expr0.Benum]
equal [Enum]	Under which condition the 2 registers are equal ?
equal [Int]
equal [Reg]	Equality test.
equal_int [Int]
equal_int [Reg]
equal_label [Enum]	Under which condition the register is equal to the label ?
exist [Expr1.O.Bool]
exist [Expr1.Bool]
exist [Expr0.O.Bool]
exist [Expr0.Bool]
extend [Int]
extend [Reg]	register extension or truncation.
extend_environment [Expr1.O.List]
extend_environment [Expr1.O.Benum]
extend_environment [Expr1.O.Bint]
extend_environment [Expr1.O.Bool]
extend_environment [Expr1.O]
extend_environment [Expr1.List]
extend_environment [Expr1.Benum]	Extend the underlying environment to a superenvironment, and adapt accordingly the underlying representation
extend_environment [Expr1.Bint]	Extend the underlying environment to a superenvironment, and adapt accordingly the underlying representation
extend_environment [Expr1.Bool]	Extend the underlying environment to a superenvironment, and adapt accordingly the underlying representation
extend_environment [Expr1]	Extend the underlying environment to a superenvironment, and adapt accordingly the underlying representation
extend_environment [Env]	`extend_environment permute value env` embed `value` in the new (super)environment `env`, by computing the permutation transformation and using `permute` to apply it to the value.
F
forall [Expr1.O.Bool]
forall [Expr1.Bool]
forall [Expr0.O.Bool]
forall [Expr0.Bool]
forget_list [Domain1.O]	Eliminating variables
forget_list [Domain1]	Eliminating variables
forget_list [Domain0.O]	Eliminating variables
forget_list [Domain0]	Eliminating variables
G
get_cond [Cond]
get_env [Domain1.O]
get_env [Domain1]
get_env [Expr1.O.List]
get_env [Expr1.O.Benum]
get_env [Expr1.O.Bint]
get_env [Expr1.O.Bool]
get_env [Expr1.O]
get_env [Expr1.List]
get_env [Expr1.Benum]
get_env [Expr1.Bint]
get_env [Expr1.Bool]
get_env [Expr1]
get_env [Cond]
get_env [Env]
get_val0 [Cond]
get_val0 [Env]
get_val1 [Cond]
greater [Int]
greater [Reg]	Signed strictly-greater-than test.
greater_int [Int]
greater_int [Reg]
greatereq [Int]
greatereq [Reg]	Signed greater-or-equal test.
greatereq_int [Int]
greatereq_int [Reg]
guard_of_int [Expr1.O.Bint]	Return the guard of the integer value.
guard_of_int [Expr1.Bint]	Return the guard of the integer value.
guard_of_int [Expr0.O.Bint]	Return the guard of the integer value.
guard_of_int [Expr0.Bint]	Return the guard of the integer value.
guard_of_int [Int]	Return the guard of the integer value in the BDD register.
guard_of_int [Reg]	Return the guard of the integer value in the BDD register.
guard_of_label [Expr1.O.Benum]	Return the guard of the label.
guard_of_label [Expr1.Benum]	Return the guard of the label.
guard_of_label [Expr0.O.Benum]	Return the guard of the label.
guard_of_label [Expr0.Benum]	Return the guard of the label.
guard_of_label [Enum]	Return the guard of the label in the BDD register.
guard_of_minterm [Reg]	Return the guard of the deterministic minterm in the BDD register.
guardints [Expr1.O.Bint]	Return the list `g -> n` of guarded values.
guardints [Expr1.Bint]	Return the list `g -> n` of guarded values.
guardints [Expr0.O.Bint]	Return the list `g -> n` of guarded values.
guardints [Expr0.Bint]	Return the list `g -> n` of guarded values.
guardints [Int]	Return the list `g -> n` represented by the BDD register.
guardints [Reg]	Return the list `g -> n` represented by the BDD register.
guardlabels [Expr1.O.Benum]	Return the list `g -> label` of guarded values.
guardlabels [Expr1.Benum]	Return the list `g -> label` of guarded values.
guardlabels [Expr0.O.Benum]	Return the list `g -> label` of guarded values.
guardlabels [Expr0.Benum]	Return the list `g -> label` of guarded values.
guardlabels [Enum]	Return the list `g -> label` represented by the BDD register.
H
higher [Reg]	Unsigned strictly-greater-than test.
higher_int [Reg]	Tests w.r.t.
highereq [Reg]	Unsigned greater-or-equal test.
highereq_int [Reg]
I
id_of_vdd [Output]	Output the MTBDD and return its identifier
idb_of_cond [Cond]
is_and_false [Expr0.O.Bool]
is_and_false [Expr0.Bool]
is_bottom [Domain1.O]
is_bottom [Domain1]
is_bottom [Domain0.O]
is_bottom [Domain0]
is_cst [Expr1.O.Bool]
is_cst [Expr1.Bool]
is_cst [Expr0.O.Bool]
is_cst [Expr0.Bool]
is_cst [Enum]	Does the register contain a constant value ?
is_cst [Int]
is_cst [Reg]	Tests whether it contains a constant value.
is_eq [Domain1.O]
is_eq [Domain1]
is_eq [Domain0.O]
is_eq [Domain0]
is_eq [Expr1.O.Bool]
is_eq [Expr1.Bool]
is_eq [Expr0.O.Bool]
is_eq [Expr0.Bool]
is_eq [Cond]
is_eq [Env]	Test equality of environments in terms of types and variables (but not in term of indexes)
is_equal [Domain0.O.Asssub]
is_false [Expr1.O.Bool]
is_false [Expr1.Bool]
is_false [Expr0.O.Bool]
is_false [Expr0.Bool]
is_indet [Reg.Minterm]	Is the minterm completely non-determinated ? (ie, contain only undefined values)
is_inter_false [Expr1.O.Bool]
is_inter_false [Expr1.Bool]
is_leq [Domain1.O]
is_leq [Domain1]
is_leq [Domain0.O]
is_leq [Domain0]
is_leq [Expr1.O.Bool]
is_leq [Expr1.Bool]
is_leq [Expr0.O.Bool]
is_leq [Expr0.Bool]
is_leq [Cond]
is_leq [Env]	Test inclusion of environments in terms of types and variables (but not in term of indexes)
is_top [Domain1.O]
is_top [Domain1]
is_top [Domain0.O]
is_top [Domain0]
is_true [Expr1.O.Bool]
is_true [Expr1.Bool]
is_true [Expr0.O.Bool]
is_true [Expr0.Bool]
is_variable_unconstrained [Domain1.O]	Tests
is_variable_unconstrained [Domain1]	Tests
is_variable_unconstrained [Domain0.O]	Tests
is_variable_unconstrained [Domain0]	Tests
ite [Expr1.O.Benum]
ite [Expr1.O.Bint]
ite [Expr1.O.Bool]	If-then-else
ite [Expr1.O]	If-then-else operation
ite [Expr1.Benum]
ite [Expr1.Bint]
ite [Expr1.Bool]	If-then-else
ite [Expr1]	If-then-else operation
ite [Expr0.O.Benum]
ite [Expr0.O.Bint]
ite [Expr0.O.Bool]	If-then-else
ite [Expr0.O]	If-then-else operation
ite [Expr0.Benum]
ite [Expr0.Bint]
ite [Expr0.Bool]	If-then-else
ite [Expr0]	If-then-else operation
ite [Enum]	If-then-else operator.
ite [Int]
ite [Reg]	if-then-else operation.
iter [Enum.Minterm]	Iter the function on all label of the given type contained in the minterm.
iter [Int.Minterm]	Iterate the function on all the integer values represented by the argument minterm.
iter [Reg.Minterm]	Iterate the function on all determinated minterms represented by the argument minterm.
iter_bdef_ordered [Output]	Iterate on definitions of BDD identifiers, in a topological order.
iter_cond_ordered [Output]	Iterate the function on all the registered conditions, from level 0 to higher levels.
iter_ordered [Env]	Iter on all finite-state variables declared in the database
iter_vdef_ordered [Output]	Iterate on definitions of MTBDD identifiers, in a topological order.
J
join [Domain1.O]
join [Domain1]
join [Domain0.O]
join [Domain0]
L
label_of_typcode [Enum]	Return the label associated to the given code interpreted as of type the given type.
labels [Env]	Return the list of labels (not variables)
labels_of_typ [Enum]	Return the array of labels defining the type
lce [Cond]
lce [Env]	Least common environment
leq [Expr1.O.Bool]	Implication
leq [Expr1.Bool]	Implication
leq [Expr0.O.Bool]	Implication
leq [Expr0.Bool]	Implication
lnot [Reg]	Logical operations
M
make [Expr1.O]
make [Expr1]
make [Cond]
make [Env.O]
make [Env]	Create a new environment.
make_bdd [Output]	Functions
make_mtbdd [Output]
make_mtbddc [Output]	Create a database for printing MTBDDs
make_string [Env]	`make_string XXX = make ~symbol:string_symbol XXX`
make_symbol [Env]	Generic function for creating a manager for symbols.
make_value [Cond]
make_value [Env]	Constructor
make_vdd [Output]
mand [Expr0.O.Expr]
map [Enum.Minterm]	Apply the function to all label of the given type contained in the minterm and return the list of the results.
map [Int.Minterm]	Apply the function to all integer values represented by the argument minterm and return the list of the results.
map [Reg.Minterm]	Apply the function to all determinated minterms represented by the argument minterm and return the list of the results.
map_atom [Expr0.O.Expr]
map_conjunction [Expr0.O.Expr]
map_disjunction [Expr0.O.Expr]
map_term [Expr0.O.Expr]
mapbinop [Env]
mapbinope [Env]
mapterop [Env]
mapunop [Env]
marshal [Env]	Safe marshalling function, generating strings without NULL characters.
maxcode_of_typ [Enum]	Return the maximal integer corresponding to a label belonging to the type.
meet [Domain1.O]
meet [Domain1]
meet [Domain0.O]
meet [Domain0]
meet_condition [Domain1.O]	Lattice operations
meet_condition [Domain1]	Lattice operations
meet_condition [Domain0.O]	Lattice operations
meet_condition [Domain0]	Lattice operations
mem_label [Env]	Is the label a label defined in the database ?
mem_typ [Env]	Is the type defined in the database ?
mem_typcode [Enum]	Does the integer code some label of the given type ?
mem_var [Env]	Is the label/var defined in the database ?
min_size [Reg]	`min_size cst` computes the minimum number of bits required to represent the given constant.
mul [Expr1.O.Bint]
mul [Expr1.Bint]
mul [Expr0.O.Bint]
mul [Expr0.Bint]
mul [Int]
mul [Reg]	(Unsigned) multiplication
N
nand [Expr1.O.Bool]
nand [Expr1.Bool]
nand [Expr0.O.Bool]
nand [Expr0.Bool]
neg [Expr1.O.Bint]
neg [Expr1.Bint]
neg [Expr0.O.Bint]
neg [Expr0.Bint]
neg [Int]
neg [Reg]	Unary negation; be cautious, if the size of integer is `n`, the negation of `-2^(n-1)` is itself.
nor [Expr1.O.Bool]
nor [Expr1.Bool]
nor [Expr0.O.Bool]
nor [Expr0.Bool]
normalize_with [Cond]	Combine the two previous functions, and return the permutation
normalize_with [Env]	Combine the two previous functions, and return the permutation
notfound [Env]
nxor [Expr1.O.Bool]	Exclusive or, not and, nor or and not xor
nxor [Expr1.Bool]	Exclusive or, not and, nor or and not xor
nxor [Expr0.O.Bool]	Exclusive or, not and, nor or and not xor
nxor [Expr0.Bool]	Exclusive or, not and, nor or and not xor
O
of_bool [Expr1.O.Bool]
of_bool [Expr1.Bool]
of_bool [Expr0.O.Bool]
of_bool [Expr0.Bool]
of_domain0 [Domain1.O]
of_domain0 [Domain1]
of_expr [Expr1.O.Benum]
of_expr [Expr1.O.Bint]
of_expr [Expr1.O.Bool]
of_expr [Expr1.Benum]
of_expr [Expr1.Bint]
of_expr [Expr1.Bool]
of_expr [Expr0.O.Benum]
of_expr [Expr0.O.Bint]
of_expr [Expr0.O.Bool]
of_expr [Expr0.Benum]
of_expr [Expr0.Bint]
of_expr [Expr0.Bool]
of_expr0 [Expr1.O.Benum]
of_expr0 [Expr1.O.Bint]
of_expr0 [Expr1.O.Bool]
of_expr0 [Expr1.O]	Creation from an expression without environment
of_expr0 [Expr1.Benum]	Creation from an expression of level 0 (without environment)
of_expr0 [Expr1.Bint]	Creation from an expression of level 0 (without environment)
of_expr0 [Expr1.Bool]	Creation from an expression of level 0 (without environment)
of_expr0 [Expr1]	Creation from an expression of level 0 (without environment) (make should be considered as obsolete)
of_expr1 [Domain1.O]
of_expr1 [Domain1]
of_int [Expr1.O.Bint]
of_int [Expr1.Bint]
of_int [Expr0.O.Bint]
of_int [Expr0.Bint]
of_int [Int]
of_int [Reg.Minterm]	Convert a possibly negative integer into a minterm of size `size`
of_int [Reg]	`of_int size cst` puts the constant integer `cst` in a constant register of size `size`.
of_label [Enum]	Create a register of the type of the label containing the label
of_lexpr [Expr1.O.List]
of_lexpr [Expr1.List]
of_lexpr0 [Expr1.O.List]
of_lexpr0 [Expr1.List]
P
permutation [Cond]	Compute the permutation for normalizing the environment
permutation [Env]	Compute the permutation for normalizing the environment
permutation12 [Cond]
permutation12 [Env]	Permutation for going from a subenvironment to a superenvironment
permutation21 [Cond]
permutation21 [Env]	Permutation from a superenvironment to a subenvironment
permutation_of_offset [Env]
permutation_of_rename [Expr0.O]
permute [Expr0.O.Benum]
permute [Expr0.O.Bint]
permute [Expr0.O.Bool]
permute [Expr0.O]
permute [Expr0.Benum]
permute [Expr0.Bint]
permute [Expr0.Bool]
permute [Enum]	Permutation (scale `Cudd.Bdd.permute` and `Cudd.Bdd.permute_memo`)
permute [Int]	Permutation (scale `Cudd.Bdd.permute` and `Cudd.Bdd.permute_memo`)
permute [Reg]	Permutation (scale `Cudd.Bdd.permute` and `Cudd.Bdd.permute_memo`)
permute_list [Expr0.O]
permute_with [Cond]	Apply the given permutation to the environment
permute_with [Env]	Apply the given permutation to the environment
post [Domain0.O.Asssub]
postcondition [Domain0.O.Asssub]
pred [Expr1.O.Bint]
pred [Expr1.Bint]
pred [Expr0.O.Bint]
pred [Expr0.Bint]
pred [Int]
pred [Reg]	Predecessor operation; returns the new register and the carry.
print [Domain1.O]
print [Domain1]
print [Domain0.O]
print [Domain0]
print [Expr1.O.List]
print [Expr1.O.Benum]
print [Expr1.O.Bint]
print [Expr1.O.Bool]
print [Expr1.O]
print [Expr1.List]
print [Expr1.Benum]
print [Expr1.Bint]
print [Expr1.Bool]
print [Expr1]
print [Expr0.O.Benum]
print [Expr0.O.Bint]
print [Expr0.O.Bool]
print [Expr0.O]	Print an expression
print [Expr0.Benum]
print [Expr0.Bint]
print [Expr0.Bool]
print [Expr0]	Print an expression
print [Cond]
print [Enum]	`print f fmt t` prints the register `t` using the formatter `fmt` and the function `f` to print BDDs indices.
print [Int]	`print f fmt t` prints the register `t` using the formatter `fmt` and the function `f` to print BDDs indices.
print [Env.O]	Print an environment
print [Env]	Print an environment
print [Reg]	`print f fmt t` prints the register `t` using the formatter `fmt` and the function `f` to print BDDs indices.
print_bdd [Expr0.O]	Print a BDD
print_bdd [Expr0]	Print a BDD
print_conjunction [Expr0.O.Expr]
print_disjunction [Expr0.O.Expr]
print_idcond [Expr0.O]	Print the condition
print_idcond [Expr0]	Print the condition
print_idcondb [Expr0.O]	Print the condition represented by the signed BDD index.
print_idcondb [Expr0]	Print the condition represented by the signed BDD index.
print_idcondb [Env]
print_minterm [Expr0.O]	Print a minterm
print_minterm [Expr0]	Print a minterm
print_minterm [Enum]	`print_minterm f fmt t` prints the register `t` using the formatter `fmt` and the function `f` to convert BDDs indices to names.
print_minterm [Int]	`print_minterm f fmt t` prints the register `t` using the formatter `fmt` and the function `f` to convert BDDs indices to names.
print_minterm [Reg]	`print_minterm f fmt t` prints the register `t` using the formatter `fmt` and the function `f` to convert BDDs indices to names.
print_order [Env]	Print the BDD variable ordering
print_term [Expr0.O.Expr]
print_tid [Env]
print_typ [Env]	Printing
print_typdef [Env]	Print a type definition
R
reduce_with [Cond]	Remove from the environment all conditions that do not belong to the given support.
reg_of_expr [Expr0.O]
relation_supp_compose_of_lvarlexpr [Domain0.O]
remove_vars [Env]
remove_vars_with [Env]	Remove the set of variables, and possibly normalize the environment and return the applied permutation.
rename [Domain1.O]	Change of environments
rename [Domain1]	Change of environments
rename_vars [Env]	Functional versions of the previous functions
rename_vars_with [Env]	Rename the variables, possibly normalize the environment and return the applied permutation.
restrict [Expr1.O.Benum]
restrict [Expr1.O.Bint]
restrict [Expr1.O.Bool]
restrict [Expr1.O]
restrict [Expr1.Benum]
restrict [Expr1.Bint]
restrict [Expr1.Bool]
restrict [Expr1]
restrict [Expr0.O.Benum]
restrict [Expr0.O.Bint]
restrict [Expr0.O.Bool]
restrict [Expr0.Benum]
restrict [Expr0.Bint]
restrict [Expr0.Bool]
restrict [Expr0]
restrict [Enum]
restrict [Int]
restrict [Reg]
S
scale [Expr1.O.Bint]
scale [Expr1.Bint]
scale [Expr0.O.Bint]
scale [Expr0.Bint]
scale [Int]
scale [Reg]	Multiplication by a positive constant.
shift [Cond]
shift [Env]	Shift all the indices by the offset
shift_left [Expr1.O.Bint]
shift_left [Expr1.Bint]
shift_left [Expr0.O.Bint]
shift_left [Expr0.Bint]
shift_left [Int]
shift_left [Reg]	`shift_left man t n` shifts the register to the left by `n` bits.
shift_right [Expr1.O.Bint]
shift_right [Expr1.Bint]
shift_right [Expr0.O.Bint]
shift_right [Expr0.Bint]
shift_right [Int]
shift_right [Reg]	`shift_right t n` shifts the register to the right by `n` bits.
shift_right_logical [Reg]	Same as `shift_right`, but here logical shift: a zero is always inserted.
signid_of_bdd [Output]	Output the BDD and return its identifier
size [Domain1.O]
size [Domain1]	Size of an abstract value (number of nodes)
size [Domain0]	Size of an abstract value (number of nodes)
size_of_typ [Enum]	Return the cardinality of a type (the number of its labels)
sort [Domain0.O.Asssub]
string_symbol [Env]	Standard manager for symbols of type `string`
sub [Expr1.O.Bint]
sub [Expr1.Bint]
sub [Expr0.O.Bint]
sub [Expr0.Bint]
sub [Int]
sub [Reg]	Substraction; returns the new register, the carry, and the overflow (for signed integers).
substitute [Expr1.O.Benum]
substitute [Expr1.O.Bint]
substitute [Expr1.O.Bool]
substitute [Expr1.O]	Parallel substitution of variables by expressions
substitute [Expr1.Benum]
substitute [Expr1.Bint]
substitute [Expr1.Bool]
substitute [Expr1]	Parallel substitution of variables by expressions
substitute [Expr0.O.Benum]
substitute [Expr0.O.Bint]
substitute [Expr0.O.Bool]
substitute [Expr0.O]	Parallel substitution of variables by expressions
substitute [Expr0.Benum]
substitute [Expr0.Bint]
substitute [Expr0.Bool]
substitute [Expr0]	Parallel substitution of variables by expressions
substitute_by_var [Expr1.O.Benum]
substitute_by_var [Expr1.O.Bint]
substitute_by_var [Expr1.O.Bool]
substitute_by_var [Expr1.O]	Variable renaming.
substitute_by_var [Expr1.Benum]
substitute_by_var [Expr1.Bint]
substitute_by_var [Expr1.Bool]
substitute_by_var [Expr1]	Variable renaming.
substitute_by_var [Expr0.O.Benum]
substitute_by_var [Expr0.O.Bint]
substitute_by_var [Expr0.O.Bool]
substitute_by_var [Expr0.O]	Variable renaming.
substitute_by_var [Expr0.Benum]
substitute_by_var [Expr0.Bint]
substitute_by_var [Expr0.Bool]
substitute_by_var [Expr0]	Variable renaming.
substitute_lexpr [Domain1.O]
substitute_lexpr [Domain1]
substitute_lexpr [Domain0.O]	Substitution
substitute_lexpr [Domain0]	Substitution
substitute_listexpr [Domain1.O]	Substitution
substitute_listexpr [Domain1]	Substitution
succ [Expr1.O.Bint]
succ [Expr1.Bint]
succ [Expr0.O.Bint]
succ [Expr0.Bint]
succ [Int]
succ [Reg]	Successor operation; returns the new register and the carry.
sup [Expr1.O.Bint]
sup [Expr1.Bint]
sup [Expr0.O.Bint]
sup [Expr0.Bint]
sup_int [Expr1.O.Bint]
sup_int [Expr1.Bint]
sup_int [Expr0.O.Bint]
sup_int [Expr0.Bint]
supeq [Expr1.O.Bint]
supeq [Expr1.Bint]
supeq [Expr0.O.Bint]
supeq [Expr0.Bint]
supeq_int [Expr1.O.Bint]
supeq_int [Expr1.Bint]
supeq_int [Expr0.O.Bint]
supeq_int [Expr0.Bint]
support [Expr1.O]	Support of the expression
support [Expr1]	Support of the expression
support [Expr0.O]	Support of the expression
support [Expr0]	Support of the expression
support_cond [Expr1.O]	Return the support of an expression as a conjunction of the BDD identifiers involved in the expression
support_cond [Expr1]	Return the support of an expression as a conjunction of the BDD identifiers involved in the expression
support_cond [Expr0.O]	Return the support of an expression as a conjunction of the BDD identifiers involved in the expression
support_cond [Expr0]	Return the support of an expression as a conjunction of the BDD identifiers involved in the expression
T
tbdd_of_texpr [Expr0.O]	Concatenates in an array the BDDs involved in the expressions
tdrestrict [Expr1.O.Benum]
tdrestrict [Expr1.O.Bint]
tdrestrict [Expr1.O.Bool]
tdrestrict [Expr1.O]	Simplify the expression knowing that the BDD is true.
tdrestrict [Expr1.Benum]
tdrestrict [Expr1.Bint]
tdrestrict [Expr1.Bool]
tdrestrict [Expr1]	Simplify the expression knowing that the BDD is true.
tdrestrict [Expr0.O.Benum]
tdrestrict [Expr0.O.Bint]
tdrestrict [Expr0.O.Bool]
tdrestrict [Expr0.Benum]
tdrestrict [Expr0.Bint]
tdrestrict [Expr0.Bool]
tdrestrict [Expr0]	Simplify the expression knowing that the BDD is true.
tdrestrict [Enum]
tdrestrict [Int]
tdrestrict [Reg]
term_of_idcondb [Expr0.O.Expr]
term_of_venum [Expr0.O.Expr]
term_of_vint [Expr0.O.Expr]
texpr_of_tbdd [Expr0.O]	Inverse operation: rebuild an array of expressions from the old array of expressions (for the types) and the array of BDDs.
tid_of_var [Expr0.O]
to_code [Enum]	Convert a constant register to its value as a code.
to_domain0 [Domain1.O]
to_domain0 [Domain1]	Conversion operations
to_expr [Expr1.O.Benum]
to_expr [Expr1.O.Bint]
to_expr [Expr1.O.Bool]
to_expr [Expr1.Benum]	Conversion from/to general expression
to_expr [Expr1.Bint]	Conversion from/to general expression
to_expr [Expr1.Bool]	Conversion from/to general expression
to_expr [Expr0.O.Benum]
to_expr [Expr0.O.Bint]
to_expr [Expr0.O.Bool]
to_expr [Expr0.Benum]
to_expr [Expr0.Bint]
to_expr [Expr0.Bool]
to_expr0 [Expr1.O.Benum]
to_expr0 [Expr1.O.Bint]
to_expr0 [Expr1.O.Bool]
to_expr0 [Expr1.O]
to_expr0 [Expr1.Benum]	Extract resp.
to_expr0 [Expr1.Bint]	Extract resp.
to_expr0 [Expr1.Bool]	Extract resp.
to_expr0 [Expr1]	Extract resp.
to_expr1 [Domain1.O]
to_expr1 [Domain1]	Conversion operations
to_int [Int]
to_int [Reg.Minterm]	Convert a minterm to a (possibly signed) integer.
to_int [Reg]	`to_int sign x` converts a constant register to an integer.
to_label [Enum]	Convert a constant register to its value as a label.
to_lexpr [Expr1.O.List]
to_lexpr [Expr1.List]
to_lexpr0 [Expr1.O.List]
to_lexpr0 [Expr1.List]
top [Domain1.O]	Constructors
top [Domain1]	Constructors
top [Domain0.O]	Constructors
top [Domain0]	Constructors
typ_of_expr [Expr1.O]	Type of an expression
typ_of_expr [Expr1]	Type of an expression
typ_of_expr [Expr0.O]	Type of an expression
typ_of_expr [Expr0]	Type of an expression
typ_of_var [Env]	Return the type of the label/variable
typdef_of_typ [Env]	Return the definition of the type
U
unmarshal [Env]	Companion unmarshalling function
V
var [Expr1.O.Benum]
var [Expr1.O.Bint]
var [Expr1.O.Bool]
var [Expr1.O]	Expression representing the litteral var
var [Expr1.Benum]
var [Expr1.Bint]
var [Expr1.Bool]
var [Expr1]	Expression representing the litteral var
var [Expr0.O.Benum]
var [Expr0.O.Bint]
var [Expr0.O.Bool]
var [Expr0.O]	Expression representing the litteral var
var [Expr0.Benum]
var [Expr0.Bint]
var [Expr0.Bool]
var [Expr0]	Expression representing the litteral var
varmap [Expr0.O.Benum]
varmap [Expr0.O.Bint]
varmap [Expr0.O.Bool]
varmap [Expr0.O]
varmap [Expr0.Benum]
varmap [Expr0.Bint]
varmap [Expr0.Bool]
varmap [Enum]	Permutation (scale `Cudd.Bdd.varmap`)
varmap [Int]	Permutation (scale `Cudd.Bdd.varmap`)
varmap [Reg]	Permutation (scale `Cudd.Bdd.varmap`)
vars [Env]	Return the list of variables (not labels)
vectorcompose [Enum]	Composition (scale `Cudd.Bdd.vectorcompose` and `Cudd.Bdd.vectorcompose_memo`)
vectorcompose [Int]	Composition (scale `Cudd.Bdd.vectorcompose` and `Cudd.Bdd.vectorcompose_memo`)
vectorcompose [Reg]	Composition (scale `Cudd.Bdd.vectorcompose` and `Cudd.Bdd.vectorcompose_memo`)
X
xor [Expr1.O.Bool]
xor [Expr1.Bool]
xor [Expr0.O.Bool]
xor [Expr0.Bool]
Z
zero [Expr1.O.Bint]
zero [Expr1.Bint]
zero [Expr0.O.Bint]
zero [Expr0.Bint]
zero [Int]
zero [Reg]	Tests the register to zero.