コード例 #1
0
  public static void main(String[] args) throws Exception {
    int status = 127;
    try {
      IloOplFactory.setDebugMode(true);
      IloOplFactory oplF = new IloOplFactory();

      // make master model
      IloOplErrorHandler errHandler = oplF.createOplErrorHandler();
      IloOplSettings settings = oplF.createOplSettings(errHandler);

      IloOplRunConfiguration masterRC =
          oplF.createOplRunConfiguration(
              DATADIR + "/cutstock_change.mod", DATADIR + "/cutstock_change.dat");
      masterRC.setErrorHandler(errHandler);
      IloCplex masterCplex = oplF.createCplex();
      masterCplex.setOut(null);

      masterRC.setCplex(masterCplex);
      IloOplModel masterOpl = masterRC.getOplModel();
      masterOpl.generate();
      IloOplDataElements masterDataElements = masterOpl.makeDataElements();

      int nWdth = masterDataElements.getElement("Amount").asIntMap().getSize();
      ArrayList<IloNumVar> masterVars = new ArrayList<IloNumVar>();
      IloNumVarMap cuts = masterOpl.getElement("Cut").asNumVarMap();
      for (int i = 1; i <= nWdth; i++) {
        masterVars.add(cuts.get(i));
      }

      // prepare sub model source, definition and engine
      IloOplModelSource subSource = oplF.createOplModelSource(DATADIR + "/cutstock-sub.mod");
      IloOplModelDefinition subDef = oplF.createOplModelDefinition(subSource, settings);
      IloCplex subCplex = oplF.createCplex();
      subCplex.setOut(null);

      double best;
      double curr = Double.MAX_VALUE;
      do {
        best = curr;

        // Make master model
        System.out.println("Solve master.");
        if (masterCplex.solve()) {
          curr = masterCplex.getObjValue();
          System.out.println("OBJECTIVE: " + curr);
          status = 0;
        } else {
          System.out.println("No solution!");
          status = 1;
        }

        // prepare data for sub model
        IloOplDataElements subDataElements = oplF.createOplDataElements();
        subDataElements.addElement(masterDataElements.getElement("RollWidth"));
        subDataElements.addElement(masterDataElements.getElement("Size"));
        subDataElements.addElement(masterDataElements.getElement("Duals"));
        // get reduced costs and set them in sub problem
        IloNumMap duals = subDataElements.getElement("Duals").asNumMap();
        for (int i = 1; i < nWdth + 1; i++) {
          IloForAllRange forAll =
              (IloForAllRange) masterOpl.getElement("ctFill").asConstraintMap().get(i);
          duals.set(i, masterCplex.getDual(forAll));
        }
        // make sub model
        IloOplModel subOpl = oplF.createOplModel(subDef, subCplex);
        subOpl.addDataSource(subDataElements);
        subOpl.generate();

        System.out.println("Solve sub.");
        if (subCplex.solve()) {
          System.out.println("OBJECTIVE: " + subCplex.getObjValue());
          status = 0;
        } else {
          System.out.println("No solution!");
          status = 1;
        }
        if (subCplex.getObjValue() > -RC_EPS) break;

        // Add variable in master model
        IloNumVar newVar = masterCplex.numVar(0, Double.MAX_VALUE);
        IloObjective masterObj = masterOpl.getObjective();
        masterCplex.setLinearCoef(masterObj, newVar, 1);
        for (int i = 1; i < nWdth + 1; i++) {
          double coef = subCplex.getValue(subOpl.getElement("Use").asIntVarMap().get(i));
          IloForAllRange forAll =
              (IloForAllRange) masterOpl.getElement("ctFill").asConstraintMap().get(i);
          masterCplex.setLinearCoef(forAll, newVar, coef);
        }
        masterVars.add(newVar);

        subOpl.end();
      } while (best != curr && status == 0);

      IloNumVar[] masterVarsA = new IloNumVar[masterVars.size()];
      masterVars.toArray(masterVarsA);
      masterCplex.add(masterCplex.conversion(masterVarsA, IloNumVarType.Int));
      if (masterCplex.solve()) {
        System.out.println("OBJECTIVE: " + masterCplex.getObjValue());
      }
      oplF.end();
    } catch (IloOplException ex) {
      System.err.println("### OPL exception: " + ex.getMessage());
      ex.printStackTrace();
      status = 2;
    } catch (IloException ex) {
      System.err.println("### CONCERT exception: " + ex.getMessage());
      ex.printStackTrace();
      status = 3;
    } catch (Exception ex) {
      System.err.println("### UNEXPECTED UNKNOWN ERROR ...");
      ex.printStackTrace();
      status = 4;
    }
    System.exit(status);
  }
コード例 #2
0
  public double solve(Instance ins, Solution sol, int timeout) throws IloException {
    IloCplex solver = new IloCplex();
    BiIndexedIntVarMap y = new BiIndexedIntVarMap(solver, 0, 1, "y"); // (k,v)   (cluster,node)
    IndexedNumVarMap d =
        new IndexedNumVarMap(solver, 0, Double.MAX_VALUE, "dp"); // (k)     (cluster)	
    TriIndexedNumVarMap f =
        new TriIndexedNumVarMap(solver, 0, Double.MAX_VALUE, "f"); // (k,i,j) (cluster,tail,head)
    BiIndexedIntVarMap r = new BiIndexedIntVarMap(solver, 0, 1, "r"); // (k,i)   (cluster,node
    BiIndexedNumVarMap w = new BiIndexedNumVarMap(solver, 0, 1, "w"); // (i,j)   (node1<node2)

    int superRoot = ins.getNumNodes();
    // compute the weights of the objective function
    double w1 = ins.getW1() / ins.getNumNodes();
    double w2 = ins.getW2() / (ins.getLambda() * ins.getMaxClusterNumber());
    double w3 =
        2
            * ins.getW3()
            / (ins.getNumNodes() * (ins.getNumNodes() - 1) * (ins.getDMax() - ins.getDMin()));

    Set<OrderedPair> fp = new TreeSet<OrderedPair>(ins.getP());
    if (isActiveExtension(Extension.PFILTER)) {
      fp = ins.filterP();
      System.out.println("PFILTER: " + (ins.getP().size() - fp.size()) + " pairs filtered");
    }

    // compute the objective function expression
    IloNumExpr expr = solver.numExpr();

    // O1
    IloNumExpr exprO1 = solver.numExpr();
    for (int i = 0; i < ins.getNumNodes(); ++i) {
      expr = solver.numExpr();
      expr = solver.sum(expr, 1);
      for (int k = 0; k < ins.getMaxClusterNumber(); ++k) expr = solver.diff(expr, y.get(k, i));
      exprO1 = solver.sum(exprO1, solver.prod(w1, expr));
    }
    // O2
    IloNumExpr exprO2 = solver.numExpr();
    for (int k = 0; k < ins.getMaxClusterNumber(); ++k) {
      exprO2 = solver.sum(exprO2, solver.prod(w2, d.get(k)));
    }
    // O3
    IloNumExpr exprO3 = solver.numExpr();
    for (OrderedPair p : fp) {
      double dmax = ins.getDMax();
      double dist = ins.getD(p.i, p.j);
      IloNumVar wvar = w.get(p.i, p.j);
      exprO3 = solver.sum(exprO3, solver.prod(w3 * (dmax - dist), wvar));
    }
    expr = solver.sum(exprO1, solver.sum(exprO2, exprO3));
    solver.add(solver.objective(IloObjectiveSense.Minimize, expr));

    // packing constraints
    for (int i = 0; i < ins.getNumNodes(); ++i) {
      expr = solver.numExpr();
      for (int k = 0; k < ins.getMaxClusterNumber(); ++k) expr = solver.sum(expr, y.get(k, i));
      solver.addLe(expr, 1);
    }

    // root uniqueness constraints
    for (int k = 0; k < ins.getMaxClusterNumber(); ++k) {
      expr = solver.numExpr();
      for (int i = 0; i < ins.getNumNodes(); ++i) expr = solver.sum(expr, r.get(k, i));
      solver.addLe(expr, 1);
    }

    // f,y linking constraints

    // OUT
    for (int k = 0; k < ins.getMaxClusterNumber(); ++k) {
      for (int i = 0; i < ins.getNumNodes(); ++i) {
        expr = solver.numExpr();
        for (Integer j : ins.getOutcut(i)) {
          expr = solver.sum(expr, f.get(k, i, j));
        }
        expr = solver.diff(expr, solver.prod(ins.getMaxClusterSize() - 2, y.get(k, i)));
        solver.addLe(expr, 0);
      }
    }

    // f,r linking constraints
    for (int k = 0; k < ins.getMaxClusterNumber(); ++k) {
      for (int i = 0; i < ins.getNumNodes(); ++i) {
        solver.addLe(f.get(k, superRoot, i), solver.prod(ins.getMaxClusterSize(), r.get(k, i)));
      }
    }

    //		//flow generation constraints
    //		for(int k=0;k<ins.getMaxClusterNumber();++k){
    //			expr=solver.numExpr();
    //			for(int i=0;i<ins.getNumNodes();++i){
    //				expr=solver.sum(expr,f.get(k,superRoot,i));
    //				expr=solver.diff(expr, y.get(k, i));
    //			}
    //			solver.addEq(expr, 0);
    //		}

    // flow conservation constraints
    for (int k = 0; k < ins.getMaxClusterNumber(); ++k) {
      for (int i = 0; i < ins.getNumNodes(); ++i) {
        expr = solver.numExpr();
        for (Integer j : ins.getOutcut(i)) {
          expr = solver.diff(expr, f.get(k, i, j));
          expr = solver.sum(expr, f.get(k, j, i));
        }
        // i can receive flow also from the super root
        expr = solver.sum(expr, f.get(k, superRoot, i));
        solver.addEq(expr, y.get(k, i));
      }
    }

    // delta definition constraints
    for (int k = 0; k < ins.getMaxClusterNumber(); ++k) {
      expr = solver.numExpr();
      for (int i = 0; i < ins.getNumNodes(); ++i) {
        expr = solver.sum(expr, y.get(k, i));
      }
      solver.addLe(solver.diff(expr, ins.getLambda()), d.get(k));
      solver.addGe(solver.diff(expr, ins.getLambda()), solver.prod(-1, d.get(k)));
    }

    // w var definition constraints
    for (int k = 0; k < ins.getMaxClusterNumber(); ++k) {
      for (OrderedPair p : fp) {
        expr = solver.numExpr();
        expr = solver.sum(expr, w.get(p.i, p.j));
        expr = solver.diff(expr, y.get(k, p.i));
        expr = solver.diff(expr, y.get(k, p.j));
        expr = solver.sum(expr, 1);
        solver.addGe(expr, 0);
      }
    }

    if (isActiveExtension(Extension.ROOT_MINIMIZATION_CONSTRAINTS)) {
      for (int k = 0; k < ins.getMaxClusterNumber(); ++k) {
        for (OrderedPair p : fp) {
          expr = solver.sum(y.get(k, p.i), r.get(k, p.j));
          solver.addLe(expr, 1);
        }
      }
    }

    if (isActiveExtension(Extension.POLYNOMIAL_ORBITOPE)) {
      // first family
      for (int k = 0; k < ins.getMaxClusterNumber(); ++k) {
        expr = solver.numExpr();
        for (int v = 0; v <= k - 1; ++v) {
          expr = solver.sum(expr, y.get(k, v));
        }
        solver.addEq(expr, 0);
      }
      // second family
      for (int k = 1; k < ins.getMaxClusterNumber(); ++k) {
        for (int v = k; v < ins.getNumNodes(); ++v) {
          expr = solver.numExpr();
          expr = solver.sum(expr, y.get(k, v));
          for (int u = k - 1; u <= v - 1; ++u) {
            expr = solver.diff(expr, y.get(k - 1, u));
          }
          solver.addLe(expr, 0);
        }
      }
    }

    if (isActiveExtension(Extension.EXPONENTIAL_ORBITOPE)) {
      System.err.println("Extension " + Extension.EXPONENTIAL_ORBITOPE + " not implemented yet");
      throw new IllegalArgumentException();
    }

    if (isActiveExtension(Extension.FLOW_LB)) {
      // f,x lower bound
      for (int k = 0; k < ins.getMaxClusterNumber(); ++k) {
        for (int i = 0; i < ins.getNumNodes(); ++i) {
          expr = solver.numExpr();
          for (Integer j : ins.getOutcut(i)) {
            expr = solver.sum(expr, f.get(k, j, i));
          }
          expr = solver.sum(expr, f.get(k, superRoot, i));
          solver.addGe(expr, y.get(k, i));
          solver.addLe(r.get(k, i), f.get(k, superRoot, i));
        }
      }
    }

    solver.setParam(IloCplex.DoubleParam.TiLim, timeout);
    if (isActiveExtension(Extension.ROOT_BRANCHING_PRIORITY)) {
      // Add branching priorities to the root variables
      for (int k = 0; k < ins.getMaxClusterNumber(); ++k)
        for (int i = 0; i < ins.getNumNodes(); ++i) solver.setPriority(r.get(k, i), 100);
    }
    solver.setParam(IloCplex.IntParam.ParallelMode, 1);
    solver.solve();
    System.out.println("STATE=" + solver.getStatus());
    System.out.println("NN=" + solver.getNnodes());
    System.out.println("LB=" + solver.getBestObjValue());

    // If we have a feasible solution we save it
    if (solver.getStatus() == IloCplex.Status.Feasible
        || solver.getStatus() == IloCplex.Status.Optimal) {
      for (int k = 0; k < ins.getMaxClusterNumber(); ++k) {
        for (int v = 0; v < ins.getNumNodes(); ++v) {
          if (FloatUtils.eq(solver.getValue(y.get(k, v)), 1.0)) {
            sol.insert(k, v);
          }
        }
      }
    }

    return solver.getObjValue();
  }