shared_ptr<vector<Volume> > ProblemTweet::GetRandomCapacities()
{
uniform_int_distribution<Volume> dist_capacity(2, 200);
uniform_int_distribution<Dimention> dist_dimention(2, 4);
auto rand_capacity = bind(dist_capacity, random_engine);
auto dimention = dist_dimention(random_engine);
shared_ptr<vector<Volume> > capacities(new vector<Volume>(dimention));
for (Dimention i = 0; i < dimention; i++)
{
(*capacities)[i] = rand_capacity();
}
return capacities;
}
IloModel ReadModel(IloEnv env, const char* filename,
IloConstraintArray& capacityCts,
IloConstraintArray& precedenceCts) {
std::ifstream file(filename);
if (!file){
env.out() << "usage: sched_conflict <file> <failLimit>" << std::endl;
throw FileError();
}
IloModel model(env);
IloInt nbTasks, nbResources, i, j;
file >> nbTasks;
file >> nbResources;
IloCumulFunctionExprArray resources(env, nbResources);
IloIntArray capacities(env, nbResources);
for (j=0; j<nbResources; j++) {
IloInt c;
file >> c;
capacities[j] = c;
resources[j] = IloCumulFunctionExpr(env);
}
IloIntervalVarArray tasks(env, nbTasks);
char name[32];
for (i=0; i<nbTasks; i++) {
sprintf(name, "ACT%ld", i);
tasks[i] = IloIntervalVar(env, name);
ILOSETLOCATION(tasks[i]);
}
IloIntExprArray ends(env);
for (i=0; i<nbTasks; i++) {
IloIntervalVar task = tasks[i];
IloInt d, smin, emax, nbSucc;
file >> d >> smin >> emax;
task.setSizeMin(d);
task.setSizeMax(d);
task.setStartMin(smin);
task.setEndMax(emax);
ends.add(IloEndOf(task));
for (j = 0; j < nbResources; j++) {
IloInt q;
file >> q;
if (q > 0) {
resources[j] += IloPulse(task, q);
}
}
file >> nbSucc;
for (IloInt s=0; s<nbSucc; ++s) {
IloInt succ;
file >> succ;
IloConstraint pct = IloEndBeforeStart(env, task, tasks[succ]);
ILOADD(model, pct);
precedenceCts.add(pct);
}
}
for (j=0; j<nbResources; j++) {
sprintf(name, "RES%ld", j);
resources[j].setName(name);
IloConstraint cct = (resources[j] <= capacities[j]);
ILOADD(model, cct);
capacityCts.add(cct);
}
model.add(IloMinimize(env, IloMax(ends)));
return model;
}
int main(int, const char * []) {
IloEnv env;
try {
IloModel model(env);
IloInt m, o, c, q;
IloInt nbOrders = 12;
IloInt nbSlabs = 12;
IloInt nbColors = 8;
IloIntArray capacities(env, 20, 0, 11, 13, 16, 17, 19, 20,
23, 24, 25, 26, 27, 28, 29,
30, 33, 34, 40, 43, 45);
IloIntArray sizes(env, nbOrders, 22, 9, 9, 8, 8, 6, 5, 3, 3, 3, 2, 2);
IloIntArray colors(env, nbOrders, 5, 3, 4, 5, 7, 3, 6, 0, 2, 3, 1, 5);
IloIntVarArray where(env, nbOrders, 0, nbSlabs-1);
IloIntVarArray load(env, nbSlabs, 0, IloSum(sizes));
// Pack constraint
model.add(IloPack(env, load, where, sizes));
// Color constraints
for(m = 0; m < nbSlabs; m++) {
IloExprArray colorExpArray(env);
for(c = 0; c < nbColors; c++) {
IloOr orExp(env);
for(o = 0; o < nbOrders; o++){
if (colors[o] == c){
orExp.add(where[o] == m);
}
}
colorExpArray.add(orExp);
}
model.add(IloSum(colorExpArray) <= 2);
}
// Objective function
IloIntArray lossValues(env);
lossValues.add(0);
for(q = 1; q < capacities.getSize(); q++){
for(IloInt p = capacities[q-1] + 1; p <= capacities[q]; p++){
lossValues.add(capacities[q] - p);
}
}
IloExpr obj(env);
for(m = 0; m < nbSlabs; m++){
obj += lossValues[load[m]];
}
model.add(IloMinimize(env, obj));
for(m = 1; m < nbSlabs; m++){
model.add(load[m-1] >= load[m]);
}
IloCP cp(model);
if (cp.solve(IloSearchPhase(env, where))){
cp.out() << "Optimal value: " << cp.getValue(obj) << std::endl;
for (m = 0; m < nbSlabs; m++) {
IloInt p = 0;
for (o = 0; o < nbOrders; o++)
p += cp.getValue(where[o]) == m;
if (p == 0) continue;
cp.out() << "Slab " << m << " is used for order";
if (p > 1) cp.out() << "s";
cp.out() << " :";
for (o = 0; o < nbOrders; o++) {
if (cp.getValue(where[o]) == m)
cp.out() << " " << o;
}
cp.out() << std::endl;
}
}
}
catch (IloException& ex) {
env.out() << "Error: " << ex << std::endl;
}
env.end();
return 0;
}
