(%~) [Arith] 
Division and modulo on expressions.

(&&~) [Goals]  
(&&~~) [Reify]  
(**~) [Arith] 
Exponentiation of an expression to an integer value.

(*~) [Arith] 
Addition, substraction, multiplication on expressions.

(+~) [Arith]  
(~) [Arith]  
(/~) [Arith]  
(<=>~~) [Reify]  
(<=~) [Arith]  
(<=~~) [Arith]  
(<>~) [Arith] 
Strictly less, less or equal, equal, greater or equal,
strictly greater and different constraints on expressions.

(<>~~) [Arith] 
Reified strictly less, less or equal, equal, greater or equal,
strictly greater and different.

(<~) [Arith]  
(<~~) [Arith]  e1 op~~ e2 is equivalent to fd2e (Reify.boolean (e1 op~ e2)) .

(=>~~) [Reify]  
(=~) [Arith]  
(=~~) [Arith]  
(>=~) [Arith]  
(>=~~) [Arith]  
(>~) [Arith]  
(>~~) [Arith]  
(~) [Goals] 
Conjunction and disjunction over goals.

(~~) [Reify]  
A  
abs [Arith] 
Absolute value on expressions.

active_store [Cstr]  active_store () returns the list of all active constraints, i.e.

add [Data.Hashtbl]  
add [SetDomain.S]  
add [Domain]  add n d returns d {n} .

all_disjoint [Conjunto]  all_disjoint vars ensures that all the set variables of array vars
are pairwise disjoint.

argmin [Invariant.Array]  argmin a c returns the BIR index of the minimum BIR value of a for
criterion c .

array [Var.BASICFD]  array n inf sup returns an array of n new variables with domain
[inf..sup] .

atomic [Goals]  atomic ~name:"atomic" f returns a goal calling function f .

B  
binary [Invariant]  binary ~name:"Invariant.binary" f wraps the binary function f
into an operator on BIRs.

boolean [Reify]  boolean ~delay_on_negation:true c returns a boolean (0..1)
variable associated to the constraint c .

boolean [Domain] 
The domain containing
0 and 1 .

C  
cardinal [Conjunto]  cardinal v returns the cardinal (an integer variable) of the set v .

cardinal [SetDomain.S]  
choose [SetDomain.S]  
choose [Domain]  choose ord d returns the mininum value of d for order ord .

