( * ) [Fcl_misc.Operators] | |
( **~ ) [Facile.Easy] | |
( **~ ) [Facile.Arith] | |
( **~ ) [Fcl_arith] | Exponentiation of an expression to an integer value. |
( *~ ) [Facile.Easy] | |
( *~ ) [Facile.Arith] | |
( *~ ) [Fcl_arith] | Addition, substraction, multiplication on expressions. |
(%~) [Facile.Easy] | |
(%~) [Facile.Arith] | |
(%~) [Fcl_arith] | Division and modulo on expressions. |
(&&~) [Facile.Easy] | |
(&&~) [Facile.Goals] | |
(&&~) [Fcl_goals] | |
(&&~~) [Facile.Easy] | |
(&&~~) [Facile.Reify] | |
(&&~~) [Fcl_reify] | |
(+) [Fcl_misc.Operators] | |
(+~) [Facile.Easy] | |
(+~) [Facile.Arith] | |
(+~) [Fcl_arith] | |
(-) [Fcl_misc.Operators] | |
(-~) [Facile.Easy] | |
(-~) [Facile.Arith] | |
(-~) [Fcl_arith] | |
(/+) [Fcl_misc.Operators] | |
(/-) [Fcl_misc.Operators] | |
(/~) [Facile.Easy] | |
(/~) [Facile.Arith] | |
(/~) [Fcl_arith] | |
(<=>~~) [Facile.Easy] | |
(<=>~~) [Facile.Reify] | |
(<=>~~) [Fcl_reify] | |
(<=~) [Facile.Easy] | |
(<=~) [Facile.Arith] | |
(<=~) [Fcl_arith] | |
(<=~~) [Facile.Easy] | |
(<=~~) [Facile.Arith] | |
(<=~~) [Fcl_arith] | |
(<>~) [Facile.Easy] | |
(<>~) [Facile.Arith] | |
(<>~) [Fcl_arith] | Strictly less, less or equal, equal, greater or equal, strictly greater and different constraints on expressions. |
(<>~~) [Facile.Easy] | |
(<>~~) [Facile.Arith] | |
(<>~~) [Fcl_arith] | Reified strictly less, less or equal, equal, greater or equal, strictly greater and different. |
(<~) [Facile.Easy] | |
(<~) [Facile.Arith] | |
(<~) [Fcl_arith] | |
(<~~) [Facile.Easy] | |
(<~~) [Facile.Arith] | |
(<~~) [Fcl_arith] |
|
(=+) [Fcl_misc.Operators] | |
(=+.) [Fcl_misc.Operators] | |
(=>~~) [Facile.Easy] | |
(=>~~) [Facile.Reify] | |
(=>~~) [Fcl_reify] | |
(=~) [Facile.Easy] | |
(=~) [Facile.Arith] | |
(=~) [Fcl_arith] | |
(=~~) [Facile.Easy] | |
(=~~) [Facile.Arith] | |
(=~~) [Fcl_arith] | |
(>=~) [Facile.Easy] | |
(>=~) [Facile.Arith] | |
(>=~) [Fcl_arith] | |
(>=~~) [Facile.Easy] | |
(>=~~) [Facile.Arith] | |
(>=~~) [Fcl_arith] | |
(>~) [Facile.Easy] | |
(>~) [Facile.Arith] | |
(>~) [Fcl_arith] | |
(>~~) [Facile.Easy] | |
(>~~) [Facile.Arith] | |
(>~~) [Fcl_arith] | |
(||~) [Facile.Easy] | |
(||~) [Facile.Goals] | |
(||~) [Fcl_goals] | Conjunction and disjunction over goals. |
(||~~) [Facile.Easy] | |
(||~~) [Facile.Reify] | |
(||~~) [Fcl_reify] | |
A | |
abs [Facile.Arith] | |
abs [Fcl_arith] | Absolute value on expressions. |
absolute [Fcl_nonlinear] | |
absolute_aux [Fcl_nonlinear] | |
active_store [Facile.Cstr] | |
active_store [Fcl_cstr] |
|
add [Facile.Data.Hashtbl] | |
add [Facile.SetDomain.S] | |
add [Facile.Domain] | |
add [Fcl_data.Hashtbl] | |
add [Fcl_setDomain.S] | |
add [Fcl_domain] |
|
all_disjoint [Facile.Conjunto] | |
all_disjoint [Fcl_conjunto] |
|
arg_max_array [Fcl_misc] | |
arg_min_array [Fcl_misc] | |
argmin [Facile.Invariant.Array] | |
argmin [Fcl_invariant.Array] |
|
array [Facile.Var.BASICFD] | |
array [Fcl_var.BASICFD] |
|
atmost1 [Facile.Conjunto] | |
atomic [Facile.Goals] | |
atomic [Fcl_goals] |
|
B | |
binary [Facile.Invariant] | |
binary [Fcl_invariant] |
|
boolean [Facile.Reify] | |
boolean [Facile.Domain] | |
boolean [Fcl_reify] |
|
boolean [Fcl_domain] | The domain containing |
C | |
call [Fcl_debug] | |
cardinal [Facile.Conjunto] | |
cardinal [Facile.SetDomain.S] | |
cardinal [Fcl_conjunto] |
|
cardinal [Fcl_setDomain.S] | |
choose [Facile.SetDomain.S] | |
choose [Facile.Domain] | |
choose [Fcl_setDomain.S] | |
choose [Fcl_domain] |
|
choose_index [Facile.Goals.GlArray] | |
choose_index [Facile.Goals.Array] | |
choose_index [Fcl_goals.Array] |
|
compare [Facile.Var.BASICFD] | |
compare [Facile.SetDomain.S] | |
compare [Facile.Domain] | |
compare [Fcl_var.BASICFD] | Compares two variables. |
compare [Fcl_setDomain.S] | |
compare [Fcl_domain] |
|
compare_elt [Facile.Domain] | |
compare_elt [Fcl_domain] |
|
compare_elt [Fcl_float] | |
compare_expr [Fcl_expr] | |
compare_intexpr [Fcl_expr] | |
constant [Facile.Invariant] | |
constant [Fcl_invariant] |
|
constrain [Fcl_expr] |
|
constraints_number [Facile.Var.ATTR] | |
constraints_number [Fcl_var.ATTR] |
|
create [Facile.Invariant] | |
create [Facile.Goals] | |
create [Facile.Var.BASICFD] | |
create [Facile.Cstr] | |
create [Facile.Data.Hashtbl] | |
create [Facile.Domain] | |
create [Fcl_goals] |
|
create [Fcl_invariant] |
|
create [Fcl_var.BASICFD] |
|
create [Fcl_cstr] |
|
create [Fcl_data.Hashtbl] | |
create [Fcl_domain] |
|
create_rec [Facile.Goals] | |
create_rec [Fcl_goals] |
|
cstr [Facile.Gcc] | |
cstr [Facile.Interval] | |
cstr [Facile.Boolean] | |
cstr [Facile.Sorting] | |
cstr [Facile.Alldiff] | |
cstr [Facile.Reify] | |
cstr [Fcl_sorting] |
|
cstr [Fcl_gcc] |
|
cstr [Fcl_interval] |
|
cstr [Fcl_linear] | |
cstr [Fcl_alldiff] |
|
cstr [Fcl_boolean] |
|
cstr [Fcl_reify] |
|
cut [Facile.Stak] | |
cut [Fcl_stak] |
|
D | |
delay [Facile.Var.BASICFD] | |
delay [Facile.Var] | |
delay [Fcl_var.BASICFD] |
|
depth [Facile.Stak] | |
depth [Fcl_stak] | Depth of the stack, i.e. |
dichotomic [Facile.Goals] | |
dichotomic [Fcl_goals] | Non-deterministic instantiation of a variable, by dichotomic recursive exploration of its domain. |
diff [Facile.SetDomain.S] | |
diff [Facile.Domain] | |
diff [Fcl_setDomain.S] | |
diff [Fcl_domain] |
|
diffeqsign [Fcl_nonlinear] | |
difference [Facile.Domain] | |
difference [Fcl_domain] |
|
diffsign [Fcl_nonlinear] | |
disjoint [Facile.Conjunto] | |
disjoint [Facile.Domain] | |
disjoint [Fcl_conjunto] |
|
disjoint [Fcl_domain] |
|
division [Fcl_nonlinear] | |
division_aux [Fcl_nonlinear] | |
dom [Facile.Var.ATTR] | |
dom [Fcl_var.ATTR] |
|
E | |
e2fd [Facile.Arith] | |
e2fd [Fcl_arith] |
|
elements [Facile.SetDomain.S] | |
elements [Fcl_setDomain.S] | |
elt [Facile.Var.BASICFD] | |
elt [Fcl_var.BASICFD] |
|
elt_of_list [Facile.SetDomain] | |
elt_of_list [Fcl_setDomain] | Creates a set from a list of integers. |
elt_value [Facile.Var.BASICFD] | |
elt_value [Fcl_var.BASICFD] |
|
empty [Facile.SetDomain.S] | |
empty [Facile.Domain] | |
empty [Fcl_setDomain.S] | |
empty [Fcl_domain] | The empty domain. |
epsilon [Fcl_float] | |
equal [Facile.Var.BASICFD] | |
equal [Facile.SetDomain.S] | |
equal [Fcl_var.BASICFD] | Tests if two variables are equal with respect to |
equal [Fcl_setDomain.S] | |
eval [Facile.Arith] | |
eval [Facile.Expr] | |
eval [Fcl_arith] |
|
eval [Fcl_expr] |
|
exists [Facile.Goals.List] | |
exists [Facile.Goals.Array] | |
exists [Fcl_goals.List] |
|
exists [Fcl_goals.Array] |
|
existsi [Facile.Goals.Array] | |
existsi [Fcl_goals.Array] |
|
expn [Fcl_nonlinear] | |
expn_aux [Fcl_nonlinear] | |
expn_int [Fcl_nonlinear] | |
F | |
fail [Facile.Goals] | |
fail [Facile.Stak] | |
fail [Fcl_goals] | |
fail [Fcl_stak] |
|
fatal_error [Fcl_debug] | |
fd2e [Facile.Easy] | |
fd2e [Facile.Arith] | |
fd2e [Fcl_arith] |
|
find [Facile.Data.Hashtbl] | |
find [Fcl_data.Hashtbl] | |
fold [Facile.Data.Hashtbl] | |
fold [Fcl_data.Hashtbl] | |
forall [Facile.Goals.List] | |
forall [Facile.Goals.Array] | |
forall [Fcl_goals.List] |
|
forall [Fcl_goals.Array] |
|
foralli [Facile.Goals.Array] | |
foralli [Fcl_goals.Array] |
|
fordownto [Facile.Goals] | |
fordownto [Fcl_goals] |
|
forto [Facile.Goals] | |
forto [Fcl_goals] | |
fprint [Facile.Invariant] | |
fprint [Facile.Arith] | |
fprint [Facile.Expr] | |
fprint [Facile.Goals] | |
fprint [Facile.Var.BASICFD] | |
fprint [Facile.Var.ATTR] | |
fprint [Facile.Cstr] | |
fprint [Facile.SetDomain] | |
fprint [Facile.Domain] | |
fprint [Fcl_goals] |
|
fprint [Fcl_arith] |
|
fprint [Fcl_expr] |
|
fprint [Fcl_invariant] |
|
fprint [Fcl_var.BASICFD] |
|
fprint [Fcl_var.ATTR] |
|
fprint [Fcl_cstr] |
|
fprint [Fcl_setDomain] | Pretty printing of elements and domains. |
fprint [Fcl_domain] | Pretty printing of elements and domains. |
fprint [Fcl_float] | |
fprint_array [Facile.Var.BASICFD] | |
fprint_array [Fcl_var.BASICFD] |
|
fprint_elt [Facile.SetDomain] | |
fprint_elt [Facile.Domain] | |
fprint_elt [Fcl_setDomain] | |
fprint_elt [Fcl_domain] | |
fprint_elt [Fcl_float] | |
G | |
gen_int_fun [Fcl_misc] | |
get [Facile.FdArray] | |
get [Facile.Invariant.Array] | |
get [Facile.Invariant] | |
get [Facile.Data.Hashtbl] | |
get [Facile.Stak] | |
get [Fcl_fdArray] |
|
get [Fcl_invariant.Array] |
|
get [Fcl_invariant] | Access to the content of a BIR. |
get [Fcl_data.Hashtbl] | |
get [Fcl_stak] | Dereference. |
get_boolsum_threshold [Facile.Arith] | |
get_boolsum_threshold [Fcl_arith] | Returns the minimum size for boolean sums optimization. |
get_boolsum_threshold [Fcl_linear] | Returns the minimum size for boolean sums optimization. |
get_cstr [Facile.FdArray] | |
get_cstr [Fcl_fdArray] |
|
goedel [Fcl_misc] | |
greatest_leq [Facile.Domain] | |
greatest_leq [Fcl_domain] |
|
I | |
i2e [Facile.Easy] | |
i2e [Facile.Arith] | |
i2e [Fcl_arith] |
|
id [Facile.Invariant] | |
id [Facile.Var.BASICFD] | |
id [Facile.Var.ATTR] | |
id [Facile.Cstr] | |
id [Fcl_invariant] |
|
id [Fcl_var.BASICFD] |
|
id [Fcl_var.ATTR] |
|
id [Fcl_cstr] |
|
immediate [Facile.Cstr] | |
immediate [Fcl_cstr] | |
included [Facile.SetDomain] | |
included [Facile.Domain] | |
included [Fcl_setDomain] |
|
included [Fcl_domain] |
|
included [Fcl_float] | |
indomain [Facile.Goals.Conjunto] | |
indomain [Facile.Goals] | |
indomain [Fcl_goals.Conjunto] | Non-deterministic instantiation of set variables ( |
indomain [Fcl_goals] | Non-deterministic instantiation of a variable, by labeling its domain (in increasing order). |
inf_min [Facile.Conjunto] | |
inf_min [Fcl_conjunto] |
|
init [Facile.Cstr] | |
inside [Facile.Conjunto] | |
inside [Fcl_conjunto] | |
instantiate [Facile.Goals] | |
instantiate [Fcl_goals] |
|
int [Facile.Var.BASICFD] | |
int [Facile.Domain] | |
int [Fcl_domain] | The largest representable domain. |
int_overflow [Fcl_misc] | |
int_value [Facile.Var.BASICFD] | |
int_value [Fcl_var.BASICFD] | |
inter [Facile.Conjunto] | |
inter [Facile.SetDomain.S] | |
inter [Fcl_conjunto] | Operations on sets. |
inter [Fcl_setDomain.S] | |
internal_error [Fcl_debug] | |
intersection [Facile.Domain] | |
intersection [Fcl_domain] | |
interval [Facile.Var.BASICFD] | |
interval [Facile.SetDomain] | |
interval [Facile.Domain] | |
interval [Fcl_var.BASICFD] |
|
interval [Fcl_setDomain] |
|
interval [Fcl_domain] |
|
interval [Fcl_float] | |
interval_iter [Facile.Domain] | |
interval_iter [Fcl_domain] |
|
is_bound [Facile.Var.BASICFD] | |
is_bound [Fcl_var.BASICFD] |
|
is_empty [Facile.SetDomain.S] | |
is_empty [Facile.Domain] | |
is_empty [Fcl_setDomain.S] | |
is_empty [Fcl_domain] |
|
is_member [Facile.Interval] | |
is_member [Fcl_interval] |
|
is_solved [Facile.Cstr] | |
is_solved [Fcl_cstr] |
|
is_var [Facile.Invariant.FD] | |
is_var [Facile.Var.BASICFD] | |
is_var [Fcl_invariant.FD] | BIR variants of |
is_var [Fcl_var.BASICFD] |
|
iter [Facile.Goals.GlList] | |
iter [Facile.Goals.GlArray] | |
iter [Facile.Var.FD] | |
iter [Facile.Data.Hashtbl] | |
iter [Facile.SetDomain.S] | |
iter [Facile.SetDomain] | |
iter [Facile.Domain] | |
iter [Fcl_var.FD] |
|
iter [Fcl_data.Hashtbl] | |
iter [Fcl_setDomain.S] | |
iter [Fcl_setDomain] | Iteration on values of the domain. |
iter [Fcl_domain] |
|
iter [Fcl_misc] | |
iter2 [Facile.Goals.GlArray] | |
iter_h [Facile.Goals.GlList] | |
iter_h [Facile.Goals.GlArray] | |
iter_hi [Facile.Goals.GlArray] | |
iteri [Facile.Goals.GlArray] | |
L | |
labeling [Facile.Goals.GlList] | |
labeling [Facile.Goals.List] | |
labeling [Facile.Goals.GlArray] | |
labeling [Facile.Goals.Array] | |
labeling [Fcl_goals.List] | Standard labeling, i.e. |
labeling [Fcl_goals.Array] | Standard labeling, i.e. |
largest_hole_around [Facile.Domain] | |
largest_hole_around [Fcl_domain] |
|
last_and_length [Fcl_misc] | |
later [Facile.Cstr] | |
later [Fcl_cstr] | Available priorities: immediate: as soon as possible, for quick updates;, normal: standard priority;, later: for time consuming constraints (e.g. |
lds [Facile.Goals] | |
lds [Fcl_goals] |
|
level [Facile.Stak] | |
level [Fcl_stak] | Returns the current level. |
level [Fcl_debug] | |
levels [Facile.Stak] | |
levels [Fcl_stak] | Returns the current active levels. |
linear_aux [Fcl_linear] | |
log [Fcl_debug] | |
M | |
max [Facile.FdArray] | |
max [Facile.Invariant.FD] | |
max [Facile.Var.BASICFD] | |
max [Facile.Var.ATTR] | |
max [Facile.SetDomain] | |
max [Facile.Domain] | |
max [Fcl_fdArray] |
|
max [Fcl_invariant.FD] | |
max [Fcl_var.BASICFD] |
|
max [Fcl_var.ATTR] |
|
max [Fcl_setDomain] | |
max [Fcl_domain] |
|
max [Fcl_float] | |
max [Fcl_misc.Operators] | |
max_cstr [Facile.FdArray] | |
max_cstr [Fcl_fdArray] |
|
max_elt [Facile.SetDomain.S] | |
max_elt [Fcl_setDomain.S] | |
max_of_absmod_inter [Fcl_nonlinear] | |
max_of_expr [Facile.Arith] | |
max_of_expr [Facile.Expr] | |
max_of_expr [Fcl_arith] |
|
max_of_expr [Fcl_expr] |
|
mem [Facile.Conjunto] | |
mem [Facile.Data.Hashtbl] | |
mem [Facile.SetDomain.S] | |
mem [Facile.SetDomain] | |
mem [Fcl_conjunto] |
|
mem [Fcl_data.Hashtbl] | |
mem [Fcl_setDomain.S] | |
mem [Fcl_setDomain] |
|
mem [Fcl_domain] | |
mem [Fcl_float] | |
member [Facile.Conjunto] | |
member [Facile.Goals.GlList] | |
member [Facile.Goals.List] | |
member [Facile.Var.BASICFD] | |
member [Facile.Var.ATTR] | |
member [Facile.Domain] | |
member [Fcl_goals.List] |
|
member [Fcl_conjunto] |
|
member [Fcl_var.BASICFD] |
|
member [Fcl_var.ATTR] |
|
member [Fcl_domain] |
|
min [Facile.FdArray] | |
min [Facile.Invariant.FD] | |
min [Facile.Invariant.Array] | |
min [Facile.Var.BASICFD] | |
min [Facile.Var.ATTR] | |
min [Facile.SetDomain] | |
min [Facile.Domain] | |
min [Fcl_fdArray] | |
min [Fcl_invariant.FD] | |
min [Fcl_invariant.Array] |
|
min [Fcl_var.BASICFD] |
|
min [Fcl_var.ATTR] | |
min [Fcl_setDomain] | |
min [Fcl_domain] | |
min [Fcl_float] | |
min [Fcl_misc.Operators] | |
min_cstr [Facile.FdArray] | |
min_cstr [Fcl_fdArray] | |
min_elt [Facile.SetDomain.S] | |
min_elt [Fcl_setDomain.S] | |
min_max [Facile.Var.BASICFD] | |
min_max [Facile.SetDomain] | |
min_max [Facile.Domain] | |
min_max [Fcl_var.BASICFD] |
|
min_max [Fcl_setDomain] | Access to glb and lub. |
min_max [Fcl_domain] |
|
min_max [Fcl_float] | |
min_max_abs_inter [Fcl_nonlinear] | |
min_max_div_inter [Fcl_nonlinear] | |
min_max_expn_inter [Fcl_nonlinear] | |
min_max_minus_inter [Fcl_linear] | |
min_max_mod_inter [Fcl_nonlinear] | |
min_max_mult_inter [Fcl_nonlinear] | |
min_max_of_expr [Facile.Arith] | |
min_max_of_expr [Facile.Expr] | |
min_max_of_expr [Fcl_arith] |
|
min_max_of_expr [Fcl_expr] |
|
min_max_plus_inter [Fcl_linear] | |
min_of_absmod_inter [Fcl_nonlinear] | |
min_of_expr [Facile.Arith] | |
min_of_expr [Facile.Expr] | |
min_of_expr [Fcl_arith] | |
min_of_expr [Fcl_expr] | |
minimize [Facile.Opti] | |
minimize [Facile.Goals] | |
minimize [Fcl_opti] | |
minimize [Fcl_goals] |
|
minus [Facile.Domain] | |
minus [Fcl_domain] |
|
modulo [Fcl_nonlinear] | |
modulo_aux [Fcl_nonlinear] | |
monome [Fcl_nonlinear] | |
monome_aux [Fcl_nonlinear] | |
N | |
name [Facile.Invariant] | |
name [Facile.Goals] | |
name [Facile.Var.BASICFD] | |
name [Facile.Cstr] | |
name [Fcl_goals] |
|
name [Fcl_invariant] |
|
name [Fcl_var.BASICFD] |
|
name [Fcl_cstr] |
|
nb_choice_points [Facile.Stak] | |
nb_choice_points [Fcl_stak] | Access to a global counter incremented at each choice point. |
normal [Facile.Cstr] | |
normal [Fcl_cstr] | |
not [Facile.Reify] | |
not [Fcl_reify] | Logical reification operators on constraints, namely and, or, implies, equivalent, exclusive or, not. |
not [Fcl_cstr] |
|
not_instantiated_fd [Facile.Goals.GlArray] | |
not_instantiated_fd [Facile.Goals.Array] | |
not_instantiated_fd [Fcl_goals.Array] |
|
O | |
older [Facile.Stak] | |
older [Fcl_stak] |
|
on_max [Facile.Var.BASICFD] | |
on_max [Facile.Var.ATTR] | |
on_max [Fcl_var.BASICFD] | Event occuring when the lower (resp. |
on_max [Fcl_var.ATTR] | Event occuring when the lower (resp. |
on_min [Facile.Var.BASICFD] | |
on_min [Facile.Var.ATTR] | |
on_min [Fcl_var.BASICFD] | |
on_min [Fcl_var.ATTR] | |
on_refine [Facile.Var.BASICFD] | |
on_refine [Facile.Var.ATTR] | |
on_refine [Fcl_var.BASICFD] | Event occuring when a variable is changed, i.e. |
on_refine [Fcl_var.ATTR] | Event occuring when a variable is changed, i.e. |
on_subst [Facile.Var.BASICFD] | |
on_subst [Facile.Var.ATTR] | |
on_subst [Fcl_var.BASICFD] | Event occuring when a variable is instantiated. |
on_subst [Fcl_var.ATTR] | Event occuring when a variable is instantiated. |
once [Facile.Goals] | |
once [Fcl_goals] |
|
one [Facile.Cstr] | |
one [Fcl_cstr] | |
order [Facile.Conjunto] | |
order [Fcl_conjunto] |
|
order_with_card [Facile.Conjunto] | |
order_with_card [Fcl_conjunto] |
|
outside [Facile.Conjunto] | |
outside [Fcl_conjunto] | Basic refinements for labeling. |
P | |
plus [Facile.Domain] | |
plus [Fcl_domain] |
|
post [Facile.Cstr] | |
post [Fcl_cstr] |
|
print_in_assert [Fcl_debug] | |
priority [Facile.Cstr] | |
priority [Fcl_cstr] |
|
prod [Facile.Invariant] | |
prod [Facile.Arith] | |
prod [Fcl_arith] | |
prod [Fcl_invariant] |
|
prod_fd [Facile.Arith] | |
prod_fd [Fcl_arith] |
|
protect [Fcl_misc] | |
R | |
reduce [Fcl_expr] |
|
ref [Facile.Stak] | |
ref [Fcl_stak] | Returns a reference whose modifications will be trailed during the solving of a goal. |
refine [Facile.Var.BASICFD] | |
refine [Fcl_var.BASICFD] |
|
refine_low [Facile.Var.BASICFD] | |
refine_low [Fcl_var.BASICFD] |
|
refine_low_up [Facile.Var.BASICFD] | |
refine_low_up [Fcl_var.BASICFD] |
|
refine_up [Facile.Var.BASICFD] | |
refine_up [Fcl_var.BASICFD] |
|
remove [Facile.Var.FD] | |
remove [Facile.Data.Hashtbl] | |
remove [Facile.SetDomain.S] | |
remove [Facile.Domain] | |
remove [Fcl_var.FD] |
|
remove [Fcl_data.Hashtbl] | |
remove [Fcl_setDomain.S] | |
remove [Fcl_domain] |
|
remove_closed_inter [Facile.Domain] | |
remove_closed_inter [Fcl_domain] |
|
remove_low [Facile.SetDomain.S] | |
remove_low [Facile.Domain] | |
remove_low [Fcl_setDomain.S] | |
remove_low [Fcl_domain] |
|
remove_low [Fcl_float] | |
remove_low_up [Facile.Domain] | |
remove_low_up [Fcl_domain] |
|
remove_max [Fcl_domain] |
|
remove_min [Facile.Domain] | |
remove_min [Fcl_domain] | |
remove_up [Facile.SetDomain.S] | |
remove_up [Facile.Domain] | |
remove_up [Fcl_setDomain.S] | |
remove_up [Fcl_domain] | |
remove_up [Fcl_float] | |
replace [Facile.Data.Hashtbl] | |
replace [Fcl_data.Hashtbl] | |
S | |
scalprod [Facile.Arith] | |
scalprod [Fcl_arith] | |
scalprod_fd [Facile.Arith] | |
scalprod_fd [Fcl_arith] |
|
set [Facile.Invariant] | |
set [Facile.Data.Array] | |
set [Facile.Stak] | |
set [Fcl_invariant] | Assignment of a setable BIR. |
set [Fcl_data.Array] |
|
set [Fcl_stak] | Sets a backtrackable reference. |
set_boolsum_threshold [Facile.Arith] | |
set_boolsum_threshold [Fcl_arith] | Set the minimum size for boolean sums optimization. |
set_boolsum_threshold [Fcl_linear] | Set the minimum size for boolean sums optimization. |
shift [Facile.Arith] | |
shift [Fcl_arith] |
|
shift_cstr [Fcl_linear] |
|
sigma [Facile.Goals] | |
sigma [Fcl_goals] |
|
sign [Fcl_misc.Operators] | |
singleton [Facile.SetDomain.S] | |
singleton [Fcl_setDomain.S] | |
size [Facile.Invariant.FD] | |
size [Facile.Var.BASICFD] | |
size [Facile.Var.ATTR] | |
size [Facile.Stak] | |
size [Facile.Domain] | |
size [Fcl_invariant.FD] | |
size [Fcl_var.BASICFD] |
|
size [Fcl_var.ATTR] |
|
size [Fcl_setDomain] |
|
size [Fcl_domain] |
|
size [Fcl_stak] | Size of the stack, i.e. |
size [Fcl_float] | |
smallest [Facile.Conjunto] | |
smallest [Fcl_conjunto] |
|
smallest_geq [Facile.Domain] | |
smallest_geq [Fcl_domain] | |
solve [Facile.Goals] | |
solve [Fcl_goals] |
|
sort [Facile.Sorting] | |
sort [Fcl_sorting] |
|
sortp [Facile.Sorting] | |
sortp [Fcl_sorting] |
|
sprint [Facile.Domain] | |
sprint [Fcl_domain] |
|
strictly_inf [Fcl_float] | |
subset [Facile.Conjunto] | |
subset [Facile.SetDomain.S] | |
subset [Fcl_conjunto] |
|
subset [Fcl_setDomain.S] | |
subst [Facile.Var.BASICFD] | |
success [Facile.Goals] | |
success [Fcl_goals] | Failure (resp. |
sum [Facile.Invariant] | |
sum [Facile.Arith] | |
sum [Facile.Boolean] | |
sum [Fcl_arith] | |
sum [Fcl_boolean] |
|
sum [Fcl_invariant] |
|
sum_fd [Facile.Arith] | |
sum_fd [Fcl_arith] |
|
sum_weight [Facile.Conjunto] | |
sum_weight [Fcl_conjunto] |
|
T | |
ternary [Facile.Invariant] | |
ternary [Fcl_invariant] |
|
times [Facile.Domain] | |
times [Fcl_domain] |
|
trail [Facile.Stak] | |
U | |
udiffsign [Fcl_nonlinear] | |
unary [Facile.Invariant.FD] | |
unary [Facile.Invariant] | |
unary [Fcl_invariant.FD] |
|
unary [Fcl_invariant] |
|
unify [Facile.Goals] | |
unify [Facile.Var.BASICFD] | |
unify [Fcl_goals] |
|
unify [Fcl_var.BASICFD] |
|
unify_cstr [Facile.Var.BASICFD] | |
union [Facile.Conjunto] | |
union [Facile.SetDomain.S] | |
union [Facile.Domain] | |
union [Fcl_conjunto] | |
union [Fcl_setDomain.S] | |
union [Fcl_domain] | Intersection (resp. |
unsafe_create [Facile.Domain] | |
unsafe_create [Fcl_domain] |
|
urbcsp [Fcl_genesis] | |
V | |
value [Facile.Var.BASICFD] | |
value [Fcl_var.BASICFD] |
|
values [Facile.Var.FD] | |
values [Facile.SetDomain] | |
values [Facile.Domain] | |
values [Fcl_var.FD] |
|
values [Fcl_setDomain] | Returns values of a domain. |
values [Fcl_domain] |
|
X | |
xor [Facile.Reify] | |
xor [Fcl_reify] | |
Z | |
zero [Facile.Cstr] | |
zero [Fcl_cstr] | The constraint which succeeds (resp. |
zero [Fcl_float] |