A | |
add [Formula.Arith] | |
add [Formula.Bint] | |
add [ArithDD] | |
add [Arith.Poly] | |
add [Arith.Lin] | |
add [Arith] | |
add [Bddint] | |
add [Bddreg] |
Addition; returns the new registerm, the carry, and the
overflow (for signed integers).
|
B | |
bddsupport [Bddvar] | |
bool_of_tbool [Bddvar.Expr] | |
C | |
cleanup [Formula] | |
clear_db [Bddoutput] |
Clear the database
|
code_of_label [Bddenum] |
Return the code associated to the label
|
cofactor [Formula] | |
cofactor [ArithDD] | |
cofactor [Bddvar] | |
compare [Arith.Condition] | |
compare [Arith.Poly] | |
compare [Arith.Lin] | |
compare [Arith] | |
compare_lterm [Arith.Lin] | |
compare_monomial [Arith.Poly] | |
compare_varexp [Arith.Poly] | |
compose [Bddvar] | |
compose_of_substitution [Formula] | |
composition_of_substitution [Bddvar] | |
compute_careset [CondDD] | |
cond_support [CondDD] | |
condition [Formula.Arith] | |
condition [ArithDD] |
Tests
|
condition [CondDD] | |
conjunction_of_minterm [Bddvar.Expr] | |
cst [Formula.Arith] | |
cst [ArithDD] | |
cst [Arith.Poly] | |
cst [Arith.Lin] | |
cst [Arith] | |
cube_of_bdd [Bddvar] |
Same as
Bdd.cube_of_bdd , but keep only the
the values of variables having a determinated value.
|
D | |
dand [Formula.Bool] | |
dfalse [Formula.Bool] | |
disjunction_of_bdd [Bddvar.Expr] | |
div [Formula.Arith] | |
div [ArithDD] | |
div [Arith.Poly] | |
div [Arith] | |
dnot [Formula.Bool] | |
dor [Formula.Bool] | |
dtrue [Formula.Bool] | |
dummy [Var] | |
E | |
eq [Formula.Arith] | |
eq [Formula.Benum] | |
eq [Formula.Bint] | |
eq [Formula.Bool] | |
eq [Formula] | |
eq [ArithDD] | |
eq_int [Formula.Bint] | |
eq_label [Formula.Benum] | |
equal [Arith] | |
equal [Bddenum] |
Under which condition the 2 registers are equal ?
|
equal [Bddint] | |
equal [Bddreg] |
Equality test.
|
equal_int [Bddint] | |
equal_int [Bddreg] | |
equal_label [Bddenum] |
Under which condition the register is equal to the label ?
|
exist [Bddvar] |
Existential quantification of a set of variables
|
exists [Formula.Bool] | |
extend [Bddint] | |
extend [Bddreg] |
register extension or truncation.
|
F | |
forall [Formula.Bool] | |
forall [Bddvar] |
Universal quantification of a set of variables
|
G | |
gmod [Formula.Arith] | |
gmod [ArithDD] | |
gmod [Arith] | |
greater [Bddint] | |
greater [Bddreg] |
Signed strictly-greater-than test.
|
greater_int [Bddreg] | |
greatereq [Bddint] | |
greatereq [Bddreg] |
Signed greater-or-equal test.
|
greatereq_int [Bddint] | |
greatereq_int [Bddreg] | |
guard_of_int [Bddint] |
Return the guard of the integer value in the BDD register.
|
guard_of_int [Bddreg] |
Return the guard of the integer value in the BDD register.
|
guard_of_label [Bddenum] |
Return the guard of the label in the BDD register.
|
guard_of_minterm [Bddreg] |
Return the guard of the deterministic minterm in the BDD register.
|
guardints [Bddint] |
Return the list
g -> n represented by the BDD register.
|
guardints [Bddreg] |
Return the list
g -> n represented by the BDD register.
|
guardlabels [Bddenum] |
Return the list
g -> label represented by the BDD register.
|
H | |
hash [Arith] | |
higher [Bddreg] |
Unsigned strictly-greater-than test.
|
higher_int [Bddreg] |
Tests w.r.t.
|
highereq [Bddreg] |
Unsigned greater-or-equal test.
|
highereq_int [Bddreg] | |
I | |
idattr_of_idd [Bddoutput] |
Output the IDD and return its identifier
|
info_of_var [Bddvar] | info associated to the variable in db
|
is_cst [Bddenum] |
Does the register contain a constant value ?
|
is_cst [Bddint] | |
is_cst [Bddreg] |
Tests whether it contains a constant value.
|
is_dependent_on_integer_only [Arith] | |
is_included_in [Formula.Bool] | |
is_indet [Bddreg.Minterm] |
Is the minterm completely non-determinated ? (ie, contain only
undefined values)
|
is_inter_empty [Formula.Bool] | |
ite [Formula.Arith] | |
ite [Formula.Benum] | |
ite [Formula.Bint] | |
ite [Formula.Bool] | |
ite [Formula] | |
ite [ArithDD] | |
ite [Bddvar] |
If-then-else operation
|
ite [Bddenum] |
If-then-else operator.
|
ite [Bddint] | |
ite [Bddreg] |
if-then-else operation.
|
iter [Bddenum.Minterm] |
Iter the function on all label of the given type contained in the
minterm.
|
iter [Bddint.Minterm] |
Iterate the function on all the integer values represented by the
argument minterm.
|
iter [Bddreg.Minterm] |
Iterate the function on all determinated minterms represented by the
argument minterm.
|
iter_bdef_ordered [Bddoutput] |
Iterate on definitions of BDD identifiers, in a topological order.
|
iter_cond [Bddoutput] |
Iterate the function on all the registered conditions
|
iter_cond_ordered [Bddoutput] |
Iterate the function on all the registered conditions, from level 0
to higher levels.
|
iter_idef_ordered [Bddoutput] |
Iterate on definitions of IDD identifiers, in a topological order.
|
iter_ordered [Bddvar] |
Iter on all variables declared in the database
|
L | |
label_of_typcode [Bddenum] |
Return the label associated to the given code interpreted as of type the
given type.
|
labels_of_typ [Bddenum] |
Return the array of labels defining the type
|
lin_of_poly [Arith] | |
lin_of_tree [Arith] | |
lnot [Bddreg] |
Logical negation (for all bits).
|
M | |
make [Arith.Condition] | |
make_db [Bddoutput] |
Create a database for printing BDDs/IDDs.
|
mand [Bddvar.Expr] |
Raises Exit if false value
|
map [Bddenum.Minterm] |
Apply the function to all label of the given type contained in the
minterm and return the list of the results.
|
map [Bddint.Minterm] |
Apply the function to all integer values represented by the
argument minterm and return the list of the results.
|
map [Bddreg.Minterm] |
Apply the function to all determinated minterms represented by the
argument minterm and return the list of the results.
|
maxcode_of_typ [Bddenum] |
Return the maximal integer corresponding to a label belonging to the
type.
|
mem_id [Bddvar] |
Is the BDD index managed by the database ?
|
mem_typcode [Bddenum] |
Does the integer code some label of the given type ?
|
min_size [Bddreg] | min_size cst computes the minimum number of bits required
to represent the given constant.
|
mul [Formula.Arith] | |
mul [ArithDD] | |
mul [Arith.Poly] | |
mul [Arith] | |
N | |
nand [Formula.Bool] | |
neg [Formula.Bint] | |
neg [Bddint] | |
neg [Bddreg] |
Unary negation; be cautious, if the size of integer is
n ,
the negation of -2^(n-1) is itself.
|
negate [Formula.Arith] | |
negate [ArithDD] | |
negate [Arith.Condition] | |
negate [Arith.Poly] | |
negate [Arith.Lin] | |
negate [Arith] | |
nor [Formula.Bool] | |
normalize [Arith.Poly] | |
normalize [Arith.Lin] | |
normalize [Arith] | |
normalize_as_constraint [Arith.Poly] | |
normalize_as_constraint [Arith.Lin] | |
normalize_as_constraint [Arith] | |
normalize_full [Arith.Poly] | |
normalize_monomial [Arith.Poly] | |
nxor [Formula.Bool] | |
O | |
of_bool [Formula.Bool] | |
of_expr [Formula.Arith] | |
of_expr [Formula.Benum] | |
of_expr [Formula.Bint] | |
of_expr [Formula.Bool] | |
of_expr [ArithDD] | |
of_int [Formula.Bint] | |
of_int [Bddint] | |
of_int [Bddreg.Minterm] |
Convert a possibly negative integer into a minterm of size
size
|
of_int [Bddreg] | of_int size cst puts the constant integer cst in a constant register
of size size .
|
of_label [Bddenum] |
Create a register of the type of the label containing the label
|
other [Formula.Arith] | |
other [ArithDD] | |
other [Arith] | |
P | |
permutation_of_rename [Bddvar] | |
permute [Bddvar] | |
poly_of_tree [Arith] | |
pred [Formula.Bint] | |
pred [Bddint] | |
pred [Bddreg] |
Predecessor operation; returns the new register and the carry.
|
print [Formula.Arith] | |
print [Formula.Benum] | |
print [Formula.Bint] | |
print [Formula.Bool] | |
print [ArithDD] | |
print [Arith.Condition] | |
print [Arith.Tree] | |
print [Arith.Poly] | |
print [Arith.Lin] | |
print [Arith] | |
print [Bddenum] | print f fmt t prints the register t using the formatter
fmt and the function f to convert BDDs indices to
names.
|
print [Var] | |
print [Bddint] | print f fmt t prints the register t using the formatter
fmt and the function f to convert BDDs indices to
names.
|
print [Bddreg] | print f fmt t prints the register t using the formatter
fmt and the function f to convert BDDs indices to
names.
|
print_bdd [Formula] | |
print_bdd [Bddvar] |
Print a BDD
|
print_cond [Formula] | |
print_cond [CondDD] | |
print_conjunction [Bddvar.Expr] | |
print_db [Formula] | |
print_db [CondDD] | |
print_db [Bddvar] |
Print the database
|
print_db [Bddenum] |
Print the database
|
print_disjunction [Bddvar.Expr] | |
print_expr [Formula] | |
print_expr [Bddvar] |
Print an expression
|
print_id [Bddvar] |
Print the name associated to the single BDD index.
|
print_idcond [Bddvar] |
Print the condition
|
print_idcondb [Bddvar] |
Print the condition represented by the signed BDD index.
|
print_idd [Bddvar] |
Print an IDD, using the function to associate to leaf indices
strings.
|
print_info [Bddvar] |
Print an object of type
info
|
print_minterm [Bddvar] |
Print a minterm
|
print_minterm [Bddenum] | 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 [Bddint] | 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 [Bddreg] | print_minterm f fmt t prints the register t using the formatter
fmt and the function f to convert BDDs indices to
names.
|
print_term [Bddvar.Expr] | |
print_typ [Formula] | |
print_typ [CondDD] | |
print_typ [Arith] | |
print_typ [Bddvar] |
Print a type
|
print_typdef [Formula] | |
print_typdef [CondDD] | |
print_typdef [Bddvar] |
Print a type definition
|
R | |
reg_of_expr [Bddvar] |
Return the underlying array of BDD representing the expression
|
rename [Arith.Tree] | |
rename [Arith.Poly] | |
rename [Arith.Lin] | |
rename [Arith] | |
rename [Bddvar] |
Variable renaming.
|
S | |
scale [Formula.Bint] | |
scale [Arith.Poly] | |
scale [Arith.Lin] | |
scale [Bddint] | |
scale [Bddreg] |
Multiplication by a positive constant.
|
shift_left [Formula.Bint] | |
shift_left [Bddint] | |
shift_left [Bddreg] | shift_left man t n shifts the register to the left by n
bits.
|
shift_right [Formula.Bint] | |
shift_right [Bddint] | |
shift_right [Bddreg] | shift_right t n shifts the register to the right by n
bits.
|
shift_right_logical [Bddreg] |
Same as
shift_right , but here logical shift: a zero
is always inserted.
|
signid_of_bdd [Bddoutput] |
Output the BDD and return its identifier
|
size_of_typ [Bddenum] |
Return the cardinality of a type (the number of its labels)
|
sub [Formula.Arith] | |
sub [Formula.Bint] | |
sub [ArithDD] | |
sub [Arith.Poly] | |
sub [Arith.Lin] | |
sub [Arith] | |
sub [Bddint] | |
sub [Bddreg] |
Substraction; returns the new register, the carry, and the
overflow (for signed integers).
|
substitute [Formula] | |
substitute [Bddvar] |
Parallel substitution of variables by expressions
|
substitute_cond [Formula.Arith] | |
substitute_cond [ArithDD] | |
substitute_ddexpr [CondDD] | |
substitute_expr [Formula.Arith] | |
substitute_expr [ArithDD] | |
succ [Formula.Bint] | |
succ [Bddint] | |
succ [Bddreg] |
Successor operation; returns the new register and the carry.
|
sup [Formula.Arith] | |
sup [Formula.Bint] | |
sup [ArithDD] | |
supeq [Formula.Arith] | |
supeq [Formula.Bint] | |
supeq [ArithDD] | |
supeq_int [Formula.Bint] | |
support [Formula] | |
support [Arith.Condition] | |
support [Arith.Tree] | |
support [Arith.Poly] | |
support [Arith.Lin] | |
support [Arith] | |
support_cond [Formula] | |
support_cond [ArithDD] | |
support_cond [Bddvar] |
Return the support of an expression as a conjunction of the BDD
identifiers involved in the expression
|
support_leaf [ArithDD] | |
T | |
tdrestrict [Formula] | |
tdrestrict [ArithDD] | |
tdrestrict [Bddvar] | |
term_of_idcondb [Bddvar.Expr] | |
term_of_venum [Bddvar.Expr] | |
term_of_vint [Bddvar.Expr] | |
to_add [ArithDD] |
Operations
|
to_code [Bddenum] |
Convert a constant register to its value as a code.
|
to_expr [Formula.Arith] | |
to_expr [Formula.Benum] | |
to_expr [Formula.Bint] | |
to_expr [Formula.Bool] | |
to_expr [ArithDD] | |
to_int [Bddint] | |
to_int [Bddreg.Minterm] |
Convert a minterm to a (possibly signed) integer.
|
to_int [Bddreg] | to_int sign x converts a constant register to an integer.
|
to_label [Bddenum] |
Convert a constant register to its value as a label.
|
to_string [Var] | |
tree_of_lin [Arith] | |
tree_of_poly [Arith] | |
typ_of_expr [Formula] | |
typ_of_expr [Arith] | |
typ_of_expr [Bddvar] |
Type of an expression
|
V | |
var [Formula.Arith] | |
var [Formula.Benum] | |
var [Formula.Bint] | |
var [Formula.Bool] | |
var [Formula] | |
var [ArithDD] | |
var [Arith.Poly] | |
var [Arith.Lin] | |
var [Arith] | |
var [Bddvar] |
Expression representing the litteral var
|
varinfo_of_id [Bddvar] |
Return the variable and
info involved by the BDD index
|
vectorsupport_cond [Formula] | |
vectorsupport_cond [Bddvar] |
Return the support of an array of expressions as a conjunction of the
BDD identifiers involved in the expressions
|
X | |
xor [Formula.Bool] | |
Z | |
zero [Formula.Bint] | |
zero [Bddint] | |
zero [Bddreg] |
Tests the register to zero.
|