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));
}
}
