A |
| absorbant_one [ApronexprDD] |
|
| absorbant_zero [ApronexprDD] |
|
| add [Expr1.O.Apron] |
|
| add [Expr1.O.Bint] |
|
| add [Expr1.Apron] |
|
| add [Expr1.Bint] |
|
| add [Expr0.O.Apron] |
|
| add [Expr0.O.Bint] |
|
| add [Expr0.Apron] |
|
| add [Expr0.Bint] |
|
| add [ApronexprDD] |
|
| add [Apronexpr.Poly] |
|
| add [Apronexpr.Lin] |
|
| add [Apronexpr] |
|
| add_dimensions [ApronDD] |
|
| add_typ [Env] |
|
| add_typ_with [Env] |
Declaration of a new type
|
| 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)
|
| append [Bddleaf] |
Calls the right append function depending on the
options.
|
| append_disjoint [Bddleaf] |
Appends the two lists.
|
| append_unique [Bddleaf] |
Append the two lists.
|
| apply_bbinop [Syntax] |
|
| apply_binop [Syntax] |
|
| apply_change [Domainlevel1.Level0] |
|
| apply_change [Domain0] |
|
| apply_change [Bdddomain0.O] |
|
| apply_change [Bdddomain0] |
|
| apply_change [Mtbdddomain0.O] |
|
| apply_change [Mtbdddomain0] |
|
| apply_dimchange2 [ApronDD] |
|
| apply_permutation [Domainlevel1.Level0] |
|
| apply_permutation [Domain0] |
|
| apply_permutation [Bdddomain0.O] |
|
| apply_permutation [Bdddomain0] |
|
| apply_permutation [Mtbdddomain0.O] |
|
| apply_permutation [Mtbdddomain0] |
|
| aprondim_of_var [Env] |
|
| assign_lexpr [Domain1] |
|
| assign_lexpr [Domainlevel1.Level0] |
|
| assign_lexpr [Domainlevel1.Level1] |
|
| assign_lexpr [Domain0] |
|
| assign_lexpr [Bdddomain0.O] |
|
| assign_lexpr [Bdddomain0] |
|
| assign_lexpr [Mtbdddomain0.O] |
|
| assign_lexpr [Mtbdddomain0] |
|
| assign_listexpr2 [Domain1] |
|
| assign_listexpr2 [Domainlevel1.Level1] |
|
| assign_texpr_array [ApronDD] |
|
| asssub_texpr_array [ApronDD] |
|
B |
| boolexpr2_of_string [Parser] |
|
| bottom [Domain1] |
|
| bottom [Domainlevel1.Level0] |
|
| bottom [Domainlevel1.Level1] |
Basic constructor
|
| bottom [Domain0] |
|
| bottom [Bdddomain0.O] |
|
| bottom [Bdddomain0] |
|
| bottom [Mtbdddomain0.O] |
|
| bottom [Mtbdddomain0] |
|
| bottom [ApronDD] |
|
C |
| canonicalize [Domain1] |
|
| canonicalize [Bdddomain1] |
Canonicalize an abstract value by ensuring uniqueness and
disjointness properties.
|
| canonicalize [Domain0] |
|
| canonicalize [Bdddomain0.O] |
|
| canonicalize [Bdddomain0] |
Canonicalize an abstract value by ensuring uniqueness and
disjointness properties.
|
| cast [Expr1.O.Apron] |
|
| cast [Expr1.Apron] |
|
| cast [Expr0.O.Apron] |
|
| cast [Expr0.Apron] |
|
| cast [ApronexprDD] |
|
| cast [Apronexpr] |
|
| change_environment [Domain1] |
|
| change_environment [Domainlevel1.Level1] |
Change of environments and renaming
|
| check_disjointness [Bddleaf] |
Checking function: raises Failure if problem, returns
true otherwise.
|
| check_lvalue [Env] |
|
| check_lvar [Env] |
|
| check_lvarvalue [Env] |
|
| check_ovalue [Env] |
|
| check_typ2 [Expr0.O] |
|
| check_unicity [Bddleaf] |
Checking function: raises Failure if problem, returns
true otherwise.
|
| check_value [Env] |
|
| check_value2 [Env] |
|
| check_value3 [Env] |
|
| check_var [Env] |
|
| check_wellformed [Bdddomain0.O] |
|
| cofactor [Expr1.O.Apron] |
|
| cofactor [Expr1.O.Benum] |
|
| cofactor [Expr1.O.Bint] |
|
| cofactor [Expr1.O.Bool] |
|
| cofactor [Expr1.O] |
Evaluate the expression.
|
| cofactor [Expr1.Apron] |
|
| cofactor [Expr1.Benum] |
|
| cofactor [Expr1.Bint] |
|
| cofactor [Expr1.Bool] |
|
| cofactor [Expr1] |
Evaluate the expression.
|
| cofactor [Expr0.O.Apron] |
|
| cofactor [Expr0.O.Benum] |
|
| cofactor [Expr0.O.Bint] |
|
| cofactor [Expr0.O.Bool] |
|
| cofactor [Expr0.O] |
|
| cofactor [Expr0.Apron] |
|
| cofactor [Expr0.Benum] |
|
| cofactor [Expr0.Bint] |
|
| cofactor [Expr0.Bool] |
|
| cofactor [Expr0] |
Evaluate the expression.
|
| cofactors [Descend] |
|
| compare [Apronexpr.Condition] |
|
| compare [Apronexpr.Tree] |
|
| compare [Apronexpr.Poly] |
|
| compare [Apronexpr.Lin] |
|
| compare [Apronexpr] |
|
| compare_cond [Cond] |
|
| compare_lterm [Apronexpr.Lin] |
|
| compare_monomial [Apronexpr.Poly] |
|
| compare_varexp [Apronexpr.Poly] |
|
| compose_of_lvarexpr [Expr0.O] |
|
| compute_change [Env] |
|
| condition [Expr1.O.Apron] |
|
| condition [Expr1.Apron] |
|
| cons [Bddleaf] |
Calls the right cons function depending on the options.
|
| cons_disjoint [Bddleaf] |
Performs the join of a list with an element.
|
| cons_unique [Bddleaf] |
Performs the join of a list with an element.
|
| copy [Cond] |
|
| copy [Env] |
Copy
|
| cst [Expr1.O.Apron] |
|
| cst [Expr1.Apron] |
|
| cst [Expr0.O.Apron] |
|
| cst [Expr0.Apron] |
|
| cst [ApronDD] |
|
| cst [ApronexprDD] |
|
| cst [Apronexpr.Poly] |
|
| cst [Apronexpr.Lin] |
|
| cst [Apronexpr] |
|
| cst_to_expr0 [Syntax] |
|
D |
| dand [Expr1.O.Bool] |
|
| dand [Expr1.Bool] |
|
| dand [Expr0.O.Bool] |
|
| dand [Expr0.Bool] |
|
| descend [Descend] |
|
| descend_mtbdd [Descend] |
|
| dfalse [Expr1.O.Bool] |
|
| dfalse [Expr1.Bool] |
|
| dfalse [Expr0.O.Bool] |
|
| dfalse [Expr0.Bool] |
|
| div [Expr1.O.Apron] |
|
| div [Expr1.Apron] |
|
| div [Expr0.O.Apron] |
|
| div [Expr0.Apron] |
|
| div [ApronexprDD] |
|
| div [Apronexpr.Poly] |
|
| div [Apronexpr] |
|
| 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] |
|
| dor [Expr0.Bool] |
|
| dtrue [Expr1.O.Bool] |
|
| dtrue [Expr1.Bool] |
|
| dtrue [Expr0.O.Bool] |
|
| dtrue [Expr0.Bool] |
|
E |
| eq [Expr1.O.Apron] |
|
| eq [Expr1.O.Benum] |
|
| eq [Expr1.O.Bint] |
|
| eq [Expr1.O.Bool] |
Same as nxor
|
| eq [Expr1.O] |
Equality operation
|
| eq [Expr1.Apron] |
|
| eq [Expr1.Benum] |
|
| eq [Expr1.Bint] |
|
| eq [Expr1.Bool] |
Same as nxor
|
| eq [Expr1] |
Equality operation
|
| eq [Expr0.O.Apron] |
|
| eq [Expr0.O.Benum] |
|
| eq [Expr0.O.Bint] |
|
| eq [Expr0.O.Bool] |
|
| eq [Expr0.O] |
Under which condition are the expressions equal ? In case of
arithmetic expressions, do not take into account the careset.
|
| eq [Expr0.Apron] |
|
| eq [Expr0.Benum] |
|
| eq [Expr0.Bint] |
|
| eq [Expr0.Bool] |
|
| eq [Expr0] |
Under which condition are the expressions equal ? In case of
arithmetic expressions, do not take into account the careset.
|
| eq [ApronexprDD.Condition] |
|
| 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 [Apronexpr] |
|
| error [Syntax] |
|
| exist [Expr1.O.Bool] |
|
| exist [Expr1.Bool] |
|
| exist [Expr0.O.Bool] |
|
| exist [Expr0.Bool] |
|
| exist [ApronDD] |
|
| existand [ApronDD] |
|
| expr [Yacc] |
|
| expr0_of_lexbuf [Parser] |
|
| expr0_of_string [Parser] |
|
| expr1_of_string [Parser] |
|
| extend_environment [Expr2.List] |
|
| extend_environment [Expr2.Bool] |
Extend the underlying environment to a superenvironment,
and adapt accordingly the underlying representation
|
| extend_environment [Expr2.O.List] |
|
| extend_environment [Expr2.O.Bool] |
|
| extend_environment [Expr2.O] |
|
| extend_environment [Expr2] |
Extend the underlying environment to a superenvironment, and
adapt accordingly the underlying representation
|
| extend_environment [Expr1.O.List] |
|
| extend_environment [Expr1.O.Apron] |
|
| 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.Apron] |
Extend the underlying environment to a superenvironment,
and adapt accordingly the underlying representation
|
| 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
|
F |
| fold2 [Bddleaf] |
|
| forall [Expr1.O.Bool] |
|
| forall [Expr1.Bool] |
|
| forall [Expr0.O.Bool] |
|
| forall [Expr0.Bool] |
|
| forget_array [ApronDD] |
|
| forget_list [Domain1] |
|
| forget_list [Domainlevel1.Level0] |
|
| forget_list [Domainlevel1.Level1] |
Forget (existential quantification) a list of variables
|
| forget_list [Domain0] |
|
| forget_list [Bdddomain0.O] |
|
| forget_list [Bdddomain0] |
Forget (existential quantification) a list of variables
|
| forget_list [Mtbdddomain0.O] |
|
| forget_list [Mtbdddomain0] |
Forget (existential quantification) a list of variables
|
G |
| get_cond [Expr2.List] |
Extract resp.
|
| get_cond [Expr2.Bool] |
Extract resp.
|
| get_cond [Expr2.O.List] |
|
| get_cond [Expr2.O.Bool] |
|
| get_cond [Expr2.O] |
|
| get_cond [Expr2] |
Extract resp.
|
| get_cond [Cond] |
|
| get_env [Domain1] |
|
| get_env [Domainlevel1.Level1] |
|
| get_env [Expr2.List] |
|
| get_env [Expr2.Bool] |
|
| get_env [Expr2.O.List] |
|
| get_env [Expr2.O.Bool] |
|
| get_env [Expr2.O] |
|
| get_env [Expr2] |
|
| get_env [Expr1.O.List] |
|
| get_env [Expr1.List] |
|
| get_env [Expr1.Apron] |
|
| 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] |
|
| gmod [Expr1.O.Apron] |
|
| gmod [Expr1.Apron] |
|
| gmod [Expr0.O.Apron] |
|
| gmod [Expr0.Apron] |
|
| gmod [ApronexprDD] |
|
| gmod [Apronexpr] |
|
| guard [Bddleaf] |
Others
|
| 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_label [Expr1.O.Benum] |
Return the guard of the label.
|
| guard_of_label [Expr1.Benum] |
Return the guard of the label.
|
| guardints [Expr1.O.Bint] |
Return the list g -> n of guarded values.
|
| guardints [Expr1.Bint] |
Return the list g -> n of guarded values.
|
| guardlabels [Expr1.O.Benum] |
Return the list g -> label of guarded values.
|
| guardlabels [Expr1.Benum] |
Return the list g -> label of guarded values.
|
H |
| hash [Apronexpr] |
|
I |
| is_and_false [Expr0.O.Bool] |
|
| is_and_false [Expr0.Bool] |
|
| is_bottom [Domain1] |
|
| is_bottom [Domainlevel1.Level0] |
|
| is_bottom [Domainlevel1.Level1] |
|
| is_bottom [Domain0] |
|
| is_bottom [Bdddomain0.O] |
|
| is_bottom [Bdddomain0] |
|
| is_bottom [Mtbdddomain0.O] |
|
| is_bottom [Mtbdddomain0] |
|
| is_bottom [ApronDD] |
|
| is_cst [Expr1.O.Bool] |
|
| is_cst [Expr1.Bool] |
|
| is_cst [Expr0.O.Bool] |
|
| is_cst [Expr0.Bool] |
|
| is_dependent_on_integer_only [Apronexpr] |
|
| is_eq [Domain1] |
|
| is_eq [Domainlevel1.Level0] |
|
| is_eq [Domainlevel1.Level1] |
Inclusion and equality tests
|
| is_eq [Domain0] |
|
| is_eq [Bdddomain0.O] |
|
| is_eq [Bdddomain0] |
Inclusion and equality tests
|
| is_eq [Mtbdddomain0.O] |
|
| is_eq [Mtbdddomain0] |
Inclusion and equality tests
|
| is_eq [Expr1.O.Bool] |
|
| is_eq [Expr1.Bool] |
|
| is_eq [Expr0.O.Bool] |
|
| is_eq [Expr0.Bool] |
|
| is_eq [ApronDD] |
|
| is_eq [Env] |
Test equality of environments in terms of types and
variables (but not in term of indexes)
|
| is_false [Expr2.Bool] |
|
| is_false [Expr2.O.Bool] |
|
| is_false [Expr1.O.Bool] |
|
| is_false [Expr1.Bool] |
|
| is_false [Expr0.O.Bool] |
|
| is_false [Expr0.Bool] |
|
| is_inter_false [Expr1.O.Bool] |
|
| is_inter_false [Expr1.Bool] |
|
| is_leq [Domain1] |
|
| is_leq [Domainlevel1.Level0] |
|
| is_leq [Domainlevel1.Level1] |
|
| is_leq [Domain0] |
|
| is_leq [Bdddomain0.O] |
|
| is_leq [Bdddomain0] |
|
| is_leq [Mtbdddomain0.O] |
|
| is_leq [Mtbdddomain0] |
|
| is_leq [Expr1.O.Bool] |
|
| is_leq [Expr1.Bool] |
|
| is_leq [Expr0.O.Bool] |
|
| is_leq [Expr0.Bool] |
|
| is_leq [ApronDD] |
|
| is_leq [Env] |
Test inclusion of environments in terms of types and
variables (but not in term of indexes)
|
| is_one [ApronexprDD] |
|
| is_top [Domain1] |
|
| is_top [Domainlevel1.Level0] |
|
| is_top [Domainlevel1.Level1] |
Emtpiness and Universality tests
|
| is_top [Domain0] |
|
| is_top [Bdddomain0.O] |
|
| is_top [Bdddomain0] |
Emtpiness and Universality tests
|
| is_top [Mtbdddomain0.O] |
|
| is_top [Mtbdddomain0] |
Emtpiness and Universality tests
|
| is_top [ApronDD] |
|
| is_true [Expr2.Bool] |
|
| is_true [Expr2.O.Bool] |
|
| is_true [Expr1.O.Bool] |
|
| is_true [Expr1.Bool] |
|
| is_true [Expr0.O.Bool] |
|
| is_true [Expr0.Bool] |
|
| is_zero [Syntax] |
|
| is_zero [ApronexprDD] |
|
| ite [Expr1.O.Apron] |
|
| ite [Expr1.O.Benum] |
|
| ite [Expr1.O.Bint] |
|
| ite [Expr1.O.Bool] |
If-then-else
|
| ite [Expr1.O] |
If-then-else operation
|
| ite [Expr1.Apron] |
|
| ite [Expr1.Benum] |
|
| ite [Expr1.Bint] |
|
| ite [Expr1.Bool] |
If-then-else
|
| ite [Expr1] |
If-then-else operation
|
| ite [Expr0.O.Apron] |
|
| ite [Expr0.O.Benum] |
|
| ite [Expr0.O.Bint] |
|
| ite [Expr0.O.Bool] |
|
| ite [Expr0.O] |
If-then-else operation
|
| ite [Expr0.Apron] |
|
| ite [Expr0.Benum] |
|
| ite [Expr0.Bint] |
|
| ite [Expr0.Bool] |
|
| ite [Expr0] |
If-then-else operation
|
| iter2 [Bddleaf] |
Applies f to all pairs (elt1,elt2) with elt1 in
list1 and elt2 in list2.
|
J |
| join [Domain1] |
|
| join [Domainlevel1.Level0] |
|
| join [Domainlevel1.Level1] |
Meet and join
|
| join [Domain0] |
|
| join [Bdddomain0.O] |
|
| join [Bdddomain0] |
Meet and join
|
| join [Mtbdddomain0.O] |
|
| join [Mtbdddomain0] |
Meet and join
|
| join [ApronDD] |
|
L |
| labels [Env] |
Return the list of labels (not variables)
|
| lce [Env] |
Least common environment
|
| leq [Expr1.O.Bool] |
Implication
|
| leq [Expr1.Bool] |
Implication
|
| leq [Expr0.O.Bool] |
|
| leq [Expr0.Bool] |
|
| lex [Lex] |
|
| lin_of_poly [Apronexpr] |
|
| lin_of_tree [Apronexpr] |
|
| listexpr1_of_lstring [Parser] |
|
| listexpr2_of_lstring [Parser] |
|
M |
| make [Expr1.O] |
Creation from an expression without environment
|
| make [Expr1] |
|
| make [ApronexprDD.Condition] |
|
| make [Cond.O] |
|
| make [Cond] |
|
| make [Env.O] |
Create a new database.
|
| make [Env] |
Create a new environment.
|
| make [Apronexpr.Condition] |
|
| make_bdd [Domain1] |
|
| make_bdd [Domain0] |
Make a bdd manager
|
| make_global [ApronDD] |
|
| make_man [Bdddomain1] |
Makes a BDDAPRON manager from an APRON manager, and fills
options with default values
|
| make_man [Mtbdddomain1] |
Makes a BDDAPRON manager from an APRON manager.
|
| make_man [Bdddomain0] |
Makes a BDDAPRON manager from an APRON manager, and fills
options with default values
|
| make_man [Mtbdddomain0] |
Makes a BDDAPRON manager from an APRON manager.
|
| make_man [ApronDD] |
|
| make_mtbdd [Domain1] |
Make a mtbdd manager
|
| make_mtbdd [Domain0] |
Make a mtbdd manager
|
| make_op_join [ApronDD] |
|
| make_string [Env] |
make_string XXX = make ~symbol:string_symbol XXX
|
| make_symbol [Env] |
Generic function for creating a manager for symbols
Default values are Pervasives.compare, Env.marshal and Env.unmarshal.
|
| make_table [ApronDD] |
|
| make_unique [Bddleaf] |
Remove duplicatas (by reconstructing the list)
|
| make_value [Cond] |
|
| make_value [Env] |
Constructor
|
| man_is_bdd [Domain1] |
Return true iff the argument manager is a bdd manager
|
| man_is_bdd [Domain0] |
Return true iff the argument manager is a bdd manager
|
| man_is_mtbdd [Domain1] |
Return true iff the argument manager is a mtbdd manager
|
| man_is_mtbdd [Domain0] |
Return true iff the argument manager is a mtbdd manager
|
| man_of_bdd [Domain1] |
Makes a bdd manager generic
|
| man_of_bdd [Domain0] |
Makes a bdd manager generic
|
| man_of_mtbdd [Domain1] |
Makes a mtbdd manager generic
|
| man_of_mtbdd [Domain0] |
Makes a mtbdd manager generic
|
| man_to_bdd [Domain1] |
Instanciate the type of a bdd manager.
|
| man_to_bdd [Domain0] |
Instanciate the type of a bdd manager.
|
| man_to_mtbdd [Domain1] |
Instanciate the type of a mtbdd manager.
|
| man_to_mtbdd [Domain0] |
Instanciate the type of a mtbdd manager.
|
| mapbinop [Env] |
|
| mapbinope [Env] |
|
| mapterop [Env] |
|
| mapunop [Env] |
|
| marshal [Env] |
Safe marshalling function, generating strings without NULL
characters.
|
| meet [Domain1] |
|
| meet [Domainlevel1.Level0] |
|
| meet [Domainlevel1.Level1] |
|
| meet [Domain0] |
|
| meet [Bdddomain0.O] |
|
| meet [Bdddomain0] |
|
| meet [Mtbdddomain0.O] |
|
| meet [Mtbdddomain0] |
|
| meet [ApronDD] |
|
| meet_condition [Domain1] |
|
| meet_condition [Domainlevel1.Level0] |
|
| meet_condition [Domainlevel1.Level1] |
|
| meet_condition [Domain0] |
|
| meet_condition [Bdddomain0.O] |
|
| meet_condition [Bdddomain0] |
Intersection with a Boolean expression (that may involve
numerical constraints)
|
| meet_condition [Mtbdddomain0.O] |
|
| meet_condition [Mtbdddomain0] |
Intersection with a Boolean expression (that may involve
numerical constraints)
|
| meet_condition2 [Domain1] |
|
| meet_condition2 [Domainlevel1.Level1] |
Intersection with a Boolean expression (that may involve
numerical constraints)
|
| meet_idcondb [Mtbdddomain0.O] |
|
| meet_tcons_array [ApronDD] |
|
| mem_label [Env] |
Is the label a label defined in the database ?
|
| mem_typ [Env] |
Is the type defined in the database ?
|
| mem_var [Env] |
Is the label/var defined in the database ?
|
| mul [Expr1.O.Apron] |
|
| mul [Expr1.O.Bint] |
|
| mul [Expr1.Apron] |
|
| mul [Expr1.Bint] |
|
| mul [Expr0.O.Apron] |
|
| mul [Expr0.O.Bint] |
|
| mul [Expr0.Apron] |
|
| mul [Expr0.Bint] |
|
| mul [ApronexprDD] |
|
| mul [Apronexpr.Poly] |
|
| mul [Apronexpr] |
|
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] |
|
| negate [Expr1.O.Apron] |
|
| negate [Expr1.Apron] |
|
| negate [Expr0.O.Apron] |
|
| negate [Expr0.Apron] |
|
| negate [ApronexprDD] |
|
| negate [Apronexpr.Condition] |
|
| negate [Apronexpr.Poly] |
|
| negate [Apronexpr.Lin] |
|
| negate [Apronexpr] |
|
| negate_cond [Cond] |
|
| neutral_join [ApronDD] |
|
| nor [Expr1.O.Bool] |
|
| nor [Expr1.Bool] |
|
| nor [Expr0.O.Bool] |
|
| nor [Expr0.Bool] |
|
| normalize [Expr1.O.List] |
|
| normalize [Expr1.O] |
|
| normalize [Expr1.List] |
|
| normalize [Expr1] |
|
| normalize [Expr0.O] |
|
| normalize [Expr0] |
|
| normalize [Apronexpr.Poly] |
|
| normalize [Apronexpr.Lin] |
|
| normalize [Apronexpr] |
|
| normalize_as_constraint [Apronexpr.Poly] |
|
| normalize_as_constraint [Apronexpr.Lin] |
|
| normalize_as_constraint [Apronexpr] |
|
| normalize_full [Apronexpr.Poly] |
|
| normalize_monomial [Apronexpr.Poly] |
|
| 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] |
|
| nxor [Expr0.Bool] |
|
O |
| of_apron [Domain1] |
|
| of_apron [Domainlevel1.Level0] |
|
| of_apron [Domainlevel1.Level1] |
|
| of_apron [Domain0] |
|
| of_apron [Bdddomain0.O] |
|
| of_apron [Bdddomain0] |
|
| of_apron [Mtbdddomain0.O] |
|
| of_apron [Mtbdddomain0] |
|
| of_bdd [Domain1] |
Makes a pair (bdd manager,bdd abstract value) generic
|
| of_bdd [Domain0] |
Makes a pair (bdd manager,bdd abstract value) generic
|
| of_bool [Expr1.O.Bool] |
|
| of_bool [Expr1.Bool] |
|
| of_bool [Expr0.O.Bool] |
|
| of_bool [Expr0.Bool] |
|
| of_expr [Expr2.Bool] |
|
| of_expr [Expr2.O.Bool] |
|
| of_expr [Expr1.O.Apron] |
|
| of_expr [Expr1.O.Benum] |
|
| of_expr [Expr1.O.Bint] |
|
| of_expr [Expr1.O.Bool] |
|
| of_expr [Expr1.Apron] |
|
| of_expr [Expr1.Benum] |
|
| of_expr [Expr1.Bint] |
|
| of_expr [Expr1.Bool] |
|
| of_expr [Expr0.O.Apron] |
|
| of_expr [Expr0.O.Benum] |
|
| of_expr [Expr0.O.Bint] |
|
| of_expr [Expr0.O.Bool] |
|
| of_expr [Expr0.Apron] |
|
| of_expr [Expr0.Benum] |
|
| of_expr [Expr0.Bint] |
|
| of_expr [Expr0.Bool] |
|
| of_expr [ApronexprDD] |
|
| of_expr0 [Expr2.Bool] |
Creation from an expression of level 0 (without
environment)
|
| of_expr0 [Expr2.O.Bool] |
|
| of_expr0 [Expr2.O] |
|
| of_expr0 [Expr2] |
Creation from an expression of level 0 (without
environment)
|
| of_expr0 [Expr1.Apron] |
Creation from an expression of level 0 (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)
|
| of_expr1 [Expr2.Bool] |
Creation from an expression of level 1 (without condition
environment)
|
| of_expr1 [Expr2.O.Bool] |
|
| of_expr1 [Expr2.O] |
|
| of_expr1 [Expr2] |
Creation from an expression of level 1 (without condition
environment)
|
| of_int [Expr1.O.Bint] |
|
| of_int [Expr1.Bint] |
|
| of_int [Expr0.O.Bint] |
|
| of_int [Expr0.Bint] |
|
| of_lexpr [Expr1.O.List] |
|
| of_lexpr [Expr1.List] |
|
| of_lexpr0 [Expr2.List] |
Creation from a list of expressions of level 0 (without
environment)
|
| of_lexpr0 [Expr2.O.List] |
|
| of_lexpr0 [Expr1.O.List] |
|
| of_lexpr0 [Expr1.List] |
Creation from a list of expressions of level 0 (without
environment)
|
| of_lexpr1 [Expr2.List] |
Creation from a list of expressions of level 1 (without
condition environment)
|
| of_lexpr1 [Expr2.O.List] |
|
| of_listexpr1 [Expr2.List] |
Creation from an expression list of level 1 (without condition
environment)
|
| of_listexpr1 [Expr2.O.List] |
|
| of_mtbdd [Domain1] |
Makes a pair (mtbdd manager,mtbdd abstract value) generic
|
| of_mtbdd [Domain0] |
Makes a pair (mtbdd manager,mtbdd abstract value) generic
|
| one [Apronexpr.Lin] |
|
| one [Apronexpr] |
|
P |
| permute [Expr0.O.Apron] |
|
| permute [Expr0.O.Benum] |
|
| permute [Expr0.O.Bint] |
|
| permute [Expr0.O.Bool] |
|
| permute [Expr0.O] |
|
| permute [Expr0.Apron] |
|
| permute [Expr0.Benum] |
|
| permute [Expr0.Bint] |
|
| permute [Expr0.Bool] |
|
| permute [Expr0] |
|
| permute_dimensions [ApronDD] |
|
| permute_list [Expr0.O] |
|
| poly_of_tree [Apronexpr] |
|
| precedence_of_binop [Syntax] |
|
| precedence_of_expr [Syntax] |
|
| precedence_of_unop [Syntax] |
|
| pred [Expr1.O.Bint] |
|
| pred [Expr1.Bint] |
|
| pred [Expr0.O.Bint] |
|
| pred [Expr0.Bint] |
|
| print [Domain1] |
|
| print [Domainlevel1.Level0] |
|
| print [Domainlevel1.Level1] |
Printing function
|
| print [Domain0] |
|
| print [Bdddomain0.O] |
|
| print [Bdddomain0] |
Printing function
|
| print [Mtbdddomain0.O] |
|
| print [Mtbdddomain0] |
Printing function
|
| print [Expr2.List] |
|
| print [Expr2.Bool] |
|
| print [Expr2.O.List] |
|
| print [Expr2.O.Bool] |
|
| print [Expr2.O] |
|
| print [Expr2] |
|
| print [Expr1.O.List] |
|
| print [Expr1.O.Apron] |
|
| print [Expr1.O.Benum] |
|
| print [Expr1.O.Bint] |
|
| print [Expr1.O.Bool] |
|
| print [Expr1.O] |
|
| print [Expr1.List] |
|
| print [Expr1.Apron] |
|
| print [Expr1.Benum] |
|
| print [Expr1.Bint] |
|
| print [Expr1.Bool] |
|
| print [Expr1] |
|
| print [Expr0.O.Apron] |
|
| print [Expr0.O.Benum] |
|
| print [Expr0.O.Bint] |
|
| print [Expr0.O.Bool] |
|
| print [Expr0.O] |
|
| print [Expr0.Apron] |
|
| print [Expr0.Benum] |
|
| print [Expr0.Bint] |
|
| print [Expr0.Bool] |
|
| print [Expr0] |
Printing functions
|
| print [ApronDD] |
|
| print [ApronexprDD] |
|
| print [Cond] |
|
| print [Env.O] |
Print an environment
|
| print [Env] |
Print an environment
|
| print [Apronexpr.Condition] |
|
| print [Apronexpr.Tree] |
|
| print [Apronexpr.Poly] |
|
| print [Apronexpr.Lin] |
|
| print [Apronexpr] |
|
| print_bbinop [Syntax] |
|
| print_bdd [Expr0.O] |
|
| print_binop [Syntax] |
|
| print_cond [Cond] |
|
| print_cst [Syntax] |
|
| print_expr [Syntax] |
|
| print_idcondb [Env] |
|
| print_order [Env] |
Print the BDD variable ordering
|
| print_typ [Env] |
Print a type
|
| print_typ [Apronexpr] |
|
| print_typdef [Env] |
Print a type definition
|
| print_unop [Syntax] |
|
R |
| remove_dimensions [ApronDD] |
|
| remove_vars [Env] |
|
| remove_vars_with [Env] |
Remove the set of variables, as well as all constraints,
and possibly normalize the environment and return the
applied permutation.
|
| rename [Domain1] |
|
| rename [Domainlevel1.Level1] |
Rename a list of variables (thus changing the
environment).
|
| rename_vars [Env] |
Functional versions of the previous functions
|
| rename_vars_with [Env] |
Rename the variables, and remove all constraints,possibly
normalize the environment and return the applied
permutation.
|
| restrict [Expr1.O.Apron] |
|
| restrict [Expr1.O.Benum] |
|
| restrict [Expr1.O.Bint] |
|
| restrict [Expr1.O.Bool] |
|
| restrict [Expr1.O] |
|
| restrict [Expr1.Apron] |
|
| restrict [Expr1.Benum] |
|
| restrict [Expr1.Bint] |
|
| restrict [Expr1.Bool] |
|
| restrict [Expr1] |
|
| restrict [Expr0.O.Apron] |
|
| restrict [Expr0.O.Benum] |
|
| restrict [Expr0.O.Bint] |
|
| restrict [Expr0.O.Bool] |
|
| restrict [Expr0.O] |
|
| restrict [Expr0.Apron] |
|
| restrict [Expr0.Benum] |
|
| restrict [Expr0.Bint] |
|
| restrict [Expr0.Bool] |
|
| restrict [Expr0] |
|
S |
| scale [Expr1.O.Bint] |
|
| scale [Expr1.Bint] |
|
| scale [Expr0.O.Bint] |
|
| scale [Expr0.Bint] |
|
| scale [Apronexpr.Poly] |
|
| scale [Apronexpr.Lin] |
|
| shift_left [Expr1.O.Bint] |
|
| shift_left [Expr1.Bint] |
|
| shift_left [Expr0.O.Bint] |
|
| shift_left [Expr0.Bint] |
|
| shift_right [Expr1.O.Bint] |
|
| shift_right [Expr1.Bint] |
|
| shift_right [Expr0.O.Bint] |
|
| shift_right [Expr0.Bint] |
|
| size [Domain1] |
|
| size [Domainlevel1.Level0] |
|
| size [Domainlevel1.Level1] |
Size of an abstract value.
|
| size [Domain0] |
|
| size [Bdddomain0.O] |
|
| size [Bdddomain0] |
Size of an abstract value in terms of number of nodes of the MTBDD.
|
| size [Mtbdddomain0.O] |
|
| size [Mtbdddomain0] |
Size of an abstract value in terms of number of nodes of the MTBDD.
|
| special_is_leq [ApronDD] |
|
| special_join [ApronDD] |
|
| special_meet [ApronDD] |
|
| split_lvar [Descend] |
|
| split_lvarlexpr [Descend] |
|
| split_texpr [Descend] |
|
| sqrt [Expr1.O.Apron] |
|
| sqrt [Expr1.Apron] |
|
| sqrt [Expr0.O.Apron] |
|
| sqrt [Expr0.Apron] |
|
| sqrt [ApronexprDD] |
|
| sqrt [Apronexpr] |
|
| string_of_aprondim [Env] |
|
| string_symbol [Env] |
Standard manager for symbols of type string
|
| sub [Expr1.O.Apron] |
|
| sub [Expr1.O.Bint] |
|
| sub [Expr1.Apron] |
|
| sub [Expr1.Bint] |
|
| sub [Expr0.O.Apron] |
|
| sub [Expr0.O.Bint] |
|
| sub [Expr0.Apron] |
|
| sub [Expr0.Bint] |
|
| sub [ApronexprDD] |
|
| sub [Apronexpr.Poly] |
|
| sub [Apronexpr.Lin] |
|
| sub [Apronexpr] |
|
| substitute [Expr1.O.Apron] |
|
| substitute [Expr1.O.Benum] |
|
| substitute [Expr1.O.Bint] |
|
| substitute [Expr1.O.Bool] |
|
| substitute [Expr1.O] |
Parallel substitution of variables by expressions
|
| substitute [Expr1.Apron] |
|
| substitute [Expr1.Benum] |
|
| substitute [Expr1.Bint] |
|
| substitute [Expr1.Bool] |
|
| substitute [Expr1] |
Parallel substitution of variables by expressions
|
| substitute [Expr0.O.Apron] |
|
| substitute [Expr0.O.Benum] |
|
| substitute [Expr0.O.Bint] |
|
| substitute [Expr0.O.Bool] |
|
| substitute [Expr0.O] |
Parallel substitution of variables by expressions
|
| substitute [Expr0.Apron] |
|
| substitute [Expr0.Benum] |
|
| substitute [Expr0.Bint] |
|
| substitute [Expr0.Bool] |
|
| substitute [Expr0] |
Parallel substitution of variables by expressions
|
| substitute [ApronexprDD.Condition] |
|
| substitute [ApronexprDD] |
|
| substitute_by_var [Expr1.O.Apron] |
|
| 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.Apron] |
|
| 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.Apron] |
|
| substitute_by_var [Expr0.O.Benum] |
|
| substitute_by_var [Expr0.O.Bint] |
|
| substitute_by_var [Expr0.O.Bool] |
|
| substitute_by_var [Expr0.O] |
Parallel substitution of variables by variables
|
| substitute_by_var [Expr0.Apron] |
|
| substitute_by_var [Expr0.Benum] |
|
| substitute_by_var [Expr0.Bint] |
|
| substitute_by_var [Expr0.Bool] |
|
| substitute_by_var [Expr0] |
Parallel substitution of variables by variables
|
| substitute_by_var [Apronexpr.Tree] |
|
| substitute_by_var [Apronexpr.Poly] |
|
| substitute_by_var [Apronexpr.Lin] |
|
| substitute_by_var [Apronexpr] |
|
| substitute_lexpr [Domain1] |
|
| substitute_lexpr [Domainlevel1.Level0] |
|
| substitute_lexpr [Domainlevel1.Level1] |
|
| substitute_lexpr [Domain0] |
|
| substitute_lexpr [Bdddomain0.O] |
|
| substitute_lexpr [Bdddomain0] |
Parallel assignement/substitution of a list of variables by
a list of expressions
|
| substitute_lexpr [Mtbdddomain0.O] |
|
| substitute_lexpr [Mtbdddomain0] |
Parallel assignement/substitution of a list of variables by
a list of expressions
|
| substitute_linexpr [ApronexprDD] |
|
| substitute_listexpr2 [Domain1] |
|
| substitute_listexpr2 [Domainlevel1.Level1] |
Parallel assignement/substitution of a list of variables
by a list of expressions
|
| substitute_polyexpr [ApronexprDD] |
|
| substitute_texpr_array [ApronDD] |
|
| substitute_treeexpr [ApronexprDD] |
|
| succ [Expr1.O.Bint] |
|
| succ [Expr1.Bint] |
|
| succ [Expr0.O.Bint] |
|
| succ [Expr0.Bint] |
|
| sup [Expr1.O.Apron] |
|
| sup [Expr1.O.Bint] |
|
| sup [Expr1.Apron] |
|
| sup [Expr1.Bint] |
|
| sup [Expr0.O.Apron] |
|
| sup [Expr0.O.Bint] |
|
| sup [Expr0.Apron] |
|
| sup [Expr0.Bint] |
|
| sup [ApronexprDD.Condition] |
|
| sup_int [Expr1.O.Bint] |
|
| sup_int [Expr1.Bint] |
|
| sup_int [Expr0.O.Bint] |
|
| sup_int [Expr0.Bint] |
|
| supeq [Expr1.O.Apron] |
|
| supeq [Expr1.O.Bint] |
|
| supeq [Expr1.Apron] |
|
| supeq [Expr1.Bint] |
|
| supeq [Expr0.O.Apron] |
|
| supeq [Expr0.O.Bint] |
|
| supeq [Expr0.Apron] |
|
| supeq [Expr0.Bint] |
|
| supeq [ApronexprDD.Condition] |
|
| 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] |
Return the full support of the expression
|
| support [Expr0] |
Return the full support of the expression
|
| support [Apronexpr.Condition] |
|
| support [Apronexpr.Tree] |
|
| support [Apronexpr.Poly] |
|
| support [Apronexpr.Lin] |
|
| support [Apronexpr] |
|
| 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
|
| support_cond [ApronexprDD] |
|
| support_cond [Cond] |
|
| support_leaf [ApronexprDD] |
|
T |
| tdrestrict [Expr1.O.Apron] |
|
| 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.Apron] |
|
| tdrestrict [Expr1.Benum] |
|
| tdrestrict [Expr1.Bint] |
|
| tdrestrict [Expr1.Bool] |
|
| tdrestrict [Expr1] |
Simplify the expression knowing that the BDD is true.
|
| tdrestrict [Expr0.O.Apron] |
|
| tdrestrict [Expr0.O.Benum] |
|
| tdrestrict [Expr0.O.Bint] |
|
| tdrestrict [Expr0.O.Bool] |
|
| tdrestrict [Expr0.O] |
|
| tdrestrict [Expr0.Apron] |
|
| tdrestrict [Expr0.Benum] |
|
| tdrestrict [Expr0.Bint] |
|
| tdrestrict [Expr0.Bool] |
|
| tdrestrict [Expr0] |
Simplify the expression knowing that the BDD is true.
|
| texpr_cofactor [Descend] |
|
| texpr_cofactors [Descend] |
|
| texpr_support [Descend] |
|
| to_apron [Apronexpr.Condition] |
|
| to_apron [Apronexpr] |
|
| to_bdd [Domain1] |
Instanciate the type of a pair (bdd manager,bdd abstract value).
|
| to_bdd [Domain0] |
Instanciate the type of a pair (bdd manager,bdd abstract value).
|
| to_bddapron [Domain1] |
|
| to_bddapron [Domainlevel1.Level0] |
|
| to_bddapron [Domainlevel1.Level1] |
Extraction of properties
|
| to_bddapron [Domain0] |
|
| to_bddapron [Bdddomain0.O] |
|
| to_bddapron [Bdddomain0] |
Conversion to a disjunction of a conjunction of pair of a
purely Boolean formula (without numerical constraints) and an
APRON abstract value
|
| to_bddapron [Mtbdddomain0.O] |
|
| to_bddapron [Mtbdddomain0] |
Conversion to a disjunction of a conjunction of pair of a
purely Boolean formula (without numerical constraints) and an
APRON abstract value
|
| to_boolexpr2 [Syntax] |
|
| to_expr [Expr2.Bool] |
Conversion from/to general expression
|
| to_expr [Expr2.O.Bool] |
|
| to_expr [Expr1.O.Apron] |
|
| to_expr [Expr1.O.Benum] |
|
| to_expr [Expr1.O.Bint] |
|
| to_expr [Expr1.O.Bool] |
|
| to_expr [Expr1.Apron] |
Conversion from/to general expression
|
| 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.Apron] |
|
| to_expr [Expr0.O.Benum] |
|
| to_expr [Expr0.O.Bint] |
|
| to_expr [Expr0.O.Bool] |
|
| to_expr [Expr0.Apron] |
|
| to_expr [Expr0.Benum] |
|
| to_expr [Expr0.Bint] |
|
| to_expr [Expr0.Bool] |
|
| to_expr [ApronexprDD] |
|
| to_expr0 [Syntax] |
|
| to_expr0 [Expr2.Bool] |
|
| to_expr0 [Expr2.O.Bool] |
|
| to_expr0 [Expr2.O] |
|
| to_expr0 [Expr2] |
|
| to_expr0 [Expr1.Apron] |
Extract resp.
|
| 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 [Syntax] |
|
| to_expr1 [Expr2.Bool] |
Extract the underlying expression of level 0 and 1
|
| to_expr1 [Expr2.O.Bool] |
|
| to_expr1 [Expr2.O] |
|
| to_expr1 [Expr2] |
Extract the underlying expression of level 0 and 1
|
| to_level0 [Domain1] |
|
| to_level0 [Domainlevel1.Level1] |
|
| to_lexpr [Expr1.O.List] |
|
| to_lexpr [Expr1.List] |
Conversion from/to lists of general expression
|
| to_lexpr0 [Expr2.List] |
|
| to_lexpr0 [Expr2.O.List] |
|
| to_lexpr0 [Expr1.O.List] |
|
| to_lexpr0 [Expr1.List] |
Extract resp.
|
| to_lexpr1 [Expr2.List] |
Extract the underlying list of expressions of level 0 and 1
|
| to_lexpr1 [Expr2.O.List] |
|
| to_linexpr1 [Apronexpr.Lin] |
|
| to_listexpr1 [Syntax] |
|
| to_listexpr1 [Expr2.List] |
|
| to_listexpr1 [Expr2.O.List] |
|
| to_listexpr2 [Syntax] |
|
| to_mtbdd [Domain1] |
Instanciate the type of a pair (mtbdd manager,mtbdd abstract value).
|
| to_mtbdd [Domain0] |
Instanciate the type of a pair (mtbdd manager,mtbdd abstract value).
|
| to_tcons0 [Apronexpr.Condition] |
|
| to_tcons1 [Apronexpr.Condition] |
|
| to_texpr0 [Apronexpr] |
|
| to_texpr1 [Apronexpr] |
|
| top [Domain1] |
|
| top [Domainlevel1.Level0] |
|
| top [Domainlevel1.Level1] |
|
| top [Domain0] |
|
| top [Bdddomain0.O] |
|
| top [Bdddomain0] |
|
| top [Mtbdddomain0.O] |
|
| top [Mtbdddomain0] |
|
| top [ApronDD] |
|
| tree_of_lin [Apronexpr] |
|
| tree_of_poly [Apronexpr] |
|
| 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_expr [Apronexpr] |
|
| typ_of_var [Env] |
Return the type of the label/variable
|
| typdef_of_typ [Env] |
Return the definition of the type
|
U |
| unify [Domain1] |
|
| unify [Domainlevel1.Level1] |
Unify two abstract values on their least common
environment (lce, that should exist, which implies that no
variable is defined with different types in the two
initial environments).
|
| unmarshal [Env] |
Companion unmarshalling function
|
V |
| var [Expr1.O.Apron] |
|
| var [Expr1.O.Benum] |
|
| var [Expr1.O.Bint] |
|
| var [Expr1.O.Bool] |
|
| var [Expr1.O] |
Expression representing the litteral var
|
| var [Expr1.Apron] |
|
| var [Expr1.Benum] |
|
| var [Expr1.Bint] |
|
| var [Expr1.Bool] |
|
| var [Expr1] |
Expression representing the litteral var
|
| var [Expr0.O.Apron] |
|
| var [Expr0.O.Benum] |
|
| var [Expr0.O.Bint] |
|
| var [Expr0.O.Bool] |
|
| var [Expr0.O] |
Expression representing the litteral var
|
| var [Expr0.Apron] |
|
| var [Expr0.Benum] |
|
| var [Expr0.Bint] |
|
| var [Expr0.Bool] |
|
| var [Expr0] |
Expression representing the litteral var
|
| var [ApronexprDD] |
|
| var [Apronexpr.Poly] |
|
| var [Apronexpr.Lin] |
|
| var [Apronexpr] |
|
| var_of_aprondim [Env] |
|
| varmap [Expr0.O.Apron] |
|
| varmap [Expr0.O.Benum] |
|
| varmap [Expr0.O.Bint] |
|
| varmap [Expr0.O.Bool] |
|
| varmap [Expr0.O] |
|
| varmap [Expr0.Apron] |
|
| varmap [Expr0.Benum] |
|
| varmap [Expr0.Bint] |
|
| varmap [Expr0.Bool] |
|
| varmap [Expr0] |
Permutation (rather internal)
|
| vars [Env] |
Return the list of variables (not labels)
|
W |
| widening [Domain1] |
|
| widening [Domainlevel1.Level0] |
|
| widening [Domainlevel1.Level1] |
Widening
|
| widening [Domain0] |
|
| widening [Bdddomain0.O] |
|
| widening [Bdddomain0] |
Widening
|
| widening [Mtbdddomain0.O] |
|
| widening [Mtbdddomain0] |
Widening
|
| widening [ApronDD] |
|
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 [Apronexpr.Lin] |
|
| zero [Apronexpr] |
|