Choco3: More updates for Choco3 newer version (almost all are now fixed)

hakank · Dec 23, 2013 · 5b1602c · 5b1602c
1 parent 33d5556
commit 5b1602c
Show file tree

Hide file tree

Showing 13 changed files with 83 additions and 119 deletions.
diff --git a/choco3/ARoundOfGolf.java b/choco3/ARoundOfGolf.java
@@ -45,6 +45,7 @@
 import solver.Solver;
 import solver.constraints.Constraint;
 import solver.constraints.IntConstraintFactory;
+import solver.constraints.LogicalConstraintFactory;
 import solver.search.strategy.IntStrategyFactory;
 import solver.search.strategy.selectors.values.InDomainMax;
 import solver.search.strategy.selectors.values.InDomainMiddle;
@@ -136,42 +137,26 @@ public void buildModel() {
     solver.post(IntConstraintFactory.element(scoreSands, score, Sands, 0));
     solver.post(IntConstraintFactory.element(score_caddy, score, caddy, 0));
 
-    solver.post(IntConstraintFactory.implies(b3_a_1,
+    solver.post(LogicalConstraintFactory.ifThen(b3_a_1,
                                              IntConstraintFactory.arithm(VariableFactory.offset(scoreSands, 4),
                                                                          "=",
                                                                          score[Frank])));
-    solver.post(IntConstraintFactory.implies(VariableFactory.not(b3_a_1),
-                                             IntConstraintFactory.arithm(VariableFactory.offset(scoreSands, 4),
-                                                                         "!=",
-                                                                         score[Frank])));
 
-    solver.post(IntConstraintFactory.implies(b3_a_2,
+    solver.post(LogicalConstraintFactory.ifThen(b3_a_2,
                                              IntConstraintFactory.arithm(score_caddy,
                                                                          "=",
                                                                          VariableFactory.offset(scoreSands, 7))));
-    solver.post(IntConstraintFactory.implies(VariableFactory.not(b3_a_2),
-                                             IntConstraintFactory.arithm(score_caddy,
-                                                                         "!=",
-                                                                         VariableFactory.offset(scoreSands, 7))));
-
 
-    solver.post(IntConstraintFactory.implies(b3_b_1,
+    solver.post(LogicalConstraintFactory.ifThen(b3_b_1,
                                              IntConstraintFactory.arithm(VariableFactory.offset(scoreSands, 7),
                                                                          "=",
                                                                          score[Frank])));
-    solver.post(IntConstraintFactory.implies(VariableFactory.not(b3_b_1),
-                                             IntConstraintFactory.arithm(VariableFactory.offset(scoreSands, 7),
-                                                                         "!=",
-                                                                         score[Frank])));
 
-    solver.post(IntConstraintFactory.implies(b3_b_2,
+    solver.post(LogicalConstraintFactory.ifThen(b3_b_2,
                                              IntConstraintFactory.arithm(score_caddy,
                                                                          "=",
                                                                          VariableFactory.offset(scoreSands, 4))));
-    solver.post(IntConstraintFactory.implies(VariableFactory.not(b3_b_2),
-                                             IntConstraintFactory.arithm(score_caddy,
-                                                                         "!=",
-                                                                         VariableFactory.offset(scoreSands, 4))));
+
 
     BoolVar b3_a = VariableFactory.bool("b3_a", solver);
     BoolVar b3_b = VariableFactory.bool("b3_a", solver);

diff --git a/choco3/CoinsGrid.java b/choco3/CoinsGrid.java
@@ -34,11 +34,6 @@
 import solver.Solver;
 import solver.constraints.Constraint;
 import solver.constraints.IntConstraintFactory;
-import solver.constraints.nary.cnf.Literal;
-import solver.constraints.nary.cnf.Node;
-import solver.constraints.nary.cnf.Node.*;
-import solver.constraints.nary.cnf.ALogicTree;
-import solver.search.limits.FailLimit;
 import solver.search.strategy.IntStrategyFactory;
 import solver.search.loop.monitors.SearchMonitorFactory;
 import solver.variables.IntVar;
@@ -108,7 +103,7 @@ public void buildModel() {
   @Override
   public void configureSearch() {
     solver.set(IntStrategyFactory.domOverWDeg_InDomainMin(ArrayUtils.flatten(x), seed));
-    SearchMonitorFactory.luby(solver, 2, 2, new FailLimit(solver, 2), 2500);
+    // SearchMonitorFactory.luby(solver, 2, 2, new FailLimit(solver, 2), 2500);
   }
 
   @Override

diff --git a/choco3/Crew.java b/choco3/Crew.java
@@ -24,6 +24,7 @@
 import solver.Solver;
 import solver.constraints.Constraint;
 import solver.constraints.IntConstraintFactory;
+import solver.constraints.LogicalConstraintFactory;
 import solver.search.strategy.IntStrategyFactory;
 import solver.search.strategy.selectors.values.InDomainMax;
 import solver.search.strategy.selectors.values.InDomainMiddle;
@@ -150,10 +151,10 @@ public void buildModel() {
       }
       IntVar tmpSum = VariableFactory.enumerated("tmpSum", 0, num_flights, solver);
       solver.post(IntConstraintFactory.sum(tmp, tmpSum));
-      solver.post(IntConstraintFactory.implies(nw[p],
-                                               IntConstraintFactory.arithm(tmpSum, ">", 0)));
-      solver.post(IntConstraintFactory.implies(VariableFactory.not(nw[p]),
-                                               IntConstraintFactory.arithm(tmpSum, "=", 0)));
+      solver.post(LogicalConstraintFactory.ifThenElse(nw[p],
+                                                      IntConstraintFactory.arithm(tmpSum, ">", 0),
+                                                      IntConstraintFactory.arithm(tmpSum, "=", 0)));
+
 
     }
     solver.post(IntConstraintFactory.sum(nw, num_working));

diff --git a/choco3/FurnitureMoving.java b/choco3/FurnitureMoving.java
@@ -19,10 +19,6 @@
 import solver.constraints.Constraint;
 import solver.constraints.IntConstraintFactory;
 import solver.constraints.IntConstraintFactory.*;
-import solver.constraints.nary.cnf.Literal;
-import solver.constraints.nary.cnf.Node;
-import solver.constraints.nary.cnf.Node.*;
-import solver.constraints.nary.cnf.ALogicTree;
 import solver.search.strategy.IntStrategyFactory;
 import solver.variables.IntVar;
 import solver.variables.BoolVar;
@@ -92,7 +88,7 @@ public void buildModel() {
     } else {
       NumPersons = VariableFactory.fixed(num_persons, solver);
     }
-    solver.post(IntConstraintFactory.cumulative(tasks, heights, NumPersons));
+    solver.post(IntConstraintFactory.cumulative(tasks, heights, NumPersons, true));
 
     solver.post(IntConstraintFactory.maximum(MaxEndTime, ends));
 

diff --git a/choco3/FurnitureMoving2.java b/choco3/FurnitureMoving2.java
@@ -19,10 +19,6 @@
 import solver.constraints.Constraint;
 import solver.constraints.IntConstraintFactory;
 import solver.constraints.IntConstraintFactory.*;
-import solver.constraints.nary.cnf.Literal;
-import solver.constraints.nary.cnf.Node;
-import solver.constraints.nary.cnf.Node.*;
-import solver.constraints.nary.cnf.ALogicTree;
 import solver.search.strategy.IntStrategyFactory;
 import solver.variables.IntVar;
 import solver.variables.BoolVar;
@@ -83,7 +79,7 @@ public void buildModel() {
     } else {
       NumPersons = VariableFactory.fixed(num_persons, solver);
     }
-    solver.post(IntConstraintFactory.cumulative(tasks, heights, NumPersons));
+    solver.post(IntConstraintFactory.cumulative(tasks, heights, NumPersons, true));
 
     solver.post(IntConstraintFactory.maximum(MaxEndTime, ends));
 

diff --git a/choco3/JustForgotten.java b/choco3/JustForgotten.java
@@ -33,6 +33,7 @@
 import solver.constraints.Constraint;
 import solver.constraints.IntConstraintFactory;
 import solver.constraints.IntConstraintFactory.*;
+import solver.constraints.LogicalConstraintFactory;
 import solver.search.strategy.IntStrategyFactory;
 import solver.variables.IntVar;
 import solver.variables.BoolVar;
@@ -67,10 +68,15 @@ public void buildModel() {
     for(int r = 0; r < rows; r++) {
       BoolVar[] b = VariableFactory.boolArray("b", cols, solver);
       for(int c = 0; c < cols; c++) {
+        /*
         solver.post(IntConstraintFactory.implies(b[c],
                                                  IntConstraintFactory.arithm(x[c], "=", a[r][c])));
         solver.post(IntConstraintFactory.implies(VariableFactory.not(b[c]),
                                                  IntConstraintFactory.arithm(x[c], "!=", a[r][c])));
+        */
+        solver.post(LogicalConstraintFactory.ifThen(b[c],
+                                                    IntConstraintFactory.arithm(x[c], "=", a[r][c])));
+
       }
 
       solver.post(IntConstraintFactory.sum(b,VariableFactory.fixed(4, solver)));

diff --git a/choco3/KenKen2.java b/choco3/KenKen2.java
@@ -49,6 +49,7 @@
 import solver.constraints.Constraint;
 import solver.constraints.IntConstraintFactory;
 import solver.constraints.IntConstraintFactory.*;
+import solver.constraints.LogicalConstraintFactory;
 import solver.search.strategy.IntStrategyFactory;
 import solver.variables.IntVar;
 import solver.variables.BoolVar;
@@ -139,51 +140,48 @@ public void calc(int[] cc,
 
       // a+b=res
       BoolVar r1 = VariableFactory.bool("r1", solver);
-      solver.post(IntConstraintFactory.implies(r1,
-                                               IntConstraintFactory.arithm(a,"+",b,"=",res)));
-      solver.post(IntConstraintFactory.implies(VariableFactory.not(r1),
-                                               IntConstraintFactory.arithm(a,"+",b,"!=",res)));
+      solver.post(LogicalConstraintFactory.ifThenElse(r1,
+                                                      IntConstraintFactory.arithm(a,"+",b,"=",res),
+                                                      IntConstraintFactory.arithm(a,"+",b,"!=",res)));
+
 
       // a*b=res
       IntVar t2 = VariableFactory.bounded("t2", 0, a.getUB()*b.getUB(), solver);
       solver.post(IntConstraintFactory.times(a,b,t2));
       BoolVar r2 = VariableFactory.bool("r2", solver);
-      solver.post(IntConstraintFactory.implies(r2,
-                                               IntConstraintFactory.arithm(t2,"=",resVar)));
-      solver.post(IntConstraintFactory.implies(VariableFactory.not(r2),
-                                               IntConstraintFactory.arithm(t2,"!=",resVar)));
+      solver.post(LogicalConstraintFactory.ifThenElse(r2,
+                                                      IntConstraintFactory.arithm(t2,"=",resVar),
+                                                      IntConstraintFactory.arithm(t2,"!=",resVar)));
+
 
       // a*res=b (b/a=res)
       IntVar t3 = VariableFactory.bounded("t3", 0, a.getUB()*res, solver);
       solver.post(IntConstraintFactory.times(a,resVar, t3));
       BoolVar r3 = VariableFactory.bool("r3", solver);
-      solver.post(IntConstraintFactory.implies(r3,
-                                               IntConstraintFactory.arithm(t3,"=",b)));
-      solver.post(IntConstraintFactory.implies(VariableFactory.not(r3),
-                                               IntConstraintFactory.arithm(t3,"!=",b)));
+      solver.post(LogicalConstraintFactory.ifThenElse(r3,
+                                                      IntConstraintFactory.arithm(t3,"=",b),
+                                                      IntConstraintFactory.arithm(t3,"!=",b)));
+
 
       // b*res=a (a/b=res)
       IntVar t4 = VariableFactory.bounded("t4", 0, b.getUB()*res, solver);
       solver.post(IntConstraintFactory.times(b,resVar, t4));
       BoolVar r4 = VariableFactory.bool("r4", solver);
-      solver.post(IntConstraintFactory.implies(r4,
-                                               IntConstraintFactory.arithm(t4,"=",a)));
-      solver.post(IntConstraintFactory.implies(VariableFactory.not(r4),
-                                               IntConstraintFactory.arithm(t4,"!=",a)));
+      solver.post(LogicalConstraintFactory.ifThenElse(r4,
+                                                      IntConstraintFactory.arithm(t4,"=",a),
+                                                      IntConstraintFactory.arithm(t4,"!=",a)));
 
       // a-b=res
       BoolVar r5 = VariableFactory.bool("r5", solver);
-      solver.post(IntConstraintFactory.implies(r5,
-                                               IntConstraintFactory.arithm(a,"-",b,"=",res)));
-      solver.post(IntConstraintFactory.implies(VariableFactory.not(r5),
-                                               IntConstraintFactory.arithm(a,"-",b,"!=",res)));
+      solver.post(LogicalConstraintFactory.ifThenElse(r5,
+                                                      IntConstraintFactory.arithm(a,"-",b,"=",res),
+                                                      IntConstraintFactory.arithm(a,"-",b,"!=",res)));
 
       // b-a=res
       BoolVar r6 = VariableFactory.bool("r6", solver);
-      solver.post(IntConstraintFactory.implies(r6,
-                                               IntConstraintFactory.arithm(b,"-",a,"=",res)));
-      solver.post(IntConstraintFactory.implies(VariableFactory.not(r6),
-                                               IntConstraintFactory.arithm(b,"-",a,"!=",res)));
+      solver.post(LogicalConstraintFactory.ifThenElse(r6,
+                                                      IntConstraintFactory.arithm(b,"-",a,"=",res),
+                                                      IntConstraintFactory.arithm(b,"-",a,"!=",res)));
 
 
       // r1+r2+r3+r4+r5+r6 >= 1
@@ -209,19 +207,17 @@ public void calc(int[] cc,
       IntVar ssum = VariableFactory.bounded("ssum", 0, n*len, solver);
       solver.post(IntConstraintFactory.sum(xx,ssum));
       BoolVar rsum = VariableFactory.bool("rsum", solver);
-      solver.post(IntConstraintFactory.implies(rsum,
-                                               IntConstraintFactory.arithm(ssum,"=",resVar)));
-      solver.post(IntConstraintFactory.implies(VariableFactory.not(rsum),
-                                               IntConstraintFactory.arithm(ssum,"!=",resVar)));
+      solver.post(LogicalConstraintFactory.ifThenElse(rsum,
+                                                      IntConstraintFactory.arithm(ssum,"=",resVar),
+                                                      IntConstraintFactory.arithm(ssum,"!=",resVar)));
 
 
       // Product
       IntVar prod = product(xx);
       BoolVar rprod = VariableFactory.bool("rprod", solver);
-      solver.post(IntConstraintFactory.implies(rprod,
-                                               IntConstraintFactory.arithm(prod,"=",resVar)));
-      solver.post(IntConstraintFactory.implies(VariableFactory.not(rprod),
-                                               IntConstraintFactory.arithm(prod,"!=",resVar)));
+      solver.post(LogicalConstraintFactory.ifThenElse(rprod,
+                                                      IntConstraintFactory.arithm(prod,"=",resVar),
+                                                      IntConstraintFactory.arithm(prod,"!=",resVar)));
 
       solver.post(IntConstraintFactory.arithm(rsum, "+", rprod, ">=", 1));
 

diff --git a/choco3/NontransitiveDice.java b/choco3/NontransitiveDice.java
@@ -26,10 +26,7 @@
 import solver.constraints.Constraint;
 import solver.constraints.IntConstraintFactory;
 import solver.constraints.IntConstraintFactory.*;
-import solver.constraints.nary.cnf.Literal;
-import solver.constraints.nary.cnf.Node;
-import solver.constraints.nary.cnf.Node.*;
-import solver.constraints.nary.cnf.ALogicTree;
+import solver.constraints.LogicalConstraintFactory;
 import solver.search.strategy.IntStrategyFactory;
 import solver.variables.IntVar;
 import solver.variables.BoolVar;
@@ -167,10 +164,8 @@ public void buildModel() {
       BoolVar[][] sum1B = VariableFactory.boolMatrix("sum1B_"+d, n, n,solver);
       for(int r1 = 0; r1 < n; r1++) {
         for(int r2 = 0; r2 < n; r2++) {
-          solver.post(IntConstraintFactory.implies(sum1B[r1][r2],
-                                                   IntConstraintFactory.arithm(dice[d % m][r1],">", dice[(d+1)%m][r2])));
-          solver.post(IntConstraintFactory.implies(VariableFactory.not(sum1B[r1][r2]),
-                                                   IntConstraintFactory.arithm(dice[d % m][r1],"<=", dice[(d+1)%m][r2])));
+          solver.post(LogicalConstraintFactory.ifThen(sum1B[r1][r2],
+                                                      IntConstraintFactory.arithm(dice[d % m][r1],">", dice[(d+1)%m][r2])));
 
         }
       }
@@ -179,10 +174,9 @@ public void buildModel() {
       BoolVar[][] sum2B = VariableFactory.boolMatrix("sum2B_"+d, n, n,solver);
       for(int r1 = 0; r1 < n; r1++) {
         for(int r2 = 0; r2 < n; r2++) {
-          solver.post(IntConstraintFactory.implies(sum2B[r1][r2],
-                                                   IntConstraintFactory.arithm(dice[(d+1) % m][r1],">", dice[d%m][r2])));
-          solver.post(IntConstraintFactory.implies(VariableFactory.not(sum2B[r1][r2]),
-                                                   IntConstraintFactory.arithm(dice[(d+1) % m][r1],"<=", dice[d%m][r2])));
+          solver.post(LogicalConstraintFactory.ifThen(sum2B[r1][r2],
+                                                      IntConstraintFactory.arithm(dice[(d+1) % m][r1],">", dice[d%m][r2])));
+
         }
       }
       solver.post(IntConstraintFactory.sum(ArrayUtils.flatten(sum2B), comp[d%m][1]));

diff --git a/choco3/OrganizeDay.java b/choco3/OrganizeDay.java
@@ -21,10 +21,7 @@
 import solver.constraints.Constraint;
 import solver.constraints.IntConstraintFactory;
 import solver.constraints.IntConstraintFactory.*;
-import solver.constraints.nary.cnf.Literal;
-import solver.constraints.nary.cnf.Node;
-import solver.constraints.nary.cnf.Node.*;
-import solver.constraints.nary.cnf.ALogicTree;
+import solver.constraints.LogicalConstraintFactory;
 import solver.search.strategy.IntStrategyFactory;
 import solver.variables.IntVar;
 import solver.variables.BoolVar;
@@ -70,17 +67,15 @@ public void NoOverlap(IntVar s1, int d1,
   {
     // (s1 + d1 <= s2) + (s2 + d2 <= s1) == 1
     BoolVar[] b = VariableFactory.boolArray("b", 2, solver);
-
-    solver.post(IntConstraintFactory.implies(b[0],
-                                           IntConstraintFactory.arithm(VariableFactory.offset(s1,d1), "<=", s2)));
-    solver.post(IntConstraintFactory.implies(VariableFactory.not(b[0]),
-                                           IntConstraintFactory.arithm(VariableFactory.offset(s1,d1), ">", s2)));
-
-    solver.post(IntConstraintFactory.implies(b[1],
-                                           IntConstraintFactory.arithm(VariableFactory.offset(s2,d2), "<=", s1)));
-    solver.post(IntConstraintFactory.implies(VariableFactory.not(b[1]),
-                                           IntConstraintFactory.arithm(VariableFactory.offset(s2,d2), ">", s1)));
-
+    solver.post(LogicalConstraintFactory.ifThenElse(b[0],
+                                                    IntConstraintFactory.arithm(VariableFactory.offset(s1,d1), "<=", s2),
+                                                    IntConstraintFactory.arithm(VariableFactory.offset(s1,d1), ">", s2)));
+
+    solver.post(LogicalConstraintFactory.ifThenElse(b[1],
+                                                    IntConstraintFactory.arithm(VariableFactory.offset(s2,d2), "<=", s1),
+                                                    IntConstraintFactory.arithm(VariableFactory.offset(s2,d2), ">", s1)));
+
+
     solver.post(IntConstraintFactory.sum(b, VariableFactory.fixed(1, solver)));
 
   }