Index of values


( * ) [Fcl_misc.Operators]
( **~ ) [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.Arith]
(&&~) [Fcl_goals]
(&&~) [Facile.Easy]
(&&~) [Facile.Goals]
(&&~~) [Fcl_reify]
(&&~~) [Facile.Easy]
(&&~~) [Facile.Reify]
(+) [Fcl_misc.Operators]
(+~) [Fcl_arith]
(+~) [Facile.Easy]
(+~) [Facile.Arith]
(-) [Fcl_misc.Operators]
(-~) [Fcl_arith]
(-~) [Facile.Easy]
(-~) [Facile.Arith]
(/+) [Fcl_misc.Operators]
(/-) [Fcl_misc.Operators]
(/~) [Fcl_arith]
(/~) [Facile.Easy]
(/~) [Facile.Arith]
(<=>~~) [Fcl_reify]
(<=>~~) [Facile.Easy]
(<=>~~) [Facile.Reify]
(<=~) [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]
e1 op~~ e2 is equivalent to fd2e (Reify.boolean (e1 op~ e2)).
(<~~) [Facile.Easy]
(<~~) [Facile.Arith]
(=+) [Fcl_misc.Operators]
(=+.) [Fcl_misc.Operators]
(=>~~) [Fcl_reify]
(=>~~) [Facile.Easy]
(=>~~) [Facile.Reify]
(=~) [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.Arith]
(||~) [Fcl_goals]
Conjunction and disjunction over goals.
(||~) [Facile.Easy]
(||~) [Facile.Goals]
(||~~) [Fcl_reify]
(||~~) [Facile.Easy]
(||~~) [Facile.Reify]

A
abs [Fcl_arith]
Absolute value on expressions.
abs [Facile.Arith]
absolute [Fcl_nonlinear]
absolute_aux [Fcl_nonlinear]
active_store [Fcl_cstr]
active_store () returns the list of all active constraints, i.e.
active_store [Facile.Cstr]
add [Fcl_setDomain.S]
add [Fcl_domain]
add n d returns d {n}.
add [Fcl_data.Hashtbl]
add [Facile.Data.Hashtbl]
add [Facile.SetDomain.S]
add [Facile.Domain]
all_disjoint [Fcl_conjunto]
all_disjoint vars ensures that all the set variables of array vars are pairwise disjoint.
all_disjoint [Facile.Conjunto]
arg_max_array [Fcl_misc]
arg_min_array [Fcl_misc]
argmin [Fcl_invariant.Array]
argmin a c returns the BIR index of the minimum BIR value of a for criterion c.
argmin [Facile.Invariant.Array]
array [Fcl_var.BASICFD]
array n inf sup returns an array of n new variables with domain [inf..sup].
array [Facile.Var.BASICFD]
atmost1 [Facile.Conjunto]
atomic [Fcl_goals]
atomic ~name:"atomic" f returns a goal calling function f.
atomic [Facile.Goals]

B
binary [Fcl_invariant]
binary ~name:"Invariant.binary" f wraps the binary function f into an operator on BIRs.
binary [Facile.Invariant]
boolean [Fcl_reify]
boolean ~delay_on_negation:true c returns a boolean (0..1) variable associated to the constraint c.
boolean [Fcl_domain]
The domain containing 0 and 1.
boolean [Facile.Reify]
boolean [Facile.Domain]

