replace several more instances of ?/1 by (#)/1

src/lib/clpz.pl

@@ -1917,7 +1917,7 @@ label([], _, Selection, Order, Choice, Optim0, Consistency, Vars) :-
 exprs_singlevars([], []).
 exprs_singlevars([E|Es], [SV|SVs]) :-
         E =.. [F,Expr],
-        ?(Single) #= Expr,
+        #Single #= Expr,
         SV =.. [F,Single],
         exprs_singlevars(Es, SVs).
 
@@ -2316,7 +2316,7 @@ coeff_int_linsum(C, I, S0, S) :- S is S0 + C*I.
 
 sum([], _, Sum, Op, Value) :- call(Op, Sum, Value).
 sum([C|Cs], [X|Xs], Acc, Op, Value) :-
-        ?(NAcc) #= Acc + C* ?(X),
+        #NAcc #= Acc + C* #X,
         sum(Cs, Xs, NAcc, Op, Value).
 
 multiples([], [], _).
@@ -2325,7 +2325,7 @@ multiples([C|Cs], [V|Vs], Left) :-
             (   N =\= 1, gcd(C,N) =:= 1 ->
                 gcd(Cs, N, GCD0),
                 gcd(Left, GCD0, GCD),
-                (   GCD > 1 -> ?(V) #= GCD * ?(_)
+                (   GCD > 1 -> #V #= GCD * #_
                 ;   true
                 )
             ;   true
@@ -2563,14 +2563,14 @@ parse_clpz(E, R,
              m(A*B)            => [p(ptimes(A, B, R))],
              m(A-B)            => [p(pplus(R,B,A))],
              m(-A)             => [p(ptimes(-1,A,R))],
-             m(max(A,B))       => [g(A #=< ?(R)), g(B #=< R), p(pmax(A, B, R))],
+             m(max(A,B))       => [g(A #=< #R), g(B #=< R), p(pmax(A, B, R))],
-             m(min(A,B))       => [g(A #>= ?(R)), g(B #>= R), p(pmin(A, B, R))],
+             m(min(A,B))       => [g(A #>= #R), g(B #>= R), p(pmin(A, B, R))],
              m(A mod B)        => [g(B #\= 0), p(pmod(A, B, R))],
              m(A rem B)        => [g(B #\= 0), p(prem(A, B, R))],
-             m(abs(A))         => [g(?(R) #>= 0), p(pabs(A, R))],
+             m(abs(A))         => [g(#R #>= 0), p(pabs(A, R))],
              m(A/B)            => [g(B #\= 0), p(prdiv(A, B, R))],
              m(A//B)           => [g(B #\= 0), p(ptzdiv(A, B, R))],
-             m(A div B)        => [g(?(R) #= (A - (A mod B)) // B)],
+             m(A div B)        => [g(#R #= (A - (A mod B)) // B)],
              m(A^B)            => [p(pexp(A, B, R))],
              m(sign(A))        => [g(R in -1..1), p(psign(A, R))],
              % bitwise operations
@@ -2765,7 +2765,7 @@ matches([
          m_c(any(X) #>= any(Y), left_right_linsum_const(X, Y, Cs, Vs, Const)) =>
             [g((   Cs = [1], Vs = [A] -> geq(A, Const)
                ;   Cs = [-1], Vs = [A] -> Const1 is -Const, geq(Const1, A)
-               ;   Cs = [1,1], Vs = [A,B] -> ?(A) + ?(B) #= ?(S), geq(S, Const)
+               ;   Cs = [1,1], Vs = [A,B] -> #A + #B #= #S, geq(S, Const)
                ;   Cs = [1,-1], Vs = [A,B] ->
                    (   Const =:= 0 -> geq(A, B)
                    ;   C1 is -Const,
@@ -2777,13 +2777,13 @@ matches([
                        propagator_init_trigger(x_leq_y_plus_c(A, B, C1))
                    )
                ;   Cs = [-1,-1], Vs = [A,B] ->
-                   ?(A) + ?(B) #= ?(S), Const1 is -Const, geq(Const1, S)
+                   #A + #B #= #S, Const1 is -Const, geq(Const1, S)
                ;   scalar_product_(#>=, Cs, Vs, Const)
                ))],
          m(any(X) - any(Y) #>= integer(C))     => [d(X, X1), d(Y, Y1), g(C1 is -C), p(x_leq_y_plus_c(Y1, X1, C1))],
          m(integer(X) #>= any(Z) + integer(A)) => [g(C is X - A), r(C, Z)],
          m(abs(any(X)-any(Y)) #>= any(Z))  =>
-           [d(X, X1), d(Y, Y1), d(Z, Z1), g((abs(?(A))#= ?(B),Y1+A#=X1,Z1#=<B))],
+           [d(X, X1), d(Y, Y1), d(Z, Z1), g((abs(#A)#= #B,Y1+A#=X1,Z1#=<B))],
          m(abs(any(X)) #>= integer(I))         => [d(X, RX), g((I>0 -> I1 is -I, RX in inf..I1 \/ I..sup; true))],
          m(integer(I) #>= abs(any(X)))         => [d(X, RX), g(I>=0), g(I1 is -I), g(RX in I1..I)],
          m(any(X) #>= any(Y))                  => [d(X, RX), d(Y, RY), g(geq(RX, RY))],
@@ -3530,7 +3530,7 @@ parse_reified(E, R, D,
                m(-A)         => [d(D), p(ptimes(-1,A,R)), a(R)],
                m(max(A,B))   => [d(D), p(pgeq(R, A)), p(pgeq(R, B)), p(pmax(A,B,R)), a(A,B,R)],
                m(min(A,B))   => [d(D), p(pgeq(A, R)), p(pgeq(B, R)), p(pmin(A,B,R)), a(A,B,R)],
-               m(abs(A))     => [g(?(R)#>=0), d(D), p(pabs(A, R)), a(A,R)],
+               m(abs(A))     => [g(#R#>=0), d(D), p(pabs(A, R)), a(A,R)],
                m(A/B)        => [p(preified_slash(A,B,D,R)), a(A,B,R)],
                m(A//B)       => [skeleton(A,B,D,R,ptzdiv)],
                m(A div B)    => [skeleton(A,B,D,R,pdiv)],
@@ -3670,7 +3670,7 @@ reify_(tuples_in(Tuples, Relation), B) -->
         { maplist(relation_tuple_b_prop(Relation), Tuples, Bs, Ps),
           maplist(monotonic, Bs, Bs1),
           fold_statement(conjunction, Bs1, And),
-          ?(B) #<==> And },
+          #B #<==> And },
         propagator_init_trigger([B], tuples_not_in(Tuples, Relation, B)),
         kill_reified_tuples(Bs, Ps, Bs),
         list(Ps),
@@ -3772,7 +3772,7 @@ conjunction(E, Conj, Conj #/\ E).
 
 disjunction(E, Disj, Disj #\/ E).
 
-var_eq(V, N, ?(V) #= N).
+var_eq(V, N, #V #= N).
 
 % Match variables to created skeleton.
 
@@ -4274,7 +4274,7 @@ lex_chain_(Prop, Ls, Prev, Ls) :-
 
 lex_le([], []).
 lex_le([V1|V1s], [V2|V2s]) :-
-        ?(V1) #=< ?(V2),
+        #V1 #=< #V2,
         (   integer(V1) ->
             (   integer(V2) ->
                 (   V1 =:= V2 -> lex_le(V1s, V2s) ;  true )
@@ -6559,7 +6559,7 @@ element_domain(V, VD) :-
 
 element_([], _, _, _).
 element_([I|Is], N0, N, V) :-
-        ?(I) #\= ?(V) #==> ?(N) #\= N0,
+        #I #\= #V #==> #N #\= N0,
         N1 is N0 + 1,
         element_(Is, N1, N, V).
 
@@ -7103,25 +7103,25 @@ cumulative(Tasks, Options) :-
 fully_elastic_relaxation(Tasks, Limit) :-
         maplist(task_duration_consumption, Tasks, Ds, Cs),
         maplist(area, Ds, Cs, As),
-        sum(As, #=, ?(Area)),
+        sum(As, #=, #Area),
-        ?(MinTime) #= (Area + Limit - 1) // Limit,
+        #MinTime #= (Area + Limit - 1) // Limit,
         tasks_minstart_maxend(Tasks, MinStart, MaxEnd),
         MaxEnd #>= MinStart + MinTime.
 
 task_duration_consumption(task(_,D,_,C,_), D, C).
 
-area(X, Y, Area) :- ?(Area) #= ?(X) * ?(Y).
+area(X, Y, Area) :- #Area #= #X * #Y.
 
 tasks_minstart_maxend(Tasks, Start, End) :-
         maplist(task_start_end, Tasks, [Start0|Starts], [End0|Ends]),
         foldl(min_, Starts, Start0, Start),
         foldl(max_, Ends, End0, End).
 
-max_(E, M0, M) :- ?(M) #= max(E, M0).
+max_(E, M0, M) :- #M #= max(E, M0).
 
-min_(E, M0, M) :- ?(M) #= min(E, M0).
+min_(E, M0, M) :- #M #= min(E, M0).
 
-task_start_end(task(Start,_,End,_,_), ?(Start), ?(End)).
+task_start_end(task(Start,_,End,_,_), #Start, #End).
 
 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    All time slots must respect the resource limit.
@@ -7136,8 +7136,8 @@ resource_limit(T0, T, Tasks, Bss, L) :-
 
 task_bs(Task, InfStart-Bs) :-
         Task = task(Start,D,End,_,_Id),
-        ?(D) #> 0,
+        #D #> 0,
-        ?(End) #= ?(Start) + ?(D),
+        #End #= #Start + #D,
         maplist(finite_domain, [End,Start,D]),
         fd_inf(Start, InfStart),
         fd_sup(End, SupEnd),
@@ -7147,20 +7147,20 @@ task_bs(Task, InfStart-Bs) :-
 
 task_running([], _, _, _).
 task_running([B|Bs], Start, End, T) :-
-        ((T #>= Start) #/\ (T #< End)) #<==> ?(B),
+        ((T #>= Start) #/\ (T #< End)) #<==> #B,
         T1 is T + 1,
         task_running(Bs, Start, End, T1).
 
 contribution_at(T, Task, Offset-Bs, Contribution) :-
         Task = task(Start,_,End,C,_),
-        ?(C) #>= 0,
+        #C #>= 0,
         fd_inf(Start, InfStart),
         fd_sup(End, SupEnd),
         (   T < InfStart -> Contribution = 0
         ;   T >= SupEnd -> Contribution = 0
         ;   Index is T - Offset,
             nth0(Index, Bs, B),
-            ?(Contribution) #= B*C
+            #Contribution #= B*C
         ).
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -7188,10 +7188,10 @@ non_overlapping_(A, B) :-
         a_not_in_b(B, A).
 
 a_not_in_b([_,AX,AW,AY,AH], [_,BX,BW,BY,BH]) :-
-        ?(AX) #=< ?(BX) #/\ ?(BX) #< ?(AX) + ?(AW) #==>
+        #AX #=< #BX #/\ #BX #< #AX + #AW #==>
-                   ?(AY) + ?(AH) #=< ?(BY) #\/ ?(BY) + ?(BH) #=< ?(AY),
+                   #AY + #AH #=< #BY #\/ #BY + #BH #=< #AY,
-        ?(AY) #=< ?(BY) #/\ ?(BY) #< ?(AY) + ?(AH) #==>
+        #AY #=< #BY #/\ #BY #< #AY + #AH #==>
-                   ?(AX) + ?(AW) #=< ?(BX) #\/ ?(BX) + ?(BW) #=< ?(AX).
+                   #AX + #AW #=< #BX #\/ #BX + #BW #=< #AX.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -7348,7 +7348,7 @@ exprs_values([E0|Es], [V|Vs]) -->
         { term_variables(E0, EVs0),
           copy_term(E0, E),
           term_variables(E, EVs),
-          ?(V) #= E },
+          #V #= E },
         match_variables(EVs0, EVs),
         exprs_values(Es, Vs).
 
@@ -7398,7 +7398,7 @@ source(source(_)).
 
 sink(sink(_)).
 
-monotonic(Var, ?(Var)).
+monotonic(Var, #Var).
 
 arc_normalized(Cs, Arc0, Arc) :- arc_normalized_(Arc0, Cs, Arc).
 
@@ -7457,9 +7457,9 @@ zcompare(Order, A, B) :-
             propagator_init_trigger([A,B], pzcompare(Order, A, B))
         ).
 
-zcompare_(=, A, B) :- ?(A) #= ?(B).
+zcompare_(=, A, B) :- #A #= #B.
-zcompare_(<, A, B) :- ?(A) #< ?(B).
+zcompare_(<, A, B) :- #A #< #B.
-zcompare_(>, A, B) :- ?(A) #> ?(B).
+zcompare_(>, A, B) :- #A #> #B.
 
 %% chain(+Relation, +Zs)
 %
@@ -7492,7 +7492,7 @@ chain_relation(#=<).
 chain_relation(#>).
 chain_relation(#>=).
 
-chain(Relation, X, Prev, X) :- call(Relation, ?(Prev), ?(X)).
+chain(Relation, X, Prev, X) :- call(Relation, #Prev, #X).
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -