public static void main(String[] args) {
RuleModel m = new RuleModel();
m.buildConsecutiveWERule();
m.buildNoNightBeforeFreeWE();
m.buildNoMoreThanDayRule();
m.buildRestAfterNight();
m.buildCompleteWE();
m.fillModel();
m.addLexConstraint();
m.addMandatoryShift();
m.addMinCoverConstraint();
CPSolver s = new CPSolver();
s.read(m);
ArrayList<IntDomainVar> mars = new ArrayList<IntDomainVar>();
for (int i = 0; i < 8; i++) mars.add(s.getVar(m.cvs[i][4]));
int[][] lowb = new int[28][3];
{
for (int i = 0; i < lowb.length; i++) {
lowb[i][0] = 3;
lowb[i][1] = 1;
lowb[i][2] = 4;
}
}
CoverVarValSelector sel = new CoverVarValSelector(s, m.vs, lowb);
// s.attachGoal(new AssignVar(sel,sel));
// s.attachGoal(new AssignVar(new StaticVarOrder(mars.toArray(new IntDomainVar[8])),new
// DecreasingDomain()));
s.attachGoal(
new AssignVar(
new StaticVarOrder(s, s.getVar(ArrayUtils.flatten(ArrayUtils.transpose(m.vs)))),
new IncreasingDomain()));
// s.addGoal(new AssignVar(new
// RandomIntVarSelector(s,s.getVar(ArrayUtils.flatten(ArrayUtils.transpose(m.vs))),0),new
// RandomIntValSelector()));
if (s.solve()) {
int i = 0;
for (IntegerVariable[] va : m.vs) {
for (IntDomainVar v : s.getVar(va)) {
System.out.print(toChar(v.getVal()) + " ");
}
System.out.print(" | ");
for (IntDomainVar v : s.getVar(m.cvs[i++])) {
System.out.print(v.getVal() + " ");
}
System.out.println("");
}
}
s.printRuntimeStatistics();
}
@Test
public void testDXYZProp4() {
IntegerVariable v0 = makeIntVar("v0", -1, 5);
IntegerVariable v1 = makeIntVar("v1", -5, 6);
IntegerVariable v2 = makeIntVar("v2", -2, 2);
m.addConstraint(distanceEQ(v0, v1, v2, 0));
s.read(m);
try {
s.propagate();
} catch (ContradictionException e) {
assertTrue(false);
}
assertEquals(-3, s.getVar(v1).getInf());
assertEquals(0, s.getVar(v2).getInf());
}
public ChocoSolver(SolvableModel model, int seed) {
initModel(model);
solver.addGoal(
new DomOverWDegBranchingNew(
solver, solver.getVar(model.getVariables()), new IncreasingDomain(), seed));
}
public int getIntValue(Object dpVar) {
try {
return solver.getVar((IntegerVariable) dpVar).getVal();
} catch (Throwable t) {
return ((IntegerVariable) dpVar).getLowB();
}
}
@Test
public void testDXYZProp1bis() {
IntegerVariable v0 = makeIntVar("v0", 1, 4);
IntegerVariable v1 = makeIntVar("v1", 5, 7);
IntegerVariable v2 = makeIntVar("v2", -100, 100);
m.addVariables(Options.V_BOUND, v0, v1, v2);
m.addConstraint(distanceEQ(v0, v1, v2, 2));
s.read(m);
try {
s.propagate();
} catch (ContradictionException e) {
LOGGER.info(e.getMessage());
assertTrue(false);
}
assertEquals(-1, s.getVar(v2).getInf());
assertEquals(4, s.getVar(v2).getSup());
}
@Test
public void testDXYZProp5() {
IntegerVariable v0 = makeIntVar("v0", -1, 1);
IntegerVariable v1 = makeIntVar("v1", -5, 6);
IntegerVariable v2 = makeIntVar("v2", 3, 10);
m.addConstraint(distanceEQ(v0, v1, v2, 0));
s.read(m);
try {
s.propagate();
} catch (ContradictionException e) {
assertTrue(false);
}
LOGGER.info("" + v1.pretty());
assertTrue(!s.getVar(v1).canBeInstantiatedTo(0));
assertTrue(!s.getVar(v1).canBeInstantiatedTo(1));
assertTrue(!s.getVar(v1).canBeInstantiatedTo(-1));
assertEquals(7, s.getVar(v2).getSup());
}
public void setHeuristic(ChocoHeuristic heuristic) {
switch (heuristic) {
case MIN_DOMAIN:
{
solver.setVarIntSelector(new MinDomain(solver, solver.getVar(model.getVariables())));
break;
}
case DOM_OVER_WDEG:
{
solver.addGoal(
new DomOverWDegBranchingNew(
solver, solver.getVar(model.getVariables()), new IncreasingDomain(), 1));
break;
}
case DEFAULT:
{
// default heuristic
break;
}
}
}
@Test
public void test1bis() {
CPModel m = new CPModel();
RealVariable alpha = makeRealVar("alpha", -Math.PI, Math.PI);
Constraint exp = eq(cos(alpha), sin(alpha));
m.addConstraint(exp);
CPSolver s = new CPSolver();
s.read(m);
LOGGER.info("eq = " + s.getCstr(exp).pretty());
boolean first = false;
s.setFirstSolution(first);
s.generateSearchStrategy();
s.addGoal(new AssignInterval(new CyclicRealVarSelector(s), new RealIncreasingDomain()));
s.launch();
assertTrue(s.getNbSolutions() >= 2);
assertTrue(
Math.abs(Math.cos(s.getVar(alpha).getInf()) - Math.sin(s.getVar(alpha).getInf())) < 1e-8);
}
public ChocoSolver(
SolvableModel model,
int seed,
SharedHeuristicWeights sharedVariablesWeight,
SharedHeuristicWeights sharedConstraintsWeight) {
initModel(model);
solver.addGoal(
new DomOverWDegBranchingSharedWeights(
solver,
solver.getVar(model.getVariables()),
new IncreasingDomain(),
seed,
sharedVariablesWeight,
sharedConstraintsWeight));
}
@Test
public void testDXYZProp3() {
IntegerVariable v0 = makeIntVar("v0", 1, 5);
IntegerVariable v1 = makeIntVar("v1", 5, 6);
IntegerVariable v2 = makeIntVar("v2", 3, 10);
m.addVariables(Options.V_BOUND, v0, v1, v2);
m.addConstraint(distanceEQ(v0, v1, v2, 0));
s.read(m);
try {
s.propagate();
} catch (ContradictionException e) {
assertTrue(false);
}
assertEquals(3, s.getVar(v0).getSup());
assertEquals(5, s.getVar(v2).getSup());
}
@Test
public void testDXYZProp2bis() {
IntegerVariable v0 = makeIntVar("v0", 1, 5);
IntegerVariable v1 = makeIntVar("v1", 5, 10);
IntegerVariable v2 = makeIntVar("v2", 1, 2);
m.addVariables(Options.V_BOUND, v0, v1, v2);
m.addConstraint(distanceEQ(v0, v1, v2, -1));
s.read(m);
try {
s.propagate();
} catch (ContradictionException e) {
assertTrue(false);
}
assertEquals(4, s.getVar(v0).getInf());
assertEquals(6, s.getVar(v1).getSup());
s.solve();
LOGGER.info("" + s.pretty());
}
public static void main(String[] args) {
final CPSolver solver = new CPSolver();
CPModel model = new CPModel();
// VARIABLES sŽrie varA :
// 12 variables varsA[i] avec D( varsA[i] ) = { 0, 1, 2, .., 15, i+16}
int tmpdomain[] = new int[17];
for (int i = 0; i < 16; i++) tmpdomain[i] = i;
IntegerVariable[] varsA = new IntegerVariable[12];
for (int i = 0; i < 12; i++) {
tmpdomain[16] = 16 + i;
varsA[i] = makeIntVar("varsA" + i, tmpdomain.clone());
}
model.addVariables(varsA);
// VARIABLES sŽrie varB
// 16 variables varsB[i] avec D( varsB[i] ) = { 1, 2, .., 11, i+12}
tmpdomain = new int[13];
for (int i = 0; i < 12; i++) tmpdomain[i] = i;
IntegerVariable[] varsB = new IntegerVariable[16];
for (int i = 0; i < 16; i++) {
tmpdomain[12] = 16 + i;
varsB[i] = makeIntVar("varsB" + i, tmpdomain.clone());
}
model.addVariables(varsB);
// variable pour compter les varsA et varsB infŽrieureures ˆ 16
final IntegerVariable nbvarsInf16 =
makeIntVar("nbvarsInf16", 0, 28, Options.V_NO_DECISION, Options.V_BOUND);
model.addVariable(nbvarsInf16);
// ----------- dŽfinition relation binaire : rel
int[] min = new int[] {0, 0};
int[] max = new int[] {27, 27};
ArrayList<int[]> couplesOK = new ArrayList<int[]>();
addCouples(couplesOK, 0, 1);
addCouples(couplesOK, 0, 4);
addCouples(couplesOK, 0, 3);
addCouples(couplesOK, 1, 2);
addCouples(couplesOK, 2, 3);
addCouples(couplesOK, 2, 11);
addCouples(couplesOK, 3, 5);
addCouples(couplesOK, 3, 10);
addCouples(couplesOK, 4, 5);
addCouples(couplesOK, 4, 6);
addCouples(couplesOK, 5, 7);
addCouples(couplesOK, 5, 8);
addCouples(couplesOK, 6, 7);
addCouples(couplesOK, 7, 9);
addCouples(couplesOK, 8, 10);
addCouples(couplesOK, 8, 14);
addCouples(couplesOK, 8, 9);
addCouples(couplesOK, 9, 15);
addCouples(couplesOK, 10, 11);
addCouples(couplesOK, 10, 13);
addCouples(couplesOK, 11, 12);
addCouples(couplesOK, 12, 13);
addCouples(couplesOK, 13, 14);
addCouples(couplesOK, 14, 15);
for (int j = 0; j < 12; j++) {
for (int k = 0; k < 12; k++) {
addCouples(couplesOK, j + 16, k);
if (j <= k) addCouples(couplesOK, j + 16, k + 16);
}
}
BinRelation rel = makeBinRelation(min, max, couplesOK, true);
// ----contraintes entre des Vars A basŽes sur rel2
model.addConstraint(allDifferent(varsA));
model.addConstraint(relationPairAC(varsA[10], varsA[11], rel));
model.addConstraint(relationPairAC(varsA[8], varsA[9], rel));
model.addConstraint(relationPairAC(varsA[6], varsA[7], rel));
model.addConstraint(relationPairAC(varsA[5], varsA[9], rel));
model.addConstraint(relationPairAC(varsA[5], varsA[7], rel));
model.addConstraint(relationPairAC(varsA[4], varsA[10], rel));
model.addConstraint(relationPairAC(varsA[4], varsA[8], rel));
model.addConstraint(relationPairAC(varsA[4], varsA[5], rel));
model.addConstraint(relationPairAC(varsA[3], varsA[6], rel));
model.addConstraint(relationPairAC(varsA[3], varsA[5], rel));
model.addConstraint(relationPairAC(varsA[2], varsA[3], rel));
model.addConstraint(relationPairAC(varsA[1], varsA[2], rel));
model.addConstraint(relationPairAC(varsA[0], varsA[11], rel));
model.addConstraint(relationPairAC(varsA[0], varsA[4], rel));
model.addConstraint(relationPairAC(varsA[0], varsA[3], rel));
model.addConstraint(relationPairAC(varsA[0], varsA[1], rel));
// autres contraintes
model.addConstraint(lt(varsB[0], varsB[2]));
model.addConstraint(lt(varsB[0], varsB[4]));
model.addConstraint(lt(varsB[0], varsB[7]));
model.addConstraint(lt(varsB[0], varsB[9]));
model.addConstraint(lt(varsB[0], varsB[11]));
model.addConstraint(lt(varsB[0], varsB[13]));
model.addConstraint(lt(varsB[0], varsB[14]));
// ---- channeling entre vars A et vars B
model.addConstraint(inverseChannelingWithinRange(varsA, varsB));
// --- among pour compter les varsA et varsB infŽrieureures ˆ 16
tmpdomain = new int[16];
for (int i = 0; i < 16; i++) tmpdomain[i] = i;
IntegerVariable[] vars_A_et_B = ArrayUtils.append(varsA, varsB);
model.addConstraint(among(nbvarsInf16, vars_A_et_B, tmpdomain));
// --------
// model.addConstraint(Choco.eq(nbvarsInfN, 24));
solver.read(model);
try {
solver.propagate();
} catch (ContradictionException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
solver.maximize(solver.getVar(nbvarsInf16), true);
Assert.assertEquals(solver.getVar(nbvarsInf16).getVal(), 24);
}