C
call [Fcl_debug]
cardinal [Fcl_setDomain.S]
cardinal [Fcl_conjunto]
cardinal v returns the cardinal (an integer variable) of the set v.
cardinal [Facile.Conjunto]
cardinal [Facile.SetDomain.S]
choose [Fcl_setDomain.S]
choose [Fcl_domain]
choose ord d returns the mininum value of d for order ord.
choose [Facile.SetDomain.S]
choose [Facile.Domain]
choose_index [Fcl_goals.Array]
choose_index order fds returns the index of the best (minimun) free (not instantiated) variable in the array fds for the criterion order.
choose_index [Facile.Goals.GlArray]
choose_index [Facile.Goals.Array]
compare [Fcl_var.BASICFD]
Compares two variables.
compare [Fcl_setDomain.S]
compare [Fcl_domain]
compare d1 d2 is a comparison function working first on the cardinal, then (if d1 and d2 have the same size) on the lexicographic order of the domains (expressed in extension).
compare [Facile.Var.BASICFD]
compare [Facile.SetDomain.S]
compare [Facile.Domain]
compare_elt [Fcl_float]
compare_elt [Fcl_domain]
compare_elt e1 e2 is a comparison function on elements of domains.
compare_elt [Facile.Domain]
compare_expr [Fcl_expr]
compare_intexpr [Fcl_expr]
constant [Fcl_invariant]
constant ~name:"" cst returns an unsetable BIR with initial content cst.
constant [Facile.Invariant]
constrain [Fcl_expr]
constrain e op returns the constraint e op = 0 and post intermediate constraints.
constraints_number [Fcl_var.ATTR]
constraints_number a returns the number of different constraints attached to a.
constraints_number [Facile.Var.ATTR]
create [Fcl_var.BASICFD]
create ?name d returns a new variable with domain d.
create [Fcl_invariant]
create ~name:"" v returns a setable BIR with initial content v.
create [Fcl_goals]
create ~name:"create" f a returns a goal calling f a.
create [Fcl_domain]
create l builds a new domain containing the values of l.
create [Fcl_data.Hashtbl]
create [Fcl_cstr]
create ?name ?nb_wakings ?fprint ?priority ?init ?check ?not update delay builds a new constraint: name is a describing string for the constraint. Default value is "anonymous"., nb_wakings is the number of calls to Var.delay with distinct "waking_id" arguments within the constraint own delay function (see below). Default value is 1. Beware that if nb_wakings is greater than 1 and the optional init argument is not provided, init default behaviour is to do nothing (i.e. the update function will not be called)., fprint should print the constraint on an output channel taken as its only argument. Default value is to print the name string., priority is either immediate, normal or later. Time costly constraints should be waken after quick ones. Default value is normal., init is useful to perform initialization of auxiliary data structures needed and maintained by the update function. init () is called as soon as the constraint is posted. Default value is to call (update 0) if nb_wakings is equal to 1 to perform an initial propagation; if nb_wakings is greater than 1, default value is fun () -> (), i.e. it does nothing. Hence, an init argument must be provided if this is not the desired behaviour., check must be specified if the constraint is to be reifiable (as well as the not function). When the constraint is reified, check () is called to verify whether the constraint is satisfied or violated, i.e. the constraint itself or its negation is entailed by the constraint store. It should return true if the constraint is satisfied, false if it is violated and raise DontKnow when it is not known. check must not change the domains of the variables involved in the constraint. Default: Failure exception is raised., not must be specified if the constraint is reifiable (as well as check). not () should return a constraint which is the negation of the constraint being defined. When the constraint is reified, it is called to post the negation of the constraint whenever check () return false, i.e. the negation is entailed by the constraint store. Default: Failure exception is raised., update is a mandatory argument which propagates the constraint, i.e. filters domains and checks consistency. This function takes an integer as its unique parameter, according to the optional waking_id argument given to the Var.delay calls featured in the constraint own delay function (see below). When a waking event occurs, this function is called with the corresponding integer "waking_id", and must return true when the constraint is (partially) satisfied for this event, false if further propagations have to be performed, and raise Stak.Fail whenever an inconsistency is detected. The whole constraint is solved when update 0, ..., update (nb_wakings-1) have all returned true. E.g. a global constraint on an array of variables can be aware of which variable has triggered the awakening by providing the integer index of the variable as its "waking_id" to the Var.delay function. update is called with 0 by default when the nb_wakings argument has been omitted; in this case, the constraint is solved as soon as update returns true., delay schedules the awakening of the constraint ct (which is taken as its unique argument), i.e. the execution of its update function. If update id should be called (because it may propagates) when one of the events contained in the events list es occurred on variable v, then Var.delay es v ~waking_id:id ct should be called within the body of the delay function. Beware that all the "waking_ids" must be contiguous integers ranging from 0 to nb_wakings-1, otherwise the behaviour is unspecified. delay is a mandatory argument.
create [Facile.Invariant]
create [Facile.Goals]
create [Facile.Var.BASICFD]
create [Facile.Cstr]
create [Facile.Data.Hashtbl]
create [Facile.Domain]
create_rec [Fcl_goals]
create_rec ~name:"create_rec" f returns a goal calling f.
create_rec [Facile.Goals]
cstr [Fcl_sorting]
cstr a (?perm:None) sorted returns the constraint ensuring that sorted is the result of sorting array a according to the permutation perm.
cstr [Fcl_reify]
cstr ~delay_on_negation:true c b is equivalent to the constraint boolean ?delay_on_negation c =~ b.
cstr [Fcl_linear]
cstr [Fcl_interval]
cstr v inf sup b returns a constraint ensuring that the boolean variable b is instantiated to 1 if v is in inf..sup and to 0 otherwise.
cstr [Fcl_gcc]
cstr (?level:High) vars distribution returns a constraint ensuring that for each pair (c,v) of cardinal variable c and integer value v in the list distribution, c variables in the array vars will be instantiated to v, i.e.
cstr [Fcl_boolean]
cstr bools sum returns a constraint ensuring that sum is equal to the sum of the boolean variables of the array bools.
cstr [Fcl_alldiff]
alldiff (?algo:Lazy) vars States that the variables of vars are different from each other.
cstr [Facile.Gcc]
cstr [Facile.Interval]
cstr [Facile.Boolean]
cstr [Facile.Sorting]
cstr [Facile.Alldiff]
cstr [Facile.Reify]
cut [Fcl_stak]
cut l cuts the choice points left on the stack until level l.
cut [Facile.Stak]

D
delay [Fcl_var.BASICFD]
delay event_list v ~waking_id:id c suspends constraint c on all the events in event_list occurring on v.
delay [Facile.Var.BASICFD]
delay [Facile.Var]
depth [Fcl_stak]
Depth of the stack, i.e.
depth [Facile.Stak]
dichotomic [Fcl_goals]
Non-deterministic instantiation of a variable, by dichotomic recursive exploration of its domain.
dichotomic [Facile.Goals]
diff [Fcl_setDomain.S]
diff [Fcl_domain]
diff d1 d2 returns d1 d2, i.e.
diff [Facile.SetDomain.S]
diff [Facile.Domain]
diffeqsign [Fcl_nonlinear]
difference [Fcl_domain]
difference big small returns big small.
difference [Facile.Domain]
diffsign [Fcl_nonlinear]
disjoint [Fcl_domain]
disjoint d1 d2 tests whether d1 and d2 are disjoint.
disjoint [Fcl_conjunto]
disjoint v1 v2 defined by all_disjoint [|v1; v2|].
disjoint [Facile.Conjunto]
disjoint [Facile.Domain]
division [Fcl_nonlinear]
division_aux [Fcl_nonlinear]
dom [Fcl_var.ATTR]
dom a returns the integer domain of an attribute.
dom [Facile.Var.ATTR]

E
e2fd [Fcl_arith]
e2fd e creates and returns a new variable v and posts the constraint fd2e v =~ e.
e2fd [Facile.Arith]
elements [Fcl_setDomain.S]
elements [Facile.SetDomain.S]
elt [Fcl_var.BASICFD]
int n returns a new variable instantiated to integer value n.
elt [Facile.Var.BASICFD]
elt_of_list [Fcl_setDomain]
Creates a set from a list of integers.
elt_of_list [Facile.SetDomain]
elt_value [Fcl_var.BASICFD]
int_value v returns the value of v if it is instantiated and raises a Failure exception otherwise.
elt_value [Facile.Var.BASICFD]
empty [Fcl_setDomain.S]
empty [Fcl_domain]
The empty domain.
empty [Facile.SetDomain.S]
empty [Facile.Domain]
epsilon [Fcl_float]
equal [Fcl_var.BASICFD]
Tests if two variables are equal with respect to compare.
equal [Fcl_setDomain.S]
equal [Facile.Var.BASICFD]
equal [Facile.SetDomain.S]
eval [Fcl_expr]
eval e returns the integer numerical value of a fully instantiated expression e.
eval [Fcl_arith]
eval e returns the integer numerical value of a fully instantiated expression e.
eval [Facile.Arith]
eval [Facile.Expr]
exists [Fcl_goals.List]
exists ?select g [x1;x2;...;xn] is g x1 ||~ g x2 ||~ ... ||~ g xn, i.e.
exists [Fcl_goals.Array]
exists ?select g a defined by existsi ?select (fun _i x -> g x) a, i.e.
exists [Facile.Goals.List]
exists [Facile.Goals.Array]
existsi [Fcl_goals.Array]
existsi ?select g a returns the disjunctive iteration of the application of goal g on the elements of array a and on their indices.
existsi [Facile.Goals.Array]
expn [Fcl_nonlinear]
expn_aux [Fcl_nonlinear]
expn_int [Fcl_nonlinear]