choose_index [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 .

compare [Var.BASICFD] 
Compares two variables.

compare [SetDomain.S]  
compare [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_elt [Domain]  compare_elt e1 e2 is a comparison function on elements of domains.

constant [Invariant]  constant ~name:"" cst returns an unsetable BIR with initial
content cst .

constraints_number [Var.ATTR]  constraints_number a returns the number of different constraints
attached to a .

create [Goals]  create ~name:"create" f a returns a goal calling f a .

create [Invariant]  create ~name:"" v returns a setable BIR with initial content v .

create [Var.BASICFD]  create ?name d returns a new variable with domain d .

create [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_wakings1)
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_id s" must be contiguous integers ranging from
0 to nb_wakings1 , otherwise the behaviour is unspecified.
delay is a mandatory argument.

create [Data.Hashtbl]  
create [Domain]  create l builds a new domain containing the values of l .

create_rec [Goals]  create_rec ~name:"create_rec" f returns a goal calling f .

cstr [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 [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 [Alldiff]  alldiff (?algo:Lazy) vars States that the variables of vars
are different from each other.

cstr [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 [Reify]  cstr ~delay_on_negation:true c b is equivalent to the
constraint boolean ?delay_on_negation c =~ b .

cut [Stak]  cut l cuts the choice points left on the stack until level l .

D  
delay [Var.BASICFD]  delay event_list v ~waking_id:id c suspends constraint c on all
the events in event_list occurring on v .

depth [Stak] 
Depth of the stack, i.e.

dichotomic [Goals] 
Nondeterministic instantiation of a variable, by dichotomic recursive
exploration of its domain.

diff [SetDomain.S]  
diff [Domain]  diff d1 d2 returns d1 d2 , i.e.

difference [Domain]  difference big small returns big small .

disjoint [Conjunto]  disjoint v1 v2 defined by all_disjoint [v1; v2] .

disjoint [Domain]  disjoint d1 d2 tests whether d1 and d2 are disjoint.

dom [Var.ATTR]  dom a returns the integer domain of an attribute.

E  
e2fd [Arith]  e2fd e creates and returns a new variable v and posts the constraint
fd2e v =~ e .

elements [SetDomain.S]  
elt [Var.BASICFD]  int n returns a new variable instantiated to integer value n .

elt_of_list [SetDomain] 
Creates a set from a list of integers.

elt_value [Var.BASICFD]  int_value v returns the value of v if it is instantiated and raises
a Failure exception otherwise.

empty [SetDomain.S]  
empty [Domain] 
The empty domain.

equal [Var.BASICFD] 
Tests if two variables are equal with respect to
compare .

equal [SetDomain.S]  
eval [Arith]  eval e returns the integer numerical value of a fully instantiated
expression e .

exists [Goals.List]  exists ?select g [x1;x2;...;xn] is g x1 ~ g x2 ~ ... ~ g xn ,
i.e.

exists [Goals.Array]  exists ?select g a defined by existsi ?select (fun _i x > g x) a ,
i.e.

existsi [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.

F  
fail [Goals]  
fail [Stak]  fail x equivalent to raise (Fail x) .

fd2e [Arith]  fd2e v returns an expression which evaluates to n if the
variable v is instantiated to n .

find [Data.Hashtbl]  
fold [Data.Hashtbl]  
forall [Goals.List]  forall ?select g [x1;x2;...;xn] is g x1 &&~ g x2 &&~ ... &&~ g xn ,
i.e.

forall [Goals.Array]  forall ?select g a defined by foralli ?select (fun _i x > g x) a ,
i.e.

foralli [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.

fordownto [Goals]  forto min max g (resp.

forto [Goals]  
fprint [Goals]  fprint chan g prints the name of goal g on channel chan .

fprint [Arith]  fprint chan e prints expression e on channel chan .

fprint [Invariant]  fprint c ~printer:(fun _ _ > ()) r prints BIR r on channel c .

fprint [Var.BASICFD]  fprint chan v prints variable v on channel chan .

fprint [Var.ATTR]  fprint chan a prints attribute a on channel chan .

fprint [Cstr]  fprint chan c prints the constraint c on channel chan .

fprint [SetDomain] 
Pretty printing of elements and domains.

fprint [Domain] 
Pretty printing of elements and domains.

fprint_array [Var.BASICFD]  fprint_array chan vs prints array of variables vs on channel chan .

fprint_elt [SetDomain]  
fprint_elt [Domain]  
G  
get [FdArray]  get vars index returns a variable constrained to be equal to
vars.(index) .

get [Invariant.Array]  get a i returns the BIR element number i of array a .

get [Invariant] 
Access to the content of a BIR.

get [Data.Hashtbl]  
get [Stak] 
Dereference.

get_boolsum_threshold [Arith] 
Returns the minimum size for boolean sums optimization.

get_cstr [FdArray]  get_cstr vars index v returns the constraint
fd2e vars.(index) =~ fd2e v .

greatest_leq [Domain]  smallest_geq dom val (resp.

I  
i2e [Arith]  i2e n returns an expression which evaluates to n .

id [Invariant]  id r returns a unique integer associated to BIR r .

id [Var.BASICFD]  id v returns a unique integer identifying the attribute associated
with v .

id [Var.ATTR]  id a returns a unique integer identifying the attribute a .

id [Cstr]  id c returns a unique integer identifying the constraint c .

immediate [Cstr]  
included [SetDomain]  included d1 d2 tests whether the domain d1 is included in d2 ,
i.e.

included [Domain]  included d1 d2 tests whether domain d1 is included in domain d2 .

indomain [Goals.Conjunto] 
Nondeterministic instantiation of set variables (
refine of Gervet's
Conjunto).

indomain [Goals] 
Nondeterministic instantiation of a variable, by labeling its domain
(in increasing order).

inf_min [Conjunto]  inf_min v1 v2 ensures that the minimal element
of v1 is less than or equal to the minimal element of v2 .

inside [Conjunto]  
instantiate [Goals]  instantiate choose var Nondeterministic instantiation of a variable,
by labeling its domain using the value returned by the choose function.

int [Domain] 
The largest representable domain.

int_value [Var.BASICFD]  
inter [Conjunto] 
Operations on sets.

inter [SetDomain.S]  
intersection [Domain]  
interval [Var.BASICFD]  interval ?name inf sup returns a new variable with domain [inf..sup] .

interval [SetDomain]  interval glb lub builds the domain of sets greater than glb and
smaller than lub .

interval [Domain]  interval inf sup returns the domain of all integers in the closed
interval [inf..sup] .

interval_iter [Domain]  interval_iter f d successively applies function f to the bounds
of all the disjoint intervals of d in increasing order.

is_bound [Var.BASICFD]  is_bound v returns true if v is instantiated and false
otherwise.

is_empty [SetDomain.S]  
is_empty [Domain]  is_empty d tests whether the domain d is empty or not.

is_member [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_solved [Cstr]  is_solved c returns true if c is satisfied and false otherwise.

is_var [Invariant.FD] 
BIR variants of
Fd.Var access functions.

is_var [Var.BASICFD]  is_var v returns true if v is not instantiated and false
otherwise.

iter [Var.FD]  iter f v iterates f on each integer in the domain of v .

iter [Data.Hashtbl]  
iter [SetDomain.S]  
iter [SetDomain] 
Iteration on values of the domain.

iter [Domain]  iter f d successively applies function f to all element of d in
increasing order.

L  
labeling [Goals.List] 
Standard labeling, i.e.

labeling [Goals.Array] 
Standard labeling, i.e.

largest_hole_around [Domain]  largest_hole_around dom val returns the largest hole (interval)
in dom centred around val .

later [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 ...).

lds [Goals]  lds ~step:1 g returns a goal which will iteratively search g with
increasing limited discrepancy (see ) by
increment step .

level [Stak] 
Returns the current level.

levels [Stak] 
Returns the current active levels.

M  
max [FdArray]  min vars (resp.

max [Invariant.FD]  
max [Var.BASICFD]  max v returns the upper bound of v .

max [Var.ATTR]  min a (resp.

max [SetDomain]  
max [Domain]  min d (resp.

max_cstr [FdArray]  min_cstr vars mini (resp.

max_elt [SetDomain.S]  
max_of_expr [Arith]  min_of_expr e (resp.

mem [Conjunto]  mem x v states that x belongs to v .

mem [Data.Hashtbl]  
mem [SetDomain.S]  
mem [SetDomain]  mem x d tests whether x belongs to the domain d .

mem [Domain]  
member [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 [Conjunto]  member v l ensures that v will have a value in l .

member [Var.BASICFD]  member v n returns true if n belongs to the domain of v and
false otherwise.

member [Var.ATTR]  member a n tests if n belongs to dom a .

member [Domain]  member n d tests if n belongs to d .

min [FdArray]  
min [Invariant.FD]  
min [Invariant.Array]  min a c returns the minimum BIR value of a for criterion c .

min [Var.BASICFD]  min v returns the lower bound of v .

min [Var.ATTR]  
min [SetDomain]  
min [Domain]  
min_cstr [FdArray]  
min_elt [SetDomain.S]  
min_max [Var.BASICFD]  min_max v returns both the lower and upper bounds of v .

min_max [SetDomain] 
Access to glb and lub.

min_max [Domain]  min_max d returns both the lower and upper bound of d .

min_max_of_expr [Arith]  min_max_of_expr e is equivalent to (min_of_expr e, max_of_expr e) .

min_of_expr [Arith]  
minimize [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.

minus [Domain]  minus d returns the domain of opposite values of d .

N  
name [Goals]  name g returns the name of the goal g .

name [Invariant]  name r returns the name (specified or generated) of BIR r .

name [Var.BASICFD]  name v returns the name of variable v (the empty string if
it was not provided while created).

name [Cstr]  name c returns the name of the constraint c .

nb_choice_points [Stak] 
Access to a global counter incremented at each choice point.

normal [Cstr]  
not [Reify] 
Logical reification operators on constraints, namely
and, or, implies, equivalent, exclusive or, not.

not [Cstr]  not c returns the negation of c .

not_instantiated_fd [Goals.Array]  not_instantiated_fd fds returns the index of one element in fds
which is not instantiated.

O  
older [Stak]  older l1 l2 true if level l1 precedes l2 .

on_max [Var.BASICFD] 
Event occuring when the lower (resp.

on_max [Var.ATTR] 
Event occuring when the lower (resp.

on_min [Var.BASICFD]  
on_min [Var.ATTR]  
on_refine [Var.BASICFD] 
Event occuring when a variable is changed, i.e.

on_refine [Var.ATTR] 
Event occuring when a variable is changed, i.e.

on_subst [Var.BASICFD] 
Event occuring when a variable is instantiated.

on_subst [Var.ATTR] 
Event occuring when a variable is instantiated.

once [Goals]  once g cuts choice points left on goal g .

one [Cstr]  
order [Conjunto]  order v1 v2 ensures that v1 is less than or equal to v2
according to Domain.compare .

order_with_card [Conjunto]  order_with_card v1 card1 v2 card2 is equivalent to order but the cardinals
of the variables must be provided too.

outside [Conjunto] 
Basic refinements for labeling.

P  
plus [Domain]  plus d n translates a domain by n .

post [Cstr]  post c posts the constraint c to the constraint store.

priority [Cstr]  priority c returns the priority of the constraint c .

prod [Arith]  
prod [Invariant]  sum a returns a BIR equal to the product of elements of a .

prod_fd [Arith]  prod exps (resp.

R  
ref [Stak] 
Returns a reference whose modifications will be trailed during the
solving of a goal.

refine [Var.BASICFD]  refine v d reduces the domain of v with domain d .

refine_low [Var.BASICFD]  refine_low v inf reduces the domain of v by cutting all values
strictly less than inf .

refine_low_up [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_up [Var.BASICFD]  refine_up v sup reduces the domain of v by cutting all values
strictly greater than sup .

remove [Var.FD]  remove v a removes a from the domain of v .

remove [Data.Hashtbl]  
remove [SetDomain.S]  
remove [Domain]  remove n d returns d {n} .

remove_closed_inter [Domain]  remove_closed_inter inf sup d returns
d [inf..sup] , i.e.

remove_low [SetDomain.S]  
remove_low [Domain]  remove_up n d (resp.

remove_low_up [Domain]  remove_low_up low up d is a shortcut for
remove_up up (remove_low low d) .

remove_max [Domain]  remove_min d (resp.

remove_min [Domain]  
remove_up [SetDomain.S]  
remove_up [Domain]  
replace [Data.Hashtbl]  
S  
scalprod [Arith]  
scalprod_fd [Arith]  scalprod coeffs exps (resp.

set [Invariant] 
Assignment of a setable BIR.

set [Data.Array]  set t i x Bactrackable assignment of t.(i) with x .

set [Stak] 
Sets a backtrackable reference.

set_boolsum_threshold [Arith] 
Set the minimum size for boolean sums optimization.

shift [Arith]  shift x d returns a finite domain variable constrained to be
equal to x+d .

sigma [Goals]  sigma ~domain:Domain.int fgoal creates the goal (fgoal v)
where v is a new
variable of domain domain .

singleton [SetDomain.S]  
size [Invariant.FD]  
size [Var.BASICFD]  size v returns the number of integer values in the domain of v
(1 if v is instantiated).

size [Var.ATTR]  size a returns the number of integer values in the domain of a .

size [Stak] 
Size of the stack, i.e.

size [SetDomain]  size d returns glb(d)lub(d)+1, i.e.

size [Domain]  size d returns the number of integers in d .

smallest [Conjunto]  smallest v returns the smallest element (an integer variable) of v .

smallest_geq [Domain]  
solve [Goals]  solve ~control:(fun _ > ()) g solves the goal g and returns
a success (true ) or a
failure (false ).

sort [Sorting]  sort a returns an array of variables constrained to be the variables
in a sorted in increasing order.

sortp [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.

sprint [Domain]  sprint d returns a string representation of d .

subset [Conjunto]  subset v1 v2 ensures that v1 is a subset of v2 .

subset [SetDomain.S]  
success [Goals] 
Failure (resp.

sum [Arith]  
sum [Invariant]  sum a returns a BIR equal to the sum of elements of a .

sum_fd [Arith]  sum exps (resp.

sum_weight [Conjunto]  sum_weight v weights returns an integer variable equal to the sum
of the weights associated with the value in v .

T  
ternary [Invariant]  ternary ~name:"Invariant.ternary" f wraps the ternary function f
into an operator on BIRs.

times [Domain]  times d k expands a domain by factor k .

U  
unary [Invariant.FD]  unary ~name:"Invariant.XxxFd.unary" f v Wrapper of any access
function over fd type.

unary [Invariant]  unary ~name:"Invariant.unary" f wraps the unary function f into
an operator on BIRs.

unify [Goals]  unify var x instantiates variable var to x .

unify [Var.BASICFD]  unify v n instantiates variable v with integer value n .

union [Conjunto]  
union [SetDomain.S]  
union [Domain] 
Intersection (resp.

unsafe_create [Domain]  unsafe_create l builds a new domain containing the values of l .

V  
value [Var.BASICFD]  value v returns Val n if v is instantiated to n , Unk a otherwise
where a is the attribute of v .

values [Var.FD]  values v returns the list of all integers in the domain of v .

values [SetDomain] 
Returns values of a domain.

values [Domain]  value d returns the list of values of the domain d

X  
xor [Reify]  
Z  
zero [Cstr] 
The constraint which succeeds (resp.
