Example #1
0
  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();
  }
Example #2
0
  @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));
  }
Example #4
0
 public int getIntValue(Object dpVar) {
   try {
     return solver.getVar((IntegerVariable) dpVar).getVal();
   } catch (Throwable t) {
     return ((IntegerVariable) dpVar).getLowB();
   }
 }
Example #5
0
  @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());
  }
Example #6
0
  @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;
       }
   }
 }
Example #8
0
  @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));
  }
Example #10
0
  @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());
  }
Example #11
0
  @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());
  }
Example #12
0
  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);
  }