F
fail [Fcl_stak]
fail x equivalent to raise (Fail x).
fail [Fcl_goals]
fail [Facile.Goals]
fail [Facile.Stak]
fatal_error [Fcl_debug]
fd2e [Fcl_arith]
fd2e v returns an expression which evaluates to n if the variable v is instantiated to n.
fd2e [Facile.Easy]
fd2e [Facile.Arith]
find [Fcl_data.Hashtbl]
find [Facile.Data.Hashtbl]
fold [Fcl_data.Hashtbl]
fold [Facile.Data.Hashtbl]
forall [Fcl_goals.List]
forall ?select g [x1;x2;...;xn] is g x1 &&~ g x2 &&~ ... &&~ g xn, i.e.
forall [Fcl_goals.Array]
forall ?select g a defined by foralli ?select (fun _i x -> g x) a, i.e.
forall [Facile.Goals.List]
forall [Facile.Goals.Array]
foralli [Fcl_goals.Array]
foralli ?select g a returns the conjunctive iteration of the application of goal g on the elements of array a and on their indices.
foralli [Facile.Goals.Array]
fordownto [Fcl_goals]
forto min max g (resp.
fordownto [Facile.Goals]
forto [Fcl_goals]
forto [Facile.Goals]
fprint [Fcl_var.BASICFD]
fprint chan v prints variable v on channel chan.
fprint [Fcl_var.ATTR]
fprint chan a prints attribute a on channel chan.
fprint [Fcl_setDomain]
Pretty printing of elements and domains.
fprint [Fcl_invariant]
fprint c ~printer:(fun _ _ -> ()) r prints BIR r on channel c.
fprint [Fcl_goals]
fprint chan g prints the name of goal g on channel chan.
fprint [Fcl_float]
fprint [Fcl_expr]
fprint chan e prints expression e on channel chan.
fprint [Fcl_domain]
Pretty printing of elements and domains.
fprint [Fcl_cstr]
fprint chan c prints the constraint c on channel chan.
fprint [Fcl_arith]
fprint chan e prints expression e on channel chan.
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_array [Fcl_var.BASICFD]
fprint_array chan vs prints array of variables vs on channel chan.
fprint_array [Facile.Var.BASICFD]
fprint_elt [Fcl_setDomain]
fprint_elt [Fcl_float]
fprint_elt [Fcl_domain]
fprint_elt [Facile.SetDomain]
fprint_elt [Facile.Domain]

G
gen_int_fun [Fcl_misc]
get [Fcl_stak]
Dereference.
get [Fcl_invariant.Array]
get a i returns the BIR element number i of array a.
get [Fcl_invariant]
Access to the content of a BIR.
get [Fcl_fdArray]
get vars index returns a variable constrained to be equal to vars.(index).
get [Fcl_data.Hashtbl]
get [Facile.FdArray]
get [Facile.Invariant.Array]
get [Facile.Invariant]
get [Facile.Data.Hashtbl]
get [Facile.Stak]
get_boolsum_threshold [Fcl_linear]
Returns the minimum size for boolean sums optimization.
get_boolsum_threshold [Fcl_arith]
Returns the minimum size for boolean sums optimization.
get_boolsum_threshold [Facile.Arith]
get_cstr [Fcl_fdArray]
get_cstr vars index v returns the constraint fd2e vars.(index) =~ fd2e v.
get_cstr [Facile.FdArray]
goedel [Fcl_misc]
greatest_leq [Fcl_domain]
smallest_geq dom val (resp.
greatest_leq [Facile.Domain]

I
i2e [Fcl_arith]
i2e n returns an expression which evaluates to n.
i2e [Facile.Easy]
i2e [Facile.Arith]
id [Fcl_var.BASICFD]
id v returns a unique integer identifying the attribute associated with v.
id [Fcl_var.ATTR]
id a returns a unique integer identifying the attribute a.
id [Fcl_invariant]
id r returns a unique integer associated to BIR r.
id [Fcl_cstr]
id c returns a unique integer identifying the constraint c.
id [Facile.Invariant]
id [Facile.Var.BASICFD]
id [Facile.Var.ATTR]
id [Facile.Cstr]
immediate [Fcl_cstr]
immediate [Facile.Cstr]
included [Fcl_setDomain]
included d1 d2 tests whether the domain d1 is included in d2, i.e.
included [Fcl_float]
included [Fcl_domain]
included d1 d2 tests whether domain d1 is included in domain d2.
included [Facile.SetDomain]
included [Facile.Domain]
indomain [Fcl_goals.Conjunto]
Non-deterministic instantiation of set variables (refine of Gervet's Conjunto).
indomain [Fcl_goals]
Non-deterministic instantiation of a variable, by labeling its domain (in increasing order).
indomain [Facile.Goals.Conjunto]
indomain [Facile.Goals]
inf_min [Fcl_conjunto]
inf_min v1 v2 ensures that the minimal element of v1 is less than or equal to the minimal element of v2.
inf_min [Facile.Conjunto]
init [Facile.Cstr]
inside [Fcl_conjunto]
inside [Facile.Conjunto]
instantiate [Fcl_goals]
instantiate choose var Non-deterministic instantiation of a variable, by labeling its domain using the value returned by the choose function.
instantiate [Facile.Goals]
int [Fcl_domain]
The largest representable domain.
int [Facile.Var.BASICFD]
int [Facile.Domain]
int_overflow [Fcl_misc]
int_value [Fcl_var.BASICFD]
int_value [Facile.Var.BASICFD]
inter [Fcl_setDomain.S]
inter [Fcl_conjunto]
Operations on sets.
inter [Facile.Conjunto]
inter [Facile.SetDomain.S]
internal_error [Fcl_debug]
intersection [Fcl_domain]
intersection [Facile.Domain]
interval [Fcl_var.BASICFD]
interval ?name inf sup returns a new variable with domain [inf..sup].
interval [Fcl_setDomain]
interval glb lub builds the domain of sets greater than glb and smaller than lub.
interval [Fcl_float]
interval [Fcl_domain]
interval inf sup returns the domain of all integers in the closed interval [inf..sup].
interval [Facile.Var.BASICFD]
interval [Facile.SetDomain]
interval [Facile.Domain]
interval_iter [Fcl_domain]
interval_iter f d successively applies function f to the bounds of all the disjoint intervals of d in increasing order.
interval_iter [Facile.Domain]
is_bound [Fcl_var.BASICFD]
is_bound v returns true if v is instantiated and false otherwise.
is_bound [Facile.Var.BASICFD]
is_empty [Fcl_setDomain.S]
is_empty [Fcl_domain]
is_empty d tests whether the domain d is empty or not.
is_empty [Facile.SetDomain.S]
is_empty [Facile.Domain]
is_member [Fcl_interval]
is_member v inf sup returns a boolean variable which will be instantiated to 1 if v is in inf..sup and to 0 otherwise.
is_member [Facile.Interval]
is_solved [Fcl_cstr]
is_solved c returns true if c is satisfied and false otherwise.
is_solved [Facile.Cstr]
is_var [Fcl_var.BASICFD]
is_var v returns true if v is not instantiated and false otherwise.
is_var [Fcl_invariant.FD]
BIR variants of Fd.Var access functions.
is_var [Facile.Invariant.FD]
is_var [Facile.Var.BASICFD]
iter [Fcl_var.FD]
iter f v iterates f on each integer in the domain of v.
iter [Fcl_setDomain.S]
iter [Fcl_setDomain]
Iteration on values of the domain.
iter [Fcl_misc]
iter [Fcl_domain]
iter f d successively applies function f to all element of d in increasing order.
iter [Fcl_data.Hashtbl]
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]
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 [Fcl_goals.List]
Standard labeling, i.e.
labeling [Fcl_goals.Array]
Standard labeling, i.e.
labeling [Facile.Goals.GlList]
labeling [Facile.Goals.List]
labeling [Facile.Goals.GlArray]
labeling [Facile.Goals.Array]
largest_hole_around [Fcl_domain]
largest_hole_around dom val returns the largest hole (interval) in dom centred around val.
largest_hole_around [Facile.Domain]
last_and_length [Fcl_misc]
later [Fcl_cstr]
Available priorities: immediate: as soon as possible, for quick updates;, normal: standard priority;, later: for time consuming constraints (e.g. Gcc.cstr, Alldiff.cstr...).
later [Facile.Cstr]
lds [Fcl_goals]
lds ~step:1 g returns a goal which will iteratively search g with increasing limited discrepancy (see ) by increment step.
lds [Facile.Goals]
level [Fcl_stak]
Returns the current level.
level [Fcl_debug]
level [Facile.Stak]
levels [Fcl_stak]
Returns the current active levels.
levels [Facile.Stak]
linear_aux [Fcl_linear]
log [Fcl_debug]

M
max [Fcl_var.BASICFD]
max v returns the upper bound of v.
max [Fcl_var.ATTR]
min a (resp.
max [Fcl_setDomain]
max [Fcl_misc.Operators]
max [Fcl_invariant.FD]
max [Fcl_float]
max [Fcl_fdArray]
min vars (resp.
max [Fcl_domain]
min d (resp.
max [Facile.FdArray]
max [Facile.Invariant.FD]
max [Facile.Var.BASICFD]
max [Facile.Var.ATTR]
max [Facile.SetDomain]
max [Facile.Domain]
max_cstr [Fcl_fdArray]
min_cstr vars mini (resp.
max_cstr [Facile.FdArray]
max_elt [Fcl_setDomain.S]
max_elt [Facile.SetDomain.S]
max_of_absmod_inter [Fcl_nonlinear]
max_of_expr [Fcl_expr]
min_of_expr e (resp.
max_of_expr [Fcl_arith]
min_of_expr e (resp.
max_of_expr [Facile.Arith]
max_of_expr [Facile.Expr]
mem [Fcl_setDomain.S]
mem [Fcl_setDomain]
mem x d tests whether x belongs to the domain d.
mem [Fcl_float]
mem [Fcl_domain]
mem [Fcl_data.Hashtbl]
mem [Fcl_conjunto]
mem x v states that x belongs to v.
mem [Facile.Conjunto]
mem [Facile.Data.Hashtbl]
mem [Facile.SetDomain.S]
mem [Facile.SetDomain]
member [Fcl_var.BASICFD]
member v n returns true if n belongs to the domain of v and false otherwise.
member [Fcl_var.ATTR]
member a n tests if n belongs to dom a.
member [Fcl_goals.List]
member v l returns the disjunctive iteration of the instantiation of the variable v to the values in the integer list l.
member [Fcl_domain]
member n d tests if n belongs to d.
member [Fcl_conjunto]
member v l ensures that v will have a value in l.
member [Facile.Conjunto]
member [Facile.Goals.GlList]
member [Facile.Goals.List]
member [Facile.Var.BASICFD]
member [Facile.Var.ATTR]
member [Facile.Domain]
min [Fcl_var.BASICFD]
min v returns the lower bound of v.
min [Fcl_var.ATTR]
min [Fcl_setDomain]
min [Fcl_misc.Operators]
min [Fcl_invariant.FD]
min [Fcl_invariant.Array]
min a c returns the minimum BIR value of a for criterion c.
min [Fcl_float]
min [Fcl_fdArray]
min [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_cstr [Fcl_fdArray]
min_cstr [Facile.FdArray]
min_elt [Fcl_setDomain.S]
min_elt [Facile.SetDomain.S]
min_max [Fcl_var.BASICFD]
min_max v returns both the lower and upper bounds of v.
min_max [Fcl_setDomain]
Access to glb and lub.
min_max [Fcl_float]
min_max [Fcl_domain]
min_max d returns both the lower and upper bound of d.
min_max [Facile.Var.BASICFD]
min_max [Facile.SetDomain]
min_max [Facile.Domain]
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 [Fcl_expr]
min_max_of_expr e is equivalent to (min_of_expr e, max_of_expr e).
min_max_of_expr [Fcl_arith]
min_max_of_expr e is equivalent to (min_of_expr e, max_of_expr e).
min_max_of_expr [Facile.Arith]
min_max_of_expr [Facile.Expr]
min_max_plus_inter [Fcl_linear]
min_of_absmod_inter [Fcl_nonlinear]
min_of_expr [Fcl_expr]
min_of_expr [Fcl_arith]
min_of_expr [Facile.Arith]
min_of_expr [Facile.Expr]
minimize [Fcl_opti]
minimize [Fcl_goals]
minimize ~step:1 ~mode:Continue goal cost solution runs a Branch and Bound algorithm on goal for bound cost, with an improvement of at least step between each solution found.
minimize [Facile.Opti]
minimize [Facile.Goals]
minus [Fcl_domain]
minus d returns the domain of opposite values of d.
minus [Facile.Domain]
modulo [Fcl_nonlinear]
modulo_aux [Fcl_nonlinear]
monome [Fcl_nonlinear]
monome_aux [Fcl_nonlinear]

N
name [Fcl_var.BASICFD]
name v returns the name of variable v (the empty string if it was not provided while created).
name [Fcl_invariant]
name r returns the name (specified or generated) of BIR r.
name [Fcl_goals]
name g returns the name of the goal g.
name [Fcl_cstr]
name c returns the name of the constraint c.
name [Facile.Invariant]
name [Facile.Goals]
name [Facile.Var.BASICFD]
name [Facile.Cstr]
nb_choice_points [Fcl_stak]
Access to a global counter incremented at each choice point.
nb_choice_points [Facile.Stak]
normal [Fcl_cstr]
normal [Facile.Cstr]
not [Fcl_reify]
Logical reification operators on constraints, namely and, or, implies, equivalent, exclusive or, not.
not [Fcl_cstr]
not c returns the negation of c.
not [Facile.Reify]
not_instantiated_fd [Fcl_goals.Array]
not_instantiated_fd fds returns the index of one element in fds which is not instantiated.
not_instantiated_fd [Facile.Goals.GlArray]
not_instantiated_fd [Facile.Goals.Array]

O
older [Fcl_stak]
older l1 l2 true if level l1 precedes l2.
older [Facile.Stak]
on_max [Fcl_var.BASICFD]
Event occuring when the lower (resp.
on_max [Fcl_var.ATTR]
Event occuring when the lower (resp.
on_max [Facile.Var.BASICFD]
on_max [Facile.Var.ATTR]
on_min [Fcl_var.BASICFD]
on_min [Fcl_var.ATTR]
on_min [Facile.Var.BASICFD]
on_min [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_refine [Facile.Var.BASICFD]
on_refine [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.
on_subst [Facile.Var.BASICFD]
on_subst [Facile.Var.ATTR]
once [Fcl_goals]
once g cuts choice points left on goal g.
once [Facile.Goals]
one [Fcl_cstr]
one [Facile.Cstr]
order [Fcl_conjunto]
order v1 v2 ensures that v1 is less than or equal to v2 according to Domain.compare .
order [Facile.Conjunto]
order_with_card [Fcl_conjunto]
order_with_card v1 card1 v2 card2 is equivalent to order but the cardinals of the variables must be provided too.
order_with_card [Facile.Conjunto]
outside [Fcl_conjunto]
Basic refinements for labeling.
outside [Facile.Conjunto]

P
plus [Fcl_domain]
plus d n translates a domain by n.
plus [Facile.Domain]
post [Fcl_cstr]
post c posts the constraint c to the constraint store.
post [Facile.Cstr]
print_in_assert [Fcl_debug]
priority [Fcl_cstr]
priority c returns the priority of the constraint c.
priority [Facile.Cstr]
prod [Fcl_invariant]
sum a returns a BIR equal to the product of elements of a.
prod [Fcl_arith]
prod [Facile.Invariant]
prod [Facile.Arith]
prod_fd [Fcl_arith]
prod exps (resp.
prod_fd [Facile.Arith]
protect [Fcl_misc]

R
reduce [Fcl_expr]
reduce e normalizes expression e.
ref [Fcl_stak]
Returns a reference whose modifications will be trailed during the solving of a goal.
ref [Facile.Stak]
refine [Fcl_var.BASICFD]
refine v d reduces the domain of v with domain d.
refine [Facile.Var.BASICFD]
refine_low [Fcl_var.BASICFD]
refine_low v inf reduces the domain of v by cutting all values strictly less than inf.
refine_low [Facile.Var.BASICFD]
refine_low_up [Fcl_var.BASICFD]
refine_low_up v inf sup reduces the domain of v by cutting all values strictly less than inf and greater than sup.
refine_low_up [Facile.Var.BASICFD]
refine_up [Fcl_var.BASICFD]
refine_up v sup reduces the domain of v by cutting all values strictly greater than sup.
refine_up [Facile.Var.BASICFD]
remove [Fcl_var.FD]
remove v a removes a from the domain of v.
remove [Fcl_setDomain.S]
remove [Fcl_domain]
remove n d returns d {n}.
remove [Fcl_data.Hashtbl]
remove [Facile.Var.FD]
remove [Facile.Data.Hashtbl]
remove [Facile.SetDomain.S]
remove [Facile.Domain]
remove_closed_inter [Fcl_domain]
remove_closed_inter inf sup d returns d [inf..sup], i.e.
remove_closed_inter [Facile.Domain]
remove_low [Fcl_setDomain.S]
remove_low [Fcl_float]
remove_low [Fcl_domain]
remove_up n d (resp.
remove_low [Facile.SetDomain.S]
remove_low [Facile.Domain]
remove_low_up [Fcl_domain]
remove_low_up low up d is a shortcut for remove_up up (remove_low low d).
remove_low_up [Facile.Domain]
remove_max [Fcl_domain]
remove_min d (resp.
remove_min [Fcl_domain]
remove_min [Facile.Domain]
remove_up [Fcl_setDomain.S]
remove_up [Fcl_float]
remove_up [Fcl_domain]
remove_up [Facile.SetDomain.S]
remove_up [Facile.Domain]
replace [Fcl_data.Hashtbl]
replace [Facile.Data.Hashtbl]

S
scalprod [Fcl_arith]
scalprod [Facile.Arith]
scalprod_fd [Fcl_arith]
scalprod coeffs exps (resp.
scalprod_fd [Facile.Arith]
set [Fcl_stak]
Sets a backtrackable reference.
set [Fcl_invariant]
Assignment of a setable BIR.
set [Fcl_data.Array]
set t i x Bactrackable assignment of t.(i) with x.
set [Facile.Invariant]
set [Facile.Data.Array]
set [Facile.Stak]
set_boolsum_threshold [Fcl_linear]
Set the minimum size for boolean sums optimization.
set_boolsum_threshold [Fcl_arith]
Set the minimum size for boolean sums optimization.
set_boolsum_threshold [Facile.Arith]
shift [Fcl_arith]
shift x d returns a finite domain variable constrained to be equal to x+d.
shift [Facile.Arith]
shift_cstr [Fcl_linear]
shift_cstr y x d returns the constraint y = x+d
sigma [Fcl_goals]
sigma ~domain:Domain.int fgoal creates the goal (fgoal v) where v is a new variable of domain domain.
sigma [Facile.Goals]
sign [Fcl_misc.Operators]
singleton [Fcl_setDomain.S]
singleton [Facile.SetDomain.S]
size [Fcl_var.BASICFD]
size v returns the number of integer values in the domain of v (1 if v is instantiated).
size [Fcl_var.ATTR]
size a returns the number of integer values in the domain of a.
size [Fcl_stak]
Size of the stack, i.e.
size [Fcl_setDomain]
size d returns |glb(d)|-|lub(d)|+1, i.e.
size [Fcl_invariant.FD]
size [Fcl_float]
size [Fcl_domain]
size d returns the number of integers in d.
size [Facile.Invariant.FD]
size [Facile.Var.BASICFD]
size [Facile.Var.ATTR]
size [Facile.Stak]
size [Facile.Domain]
smallest [Fcl_conjunto]
smallest v returns the smallest element (an integer variable) of v.
smallest [Facile.Conjunto]
smallest_geq [Fcl_domain]
smallest_geq [Facile.Domain]
solve [Fcl_goals]
solve ~control:(fun _ -> ()) g solves the goal g and returns a success (true) or a failure (false).
solve [Facile.Goals]
sort [Fcl_sorting]
sort a returns an array of variables constrained to be the variables in a sorted in increasing order.
sort [Facile.Sorting]
sortp [Fcl_sorting]
sortp a same as sort but returns a couple (sorted, perm) where sorted is the array of sorted variables and perm is an array of variables constrained to be the permutation between a and sorted, i.e.
sortp [Facile.Sorting]
sprint [Fcl_domain]
sprint d returns a string representation of d.
sprint [Facile.Domain]
strictly_inf [Fcl_float]
subset [Fcl_setDomain.S]
subset [Fcl_conjunto]
subset v1 v2 ensures that v1 is a subset of v2.
subset [Facile.Conjunto]
subset [Facile.SetDomain.S]
subst [Facile.Var.BASICFD]
success [Fcl_goals]
Failure (resp.
success [Facile.Goals]
sum [Fcl_invariant]
sum a returns a BIR equal to the sum of elements of a.
sum [Fcl_boolean]
sum bools returns the sum (a new variable) and posts the preceding constraint.
sum [Fcl_arith]
sum [Facile.Invariant]
sum [Facile.Arith]
sum [Facile.Boolean]
sum_fd [Fcl_arith]
sum exps (resp.
sum_fd [Facile.Arith]
sum_weight [Fcl_conjunto]
sum_weight v weights returns an integer variable equal to the sum of the weights associated with the value in v.
sum_weight [Facile.Conjunto]

T
ternary [Fcl_invariant]
ternary ~name:"Invariant.ternary" f wraps the ternary function f into an operator on BIRs.
ternary [Facile.Invariant]
times [Fcl_domain]
times d k expands a domain by factor k.
times [Facile.Domain]
trail [Facile.Stak]

U
udiffsign [Fcl_nonlinear]
unary [Fcl_invariant.FD]
unary ~name:"Invariant.XxxFd.unary" f v Wrapper of any access function over fd type.
unary [Fcl_invariant]
unary ~name:"Invariant.unary" f wraps the unary function f into an operator on BIRs.
unary [Facile.Invariant.FD]
unary [Facile.Invariant]
unify [Fcl_var.BASICFD]
unify v n instantiates variable v with integer value n.
unify [Fcl_goals]
unify var x instantiates variable var to x.
unify [Facile.Goals]
unify [Facile.Var.BASICFD]
unify_cstr [Facile.Var.BASICFD]
union [Fcl_setDomain.S]
union [Fcl_domain]
Intersection (resp.
union [Fcl_conjunto]
union [Facile.Conjunto]
union [Facile.SetDomain.S]
union [Facile.Domain]
unsafe_create [Fcl_domain]
unsafe_create l builds a new domain containing the values of l.
unsafe_create [Facile.Domain]
urbcsp [Fcl_genesis]

V
value [Fcl_var.BASICFD]
value v returns Val n if v is instantiated to n, Unk a otherwise where a is the attribute of v.
value [Facile.Var.BASICFD]
values [Fcl_var.FD]
values v returns the list of all integers in the domain of v.
values [Fcl_setDomain]
Returns values of a domain.
values [Fcl_domain]
value d returns the list of values of the domain d
values [Facile.Var.FD]
values [Facile.SetDomain]
values [Facile.Domain]

X
xor [Fcl_reify]
xor [Facile.Reify]

Z
zero [Fcl_float]
zero [Fcl_cstr]
The constraint which succeeds (resp.
zero [Facile.Cstr]