Index of values


_apply_exist [Cudd.Custom]
_apply_existand [Cudd.Custom]
_apply_existandop1 [Cudd.Custom]
_apply_existop1 [Cudd.Custom]
_background [Cudd.Vdd]
Be cautious, it is not type safe (if you use Cudd.Vdd.nodes_below_level, etc...: you can try to retrieve a constant value of some type and () value of the background value will be treated as another type.
_create [Cudd.Cache]
_create [Cudd.Hash]
_decompose [Apron.Disjunction]
Decompose an abstract value
_equal [Mpfr]
_equal [Mpf]
_export [Mpz]
_gcdext [Mpz]
_get_str [Mpz]
_get_str [Mpq]
_get_str [Mpfr]
_get_str [Mpf]
_import [Mpz]
_init_set_str [Mpz]
_init_set_str [Mpfr]
_init_set_str [Mpf]
_make [Cudd.Man]
Internal, do not use !
_mpfr [Mpfrf]
_mpfrf [Mpfrf]
Unsafe conversion from and to Mpfr.t.
_mpq [Mpqf]
_mpqf [Mpqf]
Unsafe conversion from and to Mpq.t.
_mpz [Mpzf]
_mpzf [Mpzf]
_powm [Mpz]
_powm_ui [Mpz]
_print [Cudd.Add]
C printing function.
_print [Cudd.Bdd]
Raw (C) printing function.
_set_str [Mpz]
_set_str [Mpq]
_set_str [Mpfr]
_set_str [Mpf]
_sqrtrem [Mpz]
_strtofr [Mpfr]

A
abs [Mpzf]
abs [Mpz]
abs [Mpqf]
abs [Mpq]
abs [Mpfrf]
abs [Mpfr]
abs [Mpf]
absorbant_one [Bddapron.ApronexprDD]
absorbant_zero [Bddapron.ApronexprDD]
abstract0 [Apron.Abstract1]
Return resp.
acos [Mpfr]
acosh [Mpfr]
add [Bddapron.Expr1.O.Apron]
add [Bddapron.Expr1.O.Bint]
add [Bddapron.Expr1.Apron]
add [Bddapron.Expr1.Bint]
add [Bddapron.Expr0.O.Apron]
add [Bddapron.Expr0.O.Bint]
add [Bddapron.Expr0.Apron]
add [Bddapron.Expr0.Bint]
add [Bddapron.ApronexprDD]
add [Bddapron.Apronexpr.Poly]
add [Bddapron.Apronexpr.Lin]
add [Bddapron.Apronexpr]
add [Bdd.Expr1.O.Bint]
add [Bdd.Expr1.Bint]
add [Bdd.Expr0.O.Bint]
add [Bdd.Expr0.Bint]
add [Bdd.Int]
add [Bdd.Reg]
Addition; returns the new registerm, the carry, and the overflow (for signed integers).
add [Union]
Add an element to the universe (initially belonging to its singleton)
add [Symbol]
Returns the symbol associated to the given string, after having possibly registered the string if it wasn't (in this case, the symbol is fresh symbol).
add [Sette.Compare]
add [Sette]
add x s returns a set containing all elements of s, plus x.
add [SetList.S]
add x s returns a set containing all elements of s, plus x.
add [SetList]
add x s returns a set containing all elements of s, plus x.
add [Rational]
add [PSette]
add x s returns a set containing all elements of s, plus x.
add [PMappe]
add [PHashhe]
add [PDMappe]
add [PDHashhe]
add [MultiSetList.S]
add x s returns a multiset containing all elements of s, plus x.
add [MultiSetList]
add x s returns a multiset containing all elements of s, plus x.
add [Mappe.Compare]
add [Mappe]
add x y m returns a map containing the same bindings as m, plus a binding of x to y.
add [Hashhe.Compare]
add [Hashhe]
add tbl x y adds a binding of x to y in table tbl.
add [Sette.S]
add x s returns a set containing all elements of s, plus x.
add [Mappe.S]
add [DMappe.S]
add [DMappe]
Add a new binding to the current map and return the new map.
add [Hashhe.S]
add [DHashhe.S]
add [DHashhe]
Add a new binding to the table.
add [Apron.Environment]
Adding to an environment a set of integer and real variables.
add [Cudd.Add]
add [Cudd.PWeakke]
add [Cudd.Weakke.Compare]
add [Cudd.Weakke.S]
add t x adds x to t.
add [Cudd.Weakke]
add [Mpzf]
add [Mpz]
add [Mpqf]
add [Mpq]
add [Mpfrf]
add [Mpfr]
add [Mpf]
add_dimensions [Bddapron.ApronDD]
add_dimensions [Apron.Abstract0]
add_dimensions_with [Apron.Abstract0]
add_edge [FGraph1.S]
add_edge [FGraph1]
add_edge [FGraph.S]
add_edge [FGraph]
add_epsilon [Oct]
Perturbation.
add_epsilon_bin [Oct]
Perturbation.
add_hedge [SHGraph.Compare]
add_hedge [SHGraph.S]
add_hedge [SHGraph]
Add an hyperedge.
add_hedge [PSHGraph]
add_int [Mpzf]
add_int [Mpfrf]
add_q [Mpfr]
add_ray_array [Apron.Abstract1]
Add the array of generators to the abstract value (time elapse operator).
add_ray_array [Apron.Abstract0]
Add the array of generators to the abstract value (time elapse operator).
add_ray_array_with [Apron.Abstract1]
add_ray_array_with [Apron.Abstract0]
add_typ [Bddapron.Env]
add_typ [Bdd.Env]
add_typ_with [Bddapron.Env]
Declaration of a new type
add_typ_with [Bdd.Env]
Declaration of a new type
add_ui [Mpz]
add_ui [Mpfr]
add_ui [Mpf]
add_var_with [Bdd.Env]
Addition without normalization (internal)
add_vars [Bddapron.Env]
add_vars [Bdd.Env]
add_vars_with [Bddapron.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)
add_vars_with [Bdd.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)
add_vertex [SHGraph.Compare]
add_vertex [SHGraph.S]
add_vertex [SHGraph]
Add a vertex
add_vertex [PSHGraph]
add_vertex [FGraph1.S]
add_vertex [FGraph1]
add_vertex [FGraph.S]
add_vertex [FGraph]
add_z [Mpfr]
addmap [PMappe]
addmap [Mappe.Compare]
addmap [Mappe]
addmap m1 m2 merges the two maps m1 and m2.
addmap [Mappe.S]
addmul [Mpz]
addmul_ui [Mpz]
agm [Mpfr]
agreement [Cudd.Add]
append [Bddapron.Bddleaf]
Calls the right append function depending on the options.
append [Ilist]
Append two lists
append_disjoint [Bddapron.Bddleaf]
Appends the two lists.
append_unique [Bddapron.Bddleaf]
Append the two lists.
apply_bbinop [Bddapron.Syntax]
apply_binop [Bddapron.Syntax]
apply_change [Bddapron.Domainlevel1.Level0]
apply_change [Bddapron.Domain0]
apply_change [Bddapron.Bdddomain0.O]
apply_change [Bddapron.Bdddomain0]
apply_change [Bddapron.Mtbdddomain0.O]
apply_change [Bddapron.Mtbdddomain0]
apply_change [Bdd.Domain0.O]
apply_dimchange2 [Bddapron.ApronDD]
apply_dimchange2 [Apron.Abstract0]
apply_dimchange2_with [Apron.Abstract0]
apply_exist [Cudd.Add]
apply_exist [Cudd.User]
apply_existand [Cudd.Add]
apply_existand [Cudd.User]
apply_existandop1 [Cudd.Add]
apply_existandop1 [Cudd.User]
apply_existop1 [Cudd.Add]
apply_existop1 [Cudd.User]
apply_op1 [Cudd.Add]
apply_op1 [Cudd.User]
apply_op1 [Cudd.Custom]
apply_op2 [Cudd.Add]
apply_op2 [Cudd.User]
apply_op2 [Cudd.Custom]
apply_op3 [Cudd.Add]
apply_op3 [Cudd.User]
Combine the two previous operations.
apply_op3 [Cudd.Custom]
apply_opG [Cudd.Add]
apply_opG [Cudd.User]
apply_opG [Cudd.Custom]
apply_opN [Cudd.Add]
apply_opN [Cudd.User]
apply_opN [Cudd.Custom]
apply_permutation [Bddapron.Domainlevel1.Level0]
apply_permutation [Bddapron.Domain0]
apply_permutation [Bddapron.Bdddomain0.O]
apply_permutation [Bddapron.Bdddomain0]
apply_permutation [Bddapron.Mtbdddomain0.O]
apply_permutation [Bddapron.Mtbdddomain0]
apply_test2 [Cudd.Add]
apply_test2 [Cudd.User]
apply_test2 [Cudd.Custom]
approxconjdecomp [Cudd.Bdd]
Cudd_bddApproxConjDecomp.
approxdisjdecomp [Cudd.Bdd]
Cudd_bddIterConjDecomp.
approximate [Apron.Abstract1]
approximate man abs alg perform some transformation on the abstract value, guided by the argument alg.
approximate [Apron.Abstract0]
approximate man abs alg perform some transformation on the abstract value, guided by the argument alg.
apron [Bddapron.Env]
return the APRON sub-environment
apron_policy_print [Bddapron.Policy]
aprondim_of_var [Bddapron.Env]
arity [Cudd.Cache]
Returns the arity of the local cache.
arity [Cudd.Hash]
Returns the arity of the hashtable
array [Print]
Print an array
array_extend_environment [Apron.Tcons1]
Change the environement of the array of constraints for a super-environement.
array_extend_environment [Apron.Generator1]
Change the environement of the array of generators for a super-environement.
array_extend_environment [Apron.Lincons1]
Change the environement of the array of constraints for a super-environement.
array_extend_environment_with [Apron.Tcons1]
Side-effect version of the previous function
array_extend_environment_with [Apron.Generator1]
Side-effect version of the previous function
array_extend_environment_with [Apron.Lincons1]
Side-effect version of the previous function
array_get [Apron.Tcons1]
Get the element of the given index (which is not a copy)
array_get [Apron.Generator1]
Get the element of the given index (which is not a copy)
array_get [Apron.Lincons1]
Get the element of the given index (which is not a copy)
array_get_env [Apron.Tcons1]
Get the environment of the array
array_get_env [Apron.Lincons1]
Get the environment of the array
array_length [Apron.Tcons1]
Get the size of the array
array_length [Apron.Generator1]
Get the size of the array
array_length [Apron.Lincons1]
Get the size of the array
array_make [Apron.Tcons1]
Make an array of tree expression constraints with the given size and defined on the given environement.
array_make [Apron.Generator1]
Make an array of generators with the given size and defined on the given environement.
array_make [Apron.Lincons1]
Make an array of linear constraints with the given size and defined on the given environement.
array_print [Apron.Tcons1]
Print an array of constraints
array_print [Apron.Generator1]
Print an array of generators
array_print [Apron.Lincons1]
Print an array of constraints
array_set [Apron.Tcons1]
Set the element of the given index (without any copy).
array_set [Apron.Generator1]
Set the element of the given index (without any copy).
array_set [Apron.Lincons1]
Set the element of the given index (without any copy).
asin [Mpfr]
asinh [Mpfr]
assign_lexpr [Bddapron.Domain1]
assign_lexpr [Bddapron.Domainlevel1.Level0]
assign_lexpr [Bddapron.Domainlevel1.Level1]
assign_lexpr [Bddapron.Domain0]
assign_lexpr [Bddapron.Bdddomain0.O]
assign_lexpr [Bddapron.Bdddomain0]
assign_lexpr [Bddapron.Mtbdddomain0.O]
assign_lexpr [Bddapron.Mtbdddomain0]
assign_lexpr [Bdd.Domain1.O]
assign_lexpr [Bdd.Domain1]
assign_lexpr [Bdd.Domain0.O]
Assignement
assign_lexpr [Bdd.Domain0]
Assignement
assign_linexpr [Apron.Abstract1]
assign_linexpr [Apron.Abstract0]
assign_linexpr_array [Apron.Abstract1]
Parallel assignement of an array of dimensions by an array of same size of linear expressions
assign_linexpr_array [Apron.Abstract0]
Parallel assignement of an array of dimensions by an array of same size of linear expressions
assign_linexpr_array_with [Apron.Abstract1]
assign_linexpr_array_with [Apron.Abstract0]
assign_linexpr_with [Apron.Abstract1]
assign_linexpr_with [Apron.Abstract0]
assign_listexpr [Bdd.Domain1.O]
Assignement
assign_listexpr [Bdd.Domain1]
Assignement
assign_listexpr2 [Bddapron.Domain1]
assign_listexpr2 [Bddapron.Domainlevel1.Level1]
assign_texpr [Apron.Abstract1]
assign_texpr [Apron.Abstract0]
assign_texpr_array [Bddapron.ApronDD]
assign_texpr_array [Apron.Abstract1]
Parallel assignement of an array of dimensions by an array of same size of tree expressions
assign_texpr_array [Apron.Abstract0]
Parallel assignement of an array of dimensions by an array of same size of tree expressions
assign_texpr_array_with [Apron.Abstract1]
assign_texpr_array_with [Apron.Abstract0]
assign_texpr_with [Apron.Abstract1]
assign_texpr_with [Apron.Abstract0]
asssub_texpr_array [Bddapron.ApronDD]
atan [Mpfr]
atan2 [Mpfr]
atanh [Mpfr]
atome [Ilist]
Create a list element from a single element.
attredge [FGraph1.S]
attredge [FGraph1]
attredge [FGraph.S]
attredge [FGraph]
attrhedge [SHGraph.Compare]
attrhedge [SHGraph.S]
attrhedge [SHGraph]
attrhedge graph hedge returns the information associated to the hyperedge hedge
attrhedge [PSHGraph]
attrvertex [SHGraph.Compare]
attrvertex [SHGraph.S]
attrvertex [SHGraph]
attrvertex graph vertex returns the information associated to the vertex vertex
attrvertex [PSHGraph]
attrvertex [FGraph1.S]
attrvertex [FGraph1]
attrvertex [FGraph.S]
attrvertex [FGraph]
autodyn_status [Cudd.Man]

B
background [Cudd.Add]
Cuddaux_addIte/Cudd_addIte.
bdd_of_bdddomain [Bddapron.Domain1]
Make a bdd manager from an underlying BDDAPRON manager
bdd_of_bdddomain [Bddapron.Domain0]
Make a bdd manager from an underlying BDDAPRON manager
bdd_of_tcons0 [Bddapron.Common]
bdd_of_tcons0_array [Bddapron.Common]
bdd_of_vdd [Bdd.Decompose]
bdd_support_cond [Bdd.Decompose]
bddsupport [Bdd.Expr0.O]
biasedoverapprox [Cudd.Bdd]
biasedunderapprox [Cudd.Bdd]
bin_ui [Mpz]
bin_uiui [Mpz]
bindings [PMappe]
bindings [Mappe]
Return the list of all bindings of the given map.
bindings [Mappe.S]
binop [Apron.Texpr1]
binop [Apron.Texpr0]
bool_of_tbool [Bdd.Expr0.O.Expr]
booleandiff [Cudd.Bdd]
boolexpr2_of_string [Bddapron.Parser]
bottom [Bddapron.Domain1]
bottom [Bddapron.Domainlevel1.Level0]
bottom [Bddapron.Domainlevel1.Level1]
Basic constructor
bottom [Bddapron.Domain0]
bottom [Bddapron.Bdddomain0.O]
bottom [Bddapron.Bdddomain0]
bottom [Bddapron.Mtbdddomain0.O]
bottom [Bddapron.Mtbdddomain0]
bottom [Bddapron.ApronDD]
bottom [Bdd.Domain1.O]
bottom [Bdd.Domain1]
bottom [Bdd.Domain0.O]
bottom [Bdd.Domain0]
bottom [Apron.Abstract1]
Create a bottom (empty) value defined on the given environment
bottom [Apron.Abstract0]
Create a bottom (empty) value with the given number of integer and real variables
bottom [Apron.Interval]
Top and bottom intervals (using DOUBLE coefficients)
bound_dimension [Apron.Abstract0]
Return the interval of variation of the dimension in the abstract value.
bound_linexpr [Apron.Abstract1]
Return the interval of variation of the linear expression in the abstract value.
bound_linexpr [Apron.Abstract0]
Return the interval of variation of the linear expression in the abstract value.
bound_texpr [Apron.Abstract1]
Return the interval of variation of the tree expression in the abstract value.
bound_texpr [Apron.Abstract0]
Return the interval of variation of the tree expression in the abstract value.
bound_variable [Apron.Abstract1]
Return the interval of variation of the variable in the abstract value.

C
canonicalize [Bddapron.Domain1]
canonicalize [Bddapron.Bdddomain1]
Canonicalize an abstract value by ensuring uniqueness and disjointness properties.
canonicalize [Bddapron.Domain0]
canonicalize [Bddapron.Bdddomain0.O]
canonicalize [Bddapron.Bdddomain0]
Canonicalize an abstract value by ensuring uniqueness and disjointness properties.
canonicalize [Apron.Abstract1]
Put the abstract value in canonical form.
canonicalize [Apron.Abstract0]
Put the abstract value in canonical form.
canonicalize [Mpq]
cardinal [Sette]
Return the number of elements of a set.
cardinal [SetList.S]
Return the number of elements of a set.
cardinal [SetList]
Return the number of elements of a set.
cardinal [PSette]
Return the number of elements of a set.
cardinal [PMappe]
cardinal [PDMappe]
cardinal [PDHashhe]
cardinal [MultiSetList.S]
Return the number of elements of a multiset.
cardinal [MultiSetList]
Return the number of elements of a multiset.
cardinal [Mappe]
Number of keys of a map
cardinal [Sette.S]
Return the number of elements of a set.
cardinal [Mappe.S]
cardinal [DMappe.S]
cardinal [DMappe]
Return the number of bindings.
cardinal [DHashhe.S]
cardinal [DHashhe]
Return the number of bindings.
cast [Bddapron.Expr1.O.Apron]
cast [Bddapron.Expr1.Apron]
cast [Bddapron.Expr0.O.Apron]
cast [Bddapron.Expr0.Apron]
cast [Bddapron.ApronexprDD]
cast [Bddapron.Apronexpr]
cdiv_q [Mpzf]
cdiv_q [Mpz]
The first parameter holds the quotient.
cdiv_q_2exp [Mpz]
The first parameter holds the quotient.
cdiv_q_ui [Mpz]
The first parameter holds the quotient.
cdiv_qr [Mpzf]
cdiv_qr [Mpz]
The two first parameters hold resp.
cdiv_qr_ui [Mpz]
The two first parameters hold resp.
cdiv_r [Mpzf]
cdiv_r [Mpz]
The first parameter holds the remainder.
cdiv_r_2exp [Mpz]
The first parameter holds the remainder.
cdiv_r_ui [Mpz]
The first parameter holds the remainder.
cdiv_ui [Mpz]
ceil [Mpfr]
ceil [Mpf]
cfc [SHGraph.Compare]
cfc [SHGraph.S]
cfc [SHGraph]
Decomposition of the graph into Strongly Connected Components,
cfc [PSHGraph]
cfc [FGraph1.S]
cfc [FGraph1]
cfc [FGraph.S]
cfc [FGraph]
cfc_multi [SHGraph.Compare]
cfc_multi [SHGraph.S]
cfc_multi [SHGraph]
idem, but from several initial vertices.
cfc_multi [PSHGraph]
cfc_multi [FGraph1.S]
cfc_multi [FGraph1]
cfc_multi [FGraph.S]
cfc_multi [FGraph]
change_add_invert [Apron.Dim]
Assuming a transformation for add_dimensions, invert it in-place to obtain the inverse transformation using remove_dimensions
change_environment [Bddapron.Domain1]
change_environment [Bddapron.Domainlevel1.Level1]
Change of environments and renaming
change_environment [Bdd.Domain1.O]
change_environment [Bdd.Domain1]
change_environment [Apron.Abstract1]
Change the environement of the abstract values.
change_environment_with [Apron.Abstract1]
check_disjointness [Bddapron.Bddleaf]
Checking function: raises Failure if problem, returns true otherwise.
check_keys [Cudd.Man]
check_lvalue [Bddapron.Env]
check_lvalue [Bdd.Domain1.O]
check_lvalue [Bdd.Env]
check_lvar [Bddapron.Env]
check_lvar [Bdd.Env]
check_lvarvalue [Bddapron.Env]
check_lvarvalue [Bdd.Env]
check_normalized [Bdd.Cond]
check_normalized [Bdd.Env]
Prints error message and returns false if not normalized
check_ovalue [Bddapron.Env]
check_ovalue [Bdd.Env]
check_range [Mpfr]
check_typ2 [Bddapron.Expr0.O]
check_unicity [Bddapron.Bddleaf]
Checking function: raises Failure if problem, returns true otherwise.
check_value [Bddapron.Env]
check_value [Bdd.Domain1.O]
check_value [Bdd.Env]
check_value2 [Bddapron.Env]
check_value2 [Bdd.Env]
check_value3 [Bddapron.Env]
check_value3 [Bdd.Env]
check_var [Bddapron.Env]
check_var [Bdd.Env]
check_wellformed [Bddapron.Bdddomain0.O]
choose [Sette]
Return one element of the given set, or raise Not_found if the set is empty.
choose [SetList.S]
Return one element of the given set, or raise Not_found if the set is empty.
choose [SetList]
Return one element of the given set, or raise Not_found if the set is empty.
choose [PSette]
Return one element of the given set, or raise Not_found if the set is empty.
choose [PMappe]
choose [MultiSetList.S]
Return one element of the given multiset, or raise Not_found if the multiset is empty.
choose [MultiSetList]
Return one element of the given multiset, or raise Not_found if the multiset is empty.
choose [Mappe]
Returns a binding, or raise Not_found if empty
choose [Sette.S]
Return one element of the given set, or raise Not_found if the set is empty.
choose [Mappe.S]
clear [Bdd.Cond]
Clear all the conditions (results in a normalized environments)
clear [SHGraph.S]
clear [SHGraph]
Remove all vertices and hyperedges of the graph.
clear [PSHGraph]
clear [PHashhe]
clear [PDHashhe]
clear [Hashhe]
Empty a hash table.
clear [Hashhe.S]
clear [DHashhe.S]
clear [DHashhe]
Clear a table
clear [Cudd.PWeakke]
clear [Cudd.Weakke.S]
Remove all elements from the table.
clear [Cudd.Weakke]
clear [Cudd.Memo]
clear [Cudd.Cache]
Clears the content of the local cache.
clear [Cudd.Hash]
Clears the content of the hashtable
clear_all [Cudd.Hash]
Clears the content of all created hashtables
clear_common [Cudd.User]
clear_exist [Cudd.Add]
clear_exist [Cudd.User]
clear_existand [Cudd.Add]
clear_existand [Cudd.User]
clear_existandop1 [Cudd.Add]
clear_existandop1 [Cudd.User]
clear_existop1 [Cudd.Add]
clear_existop1 [Cudd.User]
clear_flags [Mpfr]
clear_inexflag [Mpfr]
clear_nanflag [Mpfr]
clear_op1 [Cudd.Add]
clear_op1 [Cudd.User]
clear_op2 [Cudd.Add]
clear_op2 [Cudd.User]
clear_op3 [Cudd.Add]
clear_op3 [Cudd.User]
clear_opG [Cudd.Add]
clear_opG [Cudd.User]
clear_opN [Cudd.Add]
clear_opN [Cudd.User]
clear_overflow [Mpfr]
clear_test2 [Cudd.Add]
clear_test2 [Cudd.User]
clear_underflow [Mpfr]
clippingand [Cudd.Bdd]
clippingexistand [Cudd.Bdd]
closure [Apron.Abstract1]
Closure: transform strict constraints into non-strict ones.
closure [Apron.Abstract0]
Closure: transform strict constraints into non-strict ones.
closure_with [Apron.Abstract1]
Side-effect version
closure_with [Apron.Abstract0]
Side-effect version
clrbit [Mpz]
cmp [Apron.Coeff]
Non Total Comparison: If the 2 coefficients are both scalars, corresp. to Scalar.cmp, If the 2 coefficients are both intervals, corresp. to Interval.cmp, otherwise, -3 if the first is a scalar, 3 otherwise
cmp [Apron.Interval]
Non Total Comparison: 0: equality -1: i1 included in i2 +1: i2 included in i1 -2: i1.inf less than or equal to i2.inf +2: i1.inf greater than i2.inf
cmp [Apron.Scalar]
Compare two coefficients, possibly converting to Mpqf.t.
cmp [Mpzf]
cmp [Mpz]
cmp [Mpqf]
cmp [Mpq]
cmp [Mpfrf]
cmp [Mpfr]
cmp [Mpf]
cmp_d [Mpz]
cmp_d [Mpf]
cmp_frac [Mpqf]
cmp_int [Apron.Scalar]
Compare a coefficient with an integer
cmp_int [Mpzf]
cmp_int [Mpqf]
cmp_int [Mpfrf]
cmp_si [Mpz]
cmp_si [Mpq]
cmp_si [Mpfr]
cmp_si [Mpf]
cmp_si_2exp [Mpfr]
cmpabs [Mpz]
cmpabs_d [Mpz]
cmpabs_ui [Mpz]
cnf_false [Bdd.Normalform]
cnf_true [Bdd.Normalform]
code_of_label [Bdd.Enum]
Return the code associated to the label
cofactor [Bddapron.Expr1.O.Apron]
cofactor [Bddapron.Expr1.O.Benum]
cofactor [Bddapron.Expr1.O.Bint]
cofactor [Bddapron.Expr1.O.Bool]
cofactor [Bddapron.Expr1.O]
Evaluate the expression.
cofactor [Bddapron.Expr1.Apron]
cofactor [Bddapron.Expr1.Benum]
cofactor [Bddapron.Expr1.Bint]
cofactor [Bddapron.Expr1.Bool]
cofactor [Bddapron.Expr1]
Evaluate the expression.
cofactor [Bddapron.Expr0.O.Apron]
cofactor [Bddapron.Expr0.O.Benum]
cofactor [Bddapron.Expr0.O.Bint]
cofactor [Bddapron.Expr0.O.Bool]
cofactor [Bddapron.Expr0.O]
cofactor [Bddapron.Expr0.Apron]
cofactor [Bddapron.Expr0.Benum]
cofactor [Bddapron.Expr0.Bint]
cofactor [Bddapron.Expr0.Bool]
cofactor [Bddapron.Expr0]
Evaluate the expression.
cofactor [Bdd.Expr1.O.Benum]
cofactor [Bdd.Expr1.O.Bint]
cofactor [Bdd.Expr1.O.Bool]
cofactor [Bdd.Expr1.O]
Evaluate the expression.
cofactor [Bdd.Expr1.Benum]
cofactor [Bdd.Expr1.Bint]
cofactor [Bdd.Expr1.Bool]
cofactor [Bdd.Expr1]
Evaluate the expression.
cofactor [Bdd.Expr0.O.Benum]
cofactor [Bdd.Expr0.O.Bint]
cofactor [Bdd.Expr0.O.Bool]
cofactor [Bdd.Expr0.Benum]
cofactor [Bdd.Expr0.Bint]
cofactor [Bdd.Expr0.Bool]
cofactor [Bdd.Expr0]
Evaluate the expression.
cofactor [Bdd.Enum]
cofactor [Bdd.Int]
Evaluation
cofactor [Bdd.Reg]
cofactor [Cudd.Add]
cofactor [Cudd.Mtbddc]
cofactor mtbdd cube evaluates mtbbdd on the cube cube
cofactor [Cudd.Mtbdd]
cofactor mtbdd cube evaluates mtbbdd on the cube cube
cofactor [Cudd.Vdd]
cofactor [Cudd.Bdd]
cofactors [Bddapron.Descend]
cofactors [Cudd.Add]
Returns the positive and negative cofactor of the ADD wrt the variable
cofactors [Cudd.Mtbddc]
Returns the positive and negative cofactor of the MTBDD wrt the variable
cofactors [Cudd.Mtbdd]
Returns the positive and negative cofactor of the MTBDD wrt the variable
cofactors [Cudd.Vdd]
cofactors [Cudd.Bdd]
Returns the positive and negative cofactor of the BDD wrt the variable
com [Mpz]
combine [PMappe]
combine [Mappe.Compare]
combine [Mappe]
combine [Mappe.S]
combineexpansive [Cudd.Mapleaf]
combineexpansive ~default ~merge (guard,leaf) vdd = merge (Vdd.ite guard leaf default) vdd.
combineleaf1 [Cudd.Mapleaf]
Generic function, instanciated above.
combineleaf1_array [Cudd.Mapleaf]
combineleaf2 [Cudd.Mapleaf]
Generic function, instanciated above.
combineleaf2_array [Cudd.Mapleaf]
Functions similar to combineleaf_array, but in which the first (resp.
combineleaf_array [Cudd.Mapleaf]
Generic function,.
combineretractive [Cudd.Mapleaf]
combinetractive (guard,leaf) vdd = Vdd.ite guard leaf vdd.
common [PMappe]
common [PDMappe]
common [Mappe.Compare]
common [Mappe]
common commondata a b returns a map the keys of which must be keys in both a and in b, and those keys are bound to interdata d1 d2.
common [Mappe.S]
common [DMappe.S]
common [DMappe]
Return the common bindings.
commoni [PMappe]
commoni [Mappe.Compare]
commoni [Mappe]
Same as common, but the function receives as arguments the key (of the first map)
commoni [Mappe.S]
compare [Bddapron.Apronexpr.Condition]
compare [Bddapron.Apronexpr.Tree]
compare [Bddapron.Apronexpr.Poly]
compare [Bddapron.Apronexpr.Lin]
compare [Bddapron.Apronexpr]
compare [Symbol]
Comparison (do not correspond at all to alphabetic order, depend on the registration order of names in the module)
compare [Sette.Compare]
compare [Sette]
Total ordering between sets.
compare [SetList.S]
Total ordering between sets.
compare [SetList]
Total ordering between sets.
compare [PSette]
Total ordering between sets.
compare [PMappe]
compare [MultiSetList.S]
Total ordering between multisets.
compare [MultiSetList]
Total ordering between multisets.
compare [Mappe.Compare]
compare [Mappe]
compare [Sette.S]
Total ordering between sets.
compare [Mappe.S]
compare [Apron.Environment]
Compare two environment.
compare [Apron.Var]
Comparison function
compare [Apron.Linexpr0]
Comparison with lexicographic ordering using Coeff.cmp, terminating by constant
compare_cond [Bddapron.Cond]
compare_idb [Bdd.Env]
Comparison
compare_lterm [Bddapron.Apronexpr.Lin]
compare_monomial [Bddapron.Apronexpr.Poly]
compare_varexp [Bddapron.Apronexpr.Poly]
comparei [PMappe]
comparei [Mappe.Compare]
comparei [Mappe]
Comparison function between maps, total if the comparison function for data is total
comparei [Mappe.S]
compose [Bdd.Expr0.O]
compose [PolkaGrid]
Compose an abstract value
compose [Apron.Disjunction]
compose [Cudd.Add]
Cuddaux_addCompose/Cudd_addCompose.
compose [Cudd.Mtbddc]
compose [Cudd.Mtbdd]
compose [Cudd.Vdd]
compose [Cudd.Bdd]
compose_list [Bdd.Expr0.O]
compose_of_lvarexpr [Bddapron.Expr0.O]
compose_opermutation [Bdd.Env]
compose_permutation [Bdd.Env]
composition_of_lvarexpr [Bdd.Expr0.O]
composition_of_lvarlexpr [Bdd.Expr0.O]
compute_careset [Bdd.Cond]
compute_change [Bddapron.Env]
compute_change [Bdd.Env]
cond_of_idb [Bdd.Cond]
condition [Bddapron.Expr1.O.Apron]
condition [Bddapron.Expr1.Apron]
condition_of_tcons0 [Bddapron.Common]
congruent_2exp_p [Mpz]
congruent_p [Mpz]
congruent_ui_p [Mpz]
conjunction_and [Bdd.Normalform]
Default merge is List.rev_append
conjunction_and_term [Bdd.Normalform]
"Merge" is list cons
conjunction_false [Bdd.Normalform]
conjunction_of_minterm [Bdd.Expr0.O.Expr]
conjunction_of_minterm [Bdd.Decompose]
conjunction_of_minterm of_idb minterm translates a minterm into an explicit conjunction of type 'a Normalform.conjunction, using the function of_idb to produce elements of type 'a.
conjunction_true [Bdd.Normalform]
cons [Bddapron.Bddleaf]
Calls the right cons function depending on the options.
cons [Ilist]
Adding a new list element at the begining of the list
cons_disjoint [Bddapron.Bddleaf]
Performs the join of a list with an element.
cons_unique [Bddapron.Bddleaf]
Performs the join of a list with an element.
const_catalan [Mpfr]
const_euler [Mpfr]
const_log2 [Mpfr]
const_pi [Mpfr]
constrain [Cudd.Add]
constrain [Cudd.Mtbddc]
constrain [Cudd.Mtbdd]
constrain [Cudd.Vdd]
constrain [Cudd.Bdd]
copy [Bddapron.Cond]
copy [Bddapron.Env]
Copy
copy [Bdd.Cond]
copy [Bdd.Env]
Copy
copy [SHGraph.S]
copy [SHGraph]
Copy an hypergraph, using the given functions to duplicate the attributes associated to the elements of the graph.
copy [PSHGraph]
copy [PHashhe]
copy [Hashhe]
Return a copy of the given hashtable.
copy [Hashhe.S]
copy [Apron.Policy]
copy [Apron.Abstract1]
Copy a value
copy [Apron.Tcons1]
Copy (deep copy)
copy [Apron.Texpr1]
Copy
copy [Apron.Generator1]
Copy (deep copy)
copy [Apron.Lincons1]
Copy (deep copy)
copy [Apron.Linexpr1]
Copy
copy [Apron.Abstract0]
Copy a value
copy [Apron.Tcons0]
Copy a tree expression constraint (deep copy)
copy [Apron.Texpr0]
Copy
copy [Apron.Generator0]
Copy a generator (deep copy)
copy [Apron.Lincons0]
Copy a linear constraint (deep copy)
copy [Apron.Linexpr0]
Copy
copy_shr [Cudd.Man]
Internal use: duplicate a block to the major heap.
coreachable [FGraph.S]
coreachable [FGraph]
coreachable_multi [FGraph.S]
coreachable_multi [FGraph]
correlation [Cudd.Bdd]
correlationweights [Cudd.Bdd]
cos [Mpfr]
cosh [Mpfr]
cot [Mpfr]
coth [Mpfr]
count [Cudd.PWeakke]
count [Cudd.Weakke.S]
Count the number of elements in the table.
count [Cudd.Weakke]
create [Union]
Create a new universe set
create [SHGraph.S]
create [SHGraph]
create n data creates an hypergraph, using n for the initial size of internal hashtables, and data for the user information
create [PSHGraph]
create [PHashhe]
create [PDHashhe]
create [Hashhe]
create n creates a new, empty hash table, with initial size n.
create [Hashhe.S]
create [DHashhe.S]
create [DHashhe]
Create a new table, with the specified initial size
create [Cudd.PWeakke]
create [Cudd.Weakke.S]
create n creates a new empty weak hash table, of initial size n.
create [Cudd.Weakke]
create [Cudd.Cache]
create [Cudd.Hash]
create ~size:n arity create a hashtable of arity arity, of the optional size n
create1 [Cudd.Cache]
create2 [Cudd.Cache]
create3 [Cudd.Cache]
Creates local caches of the given arity, with initial size size and maximal size maxsize.
create_compare [PSHGraph]
create_compare [PHashhe]
create_compare [PDHashhe]
csc [Mpfr]
csch [Mpfr]
cst [Bddapron.Expr1.O.Apron]
cst [Bddapron.Expr1.Apron]
cst [Bddapron.Expr0.O.Apron]
cst [Bddapron.Expr0.Apron]
cst [Bddapron.ApronDD]
cst [Bddapron.ApronexprDD]
cst [Bddapron.Apronexpr.Poly]
cst [Bddapron.Apronexpr.Lin]
cst [Bddapron.Apronexpr]
cst [Apron.Texpr1]
cst [Apron.Texpr0]
cst [Cudd.Add]
cst [Cudd.Mtbddc]
cst [Cudd.Mtbdd]
cst [Cudd.Vdd]
cst_to_expr0 [Bddapron.Syntax]
cst_u [Cudd.Mtbddc]
cst_u [Cudd.Mtbdd]
cube_of_bdd [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 [Bdd.Expr0]
Same as Cudd.Bdd.cube_of_bdd, but keep only the the values of variables having a determinated value.
cube_of_bdd [Cudd.Bdd]
cube_of_minterm [Cudd.Bdd]
cube_split [Bdd.Decompose]
Split a cube into a cube of Booleans and a cube of conditions
cube_union [Cudd.Bdd]
Cuddaux_bddCubeUnion.

D
dand [Bddapron.Expr1.O.Bool]
dand [Bddapron.Expr1.Bool]
dand [Bddapron.Expr0.O.Bool]
dand [Bddapron.Expr0.Bool]
dand [Bdd.Expr1.O.Bool]
dand [Bdd.Expr1.Bool]
dand [Bdd.Expr0.O.Bool]
dand [Bdd.Expr0.Bool]
dand [Cudd.Bdd]
debugcheck [Cudd.Man]
decompose [PolkaGrid]
Decompose an abstract value
decompose [Apron.Disjunction]
decompose_bdd_boolcond [Bdd.Decompose]
Decompose a BDD f into a disjunction [(f1,g1);...;(fN,gN)] such that all decisions in f1...fN are Boolean variables;, all decisions in g1...gN are (non-Boolean) conditions;, f1...fN are pairwise disjoint.
decompose_bdd_condbool [Bdd.Decompose]
Dual version
decompose_bdd_treecondbool [Bdd.Decompose]
decompose_dd_treecondbool [Bdd.Decompose]
Internal use, look at the code.
decompose_tbdd_tvdd_treecondbool [Bdd.Decompose]
Same for an array of BDDs/VDDs
decompose_vdd_treecondbool [Bdd.Decompose]
Decompose a BDD/MTBDD into a tree with decisions on conditions, and purely Boolean BDDs on leaves
delse [Cudd.Add]
delse [Cudd.Mtbddc]
Returns the negative subnode of the MTBDD
delse [Cudd.Mtbdd]
Returns the negative subnode of the MTBDD
delse [Cudd.Vdd]
delse [Cudd.Bdd]
density [Cudd.Add]
density [Cudd.Mtbddc]
density [Cudd.Mtbdd]
density [Cudd.Vdd]
density [Cudd.Bdd]
depth [Ilist]
Return the (maximal) depth of the list.
descend [Bddapron.Descend]
Obsolete, moved in Bdd.Decompose
descend [Bdd.Decompose]
descend_mtbdd [Bddapron.Descend]
dfalse [Bddapron.Expr1.O.Bool]
dfalse [Bddapron.Expr1.Bool]
dfalse [Bddapron.Expr0.O.Bool]
dfalse [Bddapron.Expr0.Bool]
dfalse [Bdd.Expr1.O.Bool]
dfalse [Bdd.Expr1.Bool]
dfalse [Bdd.Expr0.O.Bool]
dfalse [Bdd.Expr0.Bool]
dfalse [Cudd.Bdd]
Returns the false BDD
diff [Sette.Compare]
diff [Sette]
Union, intersection and set difference.
diff [SetList.S]
Union, intersection and set difference.
diff [SetList]
Union, intersection and set difference.
diff [PSette]
Union, intersection and set difference.
diff [MultiSetList.S]
Union, intersection and multiset difference.
diff [MultiSetList]
Union, intersection and multiset difference.
diff [Sette.S]
Set difference.
diff [Cudd.Add]
diff_set [MultiSetList.S]
Union, intersection and multiset difference with a set.
diff_set [MultiSetList]
Union, intersection and multiset difference with a set.
diffset [PMappe]
diffset [Mappe.Compare]
diffset [Mappe]
interset map set removes the bindings of a whose key belongs to set.
diffset [Mappe.S]
diffsetx [PDMappe]
diffsetx [DMappe.S]
diffsetx [DMappe]
Remove the two-way bindings x <->y with x in the set
diffsety [PDMappe]
diffsety [DMappe.S]
diffsety [DMappe]
Remove the two-way bindings x <->y with y in the set
dim [Apron.Texpr0]
dim_of_var [Apron.Environment]
Return the dimension associated to the given variable in the environment.
dimchange [Apron.Environment]
dimchange e1 e2 computes the transformation for converting from an environment e1 to a superenvironment e2.
dimchange2 [Apron.Environment]
dimchange2 e1 e2 computes the transformation for converting from an environment e1 to a (compatible) environment e2, by first adding (some) variables of e2 and then removing (some) variables of e1.
dimension [Apron.Policy]
dimension [Apron.Environment]
Return the dimension of the environment
dimension [Apron.Abstract0]
disable_autodyn [Cudd.Man]
disjunction_false [Bdd.Normalform]
disjunction_or [Bdd.Normalform]
Default merge is List.rev_append
disjunction_or_term [Bdd.Normalform]
"Merge" is list cons
disjunction_true [Bdd.Normalform]
div [Bddapron.Expr1.O.Apron]
div [Bddapron.Expr1.Apron]
div [Bddapron.Expr0.O.Apron]
div [Bddapron.Expr0.Apron]
div [Bddapron.ApronexprDD]
div [Bddapron.Apronexpr.Poly]
div [Bddapron.Apronexpr]
div [Rational]
div [Cudd.Add]
div [Mpqf]
div [Mpq]
div [Mpfrf]
div [Mpfr]
div [Mpf]
div_2exp [Mpq]
div_2exp [Mpfr]
div_2exp [Mpf]
div_2si [Mpfr]
div_2ui [Mpfr]
div_q [Mpfr]
div_ui [Mpfrf]
div_ui [Mpfr]
div_ui [Mpf]
div_z [Mpfr]
divexact [Mpzf]
divexact [Mpz]
divexact_ui [Mpz]
divisible_2exp_p [Mpz]
divisible_p [Mpz]
divisible_ui_p [Mpz]
dnf_false [Bdd.Normalform]
dnf_of_bdd [Bdd.Expr0.O.Expr]
dnf_of_bdd [Bdd.Decompose]
Converts a BDD into a disjunctive normal form.
dnf_true [Bdd.Normalform]
dnot [Bddapron.Expr1.O.Bool]
dnot [Bddapron.Expr1.Bool]
dnot [Bddapron.Expr0.O.Bool]
dnot [Bddapron.Expr0.Bool]
dnot [Bdd.Expr1.O.Bool]
dnot [Bdd.Expr1.Bool]
dnot [Bdd.Expr0.O.Bool]
dnot [Bdd.Expr0.Bool]
dnot [Cudd.Bdd]
dor [Bddapron.Expr1.O.Bool]
not, and and or (use of 'd' prefix because of conflict with OCaml keywords)
dor [Bddapron.Expr1.Bool]
not, and and or (use of 'd' prefix because of conflict with OCaml keywords)
dor [Bddapron.Expr0.O.Bool]
dor [Bddapron.Expr0.Bool]
dor [Bdd.Expr1.O.Bool]
not, and and or (use of 'd' prefix because of conflict with OCaml keywords)
dor [Bdd.Expr1.Bool]
not, and and or (use of 'd' prefix because of conflict with OCaml keywords)
dor [Bdd.Expr0.O.Bool]
not, and and or (use of 'd' prefix because of conflict with OCaml keywords)
dor [Bdd.Expr0.Bool]
not, and and or (use of 'd' prefix because of conflict with OCaml keywords)
dor [Cudd.Bdd]
dthen [Cudd.Add]
dthen [Cudd.Mtbddc]
Returns the positive subnode of the MTBDD
dthen [Cudd.Mtbdd]
Returns the positive subnode of the MTBDD
dthen [Cudd.Vdd]
dthen [Cudd.Bdd]
dtrue [Bddapron.Expr1.O.Bool]
dtrue [Bddapron.Expr1.Bool]
dtrue [Bddapron.Expr0.O.Bool]
dtrue [Bddapron.Expr0.Bool]
dtrue [Bdd.Expr1.O.Bool]
dtrue [Bdd.Expr1.Bool]
dtrue [Bdd.Expr0.O.Bool]
dtrue [Bdd.Expr0.Bool]
dtrue [Cudd.Bdd]
Returns the true BDD
dval [Cudd.Add]
dval [Cudd.Mtbddc]
Returns the value of the assumed constant MTBDD
dval [Cudd.Mtbdd]
Returns the value of the assumed constant MTBDD
dval [Cudd.Vdd]
dval_u [Cudd.Mtbddc]
dval_u [Cudd.Mtbdd]

E
edges [FGraph1.S]
edges [FGraph1]
edges [FGraph.S]
edges [FGraph]
eint [Mpfr]
elements [Sette]
Return the list of all elements of the given set.
elements [SetList.S]
Return the list of all elements of the given set.
elements [SetList]
Return the list of all elements of the given set.
elements [PSette]
Return the list of all elements of the given set.
elements [MultiSetList.S]
Return the list of all elements of the given multiset.
elements [MultiSetList]
Return the list of all elements of the given multiset.
elements [Sette.S]
Return the list of all elements of the given set.
empty [Sette]
The empty set.
empty [SetList.S]
The empty set.
empty [SetList]
The empty set.
empty [PSette]
The empty set.
empty [PMappe]
empty [PDMappe]
empty [MultiSetList.S]
The empty multiset.
empty [MultiSetList]
The empty multiset.
empty [Mappe]
The empty map.
empty [FGraph1.S]
empty [FGraph1]
empty [FGraph.S]
empty [FGraph]
empty [Sette.S]
The empty set.
empty [Mappe.S]
empty [DMappe.S]
empty [DMappe]
Empty map
enable_autodyn [Cudd.Man]
env [Apron.Abstract1]
eq [Bddapron.Expr1.O.Apron]
eq [Bddapron.Expr1.O.Benum]
eq [Bddapron.Expr1.O.Bint]
eq [Bddapron.Expr1.O.Bool]
Same as nxor
eq [Bddapron.Expr1.O]
Equality operation
eq [Bddapron.Expr1.Apron]
eq [Bddapron.Expr1.Benum]
eq [Bddapron.Expr1.Bint]
eq [Bddapron.Expr1.Bool]
Same as nxor
eq [Bddapron.Expr1]
Equality operation
eq [Bddapron.Expr0.O.Apron]
eq [Bddapron.Expr0.O.Benum]
eq [Bddapron.Expr0.O.Bint]
eq [Bddapron.Expr0.O.Bool]
eq [Bddapron.Expr0.O]
Under which condition are the expressions equal ? In case of arithmetic expressions, do not take into account the careset.
eq [Bddapron.Expr0.Apron]
eq [Bddapron.Expr0.Benum]
eq [Bddapron.Expr0.Bint]
eq [Bddapron.Expr0.Bool]
eq [Bddapron.Expr0]
Under which condition are the expressions equal ? In case of arithmetic expressions, do not take into account the careset.
eq [Bddapron.ApronexprDD.Condition]
eq [Bdd.Expr1.O.Benum]
eq [Bdd.Expr1.O.Bint]
eq [Bdd.Expr1.O.Bool]
Same as nxor
eq [Bdd.Expr1.O]
Equality operation
eq [Bdd.Expr1.Benum]
eq [Bdd.Expr1.Bint]
eq [Bdd.Expr1.Bool]
Same as nxor
eq [Bdd.Expr1]
Equality operation
eq [Bdd.Expr0.O.Benum]
eq [Bdd.Expr0.O.Bint]
eq [Bdd.Expr0.O.Bool]
Same as nxor
eq [Bdd.Expr0.O]
Equality operation
eq [Bdd.Expr0.Benum]
eq [Bdd.Expr0.Bint]
eq [Bdd.Expr0.Bool]
Same as nxor
eq [Bdd.Expr0]
Equality operation
eq [Cudd.Bdd]
Same as Cudd.Bdd.nxor
eq_int [Bddapron.Expr1.O.Bint]
eq_int [Bddapron.Expr1.Bint]
eq_int [Bddapron.Expr0.O.Bint]
eq_int [Bddapron.Expr0.Bint]
eq_int [Bdd.Expr1.O.Bint]
eq_int [Bdd.Expr1.Bint]
eq_int [Bdd.Expr0.O.Bint]
eq_int [Bdd.Expr0.Bint]
eq_label [Bddapron.Expr1.O.Benum]
eq_label [Bddapron.Expr1.Benum]
eq_label [Bddapron.Expr0.O.Benum]
eq_label [Bddapron.Expr0.Benum]
eq_label [Bdd.Expr1.O.Benum]
eq_label [Bdd.Expr1.Benum]
eq_label [Bdd.Expr0.O.Benum]
eq_label [Bdd.Expr0.Benum]
equal [Bddapron.Policy.Mtbdddomain0]
equal [Bddapron.Apronexpr]
equal [Bdd.Enum]
Under which condition the 2 registers are equal ?
equal [Bdd.Int]
equal [Bdd.Reg]
Equality test.
equal [Symbol]
Equality test
equal [Sette.Compare]
equal [Sette]
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
equal [SetList.S]
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
equal [SetList]
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
equal [PSette]
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
equal [PMappe]
equal [MultiSetList.S]
equal s1 s2 tests whether the multisets s1 and s2 are equal, that is, contain equal elements with equal occurence numbers.
equal [MultiSetList]
equal s1 s2 tests whether the multisets s1 and s2 are equal, that is, contain equal elements with equal occurence numbers.
equal [Mappe.Compare]
equal [Mappe]
equal [Sette.S]
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
equal [Mappe.S]
equal [Hashhe.HashedType]
The equality predicate used to compare keys.
equal [Apron.Policy]
equal [Apron.Environment]
Test equality if two environments
equal [Apron.Coeff]
Equality test
equal [Apron.Interval]
Equality test
equal [Apron.Scalar]
Equality test, possibly using a conversion to Mpqf.t.
equal [Mpqf]
equal [Mpq]
equal [Mpfrf]
equal [Mpfr]
equal [Mpf]
equal_int [Bdd.Int]
equal_int [Bdd.Reg]
equal_int [Apron.Coeff]
Is the coefficient equal to scalar b or interval b,b ?
equal_int [Apron.Interval]
Is the interval equal to i,i ?
equal_int [Apron.Scalar]
Equality test with an integer
equal_label [Bdd.Enum]
Under which condition the register is equal to the label ?
equali [PMappe]
equali [Mappe.Compare]
equali [Mappe]
equality between maps
equali [Mappe.S]
equalx [PDMappe]
equalx [DMappe.S]
equalx [DMappe]
equaly [PDMappe]
equaly [DMappe.S]
equaly [DMappe]
erf [Mpfr]
erfc [Mpfr]
error [Bddapron.Syntax]
escaped [Print]
Escape a string, replacing line breaks by linebreak (default '\n').
eval_cst [Cudd.Add]
Cuddaux_addEvalConst/Cudd_addEvalConst.
eval_cst [Cudd.Mtbddc]
eval_cst [Cudd.Mtbdd]
eval_cst [Cudd.Vdd]
even_p [Mpz]
exist [Bddapron.Expr1.O.Bool]
exist [Bddapron.Expr1.Bool]
exist [Bddapron.Expr0.O.Bool]
exist [Bddapron.Expr0.Bool]
exist [Bddapron.ApronDD]
exist [Bdd.Expr1.O.Bool]
exist [Bdd.Expr1.Bool]
exist [Bdd.Expr0.O.Bool]
exist [Bdd.Expr0.Bool]
exist [Cudd.Add]
Variation of Cudd_addExistAbstract.
exist [Cudd.Bdd]
existand [Bddapron.ApronDD]
existand [Cudd.Bdd]
exists [Symbol]
Is the string already registered ?
exists [Sette]
exists p s checks if at least one element of the set satisfies the predicate p.
exists [SetList.S]
exists p s checks if at least one element of the set satisfies the predicate p.
exists [SetList]
exists p s checks if at least one element of the set satisfies the predicate p.
exists [PSette]
exists p s checks if at least one element of the set satisfies the predicate p.
exists [Ilist]
Existence test
exists [Sette.S]
exists p s checks if at least one element of the set satisfies the predicate p.
existxor [Cudd.Bdd]
exp [Mpfr]
exp10 [Mpfr]
exp2 [Mpfr]
expand [Apron.Abstract1]
Expansion: expand a var tvar expands the variable var into itself and the additional variables in tvar, which are given the same type as var.
expand [Apron.Abstract0]
Expansion: expand a dim n expands the dimension dim into itself + n additional dimensions.
expand_with [Apron.Abstract1]
expand_with [Apron.Abstract0]
expansivemapleaf1 [Cudd.Mapleaf]
Same as above, but with \/ replaced by merge (supposed to be commutative and associative).
expansivemapleaf2 [Cudd.Mapleaf]
Same as above, but with \/ replaced by merge (supposed to be commutative and associative).
expm1 [Mpfr]
export [Mpz]
expr [Bddapron.Yacc]
expr0_of_lexbuf [Bddapron.Parser]
expr0_of_string [Bddapron.Parser]
expr1_of_string [Bddapron.Parser]
extend [Bdd.Int]
extend [Bdd.Reg]
register extension or truncation.
extend_environment [Bddapron.Expr2.List]
extend_environment [Bddapron.Expr2.Bool]
Extend the underlying environment to a superenvironment, and adapt accordingly the underlying representation
extend_environment [Bddapron.Expr2.O.List]
extend_environment [Bddapron.Expr2.O.Bool]
extend_environment [Bddapron.Expr2.O]
extend_environment [Bddapron.Expr2]
Extend the underlying environment to a superenvironment, and adapt accordingly the underlying representation
extend_environment [Bddapron.Expr1.O.List]
extend_environment [Bddapron.Expr1.O.Apron]
extend_environment [Bddapron.Expr1.O.Benum]
extend_environment [Bddapron.Expr1.O.Bint]
extend_environment [Bddapron.Expr1.O.Bool]
extend_environment [Bddapron.Expr1.O]
extend_environment [Bddapron.Expr1.List]
extend_environment [Bddapron.Expr1.Apron]
Extend the underlying environment to a superenvironment, and adapt accordingly the underlying representation
extend_environment [Bddapron.Expr1.Benum]
Extend the underlying environment to a superenvironment, and adapt accordingly the underlying representation
extend_environment [Bddapron.Expr1.Bint]
Extend the underlying environment to a superenvironment, and adapt accordingly the underlying representation
extend_environment [Bddapron.Expr1.Bool]
Extend the underlying environment to a superenvironment, and adapt accordingly the underlying representation
extend_environment [Bddapron.Expr1]
Extend the underlying environment to a superenvironment, and adapt accordingly the underlying representation
extend_environment [Bdd.Expr1.O.List]
extend_environment [Bdd.Expr1.O.Benum]
extend_environment [Bdd.Expr1.O.Bint]
extend_environment [Bdd.Expr1.O.Bool]
extend_environment [Bdd.Expr1.O]
extend_environment [Bdd.Expr1.List]
extend_environment [Bdd.Expr1.Benum]
Extend the underlying environment to a superenvironment, and adapt accordingly the underlying representation
extend_environment [Bdd.Expr1.Bint]
Extend the underlying environment to a superenvironment, and adapt accordingly the underlying representation
extend_environment [Bdd.Expr1.Bool]
Extend the underlying environment to a superenvironment, and adapt accordingly the underlying representation
extend_environment [Bdd.Expr1]
Extend the underlying environment to a superenvironment, and adapt accordingly the underlying representation
extend_environment [Bdd.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.
extend_environment [Apron.Tcons1]
Change the environement of the constraint for a super-environement.
extend_environment [Apron.Texpr1]
Change the environment of the expression for a super-environement.
extend_environment [Apron.Generator1]
Change the environement of the generator for a super-environement.
extend_environment [Apron.Lincons1]
Change the environement of the constraint for a super-environement.
extend_environment [Apron.Linexpr1]
Change the environment of the expression for a super-environement.
extend_environment_with [Apron.Tcons1]
Side-effect version of the previous function
extend_environment_with [Apron.Texpr1]
Side-effet version of the previous function
extend_environment_with [Apron.Generator1]
Side-effect version of the previous function
extend_environment_with [Apron.Lincons1]
Side-effect version of the previous function
extend_environment_with [Apron.Linexpr1]
Side-effet version of the previous function
extract [Union]
Extract the list of sets

F
fac_ui [Mpz]
fac_ui [Mpfr]
fdiv_q [Mpzf]
fdiv_q [Mpz]
fdiv_q_2exp [Mpz]
fdiv_q_ui [Mpz]
fdiv_qr [Mpzf]
fdiv_qr [Mpz]
fdiv_qr_ui [Mpz]
fdiv_r [Mpzf]
fdiv_r [Mpz]
fdiv_r_2exp [Mpz]
fdiv_r_ui [Mpz]
fdiv_ui [Mpz]
fdump [Apron.Policy]
fdump [Apron.Abstract1]
Dump on the stdout C stream the internal representation of an abstract value, for debugging purposes
fdump [Apron.Abstract0]
Dump on the stdout C stream the internal representation of an abstract value, for debugging purposes
fib2_ui [Mpz]
fib_ui [Mpz]
filter [Sette.Compare]
filter [Sette]
filter p s returns the set of all elements in s that satisfy predicate p.
filter [SetList.S]
filter p s returns the set of all elements in s that satisfy predicate p.
filter [SetList]
filter p s returns the set of all elements in s that satisfy predicate p.
filter [PSette]
filter p s returns the set of all elements in s that satisfy predicate p.
filter [PMappe]
filter [MultiSetList.S]
filter p l returns all the elements of the multiset l that satisfy the predicate p.
filter [MultiSetList]
filter p l returns all the elements of the multiset l that satisfy the predicate p.
filter [Mappe.Compare]
filter [Mappe]
filter p m returns the map of all bindings in m that satisfy predicate p.
filter [Sette.S]
filter p s returns the set of all elements in s that satisfy predicate p.
filter [Mappe.S]
find [Union]
find [PMappe]
find [PHashhe]
find [Mappe.Compare]
find [Mappe]
find x m returns the current binding of x in m, or raises Not_found if no such binding exists.
find [Hashhe.Compare]
find [Hashhe]
find tbl x returns the current binding of x in tbl, or raises Not_found if no such binding exists.
find [Mappe.S]
find [Hashhe.S]
find [Cudd.PWeakke]
find [Cudd.Weakke.Compare]
find [Cudd.Weakke.S]
find t x returns an instance of x found in t.
find [Cudd.Weakke]
find_all [PHashhe]
find_all [Hashhe.Compare]
find_all [Hashhe]
find_all tbl x returns the list of all data associated with x in tbl.
find_all [Hashhe.S]
find_all [Cudd.PWeakke]
find_all [Cudd.Weakke.Compare]
find_all [Cudd.Weakke.S]
find_all t x returns a list of all the instances of x found in t.
find_all [Cudd.Weakke]
find_or [Cudd.Weakke.Compare]
find_shadow [Cudd.Weakke.Compare]
fits_int_p [Mpz]
fits_int_p [Mpf]
fits_sint_p [Mpz]
fits_sint_p [Mpf]
fits_slong_p [Mpz]
fits_slong_p [Mpf]
fits_sshort_p [Mpz]
fits_sshort_p [Mpf]
fits_uint_p [Mpz]
fits_uint_p [Mpf]
fits_ulong_p [Mpz]
fits_ulong_p [Mpf]
fits_ushort_p [Mpz]
fits_ushort_p [Mpf]
flatten [Ilist]
Flatten the recursive list, only starting from the given
floor [Mpfr]
floor [Mpf]
flush [Cudd.Man]
fma [Mpfr]
fmod [Mpfr]
fms [Mpfr]
fold [Sette]
fold f s a computes (f xN ... (f x2 (f x1 a))...), where x1 ... xN are the elements of s.
fold [SetList.S]
fold f s a computes (f xN ... (f x2 (f x1 a))...), where x1 ... xN are the elements of s.
fold [SetList]
fold f s a computes (f xN ... (f x2 (f x1 a))...), where x1 ... xN are the elements of s.
fold [PSette]
fold f s a computes (f xN ... (f x2 (f x1 a))...), where x1 ... xN are the elements of s.
fold [PMappe]
fold [PHashhe]
fold [PDMappe]
fold [PDHashhe]
fold [MultiSetList.S]
fold f s a computes (f (xN,On) ... (f (x2,O2) (f (x1,o1) a))...), where (x1,o1) ... (xN,oN) are pairs of elements of s with their occurence number.
fold [MultiSetList]
fold f s a computes (f (xN,On) ... (f (x2,O2) (f (x1,o1) a))...), where (x1,o1) ... (xN,oN) are pairs of elements of s with their occurence number.
fold [Mappe]
fold f m a computes (f kN dN ... (f k1 d1 a)...), where k1 ... kN are the keys of all bindings in m, and d1 ... dN are the associated data.
fold [Hashhe]
fold f tbl init computes (f kN dN ... (f k1 d1 init)...), where k1 ... kN are the keys of all bindings in tbl, and d1 ... dN are the associated values.
fold [Sette.S]
fold f s a computes (f xN ... (f x2 (f x1 a))...), where x1 ... xN are the elements of s.
fold [Mappe.S]
fold [DMappe.S]
fold [DMappe]
Iterate on bindings and accumulating a result.
fold [Hashhe.S]
fold [DHashhe.S]
fold [DHashhe]
Iterate on bindings and accumulating a result.
fold [Apron.Abstract1]
Folding: fold a tvar fold the variables in the array tvar of size n>=1 and put the result in the first variable of the array.
fold [Apron.Abstract0]
Folding: fold a tdim fold the dimensions in the array tdim of size n>=1 and put the result in the first dimension of the array.
fold [Cudd.PWeakke]
fold [Cudd.Weakke.S]
fold f t init computes (f d1 (... (f dN init))) where d1 ... dN are the elements of t in some unspecified order.
fold [Cudd.Weakke]
fold2 [Bddapron.Bddleaf]
fold_edge [FGraph1.S]
fold_edge [FGraph1]
fold_edge [FGraph.S]
fold_edge [FGraph]
fold_hedge [SHGraph.S]
fold_hedge [SHGraph]
fold_hedge [PSHGraph]
fold_left [SetList.S]
Idem as List.fold_X functions
fold_left [SetList]
Idem as List.fold_X functions
fold_left [MultiSetList.S]
Idem as List.fold_X functions
fold_left [MultiSetList]
Idem as List.fold_X functions
fold_left [Ilist]
Ordinary fold function for atoms, from left to right.
fold_right [SetList.S]
fold_right [SetList]
fold_right [MultiSetList.S]
fold_right [MultiSetList]
fold_right [Ilist]
Ordinary fold function for atoms, from right to left.
fold_vertex [SHGraph.S]
fold_vertex [SHGraph]
fold_vertex [PSHGraph]
fold_vertex [FGraph1.S]
fold_vertex [FGraph1]
fold_vertex [FGraph.S]
fold_vertex [FGraph]
fold_with [Apron.Abstract1]
fold_with [Apron.Abstract0]
for_all [Sette]
for_all p s checks if all elements of the set satisfy the predicate p.
for_all [SetList.S]
for_all p s checks if all elements of the set satisfy the predicate p.
for_all [SetList]
for_all p s checks if all elements of the set satisfy the predicate p.
for_all [PSette]
for_all p s checks if all elements of the set satisfy the predicate p.
for_all [Sette.S]
for_all p s checks if all elements of the set satisfy the predicate p.
forall [Bddapron.Expr1.O.Bool]
forall [Bddapron.Expr1.Bool]
forall [Bddapron.Expr0.O.Bool]
forall [Bddapron.Expr0.Bool]
forall [Bdd.Expr1.O.Bool]
forall [Bdd.Expr1.Bool]
forall [Bdd.Expr0.O.Bool]
forall [Bdd.Expr0.Bool]
forall [Cudd.Add]
Variation of Cudd_addUnivAbstract.
forall [Cudd.Bdd]
forget [Bddapron.Formula.Expr1.Bool]
forget [Bddapron.Formula.Expr0.Bool]
forget [Bddapron.Formula.O.Expr1.Bool]
forget [Bddapron.Formula.O.Expr0.Bool]
forget [Bddapron.Bdddomain0.O.L]
forget_array [Bddapron.ApronDD]
forget_array [Apron.Abstract1]
forget_array [Apron.Abstract0]
forget_array_with [Apron.Abstract1]
forget_array_with [Apron.Abstract0]
forget_list [Bddapron.Domain1]
forget_list [Bddapron.Domainlevel1.Level0]
forget_list [Bddapron.Domainlevel1.Level1]
Forget (existential quantification) a list of variables
forget_list [Bddapron.Domain0]
forget_list [Bddapron.Bdddomain0.O]
forget_list [Bddapron.Bdddomain0]
Forget (existential quantification) a list of variables
forget_list [Bddapron.Mtbdddomain0.O]
forget_list [Bddapron.Mtbdddomain0]
Forget (existential quantification) a list of variables
forget_list [Bdd.Domain1.O]
Eliminating variables
forget_list [Bdd.Domain1]
Eliminating variables
forget_list [Bdd.Domain0.O]
Eliminating variables
forget_list [Bdd.Domain0]
Eliminating variables
frac [Mpfr]
funopt_make [Apron.Manager]
Return the default options for any function (0 or false for al fields)

G
gamma [Mpfr]
gand [Mpz]
garbage_collect [Cudd.Man]
gcd [Rational]
gcd [Mpzf]
gcd [Mpz]
gcd_ui [Mpz]
gcdext [Mpz]
genconjdecomp [Cudd.Bdd]
Cudd_bddGenDisjDecomp.
gendisjdecomp [Cudd.Bdd]
Cudd_bddVarConjDecomp.
generator [Apron.Apron_parser]
generator1_of_lexbuf [Apron.Parser]
Conversion from lexing buffers to resp.
generator1_of_lstring [Apron.Parser]
Conversion from lists of strings to array of resp.
generator1_of_string [Apron.Parser]
Conversion from strings to resp.
get [Cudd.Mtbddc]
Type conversion (no computation)
get [Cudd.Mtbdd]
Type conversion (no computation)
get_approximate_max_coeff_size [Polka]
get_arcviolation [Cudd.Man]
get_background [Cudd.Man]
get_bddvar_nb [Cudd.Man]
get_cache_hits [Cudd.Man]
get_cache_lookups [Cudd.Man]
get_cache_slots [Cudd.Man]
get_cache_used_slots [Cudd.Man]
get_coeff [Apron.Generator1]
Get the coefficient of the variable in the underlying linear expression
get_coeff [Apron.Lincons1]
Get the coefficient of the variable in the underlying linear expression
get_coeff [Apron.Linexpr1]
Get the coefficient of the variable
get_coeff [Apron.Linexpr0]
Get the coefficient corresponding to the dimension
get_cond [Bddapron.Expr2.List]
Extract resp.
get_cond [Bddapron.Expr2.Bool]
Extract resp.
get_cond [Bddapron.Expr2.O.List]
get_cond [Bddapron.Expr2.O.Bool]
get_cond [Bddapron.Expr2.O]
get_cond [Bddapron.Expr2]
Extract resp.
get_cond [Bddapron.Cond]
get_cond [Bdd.Cond]
get_crossovers [Cudd.Man]
get_cst [Apron.Lincons1]
Get the constant of the underlying linear expression
get_cst [Apron.Linexpr1]
Get the constant
get_cst [Apron.Linexpr0]
Get the constant
get_d [Mpz]
get_d [Mpq]
get_d [Mpfr]
get_d [Mpf]
get_d1 [Mpfr]
get_d_2exp [Mpz]
get_d_2exp [Mpf]
get_dead [Cudd.Man]
get_default_prec [Mpfr]
get_default_prec [Mpf]
get_default_rounding_mode [Mpfr]
get_den [Mpqf]
get_den [Mpq]
get_deserialize [Apron.Manager]
get_emax [Mpfr]
get_emin [Mpfr]
get_env [Bddapron.Domain1]
get_env [Bddapron.Domainlevel1.Level1]
get_env [Bddapron.Expr2.List]
get_env [Bddapron.Expr2.Bool]
get_env [Bddapron.Expr2.O.List]
get_env [Bddapron.Expr2.O.Bool]
get_env [Bddapron.Expr2.O]
get_env [Bddapron.Expr2]
get_env [Bddapron.Expr1.O.List]
get_env [Bddapron.Expr1.List]
get_env [Bddapron.Expr1.Apron]
get_env [Bddapron.Expr1.Benum]
get_env [Bddapron.Expr1.Bint]
get_env [Bddapron.Expr1.Bool]
get_env [Bddapron.Expr1]
get_env [Bddapron.Cond]
get_env [Bddapron.Env]
get_env [Bdd.Domain1.O]
get_env [Bdd.Domain1]
get_env [Bdd.Expr1.O.List]
get_env [Bdd.Expr1.O.Benum]
get_env [Bdd.Expr1.O.Bint]
get_env [Bdd.Expr1.O.Bool]
get_env [Bdd.Expr1.O]
get_env [Bdd.Expr1.List]
get_env [Bdd.Expr1.Benum]
get_env [Bdd.Expr1.Bint]
get_env [Bdd.Expr1.Bool]
get_env [Bdd.Expr1]
get_env [Bdd.Cond]
get_env [Bdd.Env]
get_env [Apron.Tcons1]
Get the environement of the tree expression constraint
get_env [Apron.Texpr1]
Get the environement of the expression
get_env [Apron.Generator1]
Get the environement of the generator
get_env [Apron.Lincons1]
Get the environement of the linear constraint
get_env [Apron.Linexpr1]
Get the environement of the expression
get_epsilon [Cudd.Man]
get_error [Cudd.Man]
get_exp [Mpfr]
get_flag_best [Apron.Manager]
Get the corresponding result flag
get_flag_exact [Apron.Manager]
Get the corresponding result flag
get_funopt [Apron.Manager]
Get the options sets for the function.
get_gc_nb [Cudd.Man]
get_gc_time [Cudd.Man]
get_generator0 [Apron.Generator1]
Get the underlying generator of level 0.
get_groupcheck [Cudd.Man]
get_int [Mpz]
get_int [Mpf]
get_keys [Cudd.Man]
get_library [Apron.Manager]
Get the name of the effective library which allocated the manager
get_lincons0 [Apron.Lincons1]
Get the underlying linear constraint of level 0.
get_linear [Cudd.Man]
get_linexpr0 [Apron.Linexpr1]
Get the underlying expression of level 0 (which is not a copy).
get_linexpr1 [Apron.Generator1]
Get the underlying linear expression.
get_linexpr1 [Apron.Lincons1]
Get the underlying linear expression.
get_looseupto [Cudd.Man]
get_max_cache [Cudd.Man]
get_max_cache_hard [Cudd.Man]
get_max_coeff_size [Polka]
get_max_growth [Cudd.Man]
get_max_growth_alt [Cudd.Man]
get_max_live [Cudd.Man]
get_max_mem [Cudd.Man]
get_min_dead [Cudd.Man]
get_min_hit [Cudd.Man]
get_next_autodyn [Cudd.Man]
get_node_count [Cudd.Man]
get_node_count_peak [Cudd.Man]
get_num [Mpqf]
get_num [Mpq]
get_population [Cudd.Man]
get_prec [Mpfr]
get_prec [Mpf]
get_q [Mpf]
get_recomb [Cudd.Man]
get_reordering_cycle [Cudd.Man]
get_reordering_nb [Cudd.Man]
get_reordering_time [Cudd.Man]
get_si [Mpz]
get_si [Mpf]
get_sift_max_swap [Cudd.Man]
get_sift_max_var [Cudd.Man]
get_size [Apron.Linexpr0]
Get the size of the linear expression (which may be sparse or dense)
get_slots [Cudd.Man]
get_str [Mpz]
get_str [Mpq]
get_str [Mpfr]
get_str [Mpf]
get_swap_nb [Cudd.Man]
get_symmviolation [Cudd.Man]
get_tcons0 [Apron.Tcons1]
Get the underlying tree expression constraint of level 0.
get_texpr0 [Apron.Texpr1]
Get the underlying expression of level 0 (which is not a copy).
get_texpr1 [Apron.Tcons1]
Get the underlying linear expression.
get_typ [Apron.Tcons1]
Get the constraint type
get_typ [Apron.Generator1]
Get the generator type
get_typ [Apron.Lincons1]
Get the constraint type
get_used_slots [Cudd.Man]
get_val0 [Bddapron.Cond]
get_val0 [Bddapron.Env]
get_val0 [Bdd.Cond]
get_val0 [Bdd.Env]
get_val1 [Bddapron.Cond]
get_val1 [Bdd.Cond]
get_version [Apron.Manager]
Get the version of the effective library which allocated the manager
get_z [Mpq]
get_z [Mpfr]
get_z [Mpf]
get_z_exp [Mpfr]
get_zddvar_nb [Cudd.Man]
gmod [Bddapron.Expr1.O.Apron]
gmod [Bddapron.Expr1.Apron]
gmod [Bddapron.Expr0.O.Apron]
gmod [Bddapron.Expr0.Apron]
gmod [Bddapron.ApronexprDD]
gmod [Bddapron.Apronexpr]
gmod [Mpzf]
gmod [Mpz]
gmod_ui [Mpz]
greater [Bdd.Int]
greater [Bdd.Reg]
Signed strictly-greater-than test.
greater_int [Bdd.Int]
greater_int [Bdd.Reg]
greatereq [Bdd.Int]
greatereq [Bdd.Reg]
Signed greater-or-equal test.
greatereq_int [Bdd.Int]
greatereq_int [Bdd.Reg]
group [Cudd.Man]
guard [Bddapron.Bddleaf]
Others
guard_of_int [Bddapron.Expr1.O.Bint]
Return the guard of the integer value.
guard_of_int [Bddapron.Expr1.Bint]
Return the guard of the integer value.
guard_of_int [Bdd.Expr1.O.Bint]
Return the guard of the integer value.
guard_of_int [Bdd.Expr1.Bint]
Return the guard of the integer value.
guard_of_int [Bdd.Expr0.O.Bint]
Return the guard of the integer value.
guard_of_int [Bdd.Expr0.Bint]
Return the guard of the integer value.
guard_of_int [Bdd.Int]
Return the guard of the integer value in the BDD register.
guard_of_int [Bdd.Reg]
Return the guard of the integer value in the BDD register.
guard_of_label [Bddapron.Expr1.O.Benum]
Return the guard of the label.
guard_of_label [Bddapron.Expr1.Benum]
Return the guard of the label.
guard_of_label [Bdd.Expr1.O.Benum]
Return the guard of the label.
guard_of_label [Bdd.Expr1.Benum]
Return the guard of the label.
guard_of_label [Bdd.Expr0.O.Benum]
Return the guard of the label.
guard_of_label [Bdd.Expr0.Benum]
Return the guard of the label.
guard_of_label [Bdd.Enum]
Return the guard of the label in the BDD register.
guard_of_leaf [Cudd.Add]
Guard of the given leaf
guard_of_leaf [Cudd.Mtbddc]
guard_of_leaf [Cudd.Mtbdd]
guard_of_leaf [Cudd.Vdd]
Guard of the given leaf
guard_of_leaf_u [Cudd.Mtbddc]
Guard of the given leaf
guard_of_leaf_u [Cudd.Mtbdd]
Guard of the given leaf
guard_of_minterm [Bdd.Reg]
Return the guard of the deterministic minterm in the BDD register.
guard_of_node [Cudd.Add]
Cuddaux_addGuardOfNode.
guard_of_node [Cudd.Mtbddc]
guard_of_node [Cudd.Mtbdd]
guard_of_node [Cudd.Vdd]
guard_of_nonbackground [Cudd.Add]
Guard of non background leaves
guard_of_nonbackground [Cudd.Mtbddc]
guard_of_nonbackground [Cudd.Mtbdd]
guard_of_nonbackground [Cudd.Vdd]
guardints [Bddapron.Expr1.O.Bint]
Return the list g -> n of guarded values.
guardints [Bddapron.Expr1.Bint]
Return the list g -> n of guarded values.
guardints [Bdd.Expr1.O.Bint]
Return the list g -> n of guarded values.
guardints [Bdd.Expr1.Bint]
Return the list g -> n of guarded values.
guardints [Bdd.Expr0.O.Bint]
Return the list g -> n of guarded values.
guardints [Bdd.Expr0.Bint]
Return the list g -> n of guarded values.
guardints [Bdd.Int]
Return the list g -> n represented by the BDD register.
guardints [Bdd.Reg]
Return the list g -> n represented by the BDD register.
guardlabels [Bddapron.Expr1.O.Benum]
Return the list g -> label of guarded values.
guardlabels [Bddapron.Expr1.Benum]
Return the list g -> label of guarded values.
guardlabels [Bdd.Expr1.O.Benum]
Return the list g -> label of guarded values.
guardlabels [Bdd.Expr1.Benum]
Return the list g -> label of guarded values.
guardlabels [Bdd.Expr0.O.Benum]
Return the list g -> label of guarded values.
guardlabels [Bdd.Expr0.Benum]
Return the list g -> label of guarded values.
guardlabels [Bdd.Enum]
Return the list g -> label represented by the BDD register.
guardleafs [Cudd.Add]
Returns the set of leaf values together with their guard in the ADD
guardleafs [Cudd.Mtbddc]
guardleafs [Cudd.Mtbdd]
guardleafs [Cudd.Vdd]
Returns the set of leaf values together with their guard in the ADD
guardleafs_u [Cudd.Mtbddc]
Returns the set of leaf values together with their guard in the ADD
guardleafs_u [Cudd.Mtbdd]
Returns the set of leaf values together with their guard in the ADD

H
hamdist [Mpz]
hash [Bddapron.Apronexpr]
hash [Print]
Print an hashtable
hash [Hashhe]
hash x associates a positive integer to any value of any type.
hash [Hashhe.HashedType]
A hashing function on keys.
hash [Apron.Abstract1]
hash [Apron.Environment]
Hashing function for environments
hash [Apron.Var]
Hash function
hash [Apron.Abstract0]
hash [Apron.Linexpr0]
Hashing function
hash_param [Hashhe]
hash_param n m x computes a hash value for x, with the same properties as for hash.
hashx [PDHashhe]
hashx [DHashhe.S]
hashx [DHashhe]
hashy [PDHashhe]
hashy [DHashhe.S]
hashy [DHashhe]
Return the correspondance hashtable resp.
hd [Ilist]
Return the head of the list.
hedge_dummy [SHGraph.T]
A dummy (never used) value for hyperedge identifiers (used for the functions XXX_multi)
hedge_dummy [SHGraph.S]
higher [Bdd.Reg]
Unsigned strictly-greater-than test.
higher_int [Bdd.Reg]
Tests w.r.t.
highereq [Bdd.Reg]
Unsigned greater-or-equal test.
highereq_int [Bdd.Reg]
hypot [Mpfr]

I
i_of_float [Apron.Coeff]
i_of_frac [Apron.Coeff]
i_of_int [Apron.Coeff]
i_of_mpfr [Apron.Coeff]
Create an interval coefficient from resp.
i_of_mpq [Apron.Coeff]
i_of_mpqf [Apron.Coeff]
i_of_scalar [Apron.Coeff]
Build an interval from a lower and an upper bound
id_of_vdd [Bdd.Output]
Output the MTBDD and return its identifier
idb_of_cond [Bdd.Cond]
import [Mpz]
inexflag_p [Mpfr]
inf_p [Mpfrf]
inf_p [Mpfr]
info [SHGraph.S]
info [SHGraph]
info g returns the user-information attached to the graph g
info [PSHGraph]
info [FGraph1.S]
info [FGraph1]
info [FGraph.S]
info [FGraph]
init [Mpz]
init [Mpq]
init [Mpfr]
init [Mpf]
init2 [Mpz]
init2 [Mpfr]
init2 [Mpf]
init_default [Gmp_random]
init_lc_2exp [Gmp_random]
init_lc_2exp_size [Gmp_random]
init_set [Mpz]
init_set [Mpq]
init_set [Mpfr]
init_set [Mpf]
init_set_d [Mpz]
init_set_d [Mpq]
init_set_d [Mpfr]
init_set_d [Mpf]
init_set_f [Mpfr]
init_set_q [Mpfr]
init_set_si [Mpz]
init_set_si [Mpq]
init_set_si [Mpfr]
init_set_si [Mpf]
init_set_str [Mpz]
init_set_str [Mpq]
init_set_str [Mpfr]
init_set_str [Mpf]
init_set_z [Mpq]
init_set_z [Mpfr]
inspect [Cudd.Add]
Decomposes the top node of the ADD
inspect [Cudd.Mtbddc]
Decompose the MTBDD
inspect [Cudd.Mtbdd]
Decompose the MTBDD
inspect [Cudd.Vdd]
inspect [Cudd.Bdd]
Decomposes the top node of the BDD
integer_p [Mpfr]
integer_p [Mpf]
inter [Sette.Compare]
inter [Sette]
inter [SetList.S]
inter [SetList]
inter [PSette]
inter [MultiSetList.S]
inter [MultiSetList]
inter [Sette.S]
Set intersection.
inter_set [MultiSetList.S]
inter_set [MultiSetList]
intersect [Cudd.Bdd]
interset [PMappe]
interset [Mappe.Compare]
interset [Mappe]
interset map set selects the bindings in a whose key belongs to set.
interset [Mappe.S]
intersetx [PDMappe]
intersetx [DMappe.S]
intersetx [DMappe]
Select the two-way bindings x <->y with x in the set
intersety [PDMappe]
intersety [DMappe.S]
intersety [DMappe]
Select the two-way bindings x <->y with y in the set
inv [Rational]
inv [Mpqf]
inv [Mpq]
invert [Mpz]
ior [Mpz]
is_and_false [Bddapron.Expr0.O.Bool]
is_and_false [Bddapron.Expr0.Bool]
is_and_false [Bdd.Expr0.O.Bool]
is_and_false [Bdd.Expr0.Bool]
is_bottom [Bddapron.Domain1]
is_bottom [Bddapron.Domainlevel1.Level0]
is_bottom [Bddapron.Domainlevel1.Level1]
is_bottom [Bddapron.Domain0]
is_bottom [Bddapron.Bdddomain0.O.L]
is_bottom [Bddapron.Bdddomain0.O]
is_bottom [Bddapron.Bdddomain0]
is_bottom [Bddapron.Mtbdddomain0.O]
is_bottom [Bddapron.Mtbdddomain0]
is_bottom [Bddapron.ApronDD]
is_bottom [Bdd.Domain1.O]
is_bottom [Bdd.Domain1]
is_bottom [Bdd.Domain0.O]
is_bottom [Bdd.Domain0]
is_bottom [Apron.Abstract1]
Emptiness test
is_bottom [Apron.Abstract0]
Emptiness test
is_bottom [Apron.Interval]
Does the interval contain no value ([a,b] with a>b) ?
is_box [Box.Policy]
Return true iff the argument value is a box value
is_box [Box.Abstract1]
Return true iff the argument value is a box value
is_box [Box.Abstract0]
Return true iff the argument value is a box value
is_complement [Cudd.Bdd]
is_cst [Bddapron.Expr1.O.Bool]
is_cst [Bddapron.Expr1.Bool]
is_cst [Bddapron.Expr0.O.Bool]
is_cst [Bddapron.Expr0.Bool]
is_cst [Bdd.Expr1.O.Bool]
is_cst [Bdd.Expr1.Bool]
is_cst [Bdd.Expr0.O.Bool]
is_cst [Bdd.Expr0.Bool]
is_cst [Bdd.Enum]
Does the register contain a constant value ?
is_cst [Bdd.Int]
is_cst [Bdd.Reg]
Tests whether it contains a constant value.
is_cst [Cudd.Add]
is_cst [Cudd.Mtbddc]
Is the MTBDD constant ?
is_cst [Cudd.Mtbdd]
Is the MTBDD constant ?
is_cst [Cudd.Vdd]
is_cst [Cudd.Bdd]
is_dependent_on_integer_only [Bddapron.Apronexpr]
is_dimension_unconstrained [Apron.Abstract0]
Is the dimension unconstrained in the abstract value ? If yes, this means that the existential quantification of the dimension does not change the value.
is_disjunction [Apron.Disjunction.Abstract1]
Return true iff the argument value is a disjunction value
is_disjunction [Apron.Disjunction.Abstract0]
Return true iff the argument value is a disjunction value
is_edge [FGraph1.S]
is_edge [FGraph1]
is_edge [FGraph.S]
is_edge [FGraph]
is_empty [Sette]
Test whether a set is empty or not.
is_empty [SetList.S]
Test whether a set is empty or not.
is_empty [SetList]
Test whether a set is empty or not.
is_empty [SHGraph.S]
is_empty [SHGraph]
Is the graph empty ?
is_empty [PSette]
Test whether a set is empty or not.
is_empty [PSHGraph]
is_empty [PMappe]
is_empty [PDMappe]
is_empty [MultiSetList.S]
Test whether a multiset is empty or not.
is_empty [MultiSetList]
Test whether a multiset is empty or not.
is_empty [Mappe]
Is the map empty ?
is_empty [FGraph1.S]
is_empty [FGraph1]
is_empty [FGraph.S]
is_empty [FGraph]
is_empty [Sette.S]
Test whether a set is empty or not.
is_empty [Mappe.S]
is_empty [DMappe.S]
is_eq [Bddapron.Domain1]
is_eq [Bddapron.Domainlevel1.Level0]
is_eq [Bddapron.Domainlevel1.Level1]
Inclusion and equality tests
is_eq [Bddapron.Domain0]
is_eq [Bddapron.Bdddomain0.O]
is_eq [Bddapron.Bdddomain0]
Inclusion and equality tests
is_eq [Bddapron.Mtbdddomain0.O]
is_eq [Bddapron.Mtbdddomain0]
Inclusion and equality tests
is_eq [Bddapron.Expr1.O.Bool]
is_eq [Bddapron.Expr1.Bool]
is_eq [Bddapron.Expr0.O.Bool]
is_eq [Bddapron.Expr0.Bool]
is_eq [Bddapron.ApronDD]
is_eq [Bddapron.Env]
Test equality of environments in terms of types and variables (but not in term of indexes)
is_eq [Bdd.Domain1.O]
is_eq [Bdd.Domain1]
is_eq [Bdd.Domain0.O]
is_eq [Bdd.Domain0]
is_eq [Bdd.Expr1.O.Bool]
is_eq [Bdd.Expr1.Bool]
is_eq [Bdd.Expr0.O.Bool]
is_eq [Bdd.Expr0.Bool]
is_eq [Bdd.Cond]
is_eq [Bdd.Env]
Test equality of environments in terms of types and variables (but not in term of indexes)
is_eq [Apron.Abstract1]
Equality test.
is_eq [Apron.Abstract0]
Equality test.
is_equal [Bdd.Domain0.O.Asssub]
is_equal [Cudd.Add]
Equality test
is_equal [Cudd.Mtbddc]
is_equal [Cudd.Mtbdd]
is_equal [Cudd.Vdd]
is_equal [Cudd.Bdd]
Are the two BDDs equal ?
is_equal_when [Cudd.Add]
is_equal_when [Cudd.Mtbddc]
is_equal_when [Cudd.Mtbdd]
is_equal_when [Cudd.Vdd]
is_equal_when [Cudd.Bdd]
Variation of Cudd_EquivDC.
is_eval_cst [Cudd.Add]
Variation of Cuddaux_addEvalConst/Cudd_addEvalConst.
is_eval_cst [Cudd.Mtbddc]
is_eval_cst [Cudd.Mtbdd]
is_eval_cst [Cudd.Vdd]
is_eval_cst_u [Cudd.Mtbddc]
is_eval_cst_u [Cudd.Mtbdd]
is_false [Bddapron.Expr2.Bool]
is_false [Bddapron.Expr2.O.Bool]
is_false [Bddapron.Expr1.O.Bool]
is_false [Bddapron.Expr1.Bool]
is_false [Bddapron.Expr0.O.Bool]
is_false [Bddapron.Expr0.Bool]
is_false [Bdd.Expr1.O.Bool]
is_false [Bdd.Expr1.Bool]
is_false [Bdd.Expr0.O.Bool]
is_false [Bdd.Expr0.Bool]
is_false [Cudd.Bdd]
Is it a false BDD ?
is_hedge [SHGraph.Compare]
is_hedge [SHGraph.S]
is_hedge [SHGraph]
is_hedge [PSHGraph]
is_included_in [Cudd.Bdd]
is_indet [Bdd.Reg.Minterm]
Is the minterm completely non-determinated ? (ie, contain only undefined values)
is_infty [Apron.Scalar]
Infinity test.
is_integer [Apron.Linexpr1]
Does the linear expression depend only on integer variables ?
is_integer [Mpf]
is_inter_empty [Cudd.Bdd]
Variation of Cudd_bddLeq.
is_inter_false [Bddapron.Expr1.O.Bool]
is_inter_false [Bddapron.Expr1.Bool]
is_inter_false [Bdd.Expr1.O.Bool]
is_inter_false [Bdd.Expr1.Bool]
is_interval [Apron.Coeff]
is_interval_cst [Apron.Texpr1]
is_interval_cst [Apron.Texpr0]
is_interval_linear [Apron.Texpr1]
is_interval_linear [Apron.Texpr0]
is_interval_polyfrac [Apron.Texpr1]
is_interval_polyfrac [Apron.Texpr0]
is_interval_polynomial [Apron.Texpr1]
is_interval_polynomial [Apron.Texpr0]
is_ite_cst [Cudd.Add]
Is the result of ite constant, and if it is the case, what is its value ?
is_ite_cst [Cudd.Mtbddc]
is_ite_cst [Cudd.Mtbdd]
is_ite_cst [Cudd.Vdd]
is_ite_cst [Cudd.Bdd]
is_ite_cst_u [Cudd.Mtbddc]
is_ite_cst_u [Cudd.Mtbdd]
is_leq [Bddapron.Domain1]
is_leq [Bddapron.Domainlevel1.Level0]
is_leq [Bddapron.Domainlevel1.Level1]
is_leq [Bddapron.Domain0]
is_leq [Bddapron.Bdddomain0.O]
is_leq [Bddapron.Bdddomain0]
is_leq [Bddapron.Mtbdddomain0.O]
is_leq [Bddapron.Mtbdddomain0]
is_leq [Bddapron.Expr1.O.Bool]
is_leq [Bddapron.Expr1.Bool]
is_leq [Bddapron.Expr0.O.Bool]
is_leq [Bddapron.Expr0.Bool]
is_leq [Bddapron.ApronDD]
is_leq [Bddapron.Env]
Test inclusion of environments in terms of types and variables (but not in term of indexes)
is_leq [Bdd.Domain1.O]
is_leq [Bdd.Domain1]
is_leq [Bdd.Domain0.O]
is_leq [Bdd.Domain0]
is_leq [Bdd.Expr1.O.Bool]
is_leq [Bdd.Expr1.Bool]
is_leq [Bdd.Expr0.O.Bool]
is_leq [Bdd.Expr0.Bool]
is_leq [Bdd.Cond]
is_leq [Bdd.Env]
Test inclusion of environments in terms of types and variables (but not in term of indexes)
is_leq [Apron.Abstract1]
Inclusion test.
is_leq [Apron.Abstract0]
Inclusion test.
is_leq [Apron.Interval]
Inclusion test.
is_leq [Cudd.Add]
is_leq [Cudd.Bdd]
is_leq_when [Cudd.Bdd]
Variation of Cudd_bddLeqUnless.
is_oct [Oct.Abstract1]
Return true iff the argument value is an oct value
is_oct [Oct.Abstract0]
Return true iff the argument value is an oct value
is_one [Bddapron.ApronexprDD]
is_polka [Polka.Abstract1]
is_polka [Polka.Abstract0]
is_polka_equalities [Polka.Abstract1]
Return true iff the argument manager is a polka value
is_polka_equalities [Polka.Abstract0]
Return true iff the argument manager is a polka value
is_polka_loose [Polka.Abstract1]
is_polka_loose [Polka.Abstract0]
is_polka_strict [Polka.Abstract1]
is_polka_strict [Polka.Abstract0]
is_polkagrid [PolkaGrid.Abstract1]
Return true iff the argument manager is a polkagrid value
is_polkagrid [PolkaGrid.Abstract0]
Return true iff the argument manager is a polkagrid value
is_ppl [Ppl.Abstract1]
is_ppl [Ppl.Abstract0]
is_ppl_grid [Ppl.Abstract1]
Return true iff the argument manager is a ppl value
is_ppl_grid [Ppl.Abstract0]
Return true iff the argument manager is a ppl value
is_ppl_loose [Ppl.Abstract1]
is_ppl_loose [Ppl.Abstract0]
is_ppl_strict [Ppl.Abstract1]
is_ppl_strict [Ppl.Abstract0]
is_real [Apron.Linexpr1]
Does the linear expression depend only on real variables ?
is_scalar [Apron.Texpr1]
is_scalar [Apron.Texpr0]
is_scalar [Apron.Coeff]
is_top [Bddapron.Domain1]
is_top [Bddapron.Domainlevel1.Level0]
is_top [Bddapron.Domainlevel1.Level1]
Emtpiness and Universality tests
is_top [Bddapron.Domain0]
is_top [Bddapron.Bdddomain0.O]
is_top [Bddapron.Bdddomain0]
Emtpiness and Universality tests
is_top [Bddapron.Mtbdddomain0.O]
is_top [Bddapron.Mtbdddomain0]
Emtpiness and Universality tests
is_top [Bddapron.ApronDD]
is_top [Bdd.Domain1.O]
is_top [Bdd.Domain1]
is_top [Bdd.Domain0.O]
is_top [Bdd.Domain0]
is_top [Apron.Abstract1]
Universality test
is_top [Apron.Abstract0]
Universality test
is_top [Apron.Interval]
Does the interval represent the universe ([-oo,+oo]) ?
is_true [Bddapron.Expr2.Bool]
is_true [Bddapron.Expr2.O.Bool]
is_true [Bddapron.Expr1.O.Bool]
is_true [Bddapron.Expr1.Bool]
is_true [Bddapron.Expr0.O.Bool]
is_true [Bddapron.Expr0.Bool]
is_true [Bdd.Expr1.O.Bool]
is_true [Bdd.Expr1.Bool]
is_true [Bdd.Expr0.O.Bool]
is_true [Bdd.Expr0.Bool]
is_true [Cudd.Bdd]
Is it a true BDD ?
is_unsat [Apron.Lincons1]
Is the constraint not satisfiable ?
is_var_dependent [Cudd.Bdd]
is_var_essential [Cudd.Bdd]
is_var_in [Cudd.Add]
Cuddaux_IsVarIn.
is_var_in [Cudd.Mtbddc]
is_var_in [Cudd.Mtbdd]
is_var_in [Cudd.Vdd]
is_var_in [Cudd.Bdd]
Cuddaux_IsVarIn.
is_variable_unconstrained [Bdd.Domain1.O]
Tests
is_variable_unconstrained [Bdd.Domain1]
Tests
is_variable_unconstrained [Bdd.Domain0.O]
Tests
is_variable_unconstrained [Bdd.Domain0]
Tests
is_variable_unconstrained [Apron.Abstract1]
Is the variable unconstrained in the abstract value ? If yes, this means that the existential quantification of the dimension does not change the value.
is_vertex [SHGraph.Compare]
is_vertex [SHGraph.S]
is_vertex [SHGraph]
is_vertex [PSHGraph]
is_vertex [FGraph1.S]
is_vertex [FGraph1]
is_vertex [FGraph.S]
is_vertex [FGraph]
is_zero [Bddapron.Syntax]
is_zero [Bddapron.ApronexprDD]
is_zero [Apron.Coeff]
Is the coefficient equal to scalar 0 or interval 0,0 ?
is_zero [Apron.Interval]
Is the interval equal to 0,0 ?
ite [Bddapron.Expr1.O.Apron]
ite [Bddapron.Expr1.O.Benum]
ite [Bddapron.Expr1.O.Bint]
ite [Bddapron.Expr1.O.Bool]
If-then-else
ite [Bddapron.Expr1.O]
If-then-else operation
ite [Bddapron.Expr1.Apron]
ite [Bddapron.Expr1.Benum]
ite [Bddapron.Expr1.Bint]
ite [Bddapron.Expr1.Bool]
If-then-else
ite [Bddapron.Expr1]
If-then-else operation
ite [Bddapron.Expr0.O.Apron]
ite [Bddapron.Expr0.O.Benum]
ite [Bddapron.Expr0.O.Bint]
ite [Bddapron.Expr0.O.Bool]
ite [Bddapron.Expr0.O]
If-then-else operation
ite [Bddapron.Expr0.Apron]
ite [Bddapron.Expr0.Benum]
ite [Bddapron.Expr0.Bint]
ite [Bddapron.Expr0.Bool]
ite [Bddapron.Expr0]
If-then-else operation
ite [Bdd.Expr1.O.Benum]
ite [Bdd.Expr1.O.Bint]
ite [Bdd.Expr1.O.Bool]
If-then-else
ite [Bdd.Expr1.O]
If-then-else operation
ite [Bdd.Expr1.Benum]
ite [Bdd.Expr1.Bint]
ite [Bdd.Expr1.Bool]
If-then-else
ite [Bdd.Expr1]
If-then-else operation
ite [Bdd.Expr0.O.Benum]
ite [Bdd.Expr0.O.Bint]
ite [Bdd.Expr0.O.Bool]
If-then-else
ite [Bdd.Expr0.O]
If-then-else operation
ite [Bdd.Expr0.Benum]
ite [Bdd.Expr0.Bint]
ite [Bdd.Expr0.Bool]
If-then-else
ite [Bdd.Expr0]
If-then-else operation
ite [Bdd.Enum]
If-then-else operator.
ite [Bdd.Int]
ite [Bdd.Reg]
if-then-else operation.
ite [Cudd.Add]
ite [Cudd.Mtbddc]
ite [Cudd.Mtbdd]
ite [Cudd.Vdd]
ite [Cudd.Bdd]
ite_cst [Cudd.Add]
Cuddaux_addIteConstant/Cudd_addIteConstant.
ite_cst [Cudd.Mtbddc]
ite_cst [Cudd.Mtbdd]
ite_cst [Cudd.Vdd]
ite_cst [Cudd.Bdd]
iter [Bdd.Enum.Minterm]
Iter the function on all label of the given type contained in the minterm.
iter [Bdd.Int.Minterm]
Iterate the function on all the integer values represented by the argument minterm.
iter [Bdd.Reg.Minterm]
Iterate the function on all determinated minterms represented by the argument minterm.
iter [Sette]
iter f s applies f in turn to all elements of s.
iter [SetList.S]
iter f s applies f in turn to all elements of s.
iter [SetList]
iter f s applies f in turn to all elements of s.
iter [PSette]
iter f s applies f in turn to all elements of s.
iter [PMappe]
iter [PHashhe]
iter [PDMappe]
iter [PDHashhe]
iter [MultiSetList.S]
iter f s applies f in turn to all elements of s, with their occurence number.
iter [MultiSetList]
iter f s applies f in turn to all elements of s, with their occurence number.
iter [Mappe]
iter f m applies f to all bindings in map m.
iter [Ilist]
Ordinary iteration function for atoms
iter [Hashhe]
iter f tbl applies f to all bindings in table tbl.
iter [Sette.S]
iter f s applies f in turn to all elements of s.
iter [Mappe.S]
iter [DMappe.S]
iter [DMappe]
Iterate on bindings.
iter [Hashhe.S]
iter [DHashhe.S]
iter [DHashhe]
Iterate on bindings.
iter [Apron.Generator1]
Iter the function on the pair coefficient/variable of the underlying linear expression
iter [Apron.Lincons1]
Iter the function on the pair coefficient/variable of the underlying linear expression
iter [Apron.Linexpr1]
Iter the function on the pair coefficient/variable of the linear expression
iter [Apron.Linexpr0]
iter [Cudd.PWeakke]
iter [Cudd.Weakke.S]
iter f t calls f on each element of t, in some unspecified order.
iter [Cudd.Weakke]
iter2 [Bddapron.Bddleaf]
Applies f to all pairs (elt1,elt2) with elt1 in list1 and elt2 in list2.
iter_bdef_ordered [Bdd.Output]
Iterate on definitions of BDD identifiers, in a topological order.
iter_cond_ordered [Bdd.Output]
Iterate the function on all the registered conditions, from level 0 to higher levels.
iter_cube [Cudd.Add]
Similar to Cudd.Bdd.iter_cube
iter_cube [Cudd.Mtbddc]
iter_cube [Cudd.Mtbdd]
iter_cube [Cudd.Vdd]
iter_cube [Cudd.Bdd]
iter_cube_u [Cudd.Mtbddc]
iter_cube_u [Cudd.Mtbdd]
iter_edge [FGraph1.S]
iter_edge [FGraph1]
iter_edge [FGraph.S]
iter_edge [FGraph]
iter_hedge [SHGraph.S]
iter_hedge [SHGraph]
Iterates the function f hedge attrhedge succvertices predvertices to all hyperedges of the graph.
iter_hedge [PSHGraph]
iter_node [Cudd.Add]
Similar to Cudd.Bdd.iter_node
iter_node [Cudd.Mtbddc]
iter_node [Cudd.Mtbdd]
iter_node [Cudd.Vdd]
iter_node [Cudd.Bdd]
iter_ordered [Bdd.Env]
Iter on all finite-state variables declared in the database
iter_prime [Cudd.Bdd]
iter_vdef_ordered [Bdd.Output]
Iterate on definitions of MTBDD identifiers, in a topological order.
iter_vertex [SHGraph.S]
iter_vertex [SHGraph]
Iterates the function f vertex attrvertex succhedges predhedges to all vertices of the graph.
iter_vertex [PSHGraph]
iter_vertex [FGraph1.S]
iter_vertex [FGraph1]
iter_vertex [FGraph.S]
iter_vertex [FGraph]
iterconjdecomp [Cudd.Bdd]
Cudd_bddIterDisjDecomp.
iterdisjdecomp [Cudd.Bdd]
Cudd_bddGenConjDecomp.
ithvar [Cudd.Bdd]

J
j0 [Mpfr]
j1 [Mpfr]
jacobi [Mpz]
jn [Mpfr]
join [Bddapron.Domain1]
join [Bddapron.Domainlevel1.Level0]
join [Bddapron.Domainlevel1.Level1]
Meet and join
join [Bddapron.Domain0]
join [Bddapron.Bdddomain0.O]
join [Bddapron.Bdddomain0]
Meet and join
join [Bddapron.Mtbdddomain0.O]
join [Bddapron.Mtbdddomain0]
Meet and join
join [Bddapron.ApronDD]
join [Bdd.Domain1.O]
join [Bdd.Domain1]
join [Bdd.Domain0.O]
join [Bdd.Domain0]
join [Apron.Abstract1]
Join of 2 abstract values.
join [Apron.Abstract0]
Join of 2 abstract values.
join_array [Apron.Abstract1]
Join of a non empty array of abstract values.
join_array [Apron.Abstract0]
Join of a non empty array of abstract values.
join_with [Apron.Abstract1]
join_with [Apron.Abstract0]

K
kronecker [Mpz]
kronecker_si [Mpz]

L
label_of_typcode [Bdd.Enum]
Return the label associated to the given code interpreted as of type the given type.
labels [Bddapron.Env]
Return the list of labels (not variables)
labels [Bdd.Env]
Return the list of labels (not variables)
labels_of_typ [Bdd.Enum]
Return the array of labels defining the type
lce [Bddapron.Env]
Least common environment
lce [Bdd.Cond]
lce [Bdd.Env]
Least common environment
lce [Apron.Environment]
Compute the least common environment of 2 environment, that is, the environment composed of all the variables of the 2 environments.
lce_change [Apron.Environment]
Similar to the previous function, but returns also the transformations required to convert from e1 (resp.
lcm [Mpzf]
lcm [Mpz]
lcm_ui [Mpz]
leaves [Cudd.Add]
Returns the set of leaf values (excluding the background value)
leaves [Cudd.Mtbddc]
leaves [Cudd.Mtbdd]
leaves [Cudd.Vdd]
Returns the set of leaf values (excluding the background value)
leaves_u [Cudd.Mtbddc]
Returns the set of leaf values (excluding the background value)
leaves_u [Cudd.Mtbdd]
Returns the set of leaf values (excluding the background value)
legendre [Mpz]
length [PHashhe]
length [Ilist]
Return the ength of the list.
length [Hashhe]
length tbl returns the number of bindings in tbl.
length [Hashhe.S]
leq [Bddapron.Expr1.O.Bool]
Implication
leq [Bddapron.Expr1.Bool]
Implication
leq [Bddapron.Expr0.O.Bool]
leq [Bddapron.Expr0.Bool]
leq [Bdd.Expr1.O.Bool]
Implication
leq [Bdd.Expr1.Bool]
Implication
leq [Bdd.Expr0.O.Bool]
Implication
leq [Bdd.Expr0.Bool]
Implication
level_of_var [Cudd.Man]
lex [Bddapron.Lex]
lex [Apron.Apron_lexer]
lex_eol [Parse]
Function to call on line returns in lexer
licompaction [Cudd.Bdd]
lin_of_poly [Bddapron.Apronexpr]
lin_of_tree [Bddapron.Apronexpr]
lincons [Apron.Apron_parser]
lincons1_of_lexbuf [Apron.Parser]
lincons1_of_lstring [Apron.Parser]
lincons1_of_string [Apron.Parser]
linexpr [Apron.Apron_parser]
linexpr1_of_lexbuf [Apron.Parser]
linexpr1_of_string [Apron.Parser]
list [Print]
Print a list
list [Ilist]
Create a list element from a list.
list_of_cube [Cudd.Bdd]
Converts a cube into a list of pairs of a variable and a phase.
list_of_support [Cudd.Bdd]
Converts a support into a list of variables
listexpr1_of_lstring [Bddapron.Parser]
listexpr2_of_lstring [Bddapron.Parser]
lngamma [Mpfr]
lnot [Bdd.Reg]
Logical operations
log [Cudd.Add]
log [Mpfr]
log10 [Mpfr]
log1p [Mpfr]
log2 [Mpfr]
lucnum2_ui [Mpz]
lucnum_ui [Mpz]
lvar_split [Bddapron.Common]
Split the list of variable into a positive cube (support) of Boolean variables and an array of APRON dimensions

M
make [Bddapron.Expr1.O]
Creation from an expression without environment
make [Bddapron.Expr1]
make [Bddapron.ApronexprDD.Condition]
make [Bddapron.Cond.O]
make [Bddapron.Cond]
make [Bddapron.Env.O]
Create a new database.
make [Bddapron.Env]
Create a new environment.
make [Bddapron.Apronexpr.Condition]
make [Bdd.Expr1.O]
make [Bdd.Expr1]
make [Bdd.Cond]
make [Bdd.Env.O]
make [Bdd.Env]
Create a new environment.
make [Rational]
make [PSette]
Internal, do not use
make [PSHGraph]
make [Apron.Tcons1]
Make a tree expression constraint.
make [Apron.Generator1]
Make a generator.
make [Apron.Lincons1]
Make a linear constraint.
make [Apron.Linexpr1]
Build a linear expression defined on the given argument, which is sparse by default.
make [Apron.Environment]
Making an environment from a set of integer and real variables.
make [Apron.Tcons0]
Make a tree expression constraint.
make [Apron.Generator0]
Making a generator.
make [Apron.Lincons0]
Make a linear constraint.
make [Apron.Linexpr0]
Create a linear expression.
make_bdd [Bddapron.Domain1]
Make a bdd manager from an APRON manager
make_bdd [Bddapron.Domain0]
Make a bdd manager from an APRON manager
make_bdd [Bdd.Output]
Functions
make_common [Cudd.User]
make_d [Cudd.Man]
make_exist [Cudd.Add]
make_exist [Cudd.User]
Make an existential quantification operation, with the given memoization policy, and the given underlying binary operation, assumed to be commutative and idempotent, that combines the two branch of the diagram when a decision is quantified out.
make_existand [Cudd.Add]
make_existand [Cudd.User]
make_existandop1 [Cudd.Add]
make_existandop1 [Cudd.User]
make_existop1 [Cudd.Add]
make_existop1 [Cudd.User]
make_global [Bddapron.ApronDD]
make_info [Bdd.Decompose]
Builds a temporary record of type info which gathers various informations on environment and condition.
make_man [Bddapron.Policy.Mtbdddomain0]
make_man [Bddapron.Bdddomain1]
Makes a BDDAPRON manager from an APRON manager, and fills options with default values
make_man [Bddapron.Mtbdddomain1]
Makes a BDDAPRON manager from an APRON manager.
make_man [Bddapron.Bdddomain0]
Makes a BDDAPRON manager from an APRON manager, and fills options with default values
make_man [Bddapron.Mtbdddomain0]
Makes a BDDAPRON manager from an APRON manager.
make_man [Bddapron.ApronDD]
make_mtbdd [Bddapron.Policy.Domain0]
make_mtbdd [Bddapron.Domain1]
Make a mtbdd manager from an APRON manager
make_mtbdd [Bddapron.Domain0]
Make a mtbdd manager from an APRON manager
make_mtbdd [Bdd.Output]
make_mtbddc [Bdd.Output]
Create a database for printing MTBDDs
make_op1 [Cudd.Add]
Making operations
make_op1 [Cudd.User]
Makes a binary operation, with the given memoization policy.
make_op2 [Cudd.Add]
make_op2 [Cudd.User]
Makes a binary operation, with the given memoization policy.
make_op3 [Cudd.Add]
make_op3 [Cudd.User]
make_opG [Cudd.Add]
make_opG [Cudd.User]
make_opN [Cudd.Add]
make_opN [Cudd.User]
make_op_join [Bddapron.ApronDD]
make_string [Bddapron.Env]
make_string XXX = make ~symbol:string_symbol XXX
make_string [Bdd.Env]
make_string XXX = make ~symbol:string_symbol XXX
make_symbol [Bddapron.Env]
Generic function for creating a manager for symbols Default values are Pervasives.compare, Bddapron.Env.marshal and Bddapron.Env.unmarshal.
make_symbol [Bdd.Env]
Generic function for creating a manager for symbols.
make_table [Bddapron.ApronDD]
make_table [Cudd.Mtbddc]
Building a table
make_table [Cudd.Mtbdd]
Building a table
make_test2 [Cudd.Add]
make_test2 [Cudd.User]
Register a binary test, with the given memoization policy,
make_unique [Bddapron.Bddleaf]
Remove duplicatas (by reconstructing the list)
make_unsat [Apron.Lincons1]
Build the unsatisfiable constraint -1>=0
make_v [Cudd.Man]
Variation of Cudd_Init.
make_value [Bddapron.Cond]
make_value [Bddapron.Env]
Constructor
make_value [Bdd.Cond]
make_value [Bdd.Env]
Constructor
make_vdd [Bdd.Output]
man_get_apron [Bddapron.Domain1]
man_get_apron [Bddapron.Domain0]
man_is_bdd [Bddapron.Domain1]
Return true iff the argument manager is a bdd manager
man_is_bdd [Bddapron.Domain0]
Return true iff the argument manager is a bdd manager
man_is_mtbdd [Bddapron.Domain1]
Return true iff the argument manager is a mtbdd manager
man_is_mtbdd [Bddapron.Domain0]
Return true iff the argument manager is a mtbdd manager
man_of_bdd [Bddapron.Domain1]
Makes a bdd manager generic
man_of_bdd [Bddapron.Domain0]
Makes a bdd manager generic
man_of_mtbdd [Bddapron.Domain1]
Makes a mtbdd manager generic
man_of_mtbdd [Bddapron.Domain0]
Makes a mtbdd manager generic
man_to_bdd [Bddapron.Domain1]
Instanciate the type of a bdd manager.
man_to_bdd [Bddapron.Domain0]
Instanciate the type of a bdd manager.
man_to_mtbdd [Bddapron.Domain1]
Instanciate the type of a mtbdd manager.
man_to_mtbdd [Bddapron.Domain0]
Instanciate the type of a mtbdd manager.
manager [Apron.Policy]
Policy, general
manager [Apron.Abstract1]
manager [Apron.Abstract0]
manager [Cudd.Add]
Returns the manager associated to the ADD
manager [Cudd.Mtbddc]
Returns the manager associated to the MTBDD
manager [Cudd.Mtbdd]
Returns the manager associated to the MTBDD
manager [Cudd.Vdd]
manager [Cudd.Bdd]
Returns the manager associated to the BDD
manager_alloc [T1p]
Create a Taylor1+ manager.
manager_alloc [PolkaGrid]
Create a PolkaGrid manager from a (loose or strict) polka manager, and a PPL grid manager
manager_alloc [Oct]
Allocate a new manager to manipulate octagons.
manager_alloc [Box]
Create a Box manager.
manager_alloc [Apron.Disjunction]
manager_alloc_equalities [Polka]
Create a NewPolka manager for conjunctions of linear equalities.
manager_alloc_grid [Ppl]
Allocate a new manager for linear congruences (grids)
manager_alloc_loose [Ppl]
Allocate a PPL manager for loose convex polyhedra.
manager_alloc_loose [Polka]
Create a NewPolka manager for loose convex polyhedra.
manager_alloc_strict [Ppl]
Allocate a PPL manager for strict convex polyhedra.
manager_alloc_strict [Polka]
Create a NewPolka manager for strict convex polyhedra.
manager_decompose [PolkaGrid]
Decompose the manager
manager_decompose [Apron.Disjunction]
manager_get_internal [Polka]
Get the internal submanager of a NewPolka manager.
manager_get_internal [Oct]
No internal parameters for now...
manager_get_manager [Bddapron.Policy.Mtbdddomain0]
manager_get_manager [Bddapron.Policy.Domain0]
manager_get_manager [Bddapron.Policy.Domain1]
manager_get_manager [Apron.Policy]
manager_is_box [Box]
Return true iff the argument manager is a box manager
manager_is_disjunction [Apron.Disjunction]
Return true iff the argument manager is a disjunction manager
manager_is_oct [Oct]
Return true iff the argument manager is an octagon manager
manager_is_polka [Polka]
manager_is_polka_equalities [Polka]
Return true iff the argument manager is a polka manager
manager_is_polka_loose [Polka]
manager_is_polka_strict [Polka]
manager_is_polkagrid [PolkaGrid]
Return true iff the argument manager is a polkagrid manager
manager_is_ppl [Ppl]
Type conversions
manager_is_ppl_grid [Ppl]
Return true iff the argument manager is a ppl manager
manager_is_ppl_loose [Ppl]
manager_is_ppl_strict [Ppl]
manager_of_box [Box]
Make a box manager generic
manager_of_disjunction [Apron.Disjunction]
Make a disjunction manager generic
manager_of_oct [Oct]
Make an octagon manager generic
manager_of_polka [Polka]
manager_of_polka_equalities [Polka]
Makes a polka manager generic
manager_of_polka_loose [Polka]
manager_of_polka_strict [Polka]
manager_of_polkagrid [PolkaGrid]
Makes a polkagrid manager generic
manager_of_ppl [Ppl]
manager_of_ppl_grid [Ppl]
Make a ppl manager generic
manager_of_ppl_loose [Ppl]
manager_of_ppl_strict [Ppl]
manager_to_box [Box]
Instanciate the type of a box manager.
manager_to_disjunction [Apron.Disjunction]
Instanciate the type of a disjunction manager.
manager_to_oct [Oct]
Instanciate the type of an octagon manager.
manager_to_polka [Polka]
manager_to_polka_equalities [Polka]
Instanciate the type of a polka manager.
manager_to_polka_loose [Polka]
manager_to_polka_strict [Polka]
manager_to_polkagrid [PolkaGrid]
Instanciate the type of a polkagrid manager.
manager_to_ppl [Ppl]
manager_to_ppl_grid [Ppl]
Instanciate the type of a ppl manager.
manager_to_ppl_loose [Ppl]
manager_to_ppl_strict [Ppl]
mand [Bdd.Expr0.O.Expr]
map [Bdd.Enum.Minterm]
Apply the function to all label of the given type contained in the minterm and return the list of the results.
map [Bdd.Int.Minterm]
Apply the function to all integer values represented by the argument minterm and return the list of the results.
map [Bdd.Reg.Minterm]
Apply the function to all determinated minterms represented by the argument minterm and return the list of the results.
map [SHGraph.S]
map [SHGraph]
map [PSHGraph]
map [PMappe]
map [PHashhe]
map [Mappe]
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a.
map [Ilist]
Ordinary map function
map [Hashhe]
map f tbl applies f to all bindings in table tbl and creates a new hashtable associating the results of f to the same key type.
map [FGraph1.S]
map [FGraph1]
map [FGraph.S]
map [FGraph]
map [Mappe.S]
map [Hashhe.S]
map_atom [Bdd.Expr0.O.Expr]
map_cnf [Bdd.Normalform]
map_conjunction [Bdd.Normalform]
map_disjunction [Bdd.Normalform]
map_dnf [Bdd.Normalform]
map_edge [FGraph1.S]
map_edge [FGraph1]
map_edge [FGraph.S]
map_edge [FGraph]
map_info [FGraph1.S]
map_info [FGraph1]
map_info [FGraph.S]
map_info [FGraph]
map_op1 [Cudd.Add]
map_op1 [Cudd.User]
map_op2 [Cudd.Add]
map_op2 [Cudd.User]
map_op3 [Cudd.Add]
map_op3 [Cudd.User]
map_opN [Cudd.Add]
map_opN [Cudd.User]
map_term [Bdd.Expr0.O.Expr]
map_test2 [Cudd.Add]
map_test2 [Cudd.User]
map_tree [Bdd.Normalform]
map_vertex [FGraph1.S]
map_vertex [FGraph1]
map_vertex [FGraph.S]
map_vertex [FGraph]
mapbinop [Bddapron.Env]
mapbinop [Bdd.Env]
mapbinope [Bddapron.Env]
mapbinope [Bdd.Env]
mapi [PMappe]
mapi [Mappe]
Same as map, but the function receives as arguments both the key and the associated value for each binding of the map.
mapi [Mappe.S]
mapleaf1 [Cudd.Add]
mapleaf1 [Cudd.Mapleaf]
Return the MTBDD \/ guard -> f leaf
mapleaf2 [Cudd.Add]
mapleaf2 [Cudd.Mapleaf]
Return the MTBDD \/ guard1 /\ guard2 -> f leaf1 leaf2
mapofset [PMappe]
mapofset [Mappe]
mapofset f s returns the map associating f key to key, for each element key of the set s
mapofset [Mappe.S]
mapterop [Bddapron.Env]
mapterop [Bdd.Env]
maptoset [PMappe]
maptoset [Mappe]
maptoset m returns the set of the keys in the association table
maptoset [Mappe.S]
mapunop [Bddapron.Env]
mapunop [Bdd.Env]
mapx [PDMappe]
mapx [DMappe.S]
mapx [DMappe]
mapy [PDMappe]
mapy [DMappe.S]
mapy [DMappe]
Return the correspondance map resp.
marshal [Bddapron.Env]
Safe marshalling function, generating strings without NULL characters.
marshal [Bdd.Env]
Safe marshalling function, generating strings without NULL characters.
matrix_multiply [Cudd.Add]
Variation of Cudd_addMatrixMultiply.
max [SHGraph.Compare]
max [SHGraph.S]
max [SHGraph]
Return the set of vertices without successor hyperedges
max [PSHGraph]
max [MultiSetList.S]
Return an element with the maximum occurence number, or raise Not_found if the multiset is empty.
max [MultiSetList]
Return an element with the maximum occurence number, or raise Not_found if the multiset is empty.
max [FGraph1.S]
max [FGraph1]
max [FGraph.S]
max [FGraph]
max [Cudd.Add]
max [Mpfr]
max_elt [Sette]
Same as min_elt, but returns the largest element of the given set.
max_elt [SetList.S]
Same as min_elt, but returns the largest element of the given set.
max_elt [SetList]
Same as min_elt, but returns the largest element of the given set.
max_elt [PSette]
Same as min_elt, but returns the largest element of the given set.
max_elt [MultiSetList.S]
Same as min_elt, but returns the largest element of the given multiset.
max_elt [MultiSetList]
Same as min_elt, but returns the largest element of the given multiset.
max_elt [Sette.S]
Same as Sette.S.min_elt, but returns the largest element of the given set.
max_key [PMappe]
max_key [Mappe]
Same as min_elt, but returns the largest key of the given map.
max_key [Mappe.S]
maxcode_of_typ [Bdd.Enum]
Return the maximal integer corresponding to a label belonging to the type.
maxs [MultiSetList.S]
Return the set of elements with the maximum occurence number, or raise Not_found if the multiset is empty.
maxs [MultiSetList]
Return the set of elements with the maximum occurence number, or raise Not_found if the multiset is empty.
mean [Statistic]
Returns the mean of the array.
meet [Bddapron.Domain1]
meet [Bddapron.Domainlevel1.Level0]
meet [Bddapron.Domainlevel1.Level1]
meet [Bddapron.Domain0]
meet [Bddapron.Bdddomain0.O]
meet [Bddapron.Bdddomain0]
meet [Bddapron.Mtbdddomain0.O]
meet [Bddapron.Mtbdddomain0]
meet [Bddapron.ApronDD]
meet [Bdd.Domain1.O]
meet [Bdd.Domain1]
meet [Bdd.Domain0.O]
meet [Bdd.Domain0]
meet [Apron.Abstract1]
Meet of 2 abstract values.
meet [Apron.Abstract0]
Meet of 2 abstract values.
meet_apply [Apron.Policy.Abstract1]
meet_apply [Apron.Policy.Abstract0]
meet_array [Apron.Abstract1]
Meet of a non empty array of abstract values.
meet_array [Apron.Abstract0]
Meet of a non empty array of abstract values.
meet_array_apply [Apron.Policy.Abstract1]
meet_array_apply [Apron.Policy.Abstract0]
meet_array_improve [Apron.Policy.Abstract1]
meet_array_improve [Apron.Policy.Abstract0]
meet_condition [Bddapron.Domain1]
meet_condition [Bddapron.Domainlevel1.Level0]
meet_condition [Bddapron.Domainlevel1.Level1]
meet_condition [Bddapron.Domain0]
meet_condition [Bddapron.Bdddomain0.O]
meet_condition [Bddapron.Bdddomain0]
Intersection with a Boolean expression (that may involve numerical constraints)
meet_condition [Bddapron.Mtbdddomain0.O]
meet_condition [Bddapron.Mtbdddomain0]
Intersection with a Boolean expression (that may involve numerical constraints)
meet_condition [Bdd.Domain1.O]
Lattice operations
meet_condition [Bdd.Domain1]
Lattice operations
meet_condition [Bdd.Domain0.O]
Lattice operations
meet_condition [Bdd.Domain0]
Lattice operations
meet_condition2 [Bddapron.Domain1]
meet_condition2 [Bddapron.Domainlevel1.Level1]
Intersection with a Boolean expression (that may involve numerical constraints)
meet_condition2_apply [Bddapron.Policy.Domain1]
meet_condition2_improve [Bddapron.Policy.Domain1]
meet_condition_apply [Bddapron.Policy.Mtbdddomain0]
meet_condition_apply [Bddapron.Policy.Domain0]
meet_condition_apply [Bddapron.Policy.Domain1]
meet_condition_improve [Bddapron.Policy.Mtbdddomain0]
meet_condition_improve [Bddapron.Policy.Domain0]
meet_condition_improve [Bddapron.Policy.Domain1]
meet_cube [Bddapron.Bdddomain0.O.L]
meet_idcondb [Bddapron.Mtbdddomain0.O]
meet_improve [Apron.Policy.Abstract1]
meet_improve [Apron.Policy.Abstract0]
meet_lincons_array [Apron.Abstract1]
Meet of an abstract value with an array of linear constraints.
meet_lincons_array [Apron.Abstract0]
Meet of an abstract value with an array of linear constraints.
meet_lincons_array_apply [Apron.Policy.Abstract1]
meet_lincons_array_apply [Apron.Policy.Abstract0]
meet_lincons_array_improve [Apron.Policy.Abstract1]
meet_lincons_array_improve [Apron.Policy.Abstract0]
meet_lincons_array_with [Apron.Abstract1]
meet_lincons_array_with [Apron.Abstract0]
meet_lincons_array_with_apply [Apron.Policy.Abstract1]
meet_lincons_array_with_apply [Apron.Policy.Abstract0]
meet_tcons_array [Bddapron.ApronDD]
meet_tcons_array [Apron.Abstract1]
Meet of an abstract value with an array of tree expressions constraints.
meet_tcons_array [Apron.Abstract0]
Meet of an abstract value with an array of tree expression constraints.
meet_tcons_array_apply [Apron.Policy.Abstract1]
meet_tcons_array_apply [Apron.Policy.Abstract0]
meet_tcons_array_improve [Apron.Policy.Abstract1]
meet_tcons_array_improve [Apron.Policy.Abstract0]
meet_tcons_array_with [Apron.Abstract1]
meet_tcons_array_with [Apron.Abstract0]
meet_tcons_array_with_apply [Apron.Policy.Abstract1]
meet_tcons_array_with_apply [Apron.Policy.Abstract0]
meet_with [Apron.Abstract1]
meet_with [Apron.Abstract0]
meet_with_apply [Apron.Policy.Abstract1]
meet_with_apply [Apron.Policy.Abstract0]
mem [Sette.Compare]
mem [Sette]
mem x s tests whether x belongs to the set s.
mem [SetList.S]
mem x s tests whether x belongs to the set s.
mem [SetList]
mem x s tests whether x belongs to the set s.
mem [PSette]
mem x s tests whether x belongs to the set s.
mem [PMappe]
mem [PHashhe]
mem [MultiSetList.S]
mem x s tests whether x belongs to the multiset s.
mem [MultiSetList]
mem x s tests whether x belongs to the multiset s.
mem [Mappe.Compare]
mem [Mappe]
mem x m returns true if m contains a binding for m, and false otherwise.
mem [Ilist]
Membership test.
mem [Hashhe.Compare]
mem [Hashhe]
mem tbl x checks if x is bound in tbl.
mem [Sette.S]
mem x s tests whether x belongs to the set s.
mem [Mappe.S]
mem [Hashhe.S]
mem [Cudd.PWeakke]
mem [Cudd.Weakke.Compare]
mem [Cudd.Weakke.S]
mem t x returns true if there is at least one instance of x in t, false otherwise.
mem [Cudd.Weakke]
mem_label [Bddapron.Env]
Is the label a label defined in the database ?
mem_label [Bdd.Env]
Is the label a label defined in the database ?
mem_typ [Bddapron.Env]
Is the type defined in the database ?
mem_typ [Bdd.Env]
Is the type defined in the database ?
mem_typcode [Bdd.Enum]
Does the integer code some label of the given type ?
mem_var [Bddapron.Env]
Is the label/var defined in the database ?
mem_var [Bdd.Env]
Is the label/var defined in the database ?
mem_var [Apron.Environment]
Return true if the variable is present in the environment.
memx [PDMappe]
memx [PDHashhe]
memx [DMappe.S]
memx [DMappe]
Is the object in the map ?
memx [DHashhe.S]
memx [DHashhe]
Is the object registered ?
memy [PDMappe]
memy [PDHashhe]
memy [DMappe.S]
memy [DMappe]
Is the object in the map ?
memy [DHashhe.S]
memy [DHashhe]
Is the object registered ?
merge [PMappe]
merge [PDMappe]
merge [Mappe.Compare]
merge [Mappe]
merge mergedata a b is similar to addmap a b, but if a key k is bound to d1 in m1 and to d2 in m2, the key k is bound to mergedata d1 d2 in the result
merge [Mappe.S]
merge [DMappe.S]
merge [DMappe]
Merge the two double associations.
merge [Cudd.PWeakke]
merge [Cudd.Weakke.Compare]
merge [Cudd.Weakke.S]
merge t x returns an instance of x found in t if any, or else adds x to t and return x.
merge [Cudd.Weakke]
merge_map [Cudd.PWeakke]
merge_map [Cudd.Weakke.Compare]
merge_map [Cudd.Weakke.S]
Variant of merge: merge_map t x f is equivalent to try find t x with Not_found -> let y = f x in add t y; Some y.
merge_map [Cudd.Weakke]
mergei [PMappe]
mergei [Mappe.Compare]
mergei [Mappe]
Same as merge, but the function receives as arguments the key (of the first map)
mergei [Mappe.S]
min [SHGraph.Compare]
min [SHGraph.S]
min [SHGraph]
Return the set of vertices without predecessor hyperedges
min [PSHGraph]
min [MultiSetList.S]
Return an element with the minimum occurence number, or raise Not_found if the multiset is empty.
min [MultiSetList]
Return an element with the minimum occurence number, or raise Not_found if the multiset is empty.
min [FGraph1.S]
min [FGraph1]
min [FGraph.S]
min [FGraph]
min [Cudd.Add]
min [Mpfr]
min_elt [Sette]
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
min_elt [SetList.S]
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
min_elt [SetList]
Return the smallest element of the given set (with respect to the Pervasives.compare ordering), or raise Not_found if the set is empty.
min_elt [PSette]
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
min_elt [MultiSetList.S]
Return the smallest element of the given multiset (with respect to the Pervasives.compare ordering), or raise Not_found if the multiset is empty.
min_elt [MultiSetList]
Return the smallest element of the given multiset (with respect to the Pervasives.compare ordering), or raise Not_found if the multiset is empty.
min_elt [Sette.S]
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
min_key [PMappe]
min_key [Mappe]
Return the smallest key of the given map or raise Not_found if the set is empty.
min_key [Mappe.S]
min_size [Bdd.Reg]
min_size cst computes the minimum number of bits required to represent the given constant.
minimize [Apron.Abstract1]
Minimize the size of the representation of the value.
minimize [Apron.Linexpr1]
In case of sparse representation, remove zero coefficients
minimize [Apron.Abstract0]
Minimize the size of the representation of the value.
minimize [Apron.Linexpr0]
In case of sparse representation, remove zero coefficients
minimize [Cudd.Bdd]
minimize_environment [Apron.Abstract1]
Remove from the environment of the abstract value and from the abstract value itself variables that are unconstrained in it.
minimize_environment_with [Apron.Abstract1]
mins [MultiSetList.S]
Return the set of elements with the minimum occurence number, or raise Not_found if the multiset is empty.
mins [MultiSetList]
Return the set of elements with the minimum occurence number, or raise Not_found if the multiset is empty.
minterm_of_tree [Bdd.Normalform]
Decompose a decision tree into a disjunction of pairs of a formula and a leaf.
modf [Mpfr]
mtbdd_of_mtbdddomain [Bddapron.Domain1]
Make a mtbdd manager from an underlying BDDAPRON manager
mtbdd_of_mtbdddomain [Bddapron.Domain0]
Make a mtbdd manager from an underlying BDDAPRON manager
mul [Bddapron.Expr1.O.Apron]
mul [Bddapron.Expr1.O.Bint]
mul [Bddapron.Expr1.Apron]
mul [Bddapron.Expr1.Bint]
mul [Bddapron.Expr0.O.Apron]
mul [Bddapron.Expr0.O.Bint]
mul [Bddapron.Expr0.Apron]
mul [Bddapron.Expr0.Bint]
mul [Bddapron.ApronexprDD]
mul [Bddapron.Apronexpr.Poly]
mul [Bddapron.Apronexpr]
mul [Bdd.Expr1.O.Bint]
mul [Bdd.Expr1.Bint]
mul [Bdd.Expr0.O.Bint]
mul [Bdd.Expr0.Bint]
mul [Bdd.Int]
mul [Bdd.Reg]
(Unsigned) multiplication
mul [Rational]
mul [Cudd.Add]
mul [Mpzf]
mul [Mpz]
mul [Mpqf]
mul [Mpq]
mul [Mpfrf]
mul [Mpfr]
mul [Mpf]
mul_2exp [Mpz]
mul_2exp [Mpq]
mul_2exp [Mpfr]
mul_2exp [Mpf]
mul_2si [Mpfr]
mul_2ui [Mpfr]
mul_int [Mpzf]
mul_q [Mpfr]
mul_si [Mpz]
mul_ui [Mpfrf]
mul_ui [Mpfr]
mul_ui [Mpf]
mul_z [Mpfr]
mult [MultiSetList.S]
mult elt mset returns the number of occurences of the element elt in the multiset mset.
mult [MultiSetList]
mult elt mset returns the number of occurences of the element elt in the multiset mset.

N
nan_p [Mpfrf]
nan_p [Mpfr]
nand [Bddapron.Expr1.O.Bool]
nand [Bddapron.Expr1.Bool]
nand [Bddapron.Expr0.O.Bool]
nand [Bddapron.Expr0.Bool]
nand [Bdd.Expr1.O.Bool]
nand [Bdd.Expr1.Bool]
nand [Bdd.Expr0.O.Bool]
nand [Bdd.Expr0.Bool]
nand [Cudd.Bdd]
nanflag_p [Mpfr]
narrowing [Oct]
Standard narrowing.
nbleaves [Cudd.Add]
nbleaves [Cudd.Mtbddc]
nbleaves [Cudd.Mtbdd]
nbleaves [Cudd.Vdd]
nbminterms [Cudd.Add]
nbminterms [Cudd.Mtbddc]
nbminterms [Cudd.Mtbdd]
nbminterms [Cudd.Vdd]
nbminterms [Cudd.Bdd]
nbnonzeropaths [Cudd.Add]
nbnonzeropaths [Cudd.Mtbddc]
nbnonzeropaths [Cudd.Mtbdd]
nbnonzeropaths [Cudd.Vdd]
nbpaths [Cudd.Add]
nbpaths [Cudd.Mtbddc]
nbpaths [Cudd.Mtbdd]
nbpaths [Cudd.Vdd]
nbpaths [Cudd.Bdd]
nbtruepaths [Cudd.Bdd]
neg [Bddapron.Expr1.O.Bint]
neg [Bddapron.Expr1.Bint]
neg [Bddapron.Expr0.O.Bint]
neg [Bddapron.Expr0.Bint]
neg [Bdd.Expr1.O.Bint]
neg [Bdd.Expr1.Bint]
neg [Bdd.Expr0.O.Bint]
neg [Bdd.Expr0.Bint]
neg [Bdd.Int]
neg [Bdd.Reg]
Unary negation; be cautious, if the size of integer is n, the negation of -2^(n-1) is itself.
neg [Rational]
neg [Apron.Coeff]
Negation
neg [Apron.Interval]
Negation
neg [Apron.Scalar]
Negation
neg [Mpzf]
neg [Mpz]
neg [Mpqf]
neg [Mpq]
neg [Mpfrf]
neg [Mpfr]
neg [Mpf]
negate [Bddapron.Expr1.O.Apron]
negate [Bddapron.Expr1.Apron]
negate [Bddapron.Expr0.O.Apron]
negate [Bddapron.Expr0.Apron]
negate [Bddapron.ApronexprDD]
negate [Bddapron.Apronexpr.Condition]
negate [Bddapron.Apronexpr.Poly]
negate [Bddapron.Apronexpr.Lin]
negate [Bddapron.Apronexpr]
negate_cond [Bddapron.Cond]
neutral_join [Bddapron.ApronDD]
newpid [Cudd.User]
newpid [Cudd.Custom]
newvar [Cudd.Bdd]
newvar_at_level [Cudd.Bdd]
nextabove [Mpfr]
nextbelow [Mpfr]
nextprime [Mpz]
nexttoward [Mpfr]
nodes_below_level [Cudd.Add]
Cuddaux_NodesBelowLevel.
nodes_below_level [Cudd.Mtbddc]
nodes_below_level [Cudd.Mtbdd]
nodes_below_level [Cudd.Vdd]
Cuddaux_NodesBelowLevel.
nor [Bddapron.Expr1.O.Bool]
nor [Bddapron.Expr1.Bool]
nor [Bddapron.Expr0.O.Bool]
nor [Bddapron.Expr0.Bool]
nor [Bdd.Expr1.O.Bool]
nor [Bdd.Expr1.Bool]
nor [Bdd.Expr0.O.Bool]
nor [Bdd.Expr0.Bool]
nor [Cudd.Bdd]
normalize [Bddapron.Expr1.O.List]
normalize [Bddapron.Expr1.O]
normalize [Bddapron.Expr1.List]
normalize [Bddapron.Expr1]
normalize [Bddapron.Expr0.O]
normalize [Bddapron.Expr0]
normalize [Bddapron.Apronexpr.Poly]
normalize [Bddapron.Apronexpr.Lin]
normalize [Bddapron.Apronexpr]
normalize_as_constraint [Bddapron.Apronexpr.Poly]
normalize_as_constraint [Bddapron.Apronexpr.Lin]
normalize_as_constraint [Bddapron.Apronexpr]
normalize_full [Bddapron.Apronexpr.Poly]
normalize_monomial [Bddapron.Apronexpr.Poly]
normalize_with [Bdd.Cond]
Combine the two previous functions, and return the permutation
normalize_with [Bdd.Env]
Combine the two previous functions, and return the permutation
notfound [Bdd.Env]
number_p [Mpfrf]
number_p [Mpfr]
nxor [Bddapron.Expr1.O.Bool]
Exclusive or, not and, nor or and not xor
nxor [Bddapron.Expr1.Bool]
Exclusive or, not and, nor or and not xor
nxor [Bddapron.Expr0.O.Bool]
nxor [Bddapron.Expr0.Bool]
nxor [Bdd.Expr1.O.Bool]
Exclusive or, not and, nor or and not xor
nxor [Bdd.Expr1.Bool]
Exclusive or, not and, nor or and not xor
nxor [Bdd.Expr0.O.Bool]
Exclusive or, not and, nor or and not xor
nxor [Bdd.Expr0.Bool]
Exclusive or, not and, nor or and not xor
nxor [Cudd.Bdd]

O
obj [FGraph.S]
obj [FGraph]
obj [Sette.S]
obj [Mappe.S]
odd_p [Mpz]
of_apron [Bddapron.Domain1]
of_apron [Bddapron.Domainlevel1.Level0]
of_apron [Bddapron.Domainlevel1.Level1]
of_apron [Bddapron.Domain0]
of_apron [Bddapron.Bdddomain0.O]
of_apron [Bddapron.Bdddomain0]
of_apron [Bddapron.Mtbdddomain0.O]
of_apron [Bddapron.Mtbdddomain0]
of_apronexpr [Bddapron.ApronexprDD.Condition]
of_apronexpr [Bddapron.ApronexprDD]
of_array [Apron.Linexpr0]
of_bdd [Bddapron.Domain1]
Makes a pair (bdd manager,bdd abstract value) generic
of_bdd [Bddapron.Domain0]
Makes a pair (bdd manager,bdd abstract value) generic
of_bdd [Cudd.Add]
of_bddapron [Bddapron.Domain1]
of_bddapron [Bddapron.Domainlevel1.Level0]
of_bddapron [Bddapron.Domainlevel1.Level1]
of_bddapron [Bddapron.Domain0]
of_bddapron [Bddapron.Bdddomain0.O]
of_bddapron [Bddapron.Bdddomain0]
of_bddapron [Bddapron.Mtbdddomain0.O]
of_bddapron [Bddapron.Mtbdddomain0]
of_bool [Bddapron.Expr1.O.Bool]
of_bool [Bddapron.Expr1.Bool]
of_bool [Bddapron.Expr0.O.Bool]
of_bool [Bddapron.Expr0.Bool]
of_bool [Bdd.Expr1.O.Bool]
of_bool [Bdd.Expr1.Bool]
of_bool [Bdd.Expr0.O.Bool]
of_bool [Bdd.Expr0.Bool]
of_box [Box.Policy]
Make a box value generic
of_box [Box.Abstract1]
Make a box value generic
of_box [Box.Abstract0]
Make a box value generic
of_box [Apron.Abstract1]
Abstract an hypercube.
of_box [Apron.Abstract0]
Abstract an hypercube.
of_condition [Bddapron.ApronexprDD.Condition]
of_disjunction [Apron.Disjunction.Abstract1]
Make a disjunction value generic
of_disjunction [Apron.Disjunction.Abstract0]
Make a disjunction value generic
of_domain0 [Bdd.Domain1.O]
of_domain0 [Bdd.Domain1]
of_expr [Bddapron.Expr2.Bool]
of_expr [Bddapron.Expr2.O.Bool]
of_expr [Bddapron.Expr1.O.Apron]
of_expr [Bddapron.Expr1.O.Benum]
of_expr [Bddapron.Expr1.O.Bint]
of_expr [Bddapron.Expr1.O.Bool]
of_expr [Bddapron.Expr1.Apron]
of_expr [Bddapron.Expr1.Benum]
of_expr [Bddapron.Expr1.Bint]
of_expr [Bddapron.Expr1.Bool]
of_expr [Bddapron.Expr0.O.Apron]
of_expr [Bddapron.Expr0.O.Benum]
of_expr [Bddapron.Expr0.O.Bint]
of_expr [Bddapron.Expr0.O.Bool]
of_expr [Bddapron.Expr0.Apron]
of_expr [Bddapron.Expr0.Benum]
of_expr [Bddapron.Expr0.Bint]
of_expr [Bddapron.Expr0.Bool]
of_expr [Bddapron.ApronexprDD]
of_expr [Bddapron.Apronexpr.Tree]
of_expr [Bdd.Expr1.O.Benum]
of_expr [Bdd.Expr1.O.Bint]
of_expr [Bdd.Expr1.O.Bool]
of_expr [Bdd.Expr1.Benum]
of_expr [Bdd.Expr1.Bint]
of_expr [Bdd.Expr1.Bool]
of_expr [Bdd.Expr0.O.Benum]
of_expr [Bdd.Expr0.O.Bint]
of_expr [Bdd.Expr0.O.Bool]
of_expr [Bdd.Expr0.Benum]
of_expr [Bdd.Expr0.Bint]
of_expr [Bdd.Expr0.Bool]
of_expr [Apron.Texpr1]
General constructor (actually the most efficient)
of_expr [Apron.Texpr0]
General constructor (actually the most efficient
of_expr0 [Bddapron.Expr2.Bool]
Creation from an expression of level 0 (without environment)
of_expr0 [Bddapron.Expr2.O.Bool]
of_expr0 [Bddapron.Expr2.O]
of_expr0 [Bddapron.Expr2]
Creation from an expression of level 0 (without environment)
of_expr0 [Bddapron.Expr1.Apron]
Creation from an expression of level 0 (without environment)
of_expr0 [Bddapron.Expr1.Benum]
Creation from an expression of level 0 (without environment)
of_expr0 [Bddapron.Expr1.Bint]
Creation from an expression of level 0 (without environment)
of_expr0 [Bddapron.Expr1.Bool]
Creation from an expression of level 0 (without environment)
of_expr0 [Bddapron.Expr1]
Creation from an expression of level 0 (without environment)
of_expr0 [Bdd.Expr1.O.Benum]
of_expr0 [Bdd.Expr1.O.Bint]
of_expr0 [Bdd.Expr1.O.Bool]
of_expr0 [Bdd.Expr1.O]
Creation from an expression without environment
of_expr0 [Bdd.Expr1.Benum]
Creation from an expression of level 0 (without environment)
of_expr0 [Bdd.Expr1.Bint]
Creation from an expression of level 0 (without environment)
of_expr0 [Bdd.Expr1.Bool]
Creation from an expression of level 0 (without environment)
of_expr0 [Bdd.Expr1]
Creation from an expression of level 0 (without environment) (make should be considered as obsolete)
of_expr1 [Bddapron.Expr2.Bool]
Creation from an expression of level 1 (without condition environment)
of_expr1 [Bddapron.Expr2.O.Bool]
of_expr1 [Bddapron.Expr2.O]
of_expr1 [Bddapron.Expr2]
Creation from an expression of level 1 (without condition environment)
of_expr1 [Bdd.Domain1.O]
of_expr1 [Bdd.Domain1]
of_float [Apron.Interval]
of_float [Apron.Scalar]
Create a scalar of type Float with the given value
of_float [Mpzf]
of_float [Mpz]
of_float [Mpqf]
of_float [Mpq]
of_float [Mpfrf]
of_float [Mpfr]
of_float [Mpf]
of_frac [Apron.Interval]
of_frac [Apron.Scalar]
Create a scalar of type Mpqf from resp.
of_frac [Mpqf]
of_frac [Mpq]
of_frac [Mpfrf]
of_frac [Mpfr]
of_generator_array [Oct]
Approximate a set of generators to an abstract value, with best precision.
of_infsup [Apron.Interval]
depreciated
of_infty [Apron.Scalar]
Create a scalar of type Float with the value multiplied by infinity (resulting in minus infinity, zero, or infinity
of_int [Bddapron.Expr1.O.Bint]
of_int [Bddapron.Expr1.Bint]
of_int [Bddapron.Expr0.O.Bint]
of_int [Bddapron.Expr0.Bint]
of_int [Bdd.Expr1.O.Bint]
of_int [Bdd.Expr1.Bint]
of_int [Bdd.Expr0.O.Bint]
of_int [Bdd.Expr0.Bint]
of_int [Bdd.Int]
of_int [Bdd.Reg.Minterm]
Convert a possibly negative integer into a minterm of size size
of_int [Bdd.Reg]
of_int size cst puts the constant integer cst in a constant register of size size.
of_int [Apron.Interval]
of_int [Apron.Scalar]
of_int [Mpzf]
of_int [Mpz]
of_int [Mpqf]
of_int [Mpq]
of_int [Mpfrf]
of_int [Mpfr]
of_int [Mpf]
of_label [Bdd.Enum]
Create a register of the type of the label containing the label
of_level0 [Bddapron.Domain1]
of_level0 [Bddapron.Domainlevel1.Level1]
of_lexpr [Bddapron.Expr1.O.List]
of_lexpr [Bddapron.Expr1.List]
of_lexpr [Bdd.Expr1.O.List]
of_lexpr [Bdd.Expr1.List]
of_lexpr0 [Bddapron.Expr2.List]
Creation from a list of expressions of level 0 (without environment)
of_lexpr0 [Bddapron.Expr2.O.List]
of_lexpr0 [Bddapron.Expr1.O.List]
of_lexpr0 [Bddapron.Expr1.List]
Creation from a list of expressions of level 0 (without environment)
of_lexpr0 [Bdd.Expr1.O.List]
of_lexpr0 [Bdd.Expr1.List]
of_lexpr1 [Bddapron.Expr2.List]
Creation from a list of expressions of level 1 (without condition environment)
of_lexpr1 [Bddapron.Expr2.O.List]
of_lincons0 [Bddapron.Apronexpr.Condition]
of_lincons1 [Bddapron.Apronexpr.Condition]
of_lincons_array [Apron.Abstract1]
of_lincons_array [Apron.Abstract0]
of_linexpr [Apron.Texpr1]
Conversion
of_linexpr [Apron.Texpr0]
Conversion
of_linexpr0 [Bddapron.Apronexpr.Lin]
of_linexpr0 [Bddapron.Apronexpr]
of_linexpr1 [Bddapron.Apronexpr.Lin]
of_linexpr1 [Bddapron.Apronexpr]
of_list [SetList.S]
Conversion from a list (unsafe operation)
of_list [SetList]
Conversion from a list (unsafe operation)
of_list [Ilist]
Create a recursive list from a regular list
of_list [Apron.Linexpr0]
Combines Apron.Linexpr0.make and Apron.Linexpr0.set_list (see below)
of_listexpr1 [Bddapron.Expr2.List]
Creation from an expression list of level 1 (without condition environment)
of_listexpr1 [Bddapron.Expr2.O.List]
of_lstring [Apron.Parser]
Abstraction of lists of strings representing constraints to abstract values, on the abstract domain defined by the given manager.
of_mpfr [Apron.Interval]
Create an interval from resp.
of_mpfr [Apron.Scalar]
of_mpfr [Mpfrf]
Safe conversion from and to Mpfr.t.
of_mpfrf [Apron.Scalar]
Create a scalar of type Mpfrf with the given value
of_mpq [Apron.Interval]
of_mpq [Apron.Scalar]
of_mpq [Mpqf]
Safe conversion from and to Mpq.t.
of_mpq [Mpfrf]
of_mpq [Mpfr]
of_mpq [Mpf]
of_mpqf [Apron.Interval]
of_mpqf [Apron.Scalar]
of_mpz [Mpzf]
Safe conversion from and to Mpz.t.
of_mpz [Mpqf]
of_mpz [Mpq]
of_mpz [Mpfrf]
of_mpz [Mpfr]
of_mpz [Mpf]
of_mpz2 [Mpqf]
of_mpz2 [Mpq]
of_mpz2 [Mpfrf]
of_mpz2 [Mpfr]
of_mtbdd [Bddapron.Domain1]
Makes a pair (mtbdd manager,mtbdd abstract value) generic
of_mtbdd [Bddapron.Domain0]
Makes a pair (mtbdd manager,mtbdd abstract value) generic
of_oct [Oct.Abstract1]
Make an oct value generic
of_oct [Oct.Abstract0]
Make an oct value generic
of_polka [Polka.Abstract1]
of_polka [Polka.Abstract0]
of_polka_equalities [Polka.Abstract1]
Makes a polka value generic
of_polka_equalities [Polka.Abstract0]
Makes a polka value generic
of_polka_loose [Polka.Abstract1]
of_polka_loose [Polka.Abstract0]
of_polka_strict [Polka.Abstract1]
of_polka_strict [Polka.Abstract0]
of_polkagrid [PolkaGrid.Abstract1]
Makes a polkagrid value generic
of_polkagrid [PolkaGrid.Abstract0]
Makes a polkagrid value generic
of_ppl [Ppl.Abstract1]
of_ppl [Ppl.Abstract0]
of_ppl_grid [Ppl.Abstract1]
Make a ppl value generic
of_ppl_grid [Ppl.Abstract0]
Make a ppl value generic
of_ppl_loose [Ppl.Abstract1]
of_ppl_loose [Ppl.Abstract0]
of_ppl_strict [Ppl.Abstract1]
of_ppl_strict [Ppl.Abstract0]
of_scalar [Apron.Interval]
Build an interval from a lower and an upper bound
of_set [MultiSetList.S]
Conversion from sets of module SetList.
of_set [MultiSetList]
Conversion from sets of module SetList.
of_string [Symbol]
Returns the existing symbol associated to the (registered) string.
of_string [Apron.Var]
Constructor
of_string [Mpzf]
of_string [Mpz]
of_string [Mpqf]
of_string [Mpq]
of_string [Mpfrf]
of_string [Mpfr]
of_string [Mpf]
of_tcons0 [Bddapron.Apronexpr.Condition]
of_tcons1 [Bddapron.Apronexpr.Condition]
of_tcons_array [Apron.Abstract1]
Abstract a conjunction of constraints
of_tcons_array [Apron.Abstract0]
Abstract a conjunction of constraints
of_texpr0 [Bddapron.Apronexpr]
of_texpr1 [Bddapron.Apronexpr]
one [Bddapron.Apronexpr.Lin]
one [Bddapron.Apronexpr]
option [Print]
Print an optional element
overapprox [Cudd.Bdd]
overflow_p [Mpfr]

P
pair [Print]
Print a pair
parse_file [Parse]
Same as before, but create itself a lexbuf from the given filename.
parse_lexbuf [Parse]
Takes as input a lexer, a parser compatible with the lexer (ie, they share the same type for tokens), and a lexbuf,
parse_string [Parse]
Same as before, but create itself a lexbuf from the given string.
partition [Sette.Compare]
partition [Sette]
partition p s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate p, and s2 is the set of all the elements of s that do not satisfy p.
partition [SetList.S]
partition p s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate p, and s2 is the set of all the elements of s that do not satisfy p.
partition [SetList]
partition p s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate p, and s2 is the set of all the elements of s that do not satisfy p.
partition [PSette]
partition p s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate p, and s2 is the set of all the elements of s that do not satisfy p.
partition [PMappe]
partition [MultiSetList.S]
partition p l returns a pair of multisets (l1, l2), where l1 is the multiset of all the elements of l that satisfy the predicate p, and l2 is the multiset of all the elements of l that do not satisfy p.
partition [MultiSetList]
partition p l returns a pair of multisets (l1, l2), where l1 is the multiset of all the elements of l that satisfy the predicate p, and l2 is the multiset of all the elements of l that do not satisfy p.
partition [Mappe.Compare]
partition [Mappe]
partition p m returns a pair of maps (m1, m2), where m1 is the map of all the bindings of m that satisfy the predicate p, and m2 is the map of all the bindings of m that do not satisfy p.
partition [Sette.S]
partition p s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate p, and s2 is the set of all the elements of s that do not satisfy p.
partition [Mappe.S]
perfect_power_p [Mpz]
perfect_square_p [Mpz]
perm_compose [Apron.Dim]
perm_compose perm1 perm2 composes the 2 permutations perm1 and perm2 (in this order).
perm_invert [Apron.Dim]
Invert a permutation
permutation [Bdd.Cond]
Compute the permutation for normalizing the environment
permutation [Bdd.Env]
Compute the permutation for normalizing the environment
permutation12 [Bdd.Cond]
permutation12 [Bdd.Env]
Permutation for going from a subenvironment to a superenvironment
permutation21 [Bdd.Cond]
permutation21 [Bdd.Env]
Permutation from a superenvironment to a subenvironment
permutation_of_offset [Bdd.Env]
permutation_of_rename [Bdd.Expr0.O]
permute [Bddapron.Expr0.O.Apron]
permute [Bddapron.Expr0.O.Benum]
permute [Bddapron.Expr0.O.Bint]
permute [Bddapron.Expr0.O.Bool]
permute [Bddapron.Expr0.O]
permute [Bddapron.Expr0.Apron]
permute [Bddapron.Expr0.Benum]
permute [Bddapron.Expr0.Bint]
permute [Bddapron.Expr0.Bool]
permute [Bddapron.Expr0]
permute [Bdd.Expr0.O.Benum]
permute [Bdd.Expr0.O.Bint]
permute [Bdd.Expr0.O.Bool]
permute [Bdd.Expr0.O]
permute [Bdd.Expr0.Benum]
permute [Bdd.Expr0.Bint]
permute [Bdd.Expr0.Bool]
permute [Bdd.Enum]
Permutation (scale Cudd.Bdd.permute and Cudd.Bdd.permute_memo)
permute [Bdd.Int]
Permutation (scale Cudd.Bdd.permute and Cudd.Bdd.permute_memo)
permute [Bdd.Reg]
Permutation (scale Cudd.Bdd.permute and Cudd.Bdd.permute_memo)
permute [Cudd.Add]
permute [Cudd.Mtbddc]
permute [Cudd.Mtbdd]
permute [Cudd.Vdd]
Variant with controllable memoization policy.
permute [Cudd.Bdd]
permute_dimensions [Bddapron.ApronDD]
permute_dimensions [Apron.Abstract0]
permute_dimensions_with [Apron.Abstract0]
permute_list [Bddapron.Expr0.O]
permute_list [Bdd.Expr0.O]
permute_with [Bdd.Cond]
Apply the given permutation to the environment
permute_with [Bdd.Env]
Apply the given permutation to the environment
pick_cube_on_support [Cudd.Bdd]
pick_cubes_on_support [Cudd.Bdd]
pick_leaf [Cudd.Add]
Picks (but not randomly) a non background leaf.
pick_leaf [Cudd.Mtbddc]
pick_leaf [Cudd.Mtbdd]
pick_leaf [Cudd.Vdd]
Picks (but not randomly) a non background leaf.
pick_leaf_u [Cudd.Mtbddc]
Picks (but not randomly) a non background leaf.
pick_leaf_u [Cudd.Mtbdd]
Picks (but not randomly) a non background leaf.
pick_minterm [Cudd.Bdd]
policy_manager_alloc [Box]
poly_of_tree [Bddapron.Apronexpr]
popcount [Mpz]
post [Bdd.Domain0.O.Asssub]
postcondition [Bdd.Domain0.O.Asssub]
pow [Mpfrf]
pow [Mpfr]
pow_int [Mpfrf]
pow_si [Mpfr]
pow_ui [Mpz]
pow_ui [Mpfr]
pow_ui [Mpf]
powm [Mpz]
powm_ui [Mpz]
pre_widening [Oct]
Algorithms.
precedence_of_binop [Bddapron.Syntax]
precedence_of_expr [Bddapron.Syntax]
precedence_of_unop [Bddapron.Syntax]
pred [Bddapron.Expr1.O.Bint]
pred [Bddapron.Expr1.Bint]
pred [Bddapron.Expr0.O.Bint]
pred [Bddapron.Expr0.Bint]
pred [Bdd.Expr1.O.Bint]
pred [Bdd.Expr1.Bint]
pred [Bdd.Expr0.O.Bint]
pred [Bdd.Expr0.Bint]
pred [Bdd.Int]
pred [Bdd.Reg]
Predecessor operation; returns the new register and the carry.
pred [FGraph1.S]
pred [FGraph1]
Expensive operation, requires iterations on all vertices
pred [FGraph.S]
pred [FGraph]
pred_vertex [SHGraph.Compare]
pred_vertex [SHGraph.S]
pred_vertex [SHGraph]
Predecessor vertices of a vertex by any hyperedge
pred_vertex [PSHGraph]
predhedge [SHGraph.Compare]
predhedge [SHGraph.S]
predhedge [SHGraph]
Predecessor hyperedges of a vertex
predhedge [PSHGraph]
predvertex [SHGraph.Compare]
predvertex [SHGraph.S]
predvertex [SHGraph]
Predecessor vertices of an hyperedge
predvertex [PSHGraph]
print [Bddapron.Policy.Mtbdddomain0]
print [Bddapron.Policy.Domain0]
print [Bddapron.Policy.Domain1]
print [Bddapron.Domain1]
print [Bddapron.Domainlevel1.Level0]
print [Bddapron.Domainlevel1.Level1]
Printing function
print [Bddapron.Domain0]
print [Bddapron.Bdddomain0.O]
print [Bddapron.Bdddomain0]
Printing function
print [Bddapron.Mtbdddomain0.O]
print [Bddapron.Mtbdddomain0]
Printing function
print [Bddapron.Expr2.List]
print [Bddapron.Expr2.Bool]
print [Bddapron.Expr2.O.List]
print [Bddapron.Expr2.O.Bool]
print [Bddapron.Expr2.O]
print [Bddapron.Expr2]
print [Bddapron.Expr1.O.List]
print [Bddapron.Expr1.O.Apron]
print [Bddapron.Expr1.O.Benum]
print [Bddapron.Expr1.O.Bint]
print [Bddapron.Expr1.O.Bool]
print [Bddapron.Expr1.O]
print [Bddapron.Expr1.List]
print [Bddapron.Expr1.Apron]
print [Bddapron.Expr1.Benum]
print [Bddapron.Expr1.Bint]
print [Bddapron.Expr1.Bool]
print [Bddapron.Expr1]
print [Bddapron.Expr0.O.Apron]
print [Bddapron.Expr0.O.Benum]
print [Bddapron.Expr0.O.Bint]
print [Bddapron.Expr0.O.Bool]
print [Bddapron.Expr0.O]
print [Bddapron.Expr0.Apron]
print [Bddapron.Expr0.Benum]
print [Bddapron.Expr0.Bint]
print [Bddapron.Expr0.Bool]
print [Bddapron.Expr0]
Printing functions
print [Bddapron.ApronDD]
print [Bddapron.ApronexprDD]
print [Bddapron.Cond]
print [Bddapron.Env.O]
Print an environment
print [Bddapron.Env]
Print an environment
print [Bddapron.Apronexpr.Condition]
print [Bddapron.Apronexpr.Tree]
print [Bddapron.Apronexpr.Poly]
print [Bddapron.Apronexpr.Lin]
print [Bddapron.Apronexpr]
print [Bdd.Domain1.O]
print [Bdd.Domain1]
print [Bdd.Domain0.O]
print [Bdd.Domain0]
print [Bdd.Expr1.O.List]
print [Bdd.Expr1.O.Benum]
print [Bdd.Expr1.O.Bint]
print [Bdd.Expr1.O.Bool]
print [Bdd.Expr1.O]
print [Bdd.Expr1.List]
print [Bdd.Expr1.Benum]
print [Bdd.Expr1.Bint]
print [Bdd.Expr1.Bool]
print [Bdd.Expr1]
print [Bdd.Expr0.O.Benum]
print [Bdd.Expr0.O.Bint]
print [Bdd.Expr0.O.Bool]
print [Bdd.Expr0.O]
Print an expression
print [Bdd.Expr0.Benum]
print [Bdd.Expr0.Bint]
print [Bdd.Expr0.Bool]
print [Bdd.Expr0]
Print an expression
print [Bdd.Cond]
print [Bdd.Enum]
print f fmt t prints the register t using the formatter fmt and the function f to print BDDs indices.
print [Bdd.Int]
print f fmt t prints the register t using the formatter fmt and the function f to print BDDs indices.
print [Bdd.Env.O]
Print an environment
print [Bdd.Env]
Print an environment
print [Bdd.Reg]
print f fmt t prints the register t using the formatter fmt and the function f to print BDDs indices.
print [Symbol]
Prints the symbol (its associated string).
print [Sette]
print [SetList.S]
Printing function
print [SetList]
Printing function
print [SHGraph.Compare]
print [SHGraph.S]
print [SHGraph]
Print a graph in textual format on the given formatter, using the given functions to resp.
print [Rational]
print [PSette]
print [PSHGraph]
print [PMappe]
print [PHashhe]
print [PDMappe]
print [PDHashhe]
print [MultiSetList.S]
Printing function
print [MultiSetList]
Printing function
print [Mappe]
Print a map.
print [Ilist]
Printing function.
print [Hashhe]
print [FGraph1.S]
print [FGraph1]
print [FGraph.S]
print [FGraph]
print [Sette.S]
print [Mappe.S]
print [DMappe.S]
print [DMappe]
Print the set of bindings.
print [Hashhe.S]
print [DHashhe.S]
print [DHashhe]
Print the set of bindings.
print [Box.Policy]
print [Apron.Abstract1]
Print as a set of constraints
print [Apron.Tcons1]
Print the tree expression constraint
print [Apron.Texpr1]
Print an abstract tree expression
print [Apron.Generator1]
Print the generator
print [Apron.Lincons1]
Print the linear constraint
print [Apron.Linexpr1]
Print the linear expression
print [Apron.Environment]
Printing
print [Apron.Var]
Printing function
print [Apron.Abstract0]
Print as a set of constraints
print [Apron.Tcons0]
Print a constraint
print [Apron.Texpr0]
Print an abstract tree expression, using a function converting from dimensions to names
print [Apron.Generator0]
Print a generator
print [Apron.Lincons0]
Print a constraint
print [Apron.Linexpr0]
Print a linear expression, using a function converting from dimensions to names
print [Apron.Coeff]
Printing
print [Apron.Interval]
Print an interval, under the format [inf,sup]
print [Apron.Scalar]
Print a coefficient
print [Cudd.Add]
Prints a BDD by recursively decomposing it as monomial followed by a tree.
print [Cudd.Mtbddc]
print [Cudd.Mtbdd]
print [Cudd.PWeakke]
print [Cudd.Weakke.S]
Printing function
print [Cudd.Weakke]
print [Cudd.Vdd]
print [Cudd.Bdd]
Prints a BDD by recursively decomposing it as monomial followed by a tree.
print [Mpzf]
print [Mpz]
print [Mpqf]
print [Mpq]
print [Mpfrf]
print [Mpfr]
print [Mpf]
print0 [Box.Policy]
print1 [Box.Policy]
print__minterm [Cudd.Add]
Prints the minterms of the BDD in the same way as Cudd_Printminterm.
print__minterm [Cudd.Mtbddc]
print__minterm [Cudd.Mtbdd]
print__minterm [Cudd.Vdd]
print__minterm [Cudd.Bdd]
Prints the minterms of the BDD in the same way as Cudd_Printminterm.
print_array [Apron.Abstract0]
General use
print_bbinop [Bddapron.Syntax]
print_bdd [Bddapron.Expr0.O]
print_bdd [Bdd.Expr0.O]
Print a BDD
print_bdd [Bdd.Expr0]
Print a BDD
print_binop [Bddapron.Syntax]
print_binop [Apron.Texpr1]
print_binop [Apron.Texpr0]
print_cnf [Bdd.Normalform]
print_cond [Bddapron.Cond]
print_conjunction [Bdd.Expr0.O.Expr]
print_conjunction [Bdd.Normalform]
print_cst [Bddapron.Syntax]
print_disjunction [Bdd.Normalform]
print_dnf [Bdd.Expr0.O.Expr]
print_dnf [Bdd.Normalform]
print_dot [SHGraph.S]
print_dot [SHGraph]
Output the graph in DOT format on the given formatter, using the given functions to resp print:
print_dot [PSHGraph]
print_dot [FGraph.S]
print_dot [FGraph]
print_exc [Apron.Manager]
print_exclog [Apron.Manager]
Printing functions
print_expr [Bddapron.Syntax]
print_expr [Apron.Texpr1]
Print a tree expression
print_expr [Apron.Texpr0]
Print a tree expression, using a function converting from dimensions to names
print_funid [Apron.Manager]
print_funopt [Apron.Manager]
print_hash [Symbol]
Prints hashtables on symbols.
print_idcond [Bdd.Expr0.O]
Print the condition
print_idcond [Bdd.Expr0]
Print the condition
print_idcondb [Bddapron.Env]
print_idcondb [Bdd.Expr0.O]
Print the condition represented by the signed BDD index.
print_idcondb [Bdd.Expr0]
Print the condition represented by the signed BDD index.
print_idcondb [Bdd.Env]
print_info [Cudd.Man]
print_limit [Cudd.Man]
Parameter for printing functions: specify the maximum number of minterms to be printed.
print_list [Cudd.Bdd]
print_map [Symbol]
Prints maps on symbols.
print_minterm [Bdd.Expr0.O]
Print a minterm
print_minterm [Bdd.Expr0]
Print a minterm
print_minterm [Bdd.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 [Bdd.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 [Bdd.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_minterm [Cudd.Add]
print_minterm print_id print_leaf fmt bdd prints the minterms of the BDD using print_id to print indices of variables and print_leaf to print leaf values.
print_minterm [Cudd.Mtbddc]
print_minterm [Cudd.Mtbdd]
print_minterm [Cudd.Vdd]
print_minterm [Cudd.Bdd]
print_minterm bassoc fmt bdd prints the minterms of the BDD using bassoc to convert indices of variables to names.
print_of_string [Print]
Transforms a conversion-to-string function to a printing function.
print_order [Bddapron.Env]
Print the BDD variable ordering
print_order [Bdd.Env]
Print the BDD variable ordering
print_precedence_of_binop [Apron.Texpr0]
print_precedence_of_unop [Apron.Texpr0]
print_round [Apron.Texpr1]
print_round [Apron.Texpr0]
print_round [Mpfr]
print_set [Symbol]
Prints sets of symbols.
print_sprint_binop [Apron.Texpr0]
print_sprint_unop [Apron.Texpr0]
print_table [Cudd.Mtbddc]
print_table [Cudd.Mtbdd]
print_term [Bdd.Expr0.O.Expr]
print_tid [Bdd.Env]
print_tree [Bdd.Normalform]
print_tree_minterm [Bdd.Normalform]
print_typ [Bddapron.Env]
Print a type
print_typ [Bddapron.Apronexpr]
print_typ [Bdd.Env]
Printing
print_typ [Apron.Texpr1]
print_typ [Apron.Texpr0]
print_typdef [Bddapron.Env]
Print a type definition
print_typdef [Bdd.Env]
Print a type definition
print_unop [Bddapron.Syntax]
print_unop [Apron.Texpr1]
print_unop [Apron.Texpr0]
probab_prime_p [Mpz]

R
reachable [SHGraph.Compare]
reachable [SHGraph.S]
reachable [SHGraph]
Returns the set of vertices and hyperedges that are *NOT* reachable from the given root vertex.
reachable [PSHGraph]
reachable [FGraph1.S]
reachable [FGraph1]
reachable [FGraph.S]
reachable [FGraph]
reachable_multi [SHGraph.Compare]
reachable_multi [SHGraph.S]
reachable_multi [SHGraph]
reachable_multi [PSHGraph]
reachable_multi [FGraph1.S]
reachable_multi [FGraph1]
reachable_multi [FGraph.S]
reachable_multi [FGraph]
realloc2 [Mpz]
reduce [Apron.Coeff]
Convert interval to scalar if possible
reduce_heap [Cudd.Man]
reduce_with [Bdd.Cond]
Remove from the environment all conditions that do not belong to the given support.
reg_of_expr [Bdd.Expr0.O]
relation_supp_compose_of_lvarlexpr [Bdd.Domain0.O]
reldiff [Mpfr]
reldiff [Mpf]
remainder [Mpfr]
remapoverapprox [Cudd.Bdd]
remapunderapprox [Cudd.Bdd]
remove [Sette.Compare]
remove [Sette]
remove x s returns a set containing all elements of s, except x.
remove [SetList.S]
remove x s returns a set containing all elements of s, except x.
remove [SetList]
remove x s returns a set containing all elements of s, except x.
remove [PSette]
remove x s returns a set containing all elements of s, except x.
remove [PMappe]
remove [PHashhe]
remove [PDMappe]
remove [MultiSetList.S]
remove x s returns a multiset containing all elements of s, with the occurence number of x decremented.
remove [MultiSetList]
remove x s returns a multiset containing all elements of s, with the occurence number of x decremented.
remove [Mappe.Compare]
remove [Mappe]
remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map.
remove [Hashhe.Compare]
remove [Hashhe]
remove tbl x removes the current binding of x in tbl, restoring the previous binding if it exists.
remove [Sette.S]
remove x s returns a set containing all elements of s, except x.
remove [Mappe.S]
remove [DMappe.S]
remove [DMappe]
Remove a binding defined by its first element and return the new map.
remove [Hashhe.S]
remove [Apron.Environment]
Remove from an environment a set of variables.
remove [Cudd.PWeakke]
remove [Cudd.Weakke.Compare]
remove [Cudd.Weakke.S]
remove t x removes from t one instance of x.
remove [Cudd.Weakke]
remove [Mpz]
remove_dimensions [Bddapron.ApronDD]
remove_dimensions [Apron.Abstract0]
remove_dimensions_with [Apron.Abstract0]
remove_edge [FGraph1.S]
remove_edge [FGraph1]
remove_edge [FGraph.S]
remove_edge [FGraph]
remove_hedge [SHGraph.Compare]
remove_hedge [SHGraph.S]
remove_hedge [SHGraph]
Remove the hyperedge from the graph.
remove_hedge [PSHGraph]
remove_vars [Bddapron.Env]
remove_vars [Bdd.Env]
remove_vars_with [Bddapron.Env]
Remove the set of variables, as well as all constraints, and possibly normalize the environment and return the applied permutation.
remove_vars_with [Bdd.Env]
Remove the set of variables, and possibly normalize the environment and return the applied permutation.
remove_vertex [SHGraph.Compare]
remove_vertex [SHGraph.S]
remove_vertex [SHGraph]
Remove the vertex from the graph, as well as all related hyperedges.
remove_vertex [PSHGraph]
remove_vertex [FGraph1.S]
remove_vertex [FGraph1]
Expensive operation, requires iterations on all vertices
remove_vertex [FGraph.S]
remove_vertex [FGraph]
removex [PDMappe]
removex [PDHashhe]
removex [DHashhe.S]
removex [DHashhe]
Remove a binding defined by its first element.
removey [PDMappe]
removey [PDHashhe]
removey [DHashhe.S]
removey [DHashhe]
Remove a binding defined by its second element.
rename [Bddapron.Domain1]
rename [Bddapron.Domainlevel1.Level1]
Rename a list of variables (thus changing the environment).
rename [Bdd.Domain1.O]
Change of environments
rename [Bdd.Domain1]
Change of environments
rename [Apron.Environment]
Renaming in an environment a set of variables.
rename_array [Apron.Abstract1]
Parallel renaming of the environment of the abstract value.
rename_array_with [Apron.Abstract1]
rename_perm [Apron.Environment]
Similar to previous function, but returns also the permutation on dimensions induced by the renaming.
rename_vars [Bddapron.Env]
Functional versions of the previous functions
rename_vars [Bdd.Env]
Functional versions of the previous functions
rename_vars_with [Bddapron.Env]
Rename the variables, and remove all constraints,possibly normalize the environment and return the applied permutation.
rename_vars_with [Bdd.Env]
Rename the variables, possibly normalize the environment and return the applied permutation.
replace [PHashhe]
replace [Hashhe.Compare]
replace [Hashhe]
replace tbl x y replaces the current binding of x in tbl by a binding of x to y.
replace [Hashhe.S]
replace_attrhedge [SHGraph.Compare]
replace_attrhedge [SHGraph.S]
replace_attrhedge [SHGraph]
Change the attribute of an existing hyperedge
replace_attrhedge [PSHGraph]
replace_attrvertex [SHGraph.Compare]
replace_attrvertex [SHGraph.S]
replace_attrvertex [SHGraph]
Change the attribute of an existing vertex
replace_attrvertex [PSHGraph]
repr [FGraph.S]
repr [FGraph]
repr [Sette.S]
repr [Mappe.S]
resize [Hashhe.Compare]
restrict [Bddapron.Expr1.O.Apron]
restrict [Bddapron.Expr1.O.Benum]
restrict [Bddapron.Expr1.O.Bint]
restrict [Bddapron.Expr1.O.Bool]
restrict [Bddapron.Expr1.O]
restrict [Bddapron.Expr1.Apron]
restrict [Bddapron.Expr1.Benum]
restrict [Bddapron.Expr1.Bint]
restrict [Bddapron.Expr1.Bool]
restrict [Bddapron.Expr1]
restrict [Bddapron.Expr0.O.Apron]
restrict [Bddapron.Expr0.O.Benum]
restrict [Bddapron.Expr0.O.Bint]
restrict [Bddapron.Expr0.O.Bool]
restrict [Bddapron.Expr0.O]
restrict [Bddapron.Expr0.Apron]
restrict [Bddapron.Expr0.Benum]
restrict [Bddapron.Expr0.Bint]
restrict [Bddapron.Expr0.Bool]
restrict [Bddapron.Expr0]
restrict [Bdd.Expr1.O.Benum]
restrict [Bdd.Expr1.O.Bint]
restrict [Bdd.Expr1.O.Bool]
restrict [Bdd.Expr1.O]
restrict [Bdd.Expr1.Benum]
restrict [Bdd.Expr1.Bint]
restrict [Bdd.Expr1.Bool]
restrict [Bdd.Expr1]
restrict [Bdd.Expr0.O.Benum]
restrict [Bdd.Expr0.O.Bint]
restrict [Bdd.Expr0.O.Bool]
restrict [Bdd.Expr0.Benum]
restrict [Bdd.Expr0.Bint]
restrict [Bdd.Expr0.Bool]
restrict [Bdd.Expr0]
restrict [Bdd.Enum]
restrict [Bdd.Int]
restrict [Bdd.Reg]
restrict [Cudd.Add]
restrict [Cudd.Mapleaf]
If true, simplifies in some functions MTBDDs using Cudd.Mtbdd.restrict or Cudd.Mtbddc.restrict.
restrict [Cudd.Mtbddc]
restrict [Cudd.Mtbdd]
restrict [Cudd.Vdd]
restrict [Cudd.Bdd]
Cuddaux_bddRestrict.
retractivemapleaf1 [Cudd.Mapleaf]
Assuming that the new guards delivered by the function f are disjoint, return the MTBDD default \/ (\/ nguard -> nleaf) with (nguard,nleaf) = f guard leaf.
retractivemapleaf2 [Cudd.Mapleaf]
Assuming that the new guards delivered by the function f are disjoint, return the MTBDD default \/ (\/ nguard -> nleaf) with (nguard,nleaf) = f (guard1 /\ guard2) leaf1 leaf2.
rev [Ilist]
Recursively reverse the recursive list rev [a;[b;[c];d];e;[f]] = [[f];e;[d;[c];b];a]
rev_map2_conjunction [Bdd.Normalform]
rev_map2_disjunction [Bdd.Normalform]
rev_map_conjunction [Bdd.Normalform]
rev_map_disjunction [Bdd.Normalform]
rint [Mpfr]
root [Mpz]
round [Mpfr]
round_prec [Mpfr]
rrandomb [Gmp_random.Mpz]

S
s_of_float [Apron.Coeff]
Create an interval coefficient of type Float with the given value
s_of_frac [Apron.Coeff]
Create a scalar coefficient of type Mpqf.t from resp.
s_of_int [Apron.Coeff]
s_of_mpfr [Apron.Coeff]
Create an interval coefficient of type Mpfr with the given value
s_of_mpq [Apron.Coeff]
s_of_mpqf [Apron.Coeff]
sat_interval [Apron.Abstract1]
Does the abstract value satisfy the constraint dim in interval ?
sat_interval [Apron.Abstract0]
Does the abstract value satisfy the constraint dim in interval ?
sat_lincons [Apron.Abstract1]
Does the abstract value satisfy the linear constraint ?
sat_lincons [Apron.Abstract0]
Does the abstract value satisfy the linear constraint ?
sat_tcons [Apron.Abstract1]
Does the abstract value satisfy the tree expression constraint ?
sat_tcons [Apron.Abstract0]
Does the abstract value satisfy the tree expression constraint ?
scale [Bddapron.Expr1.O.Bint]
scale [Bddapron.Expr1.Bint]
scale [Bddapron.Expr0.O.Bint]
scale [Bddapron.Expr0.Bint]
scale [Bddapron.Apronexpr.Poly]
scale [Bddapron.Apronexpr.Lin]
scale [Bdd.Expr1.O.Bint]
scale [Bdd.Expr1.Bint]
scale [Bdd.Expr0.O.Bint]
scale [Bdd.Expr0.Bint]
scale [Bdd.Int]
scale [Bdd.Reg]
Multiplication by a positive constant.
scan0 [Mpz]
scan1 [Mpz]
scfc [SHGraph.Compare]
scfc [SHGraph.S]
scfc [SHGraph]
Decomposition of the graph into Strongly Connected Sub-Components,
scfc [PSHGraph]
scfc [FGraph1.S]
scfc [FGraph1]
scfc [FGraph.S]
scfc [FGraph]
scfc_multi [SHGraph.Compare]
scfc_multi [SHGraph.S]
scfc_multi [SHGraph]
idem, but from several initial vertices.
scfc_multi [PSHGraph]
scfc_multi [FGraph1.S]
scfc_multi [FGraph1]
scfc_multi [FGraph.S]
scfc_multi [FGraph]
sec [Mpfr]
sech [Mpfr]
seed [Gmp_random]
seed_ui [Gmp_random]
select_cond [Bdd.Decompose]
select_cond_bdd [Bdd.Decompose]
set [Mpz]
set [Mpq]
set [Mpfr]
set [Mpf]
setNZ [Cudd.Add]
set_approximate_max_coeff_size [Polka]
set_arcviolation [Cudd.Man]
set_array [Apron.Generator1]
Set simultaneously a number of coefficients, as set_list.
set_array [Apron.Lincons1]
Set simultaneously a number of coefficients, as set_list.
set_array [Apron.Linexpr1]
Set simultaneously a number of coefficients, as set_list.
set_array [Apron.Linexpr0]
Set simultaneously a number of coefficients, as set_list.
set_background [Cudd.Man]
Variation of Cudd_SetBackground.
set_bottom [Apron.Interval]
Fill the interval with top (resp.
set_coeff [Apron.Generator1]
Set the coefficient of the variable in the underlying linear expression
set_coeff [Apron.Lincons1]
Set the coefficient of the variable in the underlying linear expression
set_coeff [Apron.Linexpr1]
Set the coefficient of the variable
set_coeff [Apron.Linexpr0]
Set the coefficient corresponding to the dimension
set_crossovers [Cudd.Man]
set_cst [Apron.Lincons1]
Set the constant of the underlying linear expression
set_cst [Apron.Linexpr1]
Set the constant
set_cst [Apron.Linexpr0]
Set the constant
set_d [Mpz]
set_d [Mpq]
set_d [Mpfr]
set_d [Mpf]
set_default_prec [Mpfr]
set_default_prec [Mpf]
set_default_rounding_mode [Mpfr]
set_den [Mpq]
set_deserialize [Apron.Manager]
Set / get the global manager used for deserialization
set_emax [Mpfr]
set_emin [Mpfr]
set_epsilon [Cudd.Man]
set_exp [Mpfr]
set_f [Mpfr]
set_funopt [Apron.Manager]
Set the options for the function.
set_gc [Apron.Abstract0]
TO BE DOCUMENTED
set_gc [Cudd.Man]
set_gc max gc reordering performs several things: It sets the ratio used/max for BDDs abstract values to 1/max (see the OCaml manual for details). 1 000 000 is a good value., It also sets for all the future managers that will be created the hook function to be called before a CUDD garbage collection, and the hook function to be called before a CUDD reordering. You may typically specify a OCaml garbage collection function for both hooks, in order to make OCaml dereference unused nodes, thus allowing CUDD to remove them. Default values are Gc.full_major() for both hooks.
set_groupcheck [Cudd.Man]
set_inf [Mpfr]
set_info [FGraph1.S]
set_info [FGraph1]
set_info [FGraph.S]
set_info [FGraph]
set_infsup [Apron.Interval]
Fill the interval with the given lower and upper bouunds
set_list [Apron.Generator1]
Set simultaneously a number of coefficients.
set_list [Apron.Lincons1]
Set simultaneously a number of coefficients.
set_list [Apron.Linexpr1]
Set simultaneously a number of coefficients.
set_list [Apron.Linexpr0]
Set simultaneously a number of coefficients.
set_looseupto [Cudd.Man]
set_max_cache_hard [Cudd.Man]
set_max_coeff_size [Polka]
set_max_growth [Cudd.Man]
set_max_growth_alt [Cudd.Man]
set_max_live [Cudd.Man]
set_max_mem [Cudd.Man]
set_min_hit [Cudd.Man]
set_nan [Mpfr]
set_next_autodyn [Cudd.Man]
set_num [Mpq]
set_population [Cudd.Man]
set_prec [Mpfr]
set_prec [Mpf]
set_prec_raw [Mpfr]
set_prec_raw [Mpf]
set_q [Mpfr]
set_q [Mpf]
set_recomb [Cudd.Man]
(Cudd_SetRecomb.
set_reordering_cycle [Cudd.Man]
set_si [Mpz]
set_si [Mpq]
set_si [Mpfr]
set_si [Mpf]
set_si_2exp [Mpfr]
set_sift_max_swap [Cudd.Man]
set_sift_max_var [Cudd.Man]
set_str [Mpz]
set_str [Mpq]
set_str [Mpfr]
set_str [Mpf]
set_symmviolation [Cudd.Man]
set_top [Apron.Interval]
set_typ [Apron.Tcons1]
Set the constraint type
set_typ [Apron.Generator1]
Set the generator type
set_typ [Apron.Lincons1]
Set the constraint type
set_var_operations [Apron.Var]
Initialisation of abstract type operations in C library
set_varmap [Cudd.Man]
Cuddaux_SetVarMap/Cudd_SetVarMap.
set_z [Mpq]
set_z [Mpfr]
set_z [Mpf]
setbit [Mpz]
setx [PDMappe]
setx [DMappe.S]
setx [DMappe]
Return the set of all objects in the first place of bindings.
sety [PDMappe]
sety [DMappe.S]
sety [DMappe]
Return the set of all objects in the second place of bindings.
sgn [Apron.Scalar]
Return the sign of the coefficient, which may be a negative value, zero or a positive value.
sgn [Mpzf]
sgn [Mpz]
sgn [Mpqf]
sgn [Mpq]
sgn [Mpfrf]
sgn [Mpfr]
sgn [Mpf]
shift [Bdd.Cond]
shift [Bdd.Env]
Shift all the indices by the offset
shift_left [Bddapron.Expr1.O.Bint]
shift_left [Bddapron.Expr1.Bint]
shift_left [Bddapron.Expr0.O.Bint]
shift_left [Bddapron.Expr0.Bint]
shift_left [Bdd.Expr1.O.Bint]
shift_left [Bdd.Expr1.Bint]
shift_left [Bdd.Expr0.O.Bint]
shift_left [Bdd.Expr0.Bint]
shift_left [Bdd.Int]
shift_left [Bdd.Reg]
shift_left man t n shifts the register to the left by n bits.
shift_right [Bddapron.Expr1.O.Bint]
shift_right [Bddapron.Expr1.Bint]
shift_right [Bddapron.Expr0.O.Bint]
shift_right [Bddapron.Expr0.Bint]
shift_right [Bdd.Expr1.O.Bint]
shift_right [Bdd.Expr1.Bint]
shift_right [Bdd.Expr0.O.Bint]
shift_right [Bdd.Expr0.Bint]
shift_right [Bdd.Int]
shift_right [Bdd.Reg]
shift_right t n shifts the register to the right by n bits.
shift_right_logical [Bdd.Reg]
Same as shift_right, but here logical shift: a zero is always inserted.
shuffle_heap [Cudd.Man]
si_kronecker [Mpz]
signid_of_bdd [Bdd.Output]
Output the BDD and return its identifier
sin [Mpfr]
sin_cos [Mpfr]
singleton [Sette]
singleton x returns the one-element set containing only x.
singleton [SetList.S]
singleton x returns the one-element set containing only x.
singleton [SetList]
singleton x returns the one-element set containing only x.
singleton [PSette]
singleton x returns the one-element set containing only x.
singleton [MultiSetList.S]
singleton x returns the one-element multiset containing only x.
singleton [MultiSetList]
singleton x returns the one-element multiset containing only x.
singleton [Sette.S]
singleton x returns the one-element set containing only x.
sinh [Mpfr]
size [Bddapron.Domain1]
size [Bddapron.Domainlevel1.Level0]
size [Bddapron.Domainlevel1.Level1]
Size of an abstract value.
size [Bddapron.Domain0]
size [Bddapron.Bdddomain0.O]
size [Bddapron.Bdddomain0]
Size of an abstract value in terms of number of nodes of the MTBDD.
size [Bddapron.Mtbdddomain0.O]
size [Bddapron.Mtbdddomain0]
Size of an abstract value in terms of number of nodes of the MTBDD.
size [Bdd.Domain1.O]
size [Bdd.Domain1]
Size of an abstract value (number of nodes)
size [Bdd.Domain0]
Size of an abstract value (number of nodes)
size [SHGraph.S]
size [SHGraph]
size graph returns (nbvertex,nbhedge,nbedgevh,nbedgehv)
size [PSHGraph]
size [FGraph1.S]
size [FGraph1]
size [FGraph.S]
size [FGraph]
size [Apron.Abstract1]
Return the abstract size of a value
size [Apron.Environment]
Return the size of the environment
size [Apron.Abstract0]
Return the abstract size of a value
size [Cudd.Add]
size [Cudd.Mtbddc]
size [Cudd.Mtbdd]
size [Cudd.Vdd]
size [Cudd.Bdd]
size [Mpz]
size_edge [FGraph.S]
size_edge [FGraph]
size_edgehv [SHGraph.S]
size_edgehv [SHGraph]
Number of edges (hyperedge,vertex) in the hypergraph
size_edgehv [PSHGraph]
size_edgevh [SHGraph.S]
size_edgevh [SHGraph]
Number of edges (vertex,hyperedge) in the hypergraph
size_edgevh [PSHGraph]
size_hedge [SHGraph.S]
size_hedge [SHGraph]
Number of hyperedges in the hypergraph
size_hedge [PSHGraph]
size_of_typ [Bdd.Enum]
Return the cardinality of a type (the number of its labels)
size_vertex [SHGraph.S]
size_vertex [SHGraph]
Number of vertices in the hypergraph
size_vertex [PSHGraph]
size_vertex [FGraph.S]
size_vertex [FGraph]
sizeinbase [Mpz]
sort [Bdd.Domain0.O.Asssub]
special_is_leq [Bddapron.ApronDD]
special_join [Bddapron.ApronDD]
special_meet [Bddapron.ApronDD]
split [Sette.Compare]
Meant to be internal, but exporting needed for Mappe.maptoset.
split_bdd [Bdd.Decompose]
split_level [Bdd.Decompose]
Decompose a BDD f into a disjunction [(f1,g1);...;(fN,gN)] such that all decisions in f1...fN have levels strictly less than level;, all decisions in g1...gN have levels greater than or equal to level;, f1...fN are pairwise disjoint.
split_lvar [Bddapron.Descend]
split_lvarlexpr [Bddapron.Descend]
split_texpr [Bddapron.Descend]
splitpermutation_of_envcond [Bdd.Decompose]
Two cases in (level,operm)=splitpermutation_of_envcond ...: operm=None: a BDD should be split according to level;, operm=Some(perm1,perm2): a BDD should be split by applying permutation perm1, splitting the result according to level, and applying to the resulting BDDs the inverse permutation perm2.
sprintf [Print]
Better sprintf function than Format.sprintf, as it takes the same kind of formatters as other Format.Xprintf functions.
sqrt [Bddapron.Expr1.O.Apron]
sqrt [Bddapron.Expr1.Apron]
sqrt [Bddapron.Expr0.O.Apron]
sqrt [Bddapron.Expr0.Apron]
sqrt [Bddapron.ApronexprDD]
sqrt [Bddapron.Apronexpr]
sqrt [Mpz]
sqrt [Mpfrf]
sqrt [Mpfr]
sqrt [Mpf]
sqrt_ui [Mpfr]
sqrtrem [Mpz]
squeeze [Cudd.Bdd]
srandom [Cudd.Man]
stats [Cudd.PWeakke]
stats [Cudd.Weakke.S]
Return statistics on the table.
stats [Cudd.Weakke]
std_deviation [Statistic]
Given the mean, returns the standard deviation of the array.
stdcompare [SHGraph.S]
stdcompare [SHGraph]
stdcompare [PSHGraph]
stdcompare [PHashhe]
stdcompare [Hashhe]
string_of_aprondim [Bddapron.Env]
string_of_binop [Apron.Texpr1]
string_of_binop [Apron.Texpr0]
string_of_error [Cudd.Man]
Printing functions
string_of_exc [Apron.Manager]
string_of_funid [Apron.Manager]
string_of_print [Print]
Transforms a printing function into a conversion-to-string function.
string_of_reorder [Cudd.Man]
string_of_round [Apron.Texpr1]
string_of_round [Apron.Texpr0]
string_of_round [Mpfr]
string_of_typ [Apron.Tcons1]
Convert a constraint type to a string (=,>=, or >)
string_of_typ [Apron.Texpr1]
string_of_typ [Apron.Lincons1]
Convert a constraint type to a string (=,>=, or >)
string_of_typ [Apron.Tcons0]
Convert a constraint type to a string (=,>=, or >)
string_of_typ [Apron.Texpr0]
string_of_typ [Apron.Generator0]
Convert a generator type to a string (LIN,RAY, or VTX)
string_of_typ [Apron.Lincons0]
Convert a constraint type to a string (=,>=, or >)
string_of_unop [Apron.Texpr1]
string_of_unop [Apron.Texpr0]
string_symbol [Bddapron.Env]
Standard manager for symbols of type string
string_symbol [Bdd.Env]
Standard manager for symbols of type string
strtofr [Mpfr]
sub [Bddapron.Expr1.O.Apron]
sub [Bddapron.Expr1.O.Bint]
sub [Bddapron.Expr1.Apron]
sub [Bddapron.Expr1.Bint]
sub [Bddapron.Expr0.O.Apron]
sub [Bddapron.Expr0.O.Bint]
sub [Bddapron.Expr0.Apron]
sub [Bddapron.Expr0.Bint]
sub [Bddapron.ApronexprDD]
sub [Bddapron.Apronexpr.Poly]
sub [Bddapron.Apronexpr.Lin]
sub [Bddapron.Apronexpr]
sub [Bdd.Expr1.O.Bint]
sub [Bdd.Expr1.Bint]
sub [Bdd.Expr0.O.Bint]
sub [Bdd.Expr0.Bint]
sub [Bdd.Int]
sub [Bdd.Reg]
Substraction; returns the new register, the carry, and the overflow (for signed integers).
sub [Rational]
sub [Cudd.Add]
sub [Mpzf]
sub [Mpz]
sub [Mpqf]
sub [Mpq]
sub [Mpfrf]
sub [Mpfr]
sub [Mpf]
sub_int [Mpzf]
sub_int [Mpfrf]
sub_q [Mpfr]
sub_ui [Mpz]
sub_ui [Mpfr]
sub_ui [Mpf]
sub_z [Mpfr]
submul [Mpz]
submul_ui [Mpz]
subset [Sette.Compare]
subset [Sette]
subset s1 s2 tests whether the set s1 is a subset of the set s2.
subset [SetList.S]
subset s1 s2 tests whether the set s1 is a subset of the set s2.
subset [SetList]
subset s1 s2 tests whether the set s1 is a subset of the set s2.
subset [PSette]
subset s1 s2 tests whether the set s1 is a subset of the set s2.
subset [PMappe]
subset [MultiSetList.S]
subset s1 s2 tests whether the multiset s1 is a subset of the multiset s2.
subset [MultiSetList]
subset s1 s2 tests whether the multiset s1 is a subset of the multiset s2.
subset [Mappe.Compare]
subset [Mappe]
subset [Sette.S]
subset s1 s2 tests whether the set s1 is a subset of the set s2.
subset [Mappe.S]
subsetHB [Cudd.Bdd]
subsetSP [Cudd.Bdd]
subsetcompress [Cudd.Bdd]
subseti [PMappe]
subseti [Mappe.Compare]
subseti [Mappe]
subset between maps
subseti [Mappe.S]
subsetx [PDMappe]
subsetx [DMappe.S]
subsetx [DMappe]
subsety [PDMappe]
subsety [DMappe.S]
subsety [DMappe]
Test two two-way association for equality and inclusion.
substitute [Bddapron.Expr1.O.Apron]
substitute [Bddapron.Expr1.O.Benum]
substitute [Bddapron.Expr1.O.Bint]
substitute [Bddapron.Expr1.O.Bool]
substitute [Bddapron.Expr1.O]
substitute [Bddapron.Expr1.Apron]
substitute [Bddapron.Expr1.Benum]
substitute [Bddapron.Expr1.Bint]
substitute [Bddapron.Expr1.Bool]
substitute [Bddapron.Expr1]
substitute [Bddapron.Expr0.O.Apron]
substitute [Bddapron.Expr0.O.Benum]
substitute [Bddapron.Expr0.O.Bint]
substitute [Bddapron.Expr0.O.Bool]
substitute [Bddapron.Expr0.O]
substitute [Bddapron.Expr0.Apron]
substitute [Bddapron.Expr0.Benum]
substitute [Bddapron.Expr0.Bint]
substitute [Bddapron.Expr0.Bool]
substitute [Bddapron.Expr0]
substitute [Bddapron.ApronexprDD.Condition]
substitute [Bddapron.ApronexprDD]
substitute [Bdd.Expr1.O.Benum]
substitute [Bdd.Expr1.O.Bint]
substitute [Bdd.Expr1.O.Bool]
substitute [Bdd.Expr1.O]
substitute [Bdd.Expr1.Benum]
substitute [Bdd.Expr1.Bint]
substitute [Bdd.Expr1.Bool]
substitute [Bdd.Expr1]
substitute [Bdd.Expr0.O.Benum]
substitute [Bdd.Expr0.O.Bint]
substitute [Bdd.Expr0.O.Bool]
substitute [Bdd.Expr0.O]
substitute [Bdd.Expr0.Benum]
substitute [Bdd.Expr0.Bint]
substitute [Bdd.Expr0.Bool]
substitute [Bdd.Expr0]
substitute_by_var [Bddapron.Expr1.O.Apron]
substitute_by_var [Bddapron.Expr1.O.Benum]
substitute_by_var [Bddapron.Expr1.O.Bint]
substitute_by_var [Bddapron.Expr1.O.Bool]
substitute_by_var [Bddapron.Expr1.O]
substitute_by_var [Bddapron.Expr1.Apron]
substitute_by_var [Bddapron.Expr1.Benum]
substitute_by_var [Bddapron.Expr1.Bint]
substitute_by_var [Bddapron.Expr1.Bool]
substitute_by_var [Bddapron.Expr1]
substitute_by_var [Bddapron.Expr0.O.Apron]
substitute_by_var [Bddapron.Expr0.O.Benum]
substitute_by_var [Bddapron.Expr0.O.Bint]
substitute_by_var [Bddapron.Expr0.O.Bool]
substitute_by_var [Bddapron.Expr0.O]
substitute_by_var [Bddapron.Expr0.Apron]
substitute_by_var [Bddapron.Expr0.Benum]
substitute_by_var [Bddapron.Expr0.Bint]
substitute_by_var [Bddapron.Expr0.Bool]
substitute_by_var [Bddapron.Expr0]
substitute_by_var [Bddapron.Apronexpr.Tree]
substitute_by_var [Bddapron.Apronexpr.Poly]
substitute_by_var [Bddapron.Apronexpr.Lin]
substitute_by_var [Bddapron.Apronexpr]
substitute_by_var [Bdd.Expr1.O.Benum]
substitute_by_var [Bdd.Expr1.O.Bint]
substitute_by_var [Bdd.Expr1.O.Bool]
substitute_by_var [Bdd.Expr1.O]
substitute_by_var [Bdd.Expr1.Benum]
substitute_by_var [Bdd.Expr1.Bint]
substitute_by_var [Bdd.Expr1.Bool]
substitute_by_var [Bdd.Expr1]
substitute_by_var [Bdd.Expr0.O.Benum]
substitute_by_var [Bdd.Expr0.O.Bint]
substitute_by_var [Bdd.Expr0.O.Bool]
substitute_by_var [Bdd.Expr0.O]
substitute_by_var [Bdd.Expr0.Benum]
substitute_by_var [Bdd.Expr0.Bint]
substitute_by_var [Bdd.Expr0.Bool]
substitute_by_var [Bdd.Expr0]
substitute_by_var_list [Bddapron.Expr1.O]
Variable renaming.
substitute_by_var_list [Bddapron.Expr1]
Variable renaming.
substitute_by_var_list [Bddapron.Expr0.O]
Parallel substitution of variables by variables
substitute_by_var_list [Bddapron.Expr0]
Parallel substitution of variables by variables
substitute_by_var_list [Bdd.Expr1.O]
Variable renaming.
substitute_by_var_list [Bdd.Expr1]
Variable renaming.
substitute_by_var_list [Bdd.Expr0.O]
Variable renaming.
substitute_by_var_list [Bdd.Expr0]
Variable renaming.
substitute_lexpr [Bddapron.Domain1]
substitute_lexpr [Bddapron.Domainlevel1.Level0]
substitute_lexpr [Bddapron.Domainlevel1.Level1]
substitute_lexpr [Bddapron.Domain0]
substitute_lexpr [Bddapron.Bdddomain0.O]
substitute_lexpr [Bddapron.Bdddomain0]
Parallel assignement/substitution of a list of variables by a list of expressions
substitute_lexpr [Bddapron.Mtbdddomain0.O]
substitute_lexpr [Bddapron.Mtbdddomain0]
Parallel assignement/substitution of a list of variables by a list of expressions
substitute_lexpr [Bdd.Domain1.O]
substitute_lexpr [Bdd.Domain1]
substitute_lexpr [Bdd.Domain0.O]
Substitution
substitute_lexpr [Bdd.Domain0]
Substitution
substitute_linexpr [Bddapron.ApronexprDD]
substitute_linexpr [Apron.Abstract1]
substitute_linexpr [Apron.Abstract0]
substitute_linexpr_array [Apron.Abstract1]
Parallel substitution of an array of dimensions by an array of same size of linear expressions
substitute_linexpr_array [Apron.Abstract0]
Parallel substitution of an array of dimensions by an array of same size of linear expressions
substitute_linexpr_array_with [Apron.Abstract1]
substitute_linexpr_array_with [Apron.Abstract0]
substitute_linexpr_with [Apron.Abstract1]
substitute_linexpr_with [Apron.Abstract0]
substitute_list [Bddapron.Expr1.O]
Parallel substitution of variables by expressions
substitute_list [Bddapron.Expr1]
Parallel substitution of variables by expressions
substitute_list [Bddapron.Expr0.O]
Parallel substitution of variables by expressions
substitute_list [Bddapron.Expr0]
Parallel substitution of variables by expressions
substitute_list [Bdd.Expr1.O]
Parallel substitution of variables by expressions
substitute_list [Bdd.Expr1]
Parallel substitution of variables by expressions
substitute_list [Bdd.Expr0.O]
Parallel substitution of variables by expressions
substitute_list [Bdd.Expr0]
Parallel substitution of variables by expressions
substitute_listexpr [Bdd.Domain1.O]
Substitution
substitute_listexpr [Bdd.Domain1]
Substitution
substitute_listexpr2 [Bddapron.Domain1]
substitute_listexpr2 [Bddapron.Domainlevel1.Level1]
Parallel assignement/substitution of a list of variables by a list of expressions
substitute_polyexpr [Bddapron.ApronexprDD]
substitute_texpr [Apron.Abstract1]
Assignement/Substitution of a single dimension by a single expression
substitute_texpr [Apron.Abstract0]
Assignement/Substitution of a single dimension by a single expression
substitute_texpr_array [Bddapron.ApronDD]
substitute_texpr_array [Apron.Abstract1]
Parallel substitution of an array of dimensions by an array of same size of tree expressions
substitute_texpr_array [Apron.Abstract0]
Parallel substitution of an array of dimensions by an array of same size of tree expressions
substitute_texpr_array_with [Apron.Abstract1]
substitute_texpr_array_with [Apron.Abstract0]
substitute_texpr_with [Apron.Abstract1]
Side-effect version of the previous functions
substitute_texpr_with [Apron.Abstract0]
Side-effect version of the previous functions
substitute_treeexpr [Bddapron.ApronexprDD]
succ [Bddapron.Expr1.O.Bint]
succ [Bddapron.Expr1.Bint]
succ [Bddapron.Expr0.O.Bint]
succ [Bddapron.Expr0.Bint]
succ [Bdd.Expr1.O.Bint]
succ [Bdd.Expr1.Bint]
succ [Bdd.Expr0.O.Bint]
succ [Bdd.Expr0.Bint]
succ [Bdd.Int]
succ [Bdd.Reg]
Successor operation; returns the new register and the carry.
succ [FGraph1.S]
succ [FGraph1]
succ [FGraph.S]
succ [FGraph]
succ_vertex [SHGraph.Compare]
succ_vertex [SHGraph.S]
succ_vertex [SHGraph]
Successor vertices of a vertex by any hyperedge
succ_vertex [PSHGraph]
succhedge [SHGraph.Compare]
succhedge [SHGraph.S]
succhedge [SHGraph]
Successor hyperedges of a vertex
succhedge [PSHGraph]
succvertex [SHGraph.Compare]
succvertex [SHGraph.S]
succvertex [SHGraph]
Successor vertices of an hyperedge
succvertex [PSHGraph]
sup [Bddapron.Expr1.O.Apron]
sup [Bddapron.Expr1.O.Bint]
sup [Bddapron.Expr1.Apron]
sup [Bddapron.Expr1.Bint]
sup [Bddapron.Expr0.O.Apron]
sup [Bddapron.Expr0.O.Bint]
sup [Bddapron.Expr0.Apron]
sup [Bddapron.Expr0.Bint]
sup [Bddapron.ApronexprDD.Condition]
sup [Bdd.Expr1.O.Bint]
sup [Bdd.Expr1.Bint]
sup [Bdd.Expr0.O.Bint]
sup [Bdd.Expr0.Bint]
sup_int [Bddapron.Expr1.O.Bint]
sup_int [Bddapron.Expr1.Bint]
sup_int [Bddapron.Expr0.O.Bint]
sup_int [Bddapron.Expr0.Bint]
sup_int [Bdd.Expr1.O.Bint]
sup_int [Bdd.Expr1.Bint]
sup_int [Bdd.Expr0.O.Bint]
sup_int [Bdd.Expr0.Bint]
supeq [Bddapron.Expr1.O.Apron]
supeq [Bddapron.Expr1.O.Bint]
supeq [Bddapron.Expr1.Apron]
supeq [Bddapron.Expr1.Bint]
supeq [Bddapron.Expr0.O.Apron]
supeq [Bddapron.Expr0.O.Bint]
supeq [Bddapron.Expr0.Apron]
supeq [Bddapron.Expr0.Bint]
supeq [Bddapron.ApronexprDD.Condition]
supeq [Bdd.Expr1.O.Bint]
supeq [Bdd.Expr1.Bint]
supeq [Bdd.Expr0.O.Bint]
supeq [Bdd.Expr0.Bint]
supeq_int [Bddapron.Expr1.O.Bint]
supeq_int [Bddapron.Expr1.Bint]
supeq_int [Bddapron.Expr0.O.Bint]
supeq_int [Bddapron.Expr0.Bint]
supeq_int [Bdd.Expr1.O.Bint]
supeq_int [Bdd.Expr1.Bint]
supeq_int [Bdd.Expr0.O.Bint]
supeq_int [Bdd.Expr0.Bint]
supersetHB [Cudd.Bdd]
supersetSP [Cudd.Bdd]
supersetcompress [Cudd.Bdd]
support [Bddapron.Expr1.O]
Support of the expression
support [Bddapron.Expr1]
Support of the expression
support [Bddapron.Expr0.O]
Return the full support of the expression
support [Bddapron.Expr0]
Return the full support of the expression
support [Bddapron.Apronexpr.Condition]
support [Bddapron.Apronexpr.Tree]
support [Bddapron.Apronexpr.Poly]
support [Bddapron.Apronexpr.Lin]
support [Bddapron.Apronexpr]
support [Bdd.Expr1.O]
Support of the expression
support [Bdd.Expr1]
Support of the expression
support [Bdd.Expr0.O]
Support of the expression
support [Bdd.Expr0]
Support of the expression
support [Cudd.Add]
support [Cudd.Mtbddc]
support [Cudd.Mtbdd]
support [Cudd.Vdd]
support [Cudd.Bdd]
support_cond [Bddapron.Expr1.O]
Return the support of an expression as a conjunction of the BDD identifiers involved in the expression
support_cond [Bddapron.Expr1]
Return the support of an expression as a conjunction of the BDD identifiers involved in the expression
support_cond [Bddapron.Expr0.O]
Return the support of an expression as a conjunction of the BDD identifiers involved in the expression
support_cond [Bddapron.Expr0]
Return the support of an expression as a conjunction of the BDD identifiers involved in the expression
support_cond [Bddapron.ApronexprDD]
support_cond [Bddapron.Cond]
support_cond [Bdd.Expr1.O]
Return the support of an expression as a conjunction of the BDD identifiers involved in the expression
support_cond [Bdd.Expr1]
Return the support of an expression as a conjunction of the BDD identifiers involved in the expression
support_cond [Bdd.Expr0.O]
Return the support of an expression as a conjunction of the BDD identifiers involved in the expression
support_cond [Bdd.Expr0]
Return the support of an expression as a conjunction of the BDD identifiers involved in the expression
support_diff [Cudd.Bdd]
support_inter [Cudd.Bdd]
support_leaf [Bddapron.ApronexprDD]
support_union [Cudd.Bdd]
supportsize [Cudd.Add]
supportsize [Cudd.Mtbddc]
supportsize [Cudd.Mtbdd]
supportsize [Cudd.Vdd]
supportsize [Cudd.Bdd]
swap [Mpz]
swap [Mpq]
swap [Mpfr]
swap [Mpf]

T
table [Cudd.Hash]
Internal table
tan [Mpfr]
tanh [Mpfr]
tbdd_of_texpr [Bdd.Expr0.O]
Concatenates in an array the BDDs involved in the expressions
tbdd_tvdd_cofactor [Bdd.Decompose]
tbdd_tvdd_support_cond [Bdd.Decompose]
tcons [Apron.Apron_parser]
tcons0_array_of_cubecond [Bddapron.Common]
Converts a cube of conditions into an array of APRON constraints
tcons1_of_lexbuf [Apron.Parser]
Conversion from lexing buffers to resp.
tcons1_of_lstring [Apron.Parser]
Conversion from lists of strings to array of tree constraints.
tcons1_of_string [Apron.Parser]
Conversion from lexing buffers to resp.
tdconstrain [Cudd.Add]
tdconstrain [Cudd.Mtbddc]
tdconstrain [Cudd.Mtbdd]
tdconstrain [Cudd.Vdd]
tdconstrain [Cudd.Bdd]
Cuddaux_bddTDConstrain.
tdiv_q [Mpzf]
tdiv_q [Mpz]
tdiv_q_2exp [Mpz]
tdiv_q_ui [Mpz]
tdiv_qr [Mpzf]
tdiv_qr [Mpz]
tdiv_qr_ui [Mpz]
tdiv_r [Mpzf]
tdiv_r [Mpz]
tdiv_r_2exp [Mpz]
tdiv_r_ui [Mpz]
tdiv_ui [Mpz]
tdrestrict [Bddapron.Expr1.O.Apron]
tdrestrict [Bddapron.Expr1.O.Benum]
tdrestrict [Bddapron.Expr1.O.Bint]
tdrestrict [Bddapron.Expr1.O.Bool]
tdrestrict [Bddapron.Expr1.O]
Simplify the expression knowing that the BDD is true.
tdrestrict [Bddapron.Expr1.Apron]
tdrestrict [Bddapron.Expr1.Benum]
tdrestrict [Bddapron.Expr1.Bint]
tdrestrict [Bddapron.Expr1.Bool]
tdrestrict [Bddapron.Expr1]
Simplify the expression knowing that the BDD is true.
tdrestrict [Bddapron.Expr0.O.Apron]
tdrestrict [Bddapron.Expr0.O.Benum]
tdrestrict [Bddapron.Expr0.O.Bint]
tdrestrict [Bddapron.Expr0.O.Bool]
tdrestrict [Bddapron.Expr0.O]
tdrestrict [Bddapron.Expr0.Apron]
tdrestrict [Bddapron.Expr0.Benum]
tdrestrict [Bddapron.Expr0.Bint]
tdrestrict [Bddapron.Expr0.Bool]
tdrestrict [Bddapron.Expr0]
Simplify the expression knowing that the BDD is true.
tdrestrict [Bdd.Expr1.O.Benum]
tdrestrict [Bdd.Expr1.O.Bint]
tdrestrict [Bdd.Expr1.O.Bool]
tdrestrict [Bdd.Expr1.O]
Simplify the expression knowing that the BDD is true.
tdrestrict [Bdd.Expr1.Benum]
tdrestrict [Bdd.Expr1.Bint]
tdrestrict [Bdd.Expr1.Bool]
tdrestrict [Bdd.Expr1]
Simplify the expression knowing that the BDD is true.
tdrestrict [Bdd.Expr0.O.Benum]
tdrestrict [Bdd.Expr0.O.Bint]
tdrestrict [Bdd.Expr0.O.Bool]
tdrestrict [Bdd.Expr0.Benum]
tdrestrict [Bdd.Expr0.Bint]
tdrestrict [Bdd.Expr0.Bool]
tdrestrict [Bdd.Expr0]
Simplify the expression knowing that the BDD is true.
tdrestrict [Bdd.Enum]
tdrestrict [Bdd.Int]
tdrestrict [Bdd.Reg]
tdrestrict [Cudd.Add]
tdrestrict [Cudd.Mtbddc]
tdrestrict [Cudd.Mtbdd]
tdrestrict [Cudd.Vdd]
tdrestrict [Cudd.Bdd]
Cuddaux_bddTDRestrict.
term_of_idcondb [Bdd.Expr0.O.Expr]
term_of_venum [Bdd.Expr0.O.Expr]
term_of_vint [Bdd.Expr0.O.Expr]
texpr [Apron.Apron_parser]
texpr1_of_lexbuf [Apron.Parser]
texpr1_of_string [Apron.Parser]
texpr1expr_of_lexbuf [Apron.Parser]
texpr1expr_of_string [Apron.Parser]
texpr_cofactor [Bddapron.Descend]
texpr_cofactors [Bddapron.Descend]
texpr_of_tbdd [Bdd.Expr0.O]
Inverse operation: rebuild an array of expressions from the old array of expressions (for the types) and the array of BDDs.
texpr_support [Bddapron.Descend]
threshold [Cudd.Add]
tid_of_var [Bdd.Expr0.O]
times_plus [Cudd.Add]
Variation of Cudd_addTimesPlus.
tl [Ilist]
Return the tail of the list.
to_apron0 [Bddapron.Apronexpr.Condition]
to_apron0 [Bddapron.Apronexpr]
to_apron1 [Bddapron.Apronexpr.Condition]
to_apron1 [Bddapron.Apronexpr]
to_bdd [Bddapron.Domain1]
Instanciate the type of a pair (bdd manager,bdd abstract value).
to_bdd [Bddapron.Domain0]
Instanciate the type of a pair (bdd manager,bdd abstract value).
to_bdd [Cudd.Add]
to_bdd_interval [Cudd.Add]
to_bdd_strictthreshold [Cudd.Add]
to_bdd_threshold [Cudd.Add]
to_bddapron [Bddapron.Domain1]
to_bddapron [Bddapron.Domainlevel1.Level0]
to_bddapron [Bddapron.Domainlevel1.Level1]
Extraction of properties
to_bddapron [Bddapron.Domain0]
to_bddapron [Bddapron.Bdddomain0.O]
to_bddapron [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 [Bddapron.Mtbdddomain0.O]
to_bddapron [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 [Bddapron.Syntax]
to_box [Box.Policy]
Instanciate the type of a box value.
to_box [Box.Abstract1]
Instanciate the type of a box value.
to_box [Box.Abstract0]
Instanciate the type of a box value.
to_box [Apron.Abstract1]
Convert the abstract value to an hypercube
to_box [Apron.Abstract0]
Convert the abstract value to an hypercube
to_code [Bdd.Enum]
Convert a constant register to its value as a code.
to_disjunction [Apron.Disjunction.Abstract1]
Instanciate the type of a disjunction value.
to_disjunction [Apron.Disjunction.Abstract0]
Instanciate the type of a disjunction value.
to_domain0 [Bdd.Domain1.O]
to_domain0 [Bdd.Domain1]
Conversion operations
to_expr [Bddapron.Expr2.Bool]
Conversion from/to general expression
to_expr [Bddapron.Expr2.O.Bool]
to_expr [Bddapron.Expr1.O.Apron]
to_expr [Bddapron.Expr1.O.Benum]
to_expr [Bddapron.Expr1.O.Bint]
to_expr [Bddapron.Expr1.O.Bool]
to_expr [Bddapron.Expr1.Apron]
Conversion from/to general expression
to_expr [Bddapron.Expr1.Benum]
Conversion from/to general expression
to_expr [Bddapron.Expr1.Bint]
Conversion from/to general expression
to_expr [Bddapron.Expr1.Bool]
Conversion from/to general expression
to_expr [Bddapron.Expr0.O.Apron]
to_expr [Bddapron.Expr0.O.Benum]
to_expr [Bddapron.Expr0.O.Bint]
to_expr [Bddapron.Expr0.O.Bool]
to_expr [Bddapron.Expr0.Apron]
to_expr [Bddapron.Expr0.Benum]
to_expr [Bddapron.Expr0.Bint]
to_expr [Bddapron.Expr0.Bool]
to_expr [Bddapron.ApronexprDD]
to_expr [Bddapron.Apronexpr.Tree]
to_expr [Bdd.Expr1.O.Benum]
to_expr [Bdd.Expr1.O.Bint]
to_expr [Bdd.Expr1.O.Bool]
to_expr [Bdd.Expr1.Benum]
Conversion from/to general expression
to_expr [Bdd.Expr1.Bint]
Conversion from/to general expression
to_expr [Bdd.Expr1.Bool]
Conversion from/to general expression
to_expr [Bdd.Expr0.O.Benum]
to_expr [Bdd.Expr0.O.Bint]
to_expr [Bdd.Expr0.O.Bool]
to_expr [Bdd.Expr0.Benum]
to_expr [Bdd.Expr0.Bint]
to_expr [Bdd.Expr0.Bool]
to_expr [Apron.Texpr1]
General destructor
to_expr [Apron.Texpr0]
General destructor
to_expr0 [Bddapron.Syntax]
to_expr0 [Bddapron.Expr2.Bool]
to_expr0 [Bddapron.Expr2.O.Bool]
to_expr0 [Bddapron.Expr2.O]
to_expr0 [Bddapron.Expr2]
to_expr0 [Bddapron.Expr1.Apron]
Extract resp.
to_expr0 [Bddapron.Expr1.Benum]
Extract resp.
to_expr0 [Bddapron.Expr1.Bint]
Extract resp.
to_expr0 [Bddapron.Expr1.Bool]
Extract resp.
to_expr0 [Bddapron.Expr1]
Extract resp.
to_expr0 [Bdd.Expr1.O.Benum]
to_expr0 [Bdd.Expr1.O.Bint]
to_expr0 [Bdd.Expr1.O.Bool]
to_expr0 [Bdd.Expr1.O]
to_expr0 [Bdd.Expr1.Benum]
Extract resp.
to_expr0 [Bdd.Expr1.Bint]
Extract resp.
to_expr0 [Bdd.Expr1.Bool]
Extract resp.
to_expr0 [Bdd.Expr1]
Extract resp.
to_expr1 [Bddapron.Syntax]
to_expr1 [Bddapron.Expr2.Bool]
Extract the underlying expression of level 0 and 1
to_expr1 [Bddapron.Expr2.O.Bool]
to_expr1 [Bddapron.Expr2.O]
to_expr1 [Bddapron.Expr2]
Extract the underlying expression of level 0 and 1
to_expr1 [Bdd.Domain1.O]
to_expr1 [Bdd.Domain1]
Conversion operations
to_float [Mpzf]
to_float [Mpz]
to_float [Mpqf]
to_float [Mpq]
to_float [Mpfrf]
to_float [Mpfr]
to_float [Mpf]
to_generator_array [Apron.Abstract1]
Convert the abstract value to a set of generators that defines it.
to_generator_array [Apron.Abstract0]
Convert the abstract value to a set of generators that defines it.
to_int [Bdd.Int]
to_int [Bdd.Reg.Minterm]
Convert a minterm to a (possibly signed) integer.
to_int [Bdd.Reg]
to_int sign x converts a constant register to an integer.
to_label [Bdd.Enum]
Convert a constant register to its value as a label.
to_lconjunction [Bddapron.Formula.Expr1.Bool]
to_lconjunction [Bddapron.Formula.Expr0.Bool]
to_lconjunction [Bddapron.Formula.O.Expr1.Bool]
to_lconjunction [Bddapron.Formula.O.Expr0.Bool]
to_level0 [Bddapron.Domain1]
to_level0 [Bddapron.Domainlevel1.Level1]
to_lexpr [Bddapron.Expr1.O.List]
to_lexpr [Bddapron.Expr1.List]
Conversion from/to lists of general expression
to_lexpr [Bdd.Expr1.O.List]
to_lexpr [Bdd.Expr1.List]
to_lexpr0 [Bddapron.Expr2.List]
to_lexpr0 [Bddapron.Expr2.O.List]
to_lexpr0 [Bddapron.Expr1.O.List]
to_lexpr0 [Bddapron.Expr1.List]
Extract resp.
to_lexpr0 [Bdd.Expr1.O.List]
to_lexpr0 [Bdd.Expr1.List]
to_lexpr1 [Bddapron.Expr2.List]
Extract the underlying list of expressions of level 0 and 1
to_lexpr1 [Bddapron.Expr2.O.List]
to_lincons0_set [Apron.Disjunction]
to_lincons1_set [Apron.Disjunction]
to_lincons_array [Apron.Abstract1]
Convert the abstract value to a conjunction of linear constraints.
to_lincons_array [Apron.Abstract0]
Convert the abstract value to a conjunction of linear constraints.
to_linexpr0 [Bddapron.Apronexpr.Lin]
to_linexpr0 [Bddapron.Apronexpr]
to_linexpr1 [Bddapron.Apronexpr.Lin]
to_linexpr1 [Bddapron.Apronexpr]
to_list [SetList.S]
Conversion to a list
to_list [SetList]
Conversion to a list
to_list [Ilist]
Create a regular list from a recursive list.
to_listexpr1 [Bddapron.Syntax]
to_listexpr1 [Bddapron.Expr2.List]
to_listexpr1 [Bddapron.Expr2.O.List]
to_listexpr2 [Bddapron.Syntax]
to_mpfr [Mpfrf]
to_mpq [Mpqf]
to_mpq [Mpfr]
to_mpqf [Mpfrf]
to_mpz [Mpzf]
to_mpzf2 [Mpqf]
to_mtbdd [Bddapron.Domain1]
Instanciate the type of a pair (mtbdd manager,mtbdd abstract value).
to_mtbdd [Bddapron.Domain0]
Instanciate the type of a pair (mtbdd manager,mtbdd abstract value).
to_oct [Oct.Abstract1]
Instanciate the type of an oct value.
to_oct [Oct.Abstract0]
Instanciate the type of an oct value.
to_polka [Polka.Abstract1]
to_polka [Polka.Abstract0]
to_polka_equalities [Polka.Abstract1]
Instanciate the type of a polka value.
to_polka_equalities [Polka.Abstract0]
Instanciate the type of a polka value.
to_polka_loose [Polka.Abstract1]
to_polka_loose [Polka.Abstract0]
to_polka_strict [Polka.Abstract1]
to_polka_strict [Polka.Abstract0]
to_polkagrid [PolkaGrid.Abstract1]
Instanciate the type of a polkagrid value.
to_polkagrid [PolkaGrid.Abstract0]
Instanciate the type of a polkagrid value.
to_ppl [Ppl.Abstract1]
to_ppl [Ppl.Abstract0]
to_ppl_grid [Ppl.Abstract1]
Instanciate the type of a ppl value.
to_ppl_grid [Ppl.Abstract0]
Instanciate the type of a ppl value.
to_ppl_loose [Ppl.Abstract1]
to_ppl_loose [Ppl.Abstract0]
to_ppl_strict [Ppl.Abstract1]
to_ppl_strict [Ppl.Abstract0]
to_set [MultiSetList.S]
to_set m returns the set of elements in the multiset m.
to_set [MultiSetList]
to_set m returns the set of elements in the multiset m.
to_string [Symbol]
Returns the string represented by the symbol.
to_string [Rational]
to_string [Apron.Policy]
to_string [Apron.Var]
Conversion to string
to_string [Apron.Scalar]
Conversion to string, using string_of_double, Mpqf.to_string or Mpfr.to_string
to_string [Mpzf]
to_string [Mpz]
to_string [Mpqf]
to_string [Mpq]
to_string [Mpfrf]
to_string [Mpfr]
to_string [Mpf]
to_tcons0 [Bddapron.Apronexpr.Condition]
to_tcons1 [Bddapron.Apronexpr.Condition]
to_tcons_array [Apron.Abstract1]
to_tcons_array [Apron.Abstract0]
Convert the abstract value to a conjunction of tree expression constraints.
to_texpr0 [Bddapron.Apronexpr]
to_texpr1 [Bddapron.Apronexpr]
top [Bddapron.Domain1]
top [Bddapron.Domainlevel1.Level0]
top [Bddapron.Domainlevel1.Level1]
top [Bddapron.Domain0]
top [Bddapron.Bdddomain0.O]
top [Bddapron.Bdddomain0]
top [Bddapron.Mtbdddomain0.O]
top [Bddapron.Mtbdddomain0]
top [Bddapron.ApronDD]
top [Bdd.Domain1.O]
Constructors
top [Bdd.Domain1]
Constructors
top [Bdd.Domain0.O]
Constructors
top [Bdd.Domain0]
Constructors
top [Apron.Abstract1]
Create a top (universe) value defined on the given environment
top [Apron.Abstract0]
Create a top (universe) value with the given number of integer and real variables
top [Apron.Interval]
topological_sort [SHGraph.Compare]
topological_sort [SHGraph.S]
topological_sort [SHGraph]
Topological sort of the vertices of the hypergraph starting from a root vertex.
topological_sort [PSHGraph]
topological_sort [FGraph1.S]
topological_sort [FGraph1]
topological_sort [FGraph.S]
topological_sort [FGraph]
topological_sort_multi [SHGraph.Compare]
topological_sort_multi [SHGraph.S]
topological_sort_multi [SHGraph]
Topological sort from a set of root vertices.
topological_sort_multi [PSHGraph]
topological_sort_multi [FGraph1.S]
topological_sort_multi [FGraph1]
topological_sort_multi [FGraph.S]
topological_sort_multi [FGraph]
topvar [Cudd.Add]
topvar [Cudd.Mtbddc]
Returns the index of the top node of the MTBDD (65535 for a constant MTBDD)
topvar [Cudd.Mtbdd]
Returns the index of the top node of the MTBDD (65535 for a constant MTBDD)
topvar [Cudd.Vdd]
topvar [Cudd.Bdd]
transfer [Cudd.Add]
Cuddaux_addTransfer/Cudd_bddTransfer.
transfer [Cudd.Mtbddc]
transfer [Cudd.Mtbdd]
transfer [Cudd.Vdd]
transfer [Cudd.Bdd]
transpose [SHGraph.S]
transpose [SHGraph]
Similar to copy, but hyperedges are reversed: successor vertices and predecessor vertices are exchanged.
transpose [PSHGraph]
transpose [FGraph.S]
transpose [FGraph]
tree_of_lin [Bddapron.Apronexpr]
tree_of_poly [Bddapron.Apronexpr]
triangle [Cudd.Add]
Variation of Cudd_addTriangle.
trunc [Mpfr]
trunc [Mpf]
tstbit [Mpz]
typ_of_expr [Bddapron.Expr1.O]
Type of an expression
typ_of_expr [Bddapron.Expr1]
Type of an expression
typ_of_expr [Bddapron.Expr0.O]
Type of an expression
typ_of_expr [Bddapron.Expr0]
Type of an expression
typ_of_expr [Bddapron.Apronexpr]
typ_of_expr [Bdd.Expr1.O]
Type of an expression
typ_of_expr [Bdd.Expr1]
Type of an expression
typ_of_expr [Bdd.Expr0.O]
Type of an expression
typ_of_expr [Bdd.Expr0]
Type of an expression
typ_of_var [Bddapron.Env]
Return the type of the label/variable
typ_of_var [Bdd.Env]
Return the type of the label/variable
typ_of_var [Apron.Environment]
Return the type of variables in the environment.
typdef_of_typ [Bddapron.Env]
Return the definition of the type
typdef_of_typ [Bdd.Env]
Return the definition of the type

U
ui_div [Mpfrf]
ui_div [Mpfr]
ui_div [Mpf]
ui_pow [Mpfrf]
ui_pow [Mpfr]
ui_pow_ui [Mpz]
ui_pow_ui [Mpfr]
ui_sub [Mpz]
ui_sub [Mpfr]
ui_sub [Mpf]
underapprox [Cudd.Bdd]
underflow_p [Mpfr]
ungroupall [Cudd.Man]
unify [Bddapron.Domain1]
unify [Bddapron.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).
unify [Apron.Abstract1]
Unification of 2 abstract values on their least common environment
unify_with [Apron.Abstract1]
Side-effect version
union [Union]
Computes the union of two sets and returns the resulting set
union [Sette.Compare]
union [Sette]
union [SetList.S]
union [SetList]
union [PSette]
union [MultiSetList.S]
union [MultiSetList]
union [Sette.S]
Set union.
union_set [MultiSetList.S]
union_set [MultiSetList]
unique [Cudd.Mtbddc]
Building a unique constant
unique [Cudd.Mtbdd]
Building a unique constant
unmarshal [Bddapron.Env]
Companion unmarshalling function
unmarshal [Bdd.Env]
Companion unmarshalling function
unop [Apron.Texpr1]
unop [Apron.Texpr0]
urandom [Gmp_random.Mpfr]
urandomb [Gmp_random.Mpfr]
urandomb [Gmp_random.Mpf]
urandomb [Gmp_random.Mpz]
urandomm [Gmp_random.Mpz]

V
var [Bddapron.Expr1.O.Apron]
var [Bddapron.Expr1.O.Benum]
var [Bddapron.Expr1.O.Bint]
var [Bddapron.Expr1.O.Bool]
var [Bddapron.Expr1.O]
Expression representing the litteral var
var [Bddapron.Expr1.Apron]
var [Bddapron.Expr1.Benum]
var [Bddapron.Expr1.Bint]
var [Bddapron.Expr1.Bool]
var [Bddapron.Expr1]
Expression representing the litteral var
var [Bddapron.Expr0.O.Apron]
var [Bddapron.Expr0.O.Benum]
var [Bddapron.Expr0.O.Bint]
var [Bddapron.Expr0.O.Bool]
var [Bddapron.Expr0.O]
Expression representing the litteral var
var [Bddapron.Expr0.Apron]
var [Bddapron.Expr0.Benum]
var [Bddapron.Expr0.Bint]
var [Bddapron.Expr0.Bool]
var [Bddapron.Expr0]
Expression representing the litteral var
var [Bddapron.ApronexprDD]
var [Bddapron.Apronexpr.Poly]
var [Bddapron.Apronexpr.Lin]
var [Bddapron.Apronexpr]
var [Bdd.Expr1.O.Benum]
var [Bdd.Expr1.O.Bint]
var [Bdd.Expr1.O.Bool]
var [Bdd.Expr1.O]
Expression representing the litteral var
var [Bdd.Expr1.Benum]
var [Bdd.Expr1.Bint]
var [Bdd.Expr1.Bool]
var [Bdd.Expr1]
Expression representing the litteral var
var [Bdd.Expr0.O.Benum]
var [Bdd.Expr0.O.Bint]
var [Bdd.Expr0.O.Bool]
var [Bdd.Expr0.O]
Expression representing the litteral var
var [Bdd.Expr0.Benum]
var [Bdd.Expr0.Bint]
var [Bdd.Expr0.Bool]
var [Bdd.Expr0]
Expression representing the litteral var
var [Apron.Texpr1]
var_of_aprondim [Bddapron.Env]
var_of_dim [Apron.Environment]
Return the variable corresponding to the given dimension in the environment.
var_of_level [Cudd.Man]
varconjdecomp [Cudd.Bdd]
Cudd_bddVarDisjDecomp.
vardisjdecomp [Cudd.Bdd]
variance [Statistic]
Given the mean, returns the variance of the array.
varmap [Bddapron.Expr0.O.Apron]
varmap [Bddapron.Expr0.O.Benum]
varmap [Bddapron.Expr0.O.Bint]
varmap [Bddapron.Expr0.O.Bool]
varmap [Bddapron.Expr0.O]
varmap [Bddapron.Expr0.Apron]
varmap [Bddapron.Expr0.Benum]
varmap [Bddapron.Expr0.Bint]
varmap [Bddapron.Expr0.Bool]
varmap [Bddapron.Expr0]
Permutation (rather internal)
varmap [Bdd.Expr0.O.Benum]
varmap [Bdd.Expr0.O.Bint]
varmap [Bdd.Expr0.O.Bool]
varmap [Bdd.Expr0.O]
varmap [Bdd.Expr0.Benum]
varmap [Bdd.Expr0.Bint]
varmap [Bdd.Expr0.Bool]
varmap [Bdd.Enum]
Permutation (scale Cudd.Bdd.varmap)
varmap [Bdd.Int]
Permutation (scale Cudd.Bdd.varmap)
varmap [Bdd.Reg]
Permutation (scale Cudd.Bdd.varmap)
varmap [Cudd.Add]
Cuddaux_addVarMap/Cudd_bddVarMap.
varmap [Cudd.Mtbddc]
varmap [Cudd.Mtbdd]
varmap [Cudd.Vdd]
varmap [Cudd.Bdd]
vars [Bddapron.Env]
Return the list of variables (not labels)
vars [Bdd.Env]
Return the list of variables (not labels)
vars [Apron.Environment]
Return the (lexicographically ordered) sets of integer and real variables in the environment
vdd_of_bdd [Bdd.Decompose]
vdd_support_cond [Bdd.Decompose]
vectorcompose [Bdd.Enum]
Composition (scale Cudd.Bdd.vectorcompose and Cudd.Bdd.vectorcompose_memo)
vectorcompose [Bdd.Int]
Composition (scale Cudd.Bdd.vectorcompose and Cudd.Bdd.vectorcompose_memo)
vectorcompose [Bdd.Reg]
Composition (scale Cudd.Bdd.vectorcompose and Cudd.Bdd.vectorcompose_memo)
vectorcompose [Cudd.Add]
Cuddaux_addVectorCompose/Cudd_addVectorCompose.
vectorcompose [Cudd.Mtbddc]
vectorcompose [Cudd.Mtbdd]
vectorcompose [Cudd.Vdd]
vectorcompose [Cudd.Bdd]
vectorsupport [Cudd.Add]
vectorsupport [Cudd.Mtbddc]
vectorsupport [Cudd.Mtbdd]
vectorsupport [Cudd.Vdd]
vectorsupport [Cudd.Bdd]
vectorsupport2 [Cudd.Add]
vectorsupport2 [Cudd.Mtbddc]
vectorsupport2 [Cudd.Mtbdd]
vectorsupport2 [Cudd.Vdd]
vertex_dummy [SHGraph.T]
A dummy (never used) value for vertex identifiers (used for the functions XXX_multi)
vertex_dummy [SHGraph.S]
vertices [FGraph1.S]
vertices [FGraph1]
vertices [FGraph.S]
vertices [FGraph]

W
weak [Print]
Print a weak pointer array
widening [Bddapron.Domain1]
widening [Bddapron.Domainlevel1.Level0]
widening [Bddapron.Domainlevel1.Level1]
widening [Bddapron.Domain0]
widening [Bddapron.Bdddomain0.O]
widening [Bddapron.Bdddomain0]
widening [Bddapron.Mtbdddomain0.O]
widening [Bddapron.Mtbdddomain0]
widening [Bddapron.ApronDD]
widening [Apron.Abstract1]
Widening.
widening [Apron.Abstract0]
Widening.
widening_threshold [Bddapron.Domain1]
widening_threshold [Bddapron.Domainlevel1.Level0]
widening_threshold [Bddapron.Domainlevel1.Level1]
Widening
widening_threshold [Bddapron.Domain0]
widening_threshold [Bddapron.Bdddomain0.O]
widening_threshold [Bddapron.Bdddomain0]
Widening
widening_threshold [Bddapron.Mtbdddomain0.O]
widening_threshold [Bddapron.Mtbdddomain0]
Widening
widening_threshold [Bddapron.ApronDD]
widening_threshold [Apron.Abstract1]
widening_threshold [Apron.Abstract0]
widening_thresholds [Oct]
Widening with scalar thresholds.
wrap_duration [Time]
wrap_duration duration f executes the function f and stores into !duration the time spent in f, in seconds.
wrap_duration_add [Time]
Similar to wrap_duration, but here the time spent in f is added to the value !duration.

X
x_of_y [PDMappe]
x_of_y [PDHashhe]
x_of_y [DMappe.S]
x_of_y [DMappe]
Inverse association
x_of_y [DHashhe.S]
x_of_y [DHashhe]
Inverse association.
xor [Bddapron.Expr1.O.Bool]
xor [Bddapron.Expr1.Bool]
xor [Bddapron.Expr0.O.Bool]
xor [Bddapron.Expr0.Bool]
xor [Bdd.Expr1.O.Bool]
xor [Bdd.Expr1.Bool]
xor [Bdd.Expr0.O.Bool]
xor [Bdd.Expr0.Bool]
xor [Cudd.Bdd]
xor [Mpz]

Y
y0 [Mpfr]
y1 [Mpfr]
y_of_x [PDMappe]
y_of_x [PDHashhe]
y_of_x [DMappe.S]
y_of_x [DMappe]
Association
y_of_x [DHashhe.S]
y_of_x [DHashhe]
Association.
yn [Mpfr]

Z
zero [Bddapron.Expr1.O.Bint]
zero [Bddapron.Expr1.Bint]
zero [Bddapron.Expr0.O.Bint]
zero [Bddapron.Expr0.Bint]
zero [Bddapron.Apronexpr.Lin]
zero [Bddapron.Apronexpr]
zero [Bdd.Expr1.O.Bint]
zero [Bdd.Expr1.Bint]
zero [Bdd.Expr0.O.Bint]
zero [Bdd.Expr0.Bint]
zero [Bdd.Int]
zero [Bdd.Reg]
Tests the register to zero.
zeta [Mpfr]