|
_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] |
|
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] |
|
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] |
|
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] |
|
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] |
|
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] |
|
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] |
|
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] |
|
is_eval_cst [Cudd.Add] |
|
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] |
|
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] |
|
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] |
|
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] |
|
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] |
|
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] |
|
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] |
|
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] |
|
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] |
|
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] |
|
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] |
|
print__minterm [Cudd.Mtbddc] |
|
print__minterm [Cudd.Mtbdd] |
|
print__minterm [Cudd.Vdd] |
|
print__minterm [Cudd.Bdd] |
|
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] |
|
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] |
|
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] |
|
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] |
|
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] |
|
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] |
|
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] |
|
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] |
|
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] |
|