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(); } }
void Create2DArray(IloModel model, BoolVarMatrix m){ IloEnv env = model.getEnv(); for(int i = 0; i < m.getSize(); i++){ m[i]=IloBoolVarArray(env); } return; }
/* 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; }
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)); }
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; }
// 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
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; }
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; }
static void populatebynonzero(IloModel model, NumVarMatrix varOutput, NumVar3Matrix varHelp, Range3Matrix con) { IloEnv env = model.getEnv(); IloObjective obj = IloMaximize(env); //maximization function for (int j = current; j < current + J; ++j) { for (int k = 0; k < K; ++k) { obj.setLinearCoef(varOutput[j][k], 1.0);//add all variables to objective function, factor 1 //constraint 0: express value of output objective variables model.add(varOutput[j][k] + varHelp[j][k][2] - varHelp[j][k][3] == 0); //constraint 1: Td2a>=+Td2b model.add(varHelp[j][k][5] - varHelp[j][k][4] >= 0); //constraint 2: Tj>=Td2a + Tdc + Tblow model.add(varHelp[j][k][5] <= T[j] - Tdc - Tblow[j] - Tslack); //constraint 3: Td2b = Tfa+Tfd model.add(Tfd[k] == varHelp[j][k][4] - varHelp[j][k][3]); //constraint 4: Td1a >= Td1b model.add(0 <= varHelp[j][k][1] - varHelp[j][k][0]); //constraint 5: Tfb >= Td1a+Tdf model.add(Tdf[k] <= varHelp[j][k][2] - varHelp[j][k][1]); //constraint 6: Td1b = T(j-a)+Tcd model.add(T[j - a[k]] + Tcd == varHelp[j][k][0]); //constraint 7: Td1a >= Td2b(j-b) + Tloss, 1 model.add(TlossD[k] <= varHelp[j][k][1] - varHelp[j - b[k]][k][4]); //constraint 8: Tfb >= Tfa(j-1)+Tloss, 2 model.add(TlossF[k] <= varHelp[j][k][2] - varHelp[j - 1][k][3]); //constraint 9: at least X s for every load model.add(varOutput[j][k] >= TloadMin[k]); } //constraint 10: both spoons are picked up at same time at dropoff: Td2a,1 == Td2a,2 model.add(varHelp[j][1][5] == varHelp[j][0][5]); } model.add(obj); }
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
void profit_create_vars(graph g, IloModel model, IloNumVarArray x, IloNumVarArray p, IloNumVarArray z, int **columns) { IloEnv env = model.getEnv(); string s; assignment_vars(g, model, x, columns); for(int j = 0; j < g->items; j++) { s = "p_" + itos(j); p.add(IloNumVar(env, 0.0, boundp(j), ILOFLOAT, s.c_str())); // p.add(IloNumVar(env, lowerp(j), boundp(j), ILOFLOAT, s.c_str())); } for(int i = 0; i < g->bidders; i++) { s = "z_" + itos(i); z.add(IloNumVar(env, 0.0, boundu(i), ILOFLOAT, s.c_str())); } }
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, 0.0, IloInfinity, ILOINT)); x.add(IloNumVar(env, 0.0, IloInfinity, ILOINT)); 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); IloNumVarArray sosvar(env, 2); IloNumArray sosval(env, 2); sosvar[0] = x[2]; sosvar[1] = x[3]; sosval[0] = 25.0; sosval[1] = 18.0; model.add(IloSOS1(model.getEnv(), sosvar, sosval)); } // END populatebyrow
void profit_load(graph g, IloCplex cplex, IloModel model, IloNumVarArray x, IloNumVarArray p, IloNumVarArray z, int **columns, vector<int>& allocation, vector<double>& pricing) { IloNumVarArray startVar(model.getEnv()); IloNumArray startVal(model.getEnv()); for(int j = 0; j < g->items; j++) { if(boundp(j) > 0){ startVar.add(p[j]); startVal.add(pricing[j]); } } for(int i = 0; i < g->bidders; i++) { for(int e = 0; e < g->dbidder[i]; e++) { int j = g->b_adj[i][e]; startVar.add(x[columns[i][j]]); startVal.add(allocation[i] == j ? 1 : 0); } } for(int i = 0; i < g->bidders; i++) { if(boundu(i) > 0){ startVar.add(z[i]); startVal.add(allocation[i] != -1 ? pricing[allocation[i]] : 0); } } cplex.addMIPStart(startVar, startVal); }
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
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 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); }
void CreateMixingBindingConstraint(IloModel model, BoolVarMatrix M, BoolVarMatrix Y, BoolVarMatrix X, IloNumVarArray s, IloRangeArray c){ IloEnv env = model.getEnv(); //sum[i] holds summation from //eqn-13 for operation i IloExprArray sum1(env); //Creating array M[p][i] //i is for ith operation for(int p = 0; p < M.getSize(); p++){ for(int i = 0; i < n; i++) M[p].add(IloBoolVar(env)); } //Ensuring operation remains bound to the same module for(int i = 0; i < n; i++){ sum1.add(IloExpr(env)); for(int p = 0; p < n_m; p++){ sum1[i] += M[p][i]; } c.add(sum1[i] == 1); } //Two operations running simulateneously //can not be bound to the same module for(int p = 0; p < n_m; p++){ for(int t = 0; t < T_MAX; t++){ for(int i = 0; i < n; i++){ for(int j = i+1; j < n; j++){ c.add(X[i][t] + X[j][t] + M[p][i] + M[p][j] <= 3); } } } } return; }
void CreateSchedulingConstraint(IloModel model, BoolVarMatrix X, BoolVarMatrix Y, IloNumVarArray s, IloRangeArray c){ IloEnv env = model.getEnv(); //sum[i] holds the summation //from eqn-8 for operation i IloExprArray sum(env); //The for-loop encodes all //the execution constraints for(int i = 0; i < X.getSize(); i++){ sum.add(IloExpr(env)); for(int t = 0; t < T_MAX; t++){ X[i].add(IloBoolVar(env)); sum[i] += X[i][t]; c.add( t - s[i+1] - T_MAX*(X[i][t]-1) >= 0); c.add(-t + s[i+1] - T_MAX*(X[i][t]-1) + T >= 1); } c.add(sum[i] == T); } //Resources Constraints IloExprArray summation1(env); IloExprArray summation2(env); for(int t = 0; t < T_MAX; t++){ summation1.add(IloExpr(env)); summation2.add(IloExpr(env)); for(int i = 0; i < X.getSize(); i++){ summation1[t] += X[i][t]; } for(int e = 0; e < Y.getSize(); e++){ summation2[t] += Y[e][t]; } c.add(n_r*summation1[t] + summation2[t] <= n_m*n_r); } return; }
void LpSolver::populatebyrow (CplexConverter& cplexConverter, IloModel model, IloNumVarArray x, IloRangeArray c) { IloEnv env = model.getEnv(); // CAPITAL LETTERS MEAN I NEED YOUR HELP, here is help // IloExpr cost(env); // Create Variables // cout << "size of var: " << cplexConverter.variables.size() << endl; for (int i = 0; i < cplexConverter.variables.size(); ++i){ IloNumVar iloVar(env, 0.0, cplexConverter.capacities[i], IloNumVar::Int); // cout << iloVar << endl; x.add(iloVar); } //Capacity Constraints for (auto &it : cplexConverter.atomicIdToVarIdDict){ IloExpr t(env); // cout << "adding constraint "; for (int j = 0; j < it.second.size(); j++){ // cout << "x[" << it.second[j] << "] + "; t += x[it.second[j]]; } // cout << endl; c.add(t <= cplexConverter.graph->atomicEdges[it.first]->capacity); // cout << c << endl; t.end(); } // other constraints for (auto nodePair : cplexConverter.graph->nodes){ // For all nodes Node* n = nodePair.second; if(n == cplexConverter.src){ // source constraints // IloExpr inFlow(env); IloExpr outFlow(env); for(auto &atoIn : n->atomicEdge_in){ int aeId = atoIn.second->atomicEdgeId; for (int j = 0; j < cplexConverter.atomicIdToVarIdDict[aeId].size(); j++){ // var Id int vId = cplexConverter.atomicIdToVarIdDict[aeId][j]; outFlow += x[vId]; // cost += cplexConverter.graph->atomicEdges[cplexConverter.variables[vId].atomicEdgeId]->interest_rate * x[vId]; } } for (auto &atoOut : n->atomicEdge_out){ int aeId = atoOut.second->atomicEdgeId; for (int j = 0; j < cplexConverter.atomicIdToVarIdDict[aeId].size(); j++){ // var Id int vId = cplexConverter.atomicIdToVarIdDict[aeId][j]; // inFlow += x[vId]; c.add(x[vId] == 0); // cost -= cplexConverter.graph->atomicEdges[cplexConverter.variables[vId].atomicEdgeId]->interest_rate * x[vId]; } } c.add(outFlow == cplexConverter.request); // inFlow.end(); outFlow.end(); } else if(n == cplexConverter.dest){ // destination constraints IloExpr inFlow(env); // IloExpr outFlow(env); for(auto &atoIn : n->atomicEdge_in){ int aeId = atoIn.second->atomicEdgeId; for (int j = 0; j < cplexConverter.atomicIdToVarIdDict[aeId].size(); j++){ // var Id int vId = cplexConverter.atomicIdToVarIdDict[aeId][j]; // outFlow += x[vId]; c.add(x[vId] == 0); } } for (auto &atoOut : n->atomicEdge_out){ int aeId = atoOut.second->atomicEdgeId; for (int j = 0; j < cplexConverter.atomicIdToVarIdDict[aeId].size(); j++){ // var Id int vId = cplexConverter.atomicIdToVarIdDict[aeId][j]; inFlow += x[vId]; } } c.add(inFlow == cplexConverter.request); inFlow.end(); // outFlow.end(); } else { // Monotonicity Constraints for (int i = 0; i < credNetConstants.totalIrs.size(); ++i){ IloExpr tempin(env); IloExpr tempout(env); for (auto &atoIn : n->atomicEdge_in){ int aeId = atoIn.second->atomicEdgeId; for (int j = 0; j < cplexConverter.atomicIdToVarIdDict[aeId].size(); j++){ // var Id int vId = cplexConverter.atomicIdToVarIdDict[aeId][j]; if (cplexConverter.variables[vId].interest_rate <= credNetConstants.totalIrs[i]){ tempout += x[vId]; } } } for (auto &atoOut : n->atomicEdge_out){ int aeId = atoOut.second->atomicEdgeId; for (int j = 0; j < cplexConverter.atomicIdToVarIdDict[aeId].size(); j++){ // var Id int vId = cplexConverter.atomicIdToVarIdDict[aeId][j]; if (cplexConverter.variables[vId].interest_rate <= credNetConstants.totalIrs[i]){ tempin += x[vId]; } } } c.add(tempout - tempin >= 0); tempout.end(); tempin.end(); } //Flow Constraints IloExpr inFlow(env); IloExpr outFlow(env); for(auto &atoIn : n->atomicEdge_in){ int aeId = atoIn.second->atomicEdgeId; for (int j = 0; j < cplexConverter.atomicIdToVarIdDict[aeId].size(); j++){ // var Id int vId = cplexConverter.atomicIdToVarIdDict[aeId][j]; outFlow += x[vId]; } } for (auto &atoOut : n->atomicEdge_out){ int aeId = atoOut.second->atomicEdgeId; for (int j = 0; j < cplexConverter.atomicIdToVarIdDict[aeId].size(); j++){ // var Id int vId = cplexConverter.atomicIdToVarIdDict[aeId][j]; inFlow += x[vId]; } } c.add(inFlow - outFlow == 0); inFlow.end(); outFlow.end(); } } model.add(c); // model.add(IloMinimize(env, cost)); // model.add(IloMaximize(env,cost)); //option to minimize cost // cost.end(); } // END populatebyrow
// This function creates the following model: // Minimize // obj: x1 + x2 + x3 + x4 + x5 + x6 // Subject To // c1: x1 + x2 + x5 = 8 // c2: x3 + x5 + x6 = 10 // q1: [ -x1^2 + x2^2 + x3^2 ] <= 0 // q2: [ -x4^2 + x5^2 ] <= 0 // Bounds // x2 Free // x3 Free // x5 Free // End // which is a second order cone program in standard form. // The function returns objective, variables and constraints in the // values obj, vars and rngs. // The function also sets up cone so that for a column j we have // cone[j] >= 0 Column j is in a cone constraint and is the // cone's head variable. // cone[j] == NOT_CONE_HEAD Column j is in a cone constraint but is // not the cone's head variable.. // cone[j] == NOT_IN_CONE Column j is not contained in any cone constraint. static void createmodel (IloModel& model, IloObjective &obj, IloNumVarArray &vars, IloRangeArray &rngs, IloIntArray& cone) { // The indices we assign as user objects to the modeling objects. // We define them as static data so that we don't have to worry about // dynamic memory allocation/leakage. static int indices[] = { 0, 1, 2, 3, 4, 5, 6 }; IloEnv env = model.getEnv(); // Create variables. IloNumVar x1(env, 0, IloInfinity, "x1"); IloNumVar x2(env, -IloInfinity, IloInfinity, "x2"); IloNumVar x3(env, -IloInfinity, IloInfinity, "x3"); IloNumVar x4(env, 0, IloInfinity, "x4"); IloNumVar x5(env, -IloInfinity, IloInfinity, "x5"); IloNumVar x6(env, 0, IloInfinity, "x6"); // Create objective function and immediately store it in return value. obj = IloMinimize(env, x1 + x2 + x3 + x4 + x5 + x6); // Create constraints. IloRange c1(env, 8, x1 + x2 + x5, 8, "c1"); IloRange c2(env, 10, x3 + x5 + x6, 10, "c2"); IloRange q1(env, -IloInfinity, -x1*x1 + x2*x2 + x3*x3, 0, "q1"); cone.add(2); // x1, cone head of constraint at index 2 cone.add(NOT_CONE_HEAD); // x2 cone.add(NOT_CONE_HEAD); // x3 IloRange q2(env, -IloInfinity, -x4*x4 + x5*x5, 0, "q2"); cone.add(3); // x4, cone head of constraint at index 3 cone.add(NOT_CONE_HEAD); // x5 cone.add(NOT_IN_CONE); // x6 // Setup model. model.add(obj); model.add(obj); model.add(c1); model.add(c2); model.add(q1); model.add(q2); // Setup return values. vars.add(x1); vars.add(x2); vars.add(x3); vars.add(x4); vars.add(x5); vars.add(x6); rngs.add(c1); rngs.add(c2); rngs.add(q1); rngs.add(q2); // We set the user object for each modeling object to its index in the // respective array. This makes the code in checkkkt a little simpler. for (IloInt i = 0; i < vars.getSize(); ++i) vars[i].setObject(&indices[i]); for (IloInt i = 0; i < rngs.getSize(); ++i) rngs[i].setObject(&indices[i]); }
void MakeHouse(IloModel model, IloNumExpr cost, IloIntervalVarArray allTasks, IloIntervalVarArray joeTasks, IloIntervalVarArray jimTasks, IloIntArray joeLocations, IloIntArray jimLocations, IloInt loc, IloInt rd, IloInt dd, IloNum weight) { IloEnv env = model.getEnv(); /* CREATE THE INTERVALS VARIABLES. */ char name[128]; IloIntervalVarArray tasks(env, NbTasks); for (IloInt i=0; i<NbTasks; ++i) { sprintf(name, "H%ld-%s", loc, TaskNames[i]); tasks[i] = IloIntervalVar(env, TaskDurations[i], name); allTasks.add(tasks[i]); } /* SPAN CONSTRAINT. */ sprintf(name, "H%ld", loc); IloIntervalVar house(env, name); model.add(IloSpan(env, house, tasks)); /* ADDING PRECEDENCE CONSTRAINTS. */ house.setStartMin(rd); model.add(IloEndBeforeStart(env, tasks[masonry], tasks[carpentry])); model.add(IloEndBeforeStart(env, tasks[masonry], tasks[plumbing])); model.add(IloEndBeforeStart(env, tasks[masonry], tasks[ceiling])); model.add(IloEndBeforeStart(env, tasks[carpentry], tasks[roofing])); model.add(IloEndBeforeStart(env, tasks[ceiling], tasks[painting])); model.add(IloEndBeforeStart(env, tasks[roofing], tasks[windows])); model.add(IloEndBeforeStart(env, tasks[roofing], tasks[facade])); model.add(IloEndBeforeStart(env, tasks[plumbing], tasks[facade])); model.add(IloEndBeforeStart(env, tasks[roofing], tasks[garden])); model.add(IloEndBeforeStart(env, tasks[plumbing], tasks[garden])); model.add(IloEndBeforeStart(env, tasks[windows], tasks[moving])); model.add(IloEndBeforeStart(env, tasks[facade], tasks[moving])); model.add(IloEndBeforeStart(env, tasks[garden], tasks[moving])); model.add(IloEndBeforeStart(env, tasks[painting], tasks[moving])); /* ALLOCATING TASKS TO WORKERS. */ joeTasks.add(tasks[masonry]); joeLocations.add(loc); joeTasks.add(tasks[carpentry]); joeLocations.add(loc); jimTasks.add(tasks[plumbing]); jimLocations.add(loc); jimTasks.add(tasks[ceiling]); jimLocations.add(loc); joeTasks.add(tasks[roofing]); joeLocations.add(loc); jimTasks.add(tasks[painting]); jimLocations.add(loc); jimTasks.add(tasks[windows]); jimLocations.add(loc); joeTasks.add(tasks[facade]); joeLocations.add(loc); joeTasks.add(tasks[garden]); joeLocations.add(loc); jimTasks.add(tasks[moving]); jimLocations.add(loc); /* DEFINING MINIMIZATION OBJECTIVE. */ cost += TardinessCost(house, dd, weight); cost += IloLengthOf(house); }
static void populatebyrow (IloModel model, IloNumVarArray x, IloRangeArray c) { IloEnv env = model.getEnv(); IloNumArray costs(env); IloNumArray time(env); IloNumArray product(env); int costs_array[] = {1,1,1,10,1,12,2,2,5,10}; int time_array[] = {10,1,7,3,2,3,2,3,7,1}; int product_array[] = {0,3,1,2,-2,0,0,0,0,0}; for(int i=0;i<10;i++) costs.add(costs_array[i]); for(int i=0;i<10;i++) time.add(time_array[i]); for(int i=0;i<10;i++) product.add(product_array[i]); x.add(IloBoolVar(env,"x12")); //0 x.add(IloBoolVar(env,"x24")); //1 x.add(IloBoolVar(env,"x46")); //2 x.add(IloBoolVar(env,"x13")); //3 x.add(IloBoolVar(env,"x32")); //4 x.add(IloBoolVar(env,"x35")); //5 x.add(IloBoolVar(env,"x56")); //6 x.add(IloBoolVar(env,"x25")); //7 x.add(IloBoolVar(env,"x34")); //8 x.add(IloBoolVar(env,"x45")); //9 x.add(IloNumVar(env,0,IloInfinity,ILOINT,"s2")); //10 x.add(IloNumVar(env,0,IloInfinity,ILOINT,"s3")); //11 x.add(IloNumVar(env,0,IloInfinity,ILOINT,"s4")); //12 x.add(IloNumVar(env,0,IloInfinity,ILOINT,"s5")); //13 x.add(IloNumVar(env,0,IloInfinity,ILOINT,"s1")); //14 x.add(IloNumVar(env,0,IloInfinity,ILOINT,"s6")); //15 x.add(IloNumVar(env,0,IloInfinity,ILOINT,"q2")); //16 x.add(IloNumVar(env,0,IloInfinity,ILOINT,"q3")); //17 x.add(IloNumVar(env,0,IloInfinity,ILOINT,"q4")); //18 x.add(IloNumVar(env,0,IloInfinity,ILOINT,"q5")); //19 x.add(IloNumVar(env,0,IloInfinity,ILOINT,"q1")); //20 x.add(IloNumVar(env,0,IloInfinity,ILOINT,"q6")); //21 model.add(IloMinimize(env, costs[0]*x[0] + costs[1]*x[1] + costs[2]*x[2] + costs[3]*x[3] + costs[4]*x[4] + costs[5]*x[5] + costs[6]*x[6] + costs[7]*x[7] + costs[8]*x[8] + costs[9]*x[9])); c.add(x[0]+ x[3] == 1); // arcs sortant du noeud de depart c.add(x[2]+ x[6] == 1); // arcs entrant au noeud d arrivee c.add(x[1]+ x[7] - x[0] - x[4] == 0); c.add(x[8]+ x[5] + x[4] - x[3] == 0); c.add(x[9]+ x[2] - x[1] - x[8] == 0); c.add(x[6]- x[7] - x[5] - x[9] == 0); c.add(time[0]*x[0] + time[1]*x[1] + time[2]*x[2] + time[3]*x[3] + time[4]*x[4] + time[5]*x[5] + time[6]*x[6] + time[7]*x[7] + time[8]*x[8] + time[9]*x[9] <= 14); //c.add(product[0]*x[0] + product[1]*x[1] + product[2]*x[2] + product[3]*x[3] + product[4]*x[4] + product[5]*x[5] + product[6]*x[6] + product[7]*x[7] + product[8]*x[8] + product[9]*x[9] <= 4); c.add(x[14]+time[0]-1000*(1-x[0]) - x[10]<= 0); c.add(x[20]+product[0]-1000*(1-x[0]) - x[16]<= 0); c.add(x[10]+time[1]-1000*(1-x[1]) - x[12]<= 0); c.add(x[16]+product[1]-1000*(1-x[1]) - x[18]<= 0); c.add(x[18]-product[1]-1000*(1-x[1]) - x[16]<= 0); c.add(x[12]+time[2]-1000*(1-x[2]) - x[15]<= 0); c.add(x[18]+product[2]-1000*(1-x[2]) - x[21]<= 0); c.add(x[21]-product[2]-1000*(1-x[2]) - x[18]<= 0); c.add(x[14]+time[3]-1000*(1-x[3]) - x[11]<= 0); c.add(x[20]+product[3]-1000*(1-x[3]) - x[17]<= 0); c.add(x[17]-product[3]-1000*(1-x[3]) - x[20]<= 0); c.add(x[13]+time[6]-1000*(1-x[6]) - x[15]<= 0); c.add(x[19]+product[6]-1000*(1-x[6]) - x[21]<= 0); c.add(x[10]+time[7]-1000*(1-x[7]) - x[13]<= 0); c.add(x[16]+product[7]-1000*(1-x[7]) - x[19]<= 0); c.add(x[12]+time[9]-1000*(1-x[9]) - x[13]<= 0); c.add(x[18]+product[9]-1000*(1-x[9]) - x[19]<= 0); c.add(x[11]+time[4]-1000*(1-x[4]) - x[10] <=0); c.add(x[17]+product[4]-1000*(1-x[4]) - x[16]<= 0); c.add(x[16]-product[4]-1000*(1-x[4]) - x[17]<= 0); c.add(x[11]+time[8]-1000*(1-x[8]) - x[12]<= 0); c.add(x[17]+product[8]-1000*(1-x[8]) - x[18]<= 0); c.add(x[11]+time[5]-1000*(1-x[5]) - x[13]<= 0); c.add(x[17]+product[5]-1000*(1-x[5]) - x[19]<= 0); c.add(5 <= x[10] <= 7); c.add(2 <= x[11] <= 5); c.add(5 <= x[12] <= 9); c.add(0 <= x[13] <= 20); c.add(0 <= x[14] <= 0); c.add(0 <= x[15] <= 14); /* c.add(2 <= x[17] <= 4); c.add(0 <= x[16] <= 2); c.add(3 <= x[18] <= 4); c.add(0 <= x[19] <= 1000); //c.add(0 <= x[20] <= 0);*/ c.add(3 <= x[21] <= 4); c.add( x[20] == 1); model.add(c); }
void LpSolver::addObjective(string mode, CplexConverter& cplexConverter, IloModel model, IloNumVarArray x, IloRangeArray c){ // cerr << mode << endl; IloEnv env = model.getEnv(); if (mode == "MIN_SRC_COST"){ IloExpr cost(env); // add cost to all atomic edges for (int i = 0; i < cplexConverter.variables.size(); ++i){ cost += x[i] * cplexConverter.variables[i].interest_rate; } for(auto &atoIn : cplexConverter.src->atomicEdge_in){ int aeId = atoIn.second->atomicEdgeId; for (int j = 0; j < cplexConverter.atomicIdToVarIdDict[aeId].size(); j++){ // var Id int vId = cplexConverter.atomicIdToVarIdDict[aeId][j]; cost += cplexConverter.variables[vId].interest_rate * x[vId]; // cout << "adding " << cplexConverter.variables[vId].interest_rate // << " * " << vId << endl; } } model.add(IloMinimize(env, cost)); } else if (mode == "MIN_CREDIT_COST") { IloExpr cost(env); // add cost to all atomic edges for (int i = 0; i < cplexConverter.variables.size(); ++i){ cost += x[i] * cplexConverter.variables[i].interest_rate; } for (int i = 0; i < cplexConverter.variables.size(); ++i){ int aeId = cplexConverter.variables[i].atomicEdgeId; if (!cplexConverter.graph->atomicEdges[aeId]->isDebt){ cost += x[i]; } } model.add(IloMinimize(env, cost)); } else if (mode == "MIN_CREDIT_SRC") { IloExpr cost(env); for(auto &atoIn : cplexConverter.src->atomicEdge_in){ int aeId = atoIn.second->atomicEdgeId; for (int j = 0; j < cplexConverter.atomicIdToVarIdDict[aeId].size(); j++){ // var Id int vId = cplexConverter.atomicIdToVarIdDict[aeId][j]; cost += cplexConverter.variables[vId].interest_rate * x[vId]; if (!cplexConverter.graph->atomicEdges[aeId]->isDebt){ cost += x[vId]; } // cout << "adding " << cplexConverter.variables[vId].interest_rate // << " * " << vId << endl; } } model.add(IloMinimize(env, cost)); } else if (mode == "MIN_DEGREE_SRC") { IloExpr cost(env); for(auto &atoIn : cplexConverter.src->atomicEdge_in){ int aeId = atoIn.second->atomicEdgeId; AtomicEdge* atEdge = cplexConverter.graph->atomicEdges[aeId]; for (int j = 0; j < cplexConverter.atomicIdToVarIdDict[aeId].size(); j++){ // var Id int vId = cplexConverter.atomicIdToVarIdDict[aeId][j]; cost += cplexConverter.variables[vId].interest_rate * x[vId]; if (!atEdge->isDebt){ cost += atEdge->nodeTo->degree * x[vId]; } else { cost += atEdge->nodeFrom->degree * x[vId]; } // cout << "adding " << cplexConverter.variables[vId].interest_rate // << " * " << vId << endl; } } model.add(IloMinimize(env, cost)); } else if (mode == "MAX_IR_COST") { IloExpr cost(env); // add cost to all atomic edges for (int i = 0; i < cplexConverter.variables.size(); ++i){ cost += 100 - x[i] * cplexConverter.variables[i].interest_rate; } model.add(IloMinimize(env, cost)); } else if (mode == "MIN_SUMIR_COST") { IloExpr cost(env); // add cost to all atomic edges for (int i = 0; i < cplexConverter.variables.size(); ++i){ cost += x[i] * cplexConverter.variables[i].interest_rate; } model.add(IloMinimize(env, cost)); } else if (mode == "MIN_DEGREE_COST") { IloExpr cost(env); // add cost to all atomic edges for (int i = 0; i < cplexConverter.variables.size(); ++i){ cost += x[i] * cplexConverter.variables[i].interest_rate; } for (int i = 0; i < cplexConverter.variables.size(); ++i){ int aeId = cplexConverter.variables[i].atomicEdgeId; AtomicEdge* atEdge = cplexConverter.graph->atomicEdges[aeId]; for (int j = 0; j < cplexConverter.atomicIdToVarIdDict[aeId].size(); j++){ // var Id int vId = cplexConverter.atomicIdToVarIdDict[aeId][j]; if (!atEdge->isDebt){ cost += atEdge->nodeTo->degree * x[vId]; } else { cost += atEdge->nodeFrom->degree * x[vId]; } } } model.add(IloMinimize(env, cost)); } else { // default model.add(IloMinimize(env, 1)); } }