void profit_create_objective(graph g, IloModel model, IloNumVarArray x, IloNumVarArray z, int **columns) { IloNumExpr e(model.getEnv()); for(int i = 0; i < g->bidders; i++) { e += z[i]; } model.add(IloMaximize(model.getEnv(), e)); }
/* füge die symmetrsichen Constraints hinzu (sum_{j<i} x_{ij} = 2) * Diese sind zwar auch Randfälle der SubtourEliminationConstraints, aber wenn man * sie per Hand hinzufügt, beschleunigt das die Berechnungen extrem * */ void CplexTSPSolver::add_symmetric_inout_constraints(IloModel model, IloNumVarArray x) { // wegen der Symmetrie ist nur das untere linke Dreieck mit // variablen gefüllt. die inneren Schleifen gehen zeilen entlang // und "reflektieren" an der Diagonalen. // Die Kommentare "eingehend" und "ausgehend" stimmen so nicht, // da tatsächlich symmetrie vorliegt, machen aber dennoch den Zweck // deutlich IloEnv env = model.getEnv(); for(int i=0; i<N; i++) { IloExpr expr(env); // eingehende for(int j=0; j<i; j++) expr += x[i*N+j]; // ausgehende for(int j=i+1; j<N; j++) expr += x[j*N+i]; model.add(expr == 2); expr.end(); } }
/* initialisiere N^2 Variablen und erstelle eine zu minimierende * Strecken-Zielfunktion über die Distanzmatrix c * * eigentlich sind nur (N*N-N)/2 Variablen nötig, aber dafür müsste * ich mir etwas schlaues zur Adressierung ausdenken (weil das untere linke * Dreieck einer Matrix adressiert werden muss, ist das nicht trivial) * Der Presolver scheint die überflüssigen Variablen allerdings * direkt zu verwerfen, weshalb das nicht dringend ist. * */ IloNumVarArray CplexTSPSolver::init_symmetric_var(IloModel model) { IloEnv env = model.getEnv(); // Edge Variables IloNumVarArray x(env); for(int i=0; i<N; i++) for(int j=0; j<N; j++) if(j<i) x.add(IloNumVar(env, 0, 1, mip ? ILOINT : ILOFLOAT)); else x.add(IloNumVar(env, 0, 0, ILOFLOAT)); // fülle oben rechts mit dummies model.add(x); // Cost Function IloExpr expr(env); // die folgenden Schleifen adressieren ein unteres linkes // Dreieck in einer quadratischen Matrix for(int i=0; i<N; i++) for (int j=0; j<i; j++) expr += c[i*N + j] * x[i*N + j]; model.add(IloMinimize(env, expr)); expr.end(); return x; }
// This routine creates the master ILP (arc variables x and degree constraints). // // Modeling variables: // forall (i,j) in A: // x(i,j) = 1, if arc (i,j) is selected // = 0, otherwise // // Objective: // minimize sum((i,j) in A) c(i,j) * x(i,j) // // Degree constraints: // forall i in V: sum((i,j) in delta+(i)) x(i,j) = 1 // forall i in V: sum((j,i) in delta-(i)) x(j,i) = 1 // // Binary constraints on arc variables: // forall (i,j) in A: x(i,j) in {0, 1} // void createMasterILP(IloModel mod, Arcs x, IloNumArray2 arcCost) { IloInt i, j; IloEnv env = mod.getEnv(); IloInt numNodes = x.getSize(); // Create variables x(i,j) for (i,j) in A // For simplicity, also dummy variables x(i,i) are created. // Those variables are fixed to 0 and do not partecipate to // the constraints. char varName[100]; for (i = 0; i < numNodes; ++i) { x[i] = IloIntVarArray(env, numNodes, 0, 1); x[i][i].setBounds(0, 0); for (j = 0; j < numNodes; ++j) { sprintf(varName, "x.%d.%d", (int) i, (int) j); x[i][j].setName(varName); } mod.add(x[i]); } // Create objective function: minimize sum((i,j) in A ) c(i,j) * x(i,j) IloExpr obj(env); for (i = 0; i < numNodes; ++i) { arcCost[i][i] = 0; obj += IloScalProd(x[i], arcCost[i]); } mod.add(IloMinimize(env, obj)); obj.end(); // Add the out degree constraints. // forall i in V: sum((i,j) in delta+(i)) x(i,j) = 1 for (i = 0; i < numNodes; ++i) { IloExpr expr(env); for (j = 0; j < i; ++j) expr += x[i][j]; for (j = i+1; j < numNodes; ++j) expr += x[i][j]; mod.add(expr == 1); expr.end(); } // Add the in degree constraints. // forall i in V: sum((j,i) in delta-(i)) x(j,i) = 1 for (i = 0; i < numNodes; i++) { IloExpr expr(env); for (j = 0; j < i; j++) expr += x[j][i]; for (j = i+1; j < numNodes; j++) expr += x[j][i]; mod.add(expr == 1); expr.end(); } }// END createMasterILP
static void populatebynonzero (IloModel model, IloIntVarArray x, IloRangeArray c) { IloEnv env = model.getEnv(); IloObjective obj = IloMaximize(env); int n, a; scanf("%d", &n); scanf("%d", &a); //restrição c.add(IloRange(env, -IloInfinity, a)); //variaveis for(int i=0 ; i<n; i++){ x.add(IloIntVar(env, 0, 1)); } /*x.add(IloIntVar(env, 0.0, 40.0)); x.add(IloIntVar(env)); x.add(IloIntVar(env));*/ /*obj.setLinearCoef(x[0], 1.0); obj.setLinearCoef(x[1], 2.0); obj.setLinearCoef(x[2], 3.0);*/ /*restricoes*/ for(int i=0 ; i<n; i++){ scanf("%d", &a); c[0].setLinearCoef(x[i], a); } //objetivo for(int i=0 ; i<n; i++){ scanf("%d", &a); obj.setLinearCoef(x[i], a); } /*c[0].setLinearCoef(x[1], 1.0); c[0].setLinearCoef(x[2], 1.0); c[1].setLinearCoef(x[0], 1.0); c[1].setLinearCoef(x[1], -3.0); c[1].setLinearCoef(x[2], 1.0);*/ c[0].setName("c1"); for(int i=0; i<n; i++){ char tmp[10]; printf("x%d", i+1); x[i].setName(tmp); } model.add(obj); model.add(c); } // END populatebynonzero
int createConstraintEnergy(const Problem<double>& P, IloEnv& env, IloModel& model, IloNumVarArray& t, IloNumVarMatrix& b, IloNumVarMatrix& w){ for (int i=0;i<P.nbTask;++i){ IloExpr expr(env); for (int e=0;e<2*P.nbTask-1;++e){ for (int q=0;q<P.A[i].Fi.nbPiece;++q) model.add(P.A[i].Fi.F[q].f.a*b[i][e]+ P.A[i].Fi.F[q].f.c*(t[e+1]-t[e])>=w[i][e]); expr+=w[i][e]; } model.add(expr == P.W(i)); expr.end(); } return 0; }
static void populatebyrow (IloModel model, IloNumVarArray x, IloRangeArray c) { IloEnv env = model.getEnv(); x.add(IloNumVar(env, -1.0, 1.0)); x.add(IloNumVar(env, 0.0, 1.0)); model.add(IloMinimize(env, 0.5 * (-3*x[0]*x[0] - 3*x[1]*x[1] + - 1*x[0]*x[1] ) )); c.add( - x[0] + x[1] >= 0); c.add( x[0] + x[1] >= 0); model.add(c); } // END populatebyrow
int createConstraintTimeW(const Problem<double>& P, IloModel& model, IloNumVarArray& t, IloNumVarMatrix& x, IloNumVarMatrix& y, const std::vector<double>& M_te){ const int E=2*P.nbTask; for (int i=0;i<P.nbTask;i++) { for (int e=0;e<E;++e){ model.add(x[i][e]*P.r(i) <= t[e]); model.add(t[e] <= x[i][e]*P.smax(i) + (1-x[i][e])*M_te[e]); model.add(P.d(i)*y[i][e] + (1-y[i][e])*M_te[e]>= t[e]); model.add(t[e] >= y[i][e]*P.emin(i)); } } return 0; }
int createConstraintSepEvt(const Problem<double>& P,IloModel& model, IloNumVarArray& t,const std::vector<std::vector<double>>& bound){ for (int e=0;e<2*P.nbTask-1;++e) for (uint f=1;f<bound[e].size();++f) model.add(t[e+f]-t[e]<=bound[e][f-1]); return 0; }
void Create2DArray(IloModel model, BoolVarMatrix m){ IloEnv env = model.getEnv(); for(int i = 0; i < m.getSize(); i++){ m[i]=IloBoolVarArray(env); } return; }
static void populatebycolumn (IloModel model, IloNumVarArray x, IloRangeArray c) { IloEnv env = model.getEnv(); IloObjective obj = IloMaximize(env); c.add(IloRange(env, -IloInfinity, 20.0)); c.add(IloRange(env, -IloInfinity, 30.0)); x.add(IloNumVar(obj(1.0) + c[0](-1.0) + c[1]( 1.0), 0.0, 40.0)); x.add(obj(2.0) + c[0]( 1.0) + c[1](-3.0)); x.add(obj(3.0) + c[0]( 1.0) + c[1]( 1.0)); model.add(obj); model.add(c); } // END populatebycolumn
static void populatebyrow (IloModel model, IloNumVarArray x, IloRangeArray c) { IloEnv env = model.getEnv(); x.add(IloNumVar(env, 0.0, 40.0)); x.add(IloNumVar(env)); x.add(IloNumVar(env)); x.add(IloNumVar(env, 2.0, 3.0, ILOINT)); model.add(IloMaximize(env, x[0] + 2 * x[1] + 3 * x[2] + x[3])); c.add( - x[0] + x[1] + x[2] + 10 * x[3] <= 20); c.add( x[0] - 3 * x[1] + x[2] <= 30); c.add( x[1] - 3.5* x[3] == 0); model.add(c); } // END populatebyrow
int createConstraintBmax(const Problem<double>&P, IloModel& model, IloNumVarArray& t, IloNumVarMatrix& b){ for (int i=0;i<P.nbTask;i++){ for (int e=0;e<2*P.nbTask-1;e++) model.add((t[e+1]-t[e])*P.bmax(i) >= b[i][e]); } return 0; }
void PopulateFromGraph(IloModel model, IloNumVarArray s, IloRangeArray c){ IloEnv env = model.getEnv(); // Used n+1 for accomodating an extra variable // For being able to write the objective function for(int i = 0; i <= n; i++) s.add(IloNumVar(env)); }
static void populatebyrow (IloModel model, IloNumVarArray x, IloRangeArray c) { IloEnv env = model.getEnv(); x.add(IloNumVar(env, 0.0, 40.0)); x.add(IloNumVar(env)); x.add(IloNumVar(env)); model.add(IloMaximize(env, x[0] + 2 * x[1] + 3 * x[2] - 0.5 * (33*x[0]*x[0] + 22*x[1]*x[1] + 11*x[2]*x[2] - 12*x[0]*x[1] - 23*x[1]*x[2] ) )); c.add( - x[0] + x[1] + x[2] <= 20); c.add( x[0] - 3 * x[1] + x[2] <= 30); model.add(c); } // END populatebyrow
void CreateStorageBindingConstraint(IloModel model, BoolVar3DMatrix L, BoolVarMatrix M, BoolVarMatrix X, BoolVar3DMatrix R, BoolVarMatrix Y, IloRangeArray c){ IloEnv env = model.getEnv(); //The nested for-loops generate L[p][i][t] //that is required to linearize equation 16 for(int p = 0; p < L.getSize(); p++){ for(int i = 0; i < n; i++){ for(int t = 0; t < T_MAX; t++){ L[p][i].add(IloBoolVar(env)); c.add(L[p][i][t] - M[p][i] - X[i][t] >= -1); c.add(L[p][i][t] - M[p][i] - X[i][t] <= 0); c.add(L[p][i][t] + M[p][i] - X[i][t] <= 1); c.add(L[p][i][t] - M[p][i] + X[i][t] <= 1); } } } //Contructing the array R[p][e][t] for(int p = 0; p < R.getSize(); p++){ for(int e = 0; e < E; e++){ for(int t = 0; t < T_MAX; t++){ R[p][e].add(IloBoolVar(env)); } } } //Encoding the constraint eqn-15 for(int t = 0; t < T_MAX; t++){ IloExprArray sum(env); for(int e = 0; e < E; e++){ sum.add(IloExpr(env)); for(int p = 0; p < n_m; p++){ sum[e] += R[p][e][t]; } c.add(sum[e] - Y[e][t] == 0); } } //Encoding the constraint eqn-21 for(int t = 0; t < T_MAX; t++){ IloExprArray sum1(env); IloExprArray sum2(env); for(int p = 0; p < n_m; p++){ sum1.add(IloExpr(env)); sum2.add(IloExpr(env)); for(int e = 0; e < E; e++) sum1[p] += R[p][e][t]; for(int i = 0; i < n; i++) sum2[p] += L[p][i][t]; c.add(sum1[p] - n_r*sum2[p] <= 0); } } return; }
/* * $\sum_{i > 0} v_i = k$. Ensure that exactly k nodes are active. */ static void addConstraint_k_nodes_active(IloEnv env, IloModel model, IloBoolVarArray vs, Instance& instance, u_int k) { IloExpr e_num_nodes(env); for (u_int i = 1; i < instance.n_nodes; i++) { e_num_nodes += vs[i]; } model.add(k == e_num_nodes); e_num_nodes.end(); }
/** * Objective function: * $\sum_{i, j} c_{ij} x_{ij}$ */ static void addObjectiveFunction(IloEnv env, IloModel model, IloBoolVarArray xs, vector<Instance::Edge> edges, u_int n_edges) { IloExpr e_objective(env); for (u_int m = 0; m < n_edges; m++) { e_objective += xs[m] * edges[m].weight; } model.add(IloMinimize(env, e_objective)); e_objective.end(); }
ILOSTLBEGIN IloRangeArray profit_constraints(graph g, IloModel model, IloNumVarArray x, IloNumVarArray p, IloNumVarArray z, int **columns) { string s; IloRangeArray c(model.getEnv()); c.add(assignment_ineq(g, model, x, columns)); for(int i = 0; i < g->bidders; i++) { for(int edge = 0; edge < g->dbidder[i]; edge++) { int k = g->b_adj[i][edge]; IloNumExpr e(model.getEnv()); for(int other_edge = 0; other_edge < g->dbidder[i]; other_edge++) { int j = g->b_adj[i][other_edge]; e += g->adj[i][j]*x[columns[i][j]]; } e += - z[i] + p[k]; c.add(e >= g->adj[i][k]); s = "b_" + itos(i) + "," + itos(k); c[c.getSize()-1].setName(s.c_str()); } } for(int i = 0; i < g->bidders; i++) { IloNumExpr e(model.getEnv()); e += z[i]; for(int edge = 0; edge < g->dbidder[i]; edge++) { int j = g->b_adj[i][edge]; e -= g->adj[i][j]*x[columns[i][j]]; } c.add(e <= 0); s = "c_" + itos(i); c[c.getSize()-1].setName(s.c_str()); } for(int i = 0; i < g->bidders; i++) { for(int edge = 0; edge < g->dbidder[i]; edge++) { int j = g->b_adj[i][edge]; IloNumExpr e(model.getEnv()); e += z[i] - p[j] - boundp(j)*x[columns[i][j]]; c.add(e >= - boundp(j)); s = "e_" + itos(i) + "," + itos(j); c[c.getSize()-1].setName(s.c_str()); } } return c; }
void Create3DArray(IloModel model, BoolVar3DMatrix R, int size){ IloEnv env = model.getEnv(); for(int p = 0; p < R.getSize(); p++) R[p] = BoolVarMatrix(env, E); for(int p = 0; p < R.getSize(); p++){ for(int e = 0; e < size; e++) R[p][e]=IloBoolVarArray(env); } return; }
int createConstraintMinDur(const Problem<double>& P, IloModel& model, IloNumVarArray& t, IloNumVarMatrix& x, IloNumVarMatrix& y){ const int E=2*P.nbTask; for (int i=0;i<P.nbTask;i++){ for (int e=1;e<E-1;e++) { for (int f=e;f<E;f++) model.add(t[f] >= t[e] + x[i][e] * (P.A[i].emin-P.A[i].ri) - (1-y[i][f])*(P.W(i)/P.A[i].Fi(P.bmax(i)))); } } return 0; }
int createConstraintCapacity(const Problem<double>& P, IloEnv& env, IloModel& model, IloNumVarArray& t, IloNumVarMatrix& b){ for (int e=0;e<2*P.nbTask-1; e++){ IloExpr expr(env); for (int i=0;i<P.nbTask;i++) expr+=b[i][e]; model.add(expr <= P.B*(t[e+1]-t[e])); expr.end(); } return 0; }
void wqueens(IloEnv& env, IloModel& model, IloIntVarArray& vars) { cout << "Add 3 hard AllDiff constraints for the Queens problem." << endl; model.add(vars); // ensure vars are the main decision variables int nqueen = vars.getSize(); IloIntVarArray vars1(env, nqueen, -2 * nqueen, 2 * nqueen); IloIntVarArray vars2(env, nqueen, -2 * nqueen, 2 * nqueen); for (IloInt i = 0; i < nqueen; i++) { model.add(vars1[i] == vars[i] + i); model.add(vars2[i] == vars[i] - i); } model.add(IloAllDiff(env, vars)); model.add(IloAllDiff(env, vars1)); model.add(IloAllDiff(env, vars2)); }
int createObj(const Problem<double>& P,IloEnv& env, IloModel& model, IloNumVarMatrix& b){ IloExpr expr(env); for (int i=0;i<P.nbTask;++i) { for (int e=0;e<2*P.nbTask-1;++e) expr+=b[i][e]; } model.add(IloMinimize(env,expr)); expr.end(); return 0; }
/* * No arc leads back to the artificial root node 0. * $\sum_i x_{i0} = 0$. */ static void addConstraint_no_active_incoming_arc_for_node_zero(IloEnv env, IloModel model, IloBoolVarArray xs, vector<Instance::Edge> edges, u_int n_edges) { IloExpr e_single_root(env); for (u_int m = 0; m < n_edges; m++) { const u_int j = edges[m].v2; if (j == 0) { e_single_root += xs[m]; } } model.add(e_single_root == 0); e_single_root.end(); }
void generateProblem(const ILPModel& m, IloModel& model, IloNumVarArray& x, IloRangeArray& con) { IloEnv env = model.getEnv(); IloObjective obj = (m.obj == MINIMIZE ? IloMinimize(env) : IloMaximize(env)); for (unsigned long v = 0; v < m.numberOfVariables(); ++v) { switch (m.x[v].type) { case FLT: x.add(IloNumVar(env, m.x[v].lowerBound, m.x[v].upperBound, IloNumVar::Float)); break; case BIN: x.add(IloNumVar(env, m.x[v].lowerBound, m.x[v].upperBound, IloNumVar::Bool)); break; default: x.add(IloNumVar(env, m.x[v].lowerBound, m.x[v].upperBound, IloNumVar::Int)); } obj.setLinearCoef(x[v], m.c[v]); x[v].setName(m.varDesc[v].c_str()); } for (unsigned long c = 0; c < m.numberOfConstraints(); ++c) { switch (m.ops[c]) { case LESS_EQUAL: con.add(IloRange(env, -IloInfinity, m.b[c])); break; case EQUAL: con.add(IloRange(env, m.b[c], m.b[c])); break; case GREATER_EQUAL: con.add(IloRange(env, m.b[c], IloInfinity)); } for (const pair<uint32_t, double>& p : m.A[c]) con[c].setLinearCoef(x[p.first], p.second); con[c].setName(m.conDesc[c].c_str()); } model.add(obj); model.add(con); }
int createConstraintStartBeforeEnd(const Problem<double>& P, IloEnv& env, IloModel& model, IloNumVarMatrix& x, IloNumVarMatrix& y){ for (int i=0;i<P.nbTask;++i){ for (int e=0; e < 2*P.nbTask;++e){ IloExpr expr(env); for (int f=0;f<=e ;++ f) expr += y[i][f]; for (int f=e;f<2*P.nbTask ;++ f) expr += x[i][f]; model.add(expr <= 1); } } return 0; }
/* * There are exactly k - 1 arcs not counting edges from the artificial root node 0. * $\sum_{i, j > 0} x_{ij} = k - 1$. */ static void addConstraint_k_minus_one_active_edges(IloEnv env, IloModel model, IloBoolVarArray xs, vector<Instance::Edge> edges, u_int n_edges, u_int k) { IloExpr e_num_edges(env); for (u_int m = 0; m < n_edges; m++) { const u_int i = edges[m].v1; const u_int j = edges[m].v2; if (i > 0 && j > 0) { e_num_edges += xs[m]; } } model.add(e_num_edges == k - 1); e_num_edges.end(); }
void quasi(IloEnv& env, IloModel& model, IloIntVarArray& vars) { int n = sqrt((double)vars.getSize()); cout << "Add " << n * 2 << " hard AllDiff constraints for the \"homogeneous\" QuasiGroup problem." << endl; for (int i = 0; i < n; i++) { int pos = i * n; IloIntVarArray vars1(env, n); for (int j = 0; j < n; j++) { vars1[j] = vars[pos]; pos++; } model.add(IloAllDiff(env, vars1)); } for (int j = 0; j < n; j++) { int pos = j; IloIntVarArray vars1(env, n); for (int i = 0; i < n; i++) { vars1[i] = vars[pos]; pos += n; } model.add(IloAllDiff(env, vars1)); } }
void zebra(IloEnv& env, IloModel& model, IloIntVarArray& vars) { cout << "Add 5 hard AllDiff constraints for the Zebra problem." << endl; for (int i = 0; i < 5; i++) { int pos = i * 5; IloIntVarArray vars1(env, 5); vars1[0] = vars[0 + pos]; vars1[1] = vars[1 + pos]; vars1[2] = vars[2 + pos]; vars1[3] = vars[3 + pos]; vars1[4] = vars[4 + pos]; model.add(IloAllDiff(env, vars1)); } }