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