public static void Main(String[] args)
{
try
{
CP cp = new CP();
int sizeSquare = 112;
int nbSquares = 21;
int[] size = { 50, 42, 37, 35, 33, 29, 27, 25, 24, 19, 18, 17, 16, 15, 11, 9, 8, 7, 6, 4, 2 };
IIntervalVar[] x = new IIntervalVar[nbSquares];
IIntervalVar[] y = new IIntervalVar[nbSquares];
ICumulFunctionExpr rx = cp.CumulFunctionExpr();
ICumulFunctionExpr ry = cp.CumulFunctionExpr();
for (int i = 0; i < nbSquares; ++i)
{
x[i] = cp.IntervalVar(size[i], "X" + i);
x[i].EndMax = sizeSquare;
y[i] = cp.IntervalVar(size[i], "Y" + i);
y[i].EndMax = sizeSquare;
rx = cp.Sum(rx, cp.Pulse(x[i], size[i]));
ry = cp.Sum(ry, cp.Pulse(y[i], size[i]));
for (int j = 0; j < i; ++j)
{
cp.Add(cp.Or(cp.Le(cp.EndOf(x[i]), cp.StartOf(x[j])),
cp.Or(cp.Le(cp.EndOf(x[j]), cp.StartOf(x[i])),
cp.Or(cp.Le(cp.EndOf(y[i]), cp.StartOf(y[j])),
cp.Le(cp.EndOf(y[j]), cp.StartOf(y[i]))))));
}
}
cp.Add(cp.AlwaysIn(rx, 0, sizeSquare, sizeSquare, sizeSquare));
cp.Add(cp.AlwaysIn(ry, 0, sizeSquare, sizeSquare, sizeSquare));
ISearchPhase[] phases = new ISearchPhase[2];
phases[0] = cp.SearchPhase(x);
phases[1] = cp.SearchPhase(y);
cp.SetSearchPhases(phases);
if (cp.Solve())
{
for (int i = 0; i < nbSquares; ++i)
{
Console.WriteLine("Square " + i + ": ["
+ cp.GetStart(x[i]) + "," + cp.GetEnd(x[i])
+ "] x ["
+ cp.GetStart(y[i]) + "," + cp.GetEnd(y[i])
+ "]");
}
}
}
catch (ILOG.Concert.Exception ex)
{
Console.WriteLine("Caught: " + ex);
}
}
public static void Main(String[] args)
{
try
{
CP cp = new CP();
int sizeSquare = 112;
int nbSquares = 21;
int[] size = { 50, 42, 37, 35, 33, 29, 27, 25, 24, 19, 18, 17, 16, 15, 11, 9, 8, 7, 6, 4, 2 };
IIntervalVar[] x = new IIntervalVar[nbSquares];
IIntervalVar[] y = new IIntervalVar[nbSquares];
ICumulFunctionExpr rx = cp.CumulFunctionExpr();
ICumulFunctionExpr ry = cp.CumulFunctionExpr();
for (int i = 0; i < nbSquares; ++i)
{
x[i] = cp.IntervalVar(size[i], "X" + i);
x[i].EndMax = sizeSquare;
y[i] = cp.IntervalVar(size[i], "Y" + i);
y[i].EndMax = sizeSquare;
rx = cp.Sum(rx, cp.Pulse(x[i], size[i]));
ry = cp.Sum(ry, cp.Pulse(y[i], size[i]));
for (int j = 0; j < i; ++j)
{
cp.Add(cp.Or(cp.Le(cp.EndOf(x[i]), cp.StartOf(x[j])),
cp.Or(cp.Le(cp.EndOf(x[j]), cp.StartOf(x[i])),
cp.Or(cp.Le(cp.EndOf(y[i]), cp.StartOf(y[j])),
cp.Le(cp.EndOf(y[j]), cp.StartOf(y[i]))))));
}
}
cp.Add(cp.AlwaysIn(rx, 0, sizeSquare, sizeSquare, sizeSquare));
cp.Add(cp.AlwaysIn(ry, 0, sizeSquare, sizeSquare, sizeSquare));
ISearchPhase[] phases = new ISearchPhase[2];
phases[0] = cp.SearchPhase(x);
phases[1] = cp.SearchPhase(y);
if (cp.Solve(phases))
{
for (int i = 0; i < nbSquares; ++i)
{
Console.WriteLine("Square " + i + ": ["
+ cp.GetStart(x[i]) + "," + cp.GetEnd(x[i])
+ "] x ["
+ cp.GetStart(y[i]) + "," + cp.GetEnd(y[i])
+ "]");
}
}
}
catch (ILOG.Concert.Exception ex)
{
Console.WriteLine("Caught: " + ex);
}
}
public static INumExpr EarlinessCost(IIntervalVar task, int rd, double weight, int useFunction)
{
if (useFunction != 0) {
double[] arrX = {rd};
double[] arrV = {-weight, 0.0};
INumToNumSegmentFunction f = cp.PiecewiseLinearFunction(arrX, arrV, rd, 0.0);
return cp.StartEval(task,f);
}
else
{
return cp.Prod(weight, cp.Max(0, cp.Diff(rd, cp.StartOf(task))));
}
}
public static void MakeHouse(
CP cp,
int id,
List <IIntExpr> ends,
List <IIntervalVar> allTasks,
List <IIntervalVar> joeTasks,
List <IIntervalVar> jimTasks
)
{
/// CREATE THE TIME-INTERVALS. ///
String name;
IIntervalVar[] tasks = new IIntervalVar[nbTasks];
for (int i = 0; i < nbTasks; i++)
{
name = "H" + id + "-" + taskNames[i];
tasks[i] = cp.IntervalVar(taskDurations[i], name);
allTasks.Add(tasks[i]);
}
/// ADDING PRECEDENCE CONSTRAINTS. ///
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[carpentry]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[plumbing]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[ceiling]));
cp.Add(cp.EndBeforeStart(tasks[carpentry], tasks[roofing]));
cp.Add(cp.EndBeforeStart(tasks[ceiling], tasks[painting]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[windows]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[windows], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[facade], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[garden], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[painting], tasks[moving]));
/// ADDING WORKER TASKS. ///
joeTasks.Add(tasks[masonry]);
joeTasks.Add(tasks[carpentry]);
jimTasks.Add(tasks[plumbing]);
jimTasks.Add(tasks[ceiling]);
joeTasks.Add(tasks[roofing]);
jimTasks.Add(tasks[painting]);
jimTasks.Add(tasks[windows]);
joeTasks.Add(tasks[facade]);
joeTasks.Add(tasks[garden]);
jimTasks.Add(tasks[moving]);
/// DEFINING MINIMIZATION OBJECTIVE ///
ends.Add(cp.EndOf(tasks[moving]));
}
public static INumExpr EarlinessCost(IIntervalVar task, int rd, double weight, int useFunction)
{
if (useFunction != 0)
{
double[] arrX = { rd };
double[] arrV = { -weight, 0.0 };
INumToNumSegmentFunction f = cp.PiecewiseLinearFunction(arrX, arrV, rd, 0.0);
return(cp.StartEval(task, f));
}
else
{
return(cp.Prod(weight, cp.Max(0, cp.Diff(rd, cp.StartOf(task)))));
}
}
static void Main()
{
CP cp = new CP();
/// CREATE THE TIME-INTERVALS.///
IIntervalVar masonry = cp.IntervalVar(35, "masonry ");
IIntervalVar carpentry = cp.IntervalVar(15, "carpentry ");
IIntervalVar plumbing = cp.IntervalVar(40, "plumbing ");
IIntervalVar ceiling = cp.IntervalVar(15, "ceiling ");
IIntervalVar roofing = cp.IntervalVar(5, "roofing ");
IIntervalVar painting = cp.IntervalVar(10, "painting ");
IIntervalVar windows = cp.IntervalVar(5, "windows ");
IIntervalVar facade = cp.IntervalVar(10, "facade ");
IIntervalVar garden = cp.IntervalVar(5, "garden ");
IIntervalVar moving = cp.IntervalVar(5, "moving ");
/// ADDING TEMPORAL CONSTRAINTS.///
cp.Add(cp.EndBeforeStart(masonry, carpentry));
cp.Add(cp.EndBeforeStart(masonry, plumbing));
cp.Add(cp.EndBeforeStart(masonry, ceiling));
cp.Add(cp.EndBeforeStart(carpentry, roofing));
cp.Add(cp.EndBeforeStart(ceiling, painting));
cp.Add(cp.EndBeforeStart(roofing, windows));
cp.Add(cp.EndBeforeStart(roofing, facade));
cp.Add(cp.EndBeforeStart(plumbing, facade));
cp.Add(cp.EndBeforeStart(roofing, garden));
cp.Add(cp.EndBeforeStart(plumbing, garden));
cp.Add(cp.EndBeforeStart(windows, moving));
cp.Add(cp.EndBeforeStart(facade, moving));
cp.Add(cp.EndBeforeStart(garden, moving));
cp.Add(cp.EndBeforeStart(painting, moving));
/// EXTRACTING THE MODEL AND SOLVING.///
if (cp.Solve())
{
Console.WriteLine(cp.GetDomain(masonry));
Console.WriteLine(cp.GetDomain(carpentry));
Console.WriteLine(cp.GetDomain(plumbing));
Console.WriteLine(cp.GetDomain(ceiling));
Console.WriteLine(cp.GetDomain(roofing));
Console.WriteLine(cp.GetDomain(painting));
Console.WriteLine(cp.GetDomain(windows));
Console.WriteLine(cp.GetDomain(facade));
Console.WriteLine(cp.GetDomain(garden));
Console.WriteLine(cp.GetDomain(moving));
}
else
{
Console.Write("No solution found. ");
}
}
public static INumExpr TardinessCost(IIntervalVar task, int dd, double weight, int useFunction)
{
if (useFunction != 0)
{
double[] arrX = { dd };
double[] arrV = { 0.0, weight };
INumToNumSegmentFunction f = cp.PiecewiseLinearFunction(arrX, arrV, dd, 0.0);
return(cp.EndEval(task, f));
}
else
{
return(cp.Prod(weight, cp.Max(0, cp.Diff(cp.EndOf(task), dd))));
}
}
public static void MakeHouse(CP cp,
int id,
List <IIntExpr> ends,
List <IIntervalVar> allTasks,
IStateFunction houseState)
{
/* CREATE THE TIME-INTERVALS. */
String name;
IIntervalVar[] tasks = new IIntervalVar[nbTasks];
for (int i = 0; i < nbTasks; i++)
{
name = "H" + id + "-" + taskNames[i];
tasks[i] = cp.IntervalVar(taskDurations[i], name);
workers = cp.Sum(workers, cp.Pulse(tasks[i], 1));
allTasks.Add(tasks[i]);
}
/* ADDING PRECEDENCE CONSTRAINTS */
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[carpentry]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[plumbing]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[ceiling]));
cp.Add(cp.EndBeforeStart(tasks[carpentry], tasks[roofing]));
cp.Add(cp.EndBeforeStart(tasks[ceiling], tasks[painting]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[windows]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[windows], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[facade], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[garden], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[painting], tasks[moving]));
/* ADDING STATE CONSTRAINTS */
cp.Add(cp.AlwaysEqual(houseState, tasks[masonry], dirty));
cp.Add(cp.AlwaysEqual(houseState, tasks[carpentry], dirty));
cp.Add(cp.AlwaysEqual(houseState, tasks[plumbing], clean));
cp.Add(cp.AlwaysEqual(houseState, tasks[ceiling], clean));
cp.Add(cp.AlwaysEqual(houseState, tasks[roofing], dirty));
cp.Add(cp.AlwaysEqual(houseState, tasks[painting], clean));
cp.Add(cp.AlwaysEqual(houseState, tasks[windows], dirty));
/* MAKESPAN */
ends.Add(cp.EndOf(tasks[moving]));
}
public static void Main(String[] args)
{
int nbHouses = 5;
int deadline = 318;
skill = cp.IntExpr();
List <IIntervalVar> allTasks = new List <IIntervalVar>();
List <IIntervalVar>[] workerTasks = new List <IIntervalVar> [nbWorkers];
for (int w = 0; w < nbWorkers; w++)
{
workerTasks[w] = new List <IIntervalVar>();
}
for (int h = 0; h < nbHouses; h++)
{
MakeHouse(allTasks, workerTasks, h, deadline);
}
for (int w = 0; w < nbWorkers; w++)
{
IIntervalSequenceVar seq = cp.IntervalSequenceVar(workerTasks[w].ToArray(), workerNames[w]);
cp.Add(cp.NoOverlap(seq));
}
cp.Add(cp.Maximize(skill));
/* EXTRACTING THE MODEL AND SOLVING. */
cp.SetParameter(CP.IntParam.FailLimit, 10000);
if (cp.Solve())
{
Console.WriteLine("Solution with objective " + cp.ObjValue + ":");
for (int i = 0; i < allTasks.Count; i++)
{
IIntervalVar var = (IIntervalVar)allTasks[i];
if (cp.IsPresent(allTasks[i]))
{
Console.WriteLine(cp.GetDomain((IIntervalVar)allTasks[i]));
}
}
}
else
{
Console.WriteLine("No solution found. ");
}
}
public static void MakeHouse(
int id,
int rd,
List <IIntExpr> ends,
List <IIntervalVar> allTasks)
{
/* CREATE THE TIME-INTERVALS. */
String name;
IIntervalVar[] tasks = new IIntervalVar[nbTasks];
for (int i = 0; i < nbTasks; ++i)
{
name = "H" + id + "-" + taskNames[i];
IIntervalVar task = cp.IntervalVar(taskDurations[i], name);
tasks[i] = task;
allTasks.Add(task);
workersUsage = cp.Sum(workersUsage, cp.Pulse(task, 1));
cash = cp.Diff(cash, cp.StepAtStart(task, 200 * taskDurations[i]));
}
/* ADDING TEMPORAL CONSTRAINTS. */
tasks[masonry].StartMin = rd;
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[carpentry]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[plumbing]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[ceiling]));
cp.Add(cp.EndBeforeStart(tasks[carpentry], tasks[roofing]));
cp.Add(cp.EndBeforeStart(tasks[ceiling], tasks[painting]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[windows]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[windows], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[facade], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[garden], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[painting], tasks[moving]));
/* DEFINING MINIMIZATION OBJECTIVE */
ends.Add(cp.EndOf(tasks[moving]));
}
public static IIntExpr MakeScenarioSubmodel(CP cp,
int nbJobs,
int nbMachines,
int[][] machines,
int[][] durations,
IIntervalSequenceVar[] sequences)
{
List <IIntervalVar>[] machinesOps = new List <IIntervalVar> [nbMachines];
String name;
int i, j;
for (j = 0; j < nbMachines; j++)
{
machinesOps[j] = new List <IIntervalVar>();
}
IIntExpr[] ends = new IIntExpr[nbJobs];
for (i = 0; i < nbJobs; i++)
{
IIntervalVar prec = cp.IntervalVar();
for (j = 0; j < nbMachines; j++)
{
name = "J" + i + "_O" + j;
IIntervalVar ti = cp.IntervalVar(durations[i][j], name);
machinesOps[machines[i][j]].Add(ti);
if (j > 0)
{
cp.Add(cp.EndBeforeStart(prec, ti));
}
prec = ti;
}
ends[i] = cp.EndOf(prec);
}
for (j = 0; j < nbMachines; j++)
{
name = "M" + j;
sequences[j] = cp.IntervalSequenceVar(machinesOps[j].ToArray(), name);
cp.Add(cp.NoOverlap(sequences[j]));
}
return(cp.Max(ends));
}
//----- RCPSP Model creation ------------------------------------------------
private static void buildModel(String fileName)
{
int nbTasks, nbResources;
DataReader data = new DataReader(fileName);
try {
nbTasks = data.Next();
nbResources = data.Next();
List<IIntExpr> ends = new List<IIntExpr>();
List<IConstraint> capacityCtList = new List<IConstraint>();
List<IConstraint> precedenceCtList = new List<IConstraint>();
ICumulFunctionExpr[] resources = new ICumulFunctionExpr[nbResources];
int[] capacities = new int[nbResources];
for (int j = 0; j < nbResources; j++) {
capacities[j] = data.Next();
resources[j] = cp.CumulFunctionExpr();
}
IIntervalVar[] tasks = new IIntervalVar[nbTasks];
for (int i = 0; i < nbTasks; i++) {
tasks[i] = cp.IntervalVar();
tasks[i].Name = "ACT" + i;
}
for (int i = 0; i < nbTasks; i++) {
IIntervalVar task = tasks[i];
int d, smin, emax, nbSucc;
d = data.Next();
smin = data.Next();
emax = data.Next();
task.SizeMin = d;
task.SizeMax = d;
task.StartMin = smin;
task.EndMax = emax;
ends.Add(cp.EndOf(task));
for (int j = 0; j < nbResources; j++ ) {
int q = data.Next();
if (q > 0) {
resources[j].Add(cp.Pulse(task, q));
}
}
nbSucc = data.Next();
for (int s = 0; s < nbSucc; s++ ) {
int succ = data.Next();
IConstraint pct = cp.EndBeforeStart(task, tasks[succ]);
cp.Add(pct);
precedenceCtList.Add(pct);
}
}
for (int j = 0; j < nbResources; j++) {
IConstraint cct = cp.Le(resources[j], capacities[j]);
cp.Add(cct);
capacityCtList.Add(cct);
}
precedenceCts = precedenceCtList.ToArray();
capacityCts = capacityCtList.ToArray();
IObjective objective = cp.Minimize(cp.Max(ends.ToArray()));
cp.Add(objective);
} catch (ILOG.Concert.Exception e) {
Console.WriteLine("Error: " + e);
}
}
public static void Main(String[] args)
{
try
{
CP cp = new CP();
ITransitionDistance setup1 = cp.TransitionDistance(NbTypes);
ITransitionDistance setup2 = cp.TransitionDistance(NbTypes);
int i, j;
for (i = 0; i < NbTypes; ++i)
{
for (j = 0; j < NbTypes; ++j)
{
int d1 = SetupM1[NbTypes * i + j];
if (d1 < 0)
d1 = CP.IntervalMax; // Forbidden transition
setup1.SetValue(i, j, d1);
int d2 = SetupM2[NbTypes * i + j];
if (d2 < 0)
d2 = CP.IntervalMax; // Forbidden transition
setup2.SetValue(i, j, d2);
}
}
int[] tp = new int[NbTasks];
IIntervalVar[] a = new IIntervalVar[NbTasks];
IIntervalVar[] a1 = new IIntervalVar[NbTasks];
IIntervalVar[] a2 = new IIntervalVar[NbTasks];
IIntExpr[] ends = new IIntExpr[NbTasks];
String name;
for (i = 0; i < NbTasks; ++i)
{
int type = TaskType[i];
int d1 = TaskDurM1[i];
int d2 = TaskDurM2[i];
tp[i] = type;
name = "A" + i + "_TP" + type;
a[i] = cp.IntervalVar(name);
IIntervalVar[] alt = new IIntervalVar[2];
name = "A" + i + "_M1_TP" + type;
a1[i] = cp.IntervalVar(d1, name);
a1[i].SetOptional();
alt[0] = a1[i];
name = "A" + i + "_M2_TP" + type;
a2[i] = cp.IntervalVar(d2, name);
a2[i].SetOptional();
alt[1] = a2[i];
cp.Add(cp.Alternative(a[i], alt));
ends[i] = cp.EndOf(a[i]);
}
IIntervalSequenceVar s1 = cp.IntervalSequenceVar(a1, tp);
IIntervalSequenceVar s2 = cp.IntervalSequenceVar(a2, tp);
cp.Add(cp.NoOverlap(s1, setup1, true));
cp.Add(cp.NoOverlap(s2, setup2, true));
cp.Add(cp.Minimize(cp.Max(ends)));
cp.SetParameter(CP.IntParam.FailLimit, 100000);
cp.SetParameter(CP.IntParam.LogPeriod, 10000);
if (cp.Solve())
{
Console.WriteLine("Machine 1: ");
IIntervalVar x;
for (x = cp.GetFirst(s1); !x.Equals(cp.GetLast(s1)); x = cp.GetNext(s1, x))
Console.WriteLine(cp.GetDomain(x));
Console.WriteLine(cp.GetDomain(x));
Console.WriteLine("Machine 2: ");
for (x = cp.GetFirst(s2); !x.Equals(cp.GetLast(s2)); x = cp.GetNext(s2, x))
Console.WriteLine(cp.GetDomain(x));
Console.WriteLine(cp.GetDomain(x));
Console.WriteLine("Makespan \t: " + cp.ObjValue);
}
else
{
Console.WriteLine("No solution found.");
}
}
catch (IloException e)
{
Console.WriteLine("Error: " + e);
}
}
public static void MakeHouse(
List<IIntervalVar> allTasks,
List<IIntervalVar> joeTasks,
List<IIntervalVar> jimTasks,
List<Int32> joeLocations,
List<Int32> jimLocations,
int loc,
int rd,
int dd,
double weight)
{
/* CREATE THE TIME-INTERVALS. */
String name = "H" + loc;
IIntervalVar[] tasks = new IIntervalVar[nbTasks];
for (int i = 0; i < nbTasks; i++ ) {
name = "H" + loc + "-" + taskNames[i];
tasks[i] = cp.IntervalVar(taskDurations[i], name);
allTasks.Add(tasks[i]);
}
/* SPAN CONSTRAINT */
IIntervalVar house = cp.IntervalVar(name);
cp.Add(cp.Span(house, tasks));
/* ADDING TEMPORAL CONSTRAINTS. */
house.StartMin = rd;
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[carpentry]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[plumbing]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[ceiling]));
cp.Add(cp.EndBeforeStart(tasks[carpentry], tasks[roofing]));
cp.Add(cp.EndBeforeStart(tasks[ceiling], tasks[painting]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[windows]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[windows], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[facade], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[garden], tasks[moving]));
cp.Add(cp.EndBeforeStart(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 = cp.Sum(cost, tardinessCost(house, dd, weight));
cost = cp.Sum(cost, cp.LengthOf(house));
}
//----- RCPSP Model creation ------------------------------------------------
private static void buildModel(String fileName)
{
int nbTasks, nbResources;
DataReader data = new DataReader(fileName);
try {
nbTasks = data.Next();
nbResources = data.Next();
List <IIntExpr> ends = new List <IIntExpr>();
List <IConstraint> capacityCtList = new List <IConstraint>();
List <IConstraint> precedenceCtList = new List <IConstraint>();
ICumulFunctionExpr[] resources = new ICumulFunctionExpr[nbResources];
int[] capacities = new int[nbResources];
for (int j = 0; j < nbResources; j++)
{
capacities[j] = data.Next();
resources[j] = cp.CumulFunctionExpr();
}
IIntervalVar[] tasks = new IIntervalVar[nbTasks];
for (int i = 0; i < nbTasks; i++)
{
tasks[i] = cp.IntervalVar();
tasks[i].Name = "ACT" + i;
}
for (int i = 0; i < nbTasks; i++)
{
IIntervalVar task = tasks[i];
int d, smin, emax, nbSucc;
d = data.Next();
smin = data.Next();
emax = data.Next();
task.SizeMin = d;
task.SizeMax = d;
task.StartMin = smin;
task.EndMax = emax;
ends.Add(cp.EndOf(task));
for (int j = 0; j < nbResources; j++)
{
int q = data.Next();
if (q > 0)
{
resources[j].Add(cp.Pulse(task, q));
}
}
nbSucc = data.Next();
for (int s = 0; s < nbSucc; s++)
{
int succ = data.Next();
IConstraint pct = cp.EndBeforeStart(task, tasks[succ]);
cp.Add(pct);
precedenceCtList.Add(pct);
}
}
for (int j = 0; j < nbResources; j++)
{
IConstraint cct = cp.Le(resources[j], capacities[j]);
cp.Add(cct);
capacityCtList.Add(cct);
}
precedenceCts = precedenceCtList.ToArray();
capacityCts = capacityCtList.ToArray();
IObjective objective = cp.Minimize(cp.Max(ends.ToArray()));
cp.Add(objective);
} catch (ILOG.Concert.Exception e) {
Console.WriteLine("Error: " + e);
}
}
public static void Main(String[] args)
{
String filename = "../../../../examples/data/rcpspmm_default.data";
int failLimit = 30000;
int nbTasks, nbRenewable, nbNonRenewable;
if (args.Length > 0)
{
filename = args[0];
}
if (args.Length > 1)
{
failLimit = Convert.ToInt32(args[1]);
}
CP cp = new CP();
DataReader data = new DataReader(filename);
nbTasks = data.Next();
nbRenewable = data.Next();
nbNonRenewable = data.Next();
ICumulFunctionExpr[] renewables = new ICumulFunctionExpr[nbRenewable];
IIntExpr[] nonRenewables = new IIntExpr[nbNonRenewable];
int[] capRenewables = new int[nbRenewable];
int[] capNonRenewables = new int[nbNonRenewable];
for (int j = 0; j < nbRenewable; j++)
{
renewables[j] = cp.CumulFunctionExpr();
capRenewables[j] = data.Next();
}
for (int j = 0; j < nbNonRenewable; j++)
{
nonRenewables[j] = cp.IntExpr();
capNonRenewables[j] = data.Next();
}
IIntervalVar[] tasks = new IIntervalVar[nbTasks];
List <IIntervalVar>[] modes = new List <IIntervalVar> [nbTasks];
for (int i = 0; i < nbTasks; i++)
{
tasks[i] = cp.IntervalVar();
modes[i] = new List <IIntervalVar>();
}
List <IIntExpr> ends = new List <IIntExpr>();
for (int i = 0; i < nbTasks; i++)
{
IIntervalVar task = tasks[i];
int d = data.Next();
int nbModes = data.Next();
int nbSucc = data.Next();
for (int k = 0; k < nbModes; k++)
{
IIntervalVar alt = cp.IntervalVar();
alt.SetOptional();
modes[i].Add(alt);
}
cp.Add(cp.Alternative(task, modes[i].ToArray()));
ends.Add(cp.EndOf(task));
for (int s = 0; s < nbSucc; s++)
{
int succ = data.Next();
cp.Add(cp.EndBeforeStart(task, tasks[succ]));
}
}
for (int i = 0; i < nbTasks; i++)
{
IIntervalVar task = tasks[i];
List <IIntervalVar> imodes = modes[i];
for (int k = 0; k < imodes.Count; k++)
{
int taskId = data.Next();
int modeId = data.Next();
int d = data.Next();
imodes[k].SizeMin = d;
imodes[k].SizeMax = d;
int q;
for (int j = 0; j < nbNonRenewable; j++)
{
q = data.Next();
if (0 < q)
{
renewables[j].Add(cp.Pulse(imodes[k], q));
}
}
for (int j = 0; j < nbNonRenewable; j++)
{
q = data.Next();
if (0 < q)
{
nonRenewables[j] = cp.Sum(nonRenewables[j], cp.Prod(q, cp.PresenceOf(imodes[k])));
}
}
}
}
for (int j = 0; j < nbRenewable; j++)
{
cp.Add(cp.Le(renewables[j], capRenewables[j]));
}
for (int j = 0; j < nbRenewable; j++)
{
cp.Add(cp.Le(nonRenewables[j], capNonRenewables[j]));
}
IObjective objective = cp.Minimize(cp.Max(ends.ToArray()));
cp.Add(objective);
cp.SetParameter(CP.IntParam.FailLimit, failLimit);
Console.WriteLine("Instance \t: " + filename);
if (cp.Solve())
{
Console.WriteLine("Makespan \t: " + cp.ObjValue);
}
else
{
Console.WriteLine("No solution found.");
}
}
public static void MakeHouse(List<IIntervalVar> allTasks,
List<IIntervalVar>[] workerTasks,
int id,
int deadline)
{
/* CREATE THE INTERVAL VARIABLES. */
String name;
IIntervalVar[] tasks = new IIntervalVar[nbTasks];
IIntervalVar[,] taskMatrix = new IIntervalVar[nbTasks, nbWorkers];
for (int i = 0; i < nbTasks; i++)
{
name = "H" + id + "-" + taskNames[i];
tasks[i] = cp.IntervalVar(taskDurations[i], name);
/* ALLOCATING TASKS TO WORKERS. */
List<IIntervalVar> alttasks = new List<IIntervalVar>();
for (int w = 0; w < nbWorkers; w++)
{
if (HasSkill(w, i))
{
name = "H" + id + "-" + taskNames[i] + "-" + workerNames[w];
IIntervalVar wtask = cp.IntervalVar(taskDurations[i], name);
wtask.SetOptional();
alttasks.Add(wtask);
taskMatrix[i, w] = wtask;
workerTasks[w].Add(wtask);
allTasks.Add(wtask);
/* DEFINING MAXIMIZATION OBJECTIVE. */
skill = cp.Sum(skill, cp.Prod(SkillLevel(w, i), cp.PresenceOf(wtask)));
}
}
cp.Add(cp.Alternative(tasks[i], alttasks.ToArray()));
}
/* ADDING PRECEDENCE CONSTRAINTS. */
tasks[moving].EndMax = deadline;
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[carpentry]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[plumbing]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[ceiling]));
cp.Add(cp.EndBeforeStart(tasks[carpentry], tasks[roofing]));
cp.Add(cp.EndBeforeStart(tasks[ceiling], tasks[painting]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[windows]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[windows], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[facade], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[garden], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[painting], tasks[moving]));
/* ADDING SAME-WORKER CONSTRAINTS. */
cp.Add(cp.Add(cp.Equiv(cp.PresenceOf(taskMatrix[masonry, joe]),
cp.PresenceOf(taskMatrix[carpentry, joe]))));
cp.Add(cp.Add(cp.Equiv(cp.PresenceOf(taskMatrix[roofing, jack]),
cp.PresenceOf(taskMatrix[facade, jack]))));
cp.Add(cp.Add(cp.Equiv(cp.PresenceOf(taskMatrix[carpentry, joe]),
cp.PresenceOf(taskMatrix[roofing, joe]))));
cp.Add(cp.Add(cp.Equiv(cp.PresenceOf(taskMatrix[garden, jim]),
cp.PresenceOf(taskMatrix[moving, jim]))));
}
public static void Main(String[] args)
{
String filename = "../../../../examples/data/rcpspmm_default.data";
int failLimit = 30000;
int nbTasks, nbRenewable, nbNonRenewable;
if (args.Length > 0)
filename = args[0];
if (args.Length > 1)
failLimit = Convert.ToInt32(args[1]);
CP cp = new CP();
DataReader data = new DataReader(filename);
nbTasks = data.Next();
nbRenewable = data.Next();
nbNonRenewable = data.Next();
ICumulFunctionExpr[] renewables = new ICumulFunctionExpr[nbRenewable];
IIntExpr[] nonRenewables = new IIntExpr[nbNonRenewable];
int[] capRenewables = new int[nbRenewable];
int[] capNonRenewables = new int[nbNonRenewable];
for (int j = 0; j < nbRenewable; j++)
{
renewables[j] = cp.CumulFunctionExpr();
capRenewables[j] = data.Next();
}
for (int j = 0; j < nbNonRenewable; j++)
{
nonRenewables[j] = cp.IntExpr();
capNonRenewables[j] = data.Next();
}
IIntervalVar[] tasks = new IIntervalVar[nbTasks];
List<IIntervalVar>[] modes = new List<IIntervalVar>[nbTasks];
for (int i = 0; i < nbTasks; i++)
{
tasks[i] = cp.IntervalVar();
modes[i] = new List<IIntervalVar>();
}
List<IIntExpr> ends = new List<IIntExpr>();
for (int i = 0; i < nbTasks; i++)
{
IIntervalVar task = tasks[i];
int d = data.Next();
int nbModes = data.Next();
int nbSucc = data.Next();
for (int k = 0; k < nbModes; k++)
{
IIntervalVar alt = cp.IntervalVar();
alt.SetOptional();
modes[i].Add(alt);
}
cp.Add(cp.Alternative(task, modes[i].ToArray()));
ends.Add(cp.EndOf(task));
for (int s = 0; s < nbSucc; s++)
{
int succ = data.Next();
cp.Add(cp.EndBeforeStart(task, tasks[succ]));
}
}
for (int i = 0; i < nbTasks; i++)
{
IIntervalVar task = tasks[i];
List<IIntervalVar> imodes = modes[i];
for (int k = 0; k < imodes.Count; k++)
{
int taskId = data.Next();
int modeId = data.Next();
int d = data.Next();
imodes[k].SizeMin = d;
imodes[k].SizeMax = d;
int q;
for (int j = 0; j < nbNonRenewable; j++)
{
q = data.Next();
if (0 < q)
{
renewables[j].Add(cp.Pulse(imodes[k], q));
}
}
for (int j = 0; j < nbNonRenewable; j++)
{
q = data.Next();
if (0 < q)
{
nonRenewables[j] = cp.Sum(nonRenewables[j], cp.Prod(q, cp.PresenceOf(imodes[k])));
}
}
}
}
for (int j = 0; j < nbRenewable; j++)
{
cp.Add(cp.Le(renewables[j], capRenewables[j]));
}
for (int j = 0; j < nbRenewable; j++)
{
cp.Add(cp.Le(nonRenewables[j], capNonRenewables[j]));
}
IObjective objective = cp.Minimize(cp.Max(ends.ToArray()));
cp.Add(objective);
cp.SetParameter(CP.IntParam.FailLimit, failLimit);
Console.WriteLine("Instance \t: " + filename);
if (cp.Solve())
{
Console.WriteLine("Makespan \t: " + cp.ObjValue);
}
else
{
Console.WriteLine("No solution found.");
}
}
public static void MakeHouse(
int id,
int rd,
List<IIntExpr> ends,
List<IIntervalVar> allTasks)
{
/* CREATE THE TIME-INTERVALS. */
String name;
IIntervalVar[] tasks = new IIntervalVar[nbTasks];
for (int i = 0; i < nbTasks; ++i)
{
name = "H" + id + "-" + taskNames[i];
IIntervalVar task = cp.IntervalVar(taskDurations[i], name);
tasks[i] = task;
allTasks.Add(task);
workersUsage = cp.Sum(workersUsage, cp.Pulse(task, 1));
cash = cp.Diff(cash, cp.StepAtStart(task, 200 * taskDurations[i]));
}
/* ADDING TEMPORAL CONSTRAINTS. */
tasks[masonry].StartMin = rd;
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[carpentry]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[plumbing]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[ceiling]));
cp.Add(cp.EndBeforeStart(tasks[carpentry], tasks[roofing]));
cp.Add(cp.EndBeforeStart(tasks[ceiling], tasks[painting]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[windows]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[windows], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[facade], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[garden], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[painting], tasks[moving]));
/* DEFINING MINIMIZATION OBJECTIVE */
ends.Add(cp.EndOf(tasks[moving]));
}
public static void Main(String[] args)
{
String filename = "../../../../examples/data/learningeffect_default.data";
int failLimit = 10000;
int nbJobs, nbMachines;
if (args.Length > 0)
filename = args[0];
if (args.Length > 1)
failLimit = Convert.ToInt32(args[1]);
CP cp = new CP();
DataReader data = new DataReader(filename);
nbJobs = data.Next();
nbMachines = data.Next();
IIntExpr[] ends = new IIntExpr[nbJobs];
IIntervalVar[][] machines = new IIntervalVar[nbMachines][];
int[][] sizes = new int[nbMachines][];
for (int j = 0; j < nbMachines; j++) {
machines[j] = new IIntervalVar[nbJobs];
sizes[j] = new int[nbJobs];
}
for (int i = 0; i < nbJobs; i++)
{
IIntervalVar prec = cp.IntervalVar();
for (int j = 0; j < nbMachines; j++)
{
int m, d;
m = data.Next();
d = data.Next();
IIntervalVar ti = cp.IntervalVar(0, d);
machines[m][i] = ti;
sizes[m][i] = d;
if (j > 0)
{
cp.Add(cp.EndBeforeStart(prec, ti));
}
prec = ti;
}
ends[i] = cp.EndOf(prec);
}
for (int j = 0; j < nbMachines; j++)
{
double alpha = data.Next() / ((double) 100);
IIntervalVar[] chain = new IIntervalVar[nbJobs];
IIntervalVar prec = cp.IntervalVar();
IIntExpr[] indices = new IIntExpr[nbJobs];
for (int i = 0; i < nbJobs; i++) {
IIntervalVar syncti = cp.IntervalVar();
if (i > 0)
{
cp.Add(cp.EndBeforeStart(prec, syncti));
}
prec = syncti;
chain[i] = syncti;
IIntExpr index = cp.IntVar(0, nbJobs -1);
indices[i] = index;
// Learning effect captured by the decreasing function
// of the position (0 <= alpha <= 1).
// At first position, in the sequence index = 0; there is no
// learning effect and duration of the task is its nominal duration
cp.Add(cp.Eq(cp.SizeOf(machines[j][i]),
cp.Floor(cp.Prod(sizes[j][i],
cp.Power(alpha, index)))));
}
cp.Add(cp.Isomorphism(chain, machines[j], indices, nbJobs));
// The no-overlap is a redundant constraint in this quite
// simple model - it is used only to provide stronger inference.
cp.Add(cp.NoOverlap(machines[j]));
}
IObjective objective = cp.Minimize(cp.Max(ends));
cp.Add(objective);
cp.SetParameter(CP.IntParam.FailLimit, failLimit);
Console.WriteLine("Instance \t: " + filename);
if (cp.Solve())
{
Console.WriteLine("Makespan \t: " + cp.ObjValue);
}
else
{
Console.WriteLine("No solution found.");
}
}
static void Main(string[] args)
{
int D = 5;
int W = 5;
int H = 3;
int G = 2;
int T = 12;
int[] k_g = new int[] { 2, 2 };
int ALLK = 4;
int[] cc_d = new int[] { 2, 1, 2, 1, 2 };
int[] ave = new int[] { 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1 };
int[] dur = new int[] { 1, 2, 1, 1, 2 };
int[] prf_D = new int[] { 2, 1, 1, 1, 100 };
int[] indexg_d = new int[] { 0, 1, 1, 1, 0 };
CP roster = new CP();
// intern availbility
INumToNumStepFunction resource_AveIntern = roster.NumToNumStepFunction(0, T, 100, "AvailibilityOfIntern");
for (int t = 0; t < T; t++)
{
if (ave[t] == 0)
{
resource_AveIntern.SetValue(t, t + 1, 0);
}
}
// discipline
IIntervalVar[] discipline_d = new IIntervalVar[D];
ICumulFunctionExpr hospitalNotRR = roster.CumulFunctionExpr();
for (int d = 0; d < D; d++)
{
discipline_d[d] = roster.IntervalVar();
discipline_d[d].EndMax = T;
discipline_d[d].EndMin = dur[d];
discipline_d[d].LengthMax = dur[d];
discipline_d[d].LengthMin = dur[d];
discipline_d[d].SizeMax = dur[d];
discipline_d[d].SizeMin = dur[d];
discipline_d[d].StartMax = T;
discipline_d[d].StartMin = 0;
discipline_d[d].SetIntensity(resource_AveIntern, 100);
hospitalNotRR.Add(roster.Pulse(discipline_d[d], 1));
discipline_d[d].SetOptional();
}
IIntervalSequenceVar dis = roster.IntervalSequenceVar(discipline_d);
roster.Add(roster.Ge(roster.PresenceOf(discipline_d[1]), roster.PresenceOf(discipline_d[4])));
roster.Add(roster.Before(dis, discipline_d[1], discipline_d[4]));
roster.Add(roster.NoOverlap(discipline_d));
// desciplien for not renewable resources
IIntVar[] height_t = new IIntVar[T];
for (int t = 0; t < T; t++)
{
height_t[t] = roster.IntVar(0, 1);
}
INumToNumSegmentFunction piecewise = roster.NumToNumSegmentFunction(new double[] { 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11 },
new double[] { 10, 0, 10, 1, 10, 2, 10, 3, 10, 4, 10, 5, 10, 6, 10, 7, 10, 8, 10, 9, 10, 10, 10, 11 });
INumExpr rc = roster.NumExpr();
for (int d = 0; d < D; d++)
{
rc = roster.Sum(rc, roster.StartEval(discipline_d[d], piecewise, 0));
}
for (int t = 0; t < T; t++)
{
}
IIntervalVar[] disciplineNR_d = new IIntervalVar[D];
for (int d = 0; d < D; d++)
{
disciplineNR_d[d] = roster.IntervalVar();
disciplineNR_d[d].EndMax = T;
disciplineNR_d[d].EndMin = T;
disciplineNR_d[d].LengthMax = T;
disciplineNR_d[d].LengthMin = T;
disciplineNR_d[d].SizeMax = T;
disciplineNR_d[d].SizeMin = T;
disciplineNR_d[d].StartMax = T;
disciplineNR_d[d].StartMin = 0;
disciplineNR_d[d].SetOptional();
roster.IfThen(roster.PresenceOf(discipline_d[d]), roster.PresenceOf(disciplineNR_d[d]));
}
//roster.Add(roster.IfThen(roster.PresenceOf(discipline_d[4]), roster.And(roster.Le(roster.EndOf(discipline_d[4]), roster.StartOf(discipline_d[0])),roster.PresenceOf(discipline_d[0]))));
//roster.Add(roster.StartBeforeEnd(discipline_d[4],discipline_d[0]));
// hospital changes
//ICumulFunctionExpr[] hospital
//for (int d = 0; d < D; d++)
//{
// roster.IfThen(roster.PresenceOf(disciplineNR_d[d]),);
//}
// hospital assignment
IIntervalVar[][] Hospital_dh = new IIntervalVar[D][];
for (int d = 0; d < D; d++)
{
Hospital_dh[d] = new IIntervalVar[H];
for (int h = 0; h < H; h++)
{
Hospital_dh[d][h] = roster.IntervalVar();
Hospital_dh[d][h].EndMax = T;
Hospital_dh[d][h].EndMin = dur[d];
Hospital_dh[d][h].LengthMax = dur[d];
Hospital_dh[d][h].LengthMin = dur[d];
Hospital_dh[d][h].SizeMax = dur[d];
Hospital_dh[d][h].SizeMin = dur[d];
Hospital_dh[d][h].StartMax = T;
Hospital_dh[d][h].StartMin = 0;
Hospital_dh[d][h].SetOptional();
if (h == 0 && (d != 4))
{
Hospital_dh[d][h].SetAbsent();
}
if (h == 1 && (d == 4))
{
Hospital_dh[d][h].SetAbsent();
}
if (h == 2 && (d == 4))
{
Hospital_dh[d][h].SetAbsent();
}
}
roster.Add(roster.Alternative(discipline_d[d], Hospital_dh[d]));
}
IIntervalVar[] disHospSetUp_dh = new IIntervalVar[D * H];
int[] type = new int[D * H];
for (int dh = 0; dh < D * H; dh++)
{
int dIndex = dh % D;
int hIndex = dh / D;
disHospSetUp_dh[dh] = roster.IntervalVar("DsiHosp" + "[" + dIndex + "][" + hIndex + "]");
type[dh] = hIndex;
disHospSetUp_dh[dh].SetOptional();
disHospSetUp_dh[dh] = Hospital_dh[dIndex][hIndex];
}
// changes
IIntervalSequenceVar cc = roster.IntervalSequenceVar(disHospSetUp_dh, type);
roster.NoOverlap(cc);
IIntVar[][] change_dD = new IIntVar[D][];
for (int d = 0; d < D; d++)
{
change_dD[d] = new IIntVar[D];
for (int dd = 0; dd < D; dd++)
{
change_dD[d][dd] = roster.IntVar(0, 1, "change_dD[" + d + "][" + dd + "]");
}
}
IIntVar[] change_d = new IIntVar[D];
for (int d = 0; d < D; d++)
{
change_d[d] = roster.IntVar(0, 1, "change_d[" + d + "]");
}
for (int dh = 0; dh < D * H; dh++)
{
int dIndex = dh % D;
int hIndex = dh / D;
IIntExpr chngD = roster.IntExpr();
chngD = roster.Sum(chngD, change_d[dIndex]);
roster.Add(roster.IfThen(roster.And(roster.PresenceOf(disHospSetUp_dh[dh]), roster.Neq(roster.TypeOfNext(cc, disHospSetUp_dh[dh], hIndex, hIndex), hIndex)), roster.Eq(chngD, 1)));
for (int ddh = 0; ddh < D * H; ddh++)
{
int ddIndex = ddh % D;
int hhIndex = ddh / D;
if (hhIndex == hIndex || dIndex == ddIndex)
{
continue;
}
}
}
//IIntVar[][] y_dD = new IIntVar[D][];
//for (int d = 0; d < D; d++)
//{
// y_dD[d] = new IIntVar[D];
// for (int dd= 0; dd < D; dd++)
// {
// y_dD[d][dd] = roster.IntVar(0,1);
// if (d == dd)
// {
// y_dD[d][dd] = roster.IntVar(0, 0);
// }
// }
//}
//for (int d = 0; d < D; d++)
//{
// for (int dd = 0; dd < D; dd++)
// {
// if (d != dd)
// {
// for (int h = 0; h < H; h++)
// {
// for (int hh = 0; hh < H; hh++)
// {
// if (d != dd && h != hh && true)
// {
// IIntExpr yyy = roster.IntExpr();
// yyy = roster.Sum(yyy,roster.Prod(T,y_dD[d][dd]));
// yyy = roster.Sum(yyy, roster.Prod(1, roster.EndOf(Hospital_dh[dd][hh])));
// yyy = roster.Sum(yyy, roster.Prod(-1, roster.StartOf(Hospital_dh[d][h])));
// roster.Add( roster.IfThen(roster.And(roster.PresenceOf(Hospital_dh[d][h]), roster.PresenceOf(Hospital_dh[dd][hh])), roster.AddGe(yyy, 0)));
// }
// }
// }
// }
// }
//}
//for (int d = 0; d < D; d++)
//{
// for (int dd = 0; dd < D; dd++)
// {
// if (d == dd)
// {
// continue;
// }
// IIntExpr change = roster.IntExpr();
// change = roster.Sum(change, change_dD[dd][d]);
// change = roster.Sum(change, roster.Prod(-1, y_dD[dd][d]));
// for (int ddd = 0; ddd < D; ddd++)
// {
// if (ddd == d || ddd == dd)
// {
// continue;
// }
// change = roster.Sum(change, change_dD[dd][ddd]);
// }
// roster.Add(roster.IfThen(roster.And(roster.PresenceOf(discipline_d[d]), roster.PresenceOf(discipline_d[dd])), roster.AddEq(change, 0)));
// }
//}
// all group assignment
IIntExpr allPossibleCourses = roster.IntExpr();
for (int d = 0; d < D; d++)
{
allPossibleCourses = roster.Sum(allPossibleCourses, roster.Prod(cc_d[d], roster.PresenceOf(discipline_d[d])));
}
roster.AddEq(allPossibleCourses, ALLK);
// group assignment
for (int g = 0; g < G; g++)
{
IIntExpr groupedCours_g = roster.IntExpr();
for (int d = 0; d < D; d++)
{
if (indexg_d[d] == g)
{
groupedCours_g = roster.Sum(groupedCours_g, roster.Prod(cc_d[d], roster.PresenceOf(discipline_d[d])));
}
}
roster.AddGe(groupedCours_g, k_g[g]);
}
// stay in one hospital
// objective function
INumExpr objExp = roster.NumExpr();
// discipline desire
for (int d = 0; d < D; d++)
{
objExp = roster.Sum(objExp, roster.Prod(prf_D[d], roster.PresenceOf(discipline_d[d])));
for (int dd = 0; dd < D; dd++)
{
objExp = roster.Sum(objExp, roster.Prod(-1, change_d[d]));
}
}
objExp = roster.Sum(objExp, rc);
IIntExpr makespan = roster.IntExpr();
for (int d = 0; d < D; d++)
{
makespan = roster.Max(makespan, roster.EndOf(discipline_d[d]));
}
IIntVar wait = roster.IntVar(0, T);
IIntExpr waitConst = roster.IntExpr();
waitConst = roster.Sum(waitConst, wait);
waitConst = roster.Sum(waitConst, roster.Prod(-1, makespan));
for (int d = 0; d < D; d++)
{
waitConst = roster.Sum(waitConst, roster.Prod(dur[d], roster.PresenceOf(discipline_d[d])));
}
roster.AddEq(waitConst, 0);
roster.AddMaximize(objExp);
roster.ExportModel("Roster.cpo");
roster.SetParameter(CP.IntParam.TimeMode, CP.ParameterValues.ElapsedTime);
roster.SetParameter(CP.IntParam.LogVerbosity, CP.ParameterValues.Quiet);
roster.SetParameter(CP.IntParam.SolutionLimit, 10);
// solve it now
if (roster.Solve())
{
Console.WriteLine("this is the cost of the CP column {0}", roster.ObjValue);
for (int d = 0; d < D; d++)
{
if (roster.IsPresent(discipline_d[d]))
{
Console.WriteLine("Discipline {0} with CC {1} and Dur {2} and Prf {3} started at time {4} and finished at time {5}", d, cc_d[d], dur[d], prf_D[d], roster.GetStart(discipline_d[d]), roster.GetEnd(discipline_d[d]));
}
}
for (int d = 0; d < D; d++)
{
for (int h = 0; h < H; h++)
{
if (roster.IsPresent(Hospital_dh[d][h]))
{
Console.WriteLine("Discipline {0} with CC {1} and Dur {2} and Prf {3} started at time {4} and finished at time {5} at Hospitail {6}", d, cc_d[d], dur[d], prf_D[d], roster.GetStart(Hospital_dh[d][h]), roster.GetEnd(Hospital_dh[d][h]), h);
}
}
}
for (int d = 0; d < D * H; d++)
{
int dIndex = d % D;
int hIndex = d / D;
if (roster.IsPresent(disHospSetUp_dh[d]))
{
Console.WriteLine("discpline " + dIndex + " in hospital " + hIndex);
}
}
for (int d = 0; d < D; d++)
{
if (roster.GetValue(change_d[d]) > 0.5)
{
Console.WriteLine("We have change for discipline {0}", d);
}
for (int dd = 0; dd < D; dd++)
{
if (d == dd)
{
continue;
}
}
}
Console.WriteLine("=========================================");
Console.WriteLine("Wainting time {0}", roster.GetValue(wait));
}
}
public static void Main(String[] args)
{
String filename = "../../../../examples/data/jobshopflex_default.data";
int failLimit = 10000;
if (args.Length > 0)
{
filename = args[0];
}
if (args.Length > 1)
{
failLimit = Convert.ToInt32(args[1]);
}
CP cp = new CP();
DataReader data = new DataReader(filename);
int nbJobs = data.Next();
int nbMachines = data.Next();
List <IIntervalVar>[] machines = new List <IIntervalVar> [nbMachines];
for (int j = 0; j < nbMachines; j++)
{
machines[j] = new List <IIntervalVar>();
}
List <IIntExpr> ends = new List <IIntExpr>();
for (int i = 0; i < nbJobs; i++)
{
int nbOperations = data.Next();
IIntervalVar prec = cp.IntervalVar();
for (int j = 0; j < nbOperations; j++)
{
int nbOpMachines = data.Next();
IIntervalVar master = cp.IntervalVar();
List <IIntervalVar> members = new List <IIntervalVar>();
for (int k = 0; k < nbOpMachines; k++)
{
int m = data.Next();
int d = data.Next();
IIntervalVar member = cp.IntervalVar(d);
member.SetOptional();
members.Add(member);
machines[m - 1].Add(member);
}
cp.Add(cp.Alternative(master, members.ToArray()));
if (j > 0)
{
cp.Add(cp.EndBeforeStart(prec, master));
}
prec = master;
}
ends.Add(cp.EndOf(prec));
}
for (int j = 0; j < nbMachines; j++)
{
cp.Add(cp.NoOverlap(machines[j].ToArray()));
}
IObjective objective = cp.Minimize(cp.Max(ends.ToArray()));
cp.Add(objective);
cp.SetParameter(CP.IntParam.FailLimit, failLimit);
Console.WriteLine("Instance \t: " + filename);
if (cp.Solve())
{
Console.WriteLine("Makespan \t: " + cp.ObjValue);
}
else
{
Console.WriteLine("No solution found.");
}
}
public static void Main(String[] args)
{
String filename = "../../../../examples/data/stochastic_jobshop_default.data";
int failLimit = 250000;
if (args.Length > 0)
{
filename = args[0];
}
if (args.Length > 1)
{
failLimit = Convert.ToInt32(args[1]);
}
// Data reading
DataReader data = new DataReader(filename);
int nbJobs, nbMachines, nbScenarios;
nbJobs = data.Next();
nbMachines = data.Next();
nbScenarios = data.Next();
int i, j, k;
// machines[i][j]: machine used by jth operation of job i
int[][] machines = new int[nbJobs][];
for (i = 0; i < nbJobs; i++)
{
machines[i] = new int[nbMachines];
for (j = 0; j < nbMachines; j++)
{
machines[i][j] = data.Next();
}
}
// durations[k][i][j]: duration of jth operation of job i in scenario k
int[][][] durations = new int[nbScenarios][][];
for (k = 0; k < nbScenarios; k++)
{
durations[k] = new int[nbJobs][];
for (i = 0; i < nbJobs; i++)
{
durations[k][i] = new int[nbMachines];
for (j = 0; j < nbMachines; j++)
{
durations[k][i][j] = data.Next();
}
}
}
CP cp = new CP();
IIntervalSequenceVar[] refSequences = new IIntervalSequenceVar[nbMachines];
IIntExpr sumMakespan = cp.IntExpr();
for (k = 0; k < nbScenarios; k++)
{
IIntervalSequenceVar[] scenarioSequences = new IIntervalSequenceVar[nbMachines];
IIntExpr scenarioMakespan =
MakeScenarioSubmodel(cp, nbJobs, nbMachines,
machines, durations[k],
scenarioSequences);
// Objective function is aggregated
sumMakespan = cp.Sum(sumMakespan, scenarioMakespan);
// For each machine, a sameSequence constraint is posted across all scenarios
if (0 == k)
{
refSequences = scenarioSequences;
}
else
{
for (j = 0; j < nbMachines; j++)
{
cp.Add(cp.SameSequence(refSequences[j], scenarioSequences[j]));
}
}
}
// Objective function is expected makespan
INumExpr expectedMakespan = cp.Quot(sumMakespan, nbScenarios);
IObjective objective = cp.Minimize(expectedMakespan);
cp.Add(objective);
cp.SetParameter(CP.IntParam.FailLimit, failLimit);
cp.SetParameter(CP.IntParam.LogPeriod, 1000000);
Console.WriteLine("Instance \t: " + filename);
if (cp.Solve())
{
Console.WriteLine("Expected makespan \t: " + cp.ObjValue);
for (j = 0; j < nbMachines; ++j)
{
IIntervalSequenceVar s = refSequences[j];
Console.Write(s.Name + ":\t");
IIntervalVar op = cp.GetFirst(s);
for (; !op.Equals(cp.GetLast(s)); op = cp.GetNext(s, op))
{
Console.Write(op.Name + "\t");
}
Console.WriteLine(op.Name + "\t");
}
}
else
{
Console.WriteLine("No solution found.");
}
}
private void CreateModel(String dataFile)
{
DataReader data = new DataReader(dataFile);
nbJobs = data.Next();
nbMachines = data.Next();
int[] rel = new int[nbJobs];
int[] due = new int[nbJobs];
costs = new int[nbMachines][];
int[][] dur = new int[nbMachines][];
for (int j = 0; j < nbMachines; j++)
{
costs[j] = new int[nbJobs];
dur[j] = new int[nbJobs];
}
for (int i = 0; i < nbJobs; i++)
{
rel[i] = data.Next();
}
for (int i = 0; i < nbJobs; i++)
{
due[i] = data.Next();
}
for (int j = 0; j < nbMachines; j++)
{
for (int i = 0; i < nbJobs; i++)
{
costs[j][i] = data.Next();
}
}
for (int j = 0; j < nbMachines; j++)
{
for (int i = 0; i < nbJobs; i++)
{
dur[j][i] = data.Next();
}
}
machines = new IIntervalVar[nbMachines][];
for (int j = 0; j < nbMachines; j++)
{
machines[j] = new IIntervalVar[nbJobs];
}
for (int i = 0; i < nbJobs; i++)
{
IIntervalVar job = cp.IntervalVar();
job.StartMin = rel[i];
job.EndMax = due[i];
job.Name = "Op" + i;
IIntervalVar[] jobm = new IIntervalVar[nbMachines];
for (int j = 0; j < nbMachines; j++)
{
jobm[j] = cp.IntervalVar(dur[j][i]);
jobm[j].Name = "Alt" + i + "_" + j + "_C" + costs[j][i];
jobm[j].SetOptional();
machines[j][i] = jobm[j];
}
cp.Add(cp.Alternative(job, jobm));
}
for (int j = 0; j < nbMachines; j++)
{
cp.Add(cp.NoOverlap(machines[j]));
}
}
public static void Main(String[] args)
{
String filename = "../../../../examples/data/learningeffect_default.data";
int nbJobs, nbMachines;
if (args.Length > 0)
{
filename = args[0];
}
CP cp = new CP();
DataReader data = new DataReader(filename);
nbJobs = data.Next();
nbMachines = data.Next();
IIntExpr[] ends = new IIntExpr[nbJobs];
IIntervalVar[][] machines = new IIntervalVar[nbMachines][];
int[][] sizes = new int[nbMachines][];
for (int j = 0; j < nbMachines; j++)
{
machines[j] = new IIntervalVar[nbJobs];
sizes[j] = new int[nbJobs];
}
for (int i = 0; i < nbJobs; i++)
{
IIntervalVar prec = cp.IntervalVar();
for (int j = 0; j < nbMachines; j++)
{
int m, d;
m = data.Next();
d = data.Next();
IIntervalVar ti = cp.IntervalVar(0, d);
machines[m][i] = ti;
sizes[m][i] = d;
if (j > 0)
{
cp.Add(cp.EndBeforeStart(prec, ti));
}
prec = ti;
}
ends[i] = cp.EndOf(prec);
}
for (int j = 0; j < nbMachines; j++)
{
double alpha = data.Next() / ((double)100);
IIntervalVar[] chain = new IIntervalVar[nbJobs];
IIntervalVar prec = cp.IntervalVar();
IIntExpr[] indices = new IIntExpr[nbJobs];
for (int i = 0; i < nbJobs; i++)
{
IIntervalVar syncti = cp.IntervalVar();
if (i > 0)
{
cp.Add(cp.EndBeforeStart(prec, syncti));
}
prec = syncti;
chain[i] = syncti;
IIntExpr index = cp.IntVar(0, nbJobs - 1);
indices[i] = index;
// Learning effect captured by the decreasing function
// of the position (0 <= alpha <= 1).
// At first position, in the sequence index = 0; there is no
// learning effect and duration of the task is its nominal duration
INumExpr floatDur = cp.Prod(sizes[j][i], cp.Power(alpha, index));
cp.Add(cp.Le(
cp.Abs(cp.Diff(floatDur, cp.SizeOf(machines[j][i]))),
0.5)
);
}
cp.Add(cp.Isomorphism(chain, machines[j], indices, nbJobs));
// The no-overlap is a redundant constraint in this quite
// simple model - it is used only to provide stronger inference.
cp.Add(cp.NoOverlap(machines[j]));
}
IObjective objective = cp.Minimize(cp.Max(ends));
cp.Add(objective);
cp.SetParameter(CP.IntParam.LogPeriod, 10000);
Console.WriteLine("Instance \t: " + filename);
if (cp.Solve())
{
Console.WriteLine("Makespan \t: " + cp.ObjValue);
}
else
{
Console.WriteLine("No solution found.");
}
}
public static void Main(String[] args)
{
String filename = "../../../../examples/data/rcpsp_default.data";
int failLimit = 10000;
int nbTasks, nbResources;
if (args.Length > 0)
{
filename = args[0];
}
if (args.Length > 1)
{
failLimit = Convert.ToInt32(args[1]);
}
CP cp = new CP();
DataReader data = new DataReader(filename);
try
{
nbTasks = data.Next();
nbResources = data.Next();
List <IIntExpr> ends = new List <IIntExpr>();
ICumulFunctionExpr[] resources = new ICumulFunctionExpr[nbResources];
int[] capacities = new int[nbResources];
for (int j = 0; j < nbResources; j++)
{
capacities[j] = data.Next();
resources[j] = cp.CumulFunctionExpr();
}
IIntervalVar[] tasks = new IIntervalVar[nbTasks];
for (int i = 0; i < nbTasks; i++)
{
tasks[i] = cp.IntervalVar();
}
for (int i = 0; i < nbTasks; i++)
{
IIntervalVar task = tasks[i];
int d, nbSucc;
d = data.Next();
task.SizeMin = d;
task.SizeMax = d;
ends.Add(cp.EndOf(task));
for (int j = 0; j < nbResources; j++)
{
int q = data.Next();
if (q > 0)
{
resources[j].Add(cp.Pulse(task, q));
}
}
nbSucc = data.Next();
for (int s = 0; s < nbSucc; s++)
{
int succ = data.Next();
cp.Add(cp.EndBeforeStart(task, tasks[succ - 1]));
}
}
for (int j = 0; j < nbResources; j++)
{
cp.Add(cp.Le(resources[j], capacities[j]));
}
IObjective objective = cp.Minimize(cp.Max(ends.ToArray()));
cp.Add(objective);
cp.SetParameter(CP.IntParam.FailLimit, failLimit);
Console.WriteLine("Instance \t: " + filename);
if (cp.Solve())
{
Console.WriteLine("Makespan \t: " + cp.ObjValue);
}
else
{
Console.WriteLine("No solution found.");
}
}
catch (ILOG.Concert.Exception e)
{
Console.WriteLine(" ERROR: " + e);
}
}
public static void Main(String[] args)
{
String filename = "../../../../examples/data/flowshop_default.data";
int failLimit = 10000;
int nbJobs, nbMachines;
if (args.Length > 0)
{
filename = args[0];
}
if (args.Length > 1)
{
failLimit = Convert.ToInt32(args[1]);
}
CP cp = new CP();
DataReader data = new DataReader(filename);
nbJobs = data.Next();
nbMachines = data.Next();
List <IIntExpr> ends = new List <IIntExpr>();
List <IIntervalVar>[] machines = new List <IIntervalVar> [nbMachines];
for (int j = 0; j < nbMachines; j++)
{
machines[j] = new List <IIntervalVar>();
}
for (int i = 0; i < nbJobs; i++)
{
IIntervalVar prec = cp.IntervalVar();
for (int j = 0; j < nbMachines; j++)
{
int d = data.Next();
IIntervalVar ti = cp.IntervalVar(d);
machines[j].Add(ti);
if (j > 0)
{
cp.Add(cp.EndBeforeStart(prec, ti));
}
prec = ti;
}
ends.Add(cp.EndOf(prec));
}
IIntervalSequenceVar[] seqs = new IIntervalSequenceVar[nbMachines];
for (int j = 0; j < nbMachines; j++)
{
seqs[j] = cp.IntervalSequenceVar(machines[j].ToArray());
cp.Add(cp.NoOverlap(seqs[j]));
if (0 < j)
{
cp.Add(cp.SameSequence(seqs[0], seqs[j]));
}
}
IObjective objective = cp.Minimize(cp.Max(ends.ToArray()));
cp.Add(objective);
cp.SetParameter(CP.IntParam.FailLimit, failLimit);
Console.WriteLine("Instance \t: " + filename);
if (cp.Solve())
{
Console.WriteLine("Makespan \t: " + cp.ObjValue);
}
else
{
Console.WriteLine("No solution found.");
}
}
public static INumExpr TardinessCost(IIntervalVar task, int dd, double weight, int useFunction)
{
if (useFunction != 0) {
double[] arrX = {dd};
double[] arrV = {0.0, weight};
INumToNumSegmentFunction f = cp.PiecewiseLinearFunction(arrX, arrV, dd, 0.0);
return cp.EndEval(task,f);
}
else
{
return cp.Prod(weight, cp.Max(0, cp.Diff(cp.EndOf(task),dd)));
}
}
public static void Main(String[] args)
{
try
{
CP cp = new CP();
ITransitionDistance setup1 = cp.TransitionDistance(NbTypes);
ITransitionDistance setup2 = cp.TransitionDistance(NbTypes);
int i, j;
for (i = 0; i < NbTypes; ++i)
{
for (j = 0; j < NbTypes; ++j)
{
setup1.SetValue(i, j, SetupM1[NbTypes * i + j]);
setup2.SetValue(i, j, SetupM2[NbTypes * i + j]);
}
}
int[] tp = new int[NbTasks];
IIntervalVar[] a = new IIntervalVar[NbTasks];
IIntervalVar[] a1 = new IIntervalVar[NbTasks];
IIntervalVar[] a2 = new IIntervalVar[NbTasks];
String name;
for (i = 0; i < NbTasks; ++i)
{
int type = TaskType[i];
int d = TaskDur[i];
tp[i] = type;
name = "A" + i + "_TP" + type;
a[i] = cp.IntervalVar(d, name);
IIntervalVar[] alt = new IIntervalVar[2];
name = "A" + i + "_M1_TP" + type;
a1[i] = cp.IntervalVar(name);
a1[i].SetOptional();
alt[0] = a1[i];
name = "A" + i + "_M2_TP" + type;
a2[i] = cp.IntervalVar(name);
a2[i].SetOptional();
alt[1] = a2[i];
cp.Add(cp.Alternative(a[i], alt));
}
IIntervalSequenceVar s1 = cp.IntervalSequenceVar(a1, tp);
IIntervalSequenceVar s2 = cp.IntervalSequenceVar(a2, tp);
cp.Add(cp.NoOverlap(s1, setup1, true));
cp.Add(cp.NoOverlap(s2, setup2, true));
IIntExpr nbLongSetups = cp.IntExpr();
for (i = 0; i < NbTasks; ++i)
{
int tpi = TaskType[i];
int[] isLongSetup1 = new int[NbTypes + 1];
int[] isLongSetup2 = new int[NbTypes + 1];
for (j = 0; j < NbTypes; ++j)
{
isLongSetup1[j] = (30 <= SetupM1[NbTypes * tpi + j]) ? 1 : 0;
isLongSetup2[j] = (30 <= SetupM2[NbTypes * tpi + j]) ? 1 : 0;
}
isLongSetup1[NbTypes] = 0; // Last on resource or resource not selected
isLongSetup2[NbTypes] = 0; // Last on resource or resource not selected
nbLongSetups = cp.Sum(nbLongSetups,
cp.Element(isLongSetup1, cp.TypeOfNext(s1, a1[i], NbTypes, NbTypes)));
nbLongSetups = cp.Sum(nbLongSetups,
cp.Element(isLongSetup2, cp.TypeOfNext(s2, a2[i], NbTypes, NbTypes)));
}
cp.Add(cp.Minimize(nbLongSetups));
cp.SetParameter(CP.IntParam.FailLimit, 100000);
cp.SetParameter(CP.IntParam.LogPeriod, 10000);
if (cp.Solve())
{
Console.WriteLine("Machine 1: ");
IIntervalVar x;
for (x = cp.GetFirst(s1); !x.Equals(cp.GetLast(s1)); x = cp.GetNext(s1, x))
Console.WriteLine(cp.GetDomain(x));
Console.WriteLine(cp.GetDomain(x));
Console.WriteLine("Machine 2: ");
for (x = cp.GetFirst(s2); !x.Equals(cp.GetLast(s2)); x = cp.GetNext(s2, x))
Console.WriteLine(cp.GetDomain(x));
Console.WriteLine(cp.GetDomain(x));
Console.WriteLine("Number of long transition times \t: " + cp.ObjValue);
}
else
{
Console.WriteLine("No solution found.");
}
}
catch (IloException e)
{
Console.WriteLine("Error: " + e);
}
}
public static void Main(String[] args)
{
try
{
CP cp = new CP();
ITransitionDistance setup1 = cp.TransitionDistance(NbTypes);
ITransitionDistance setup2 = cp.TransitionDistance(NbTypes);
int i, j;
for (i = 0; i < NbTypes; ++i)
{
for (j = 0; j < NbTypes; ++j)
{
setup1.SetValue(i, j, SetupM1[NbTypes * i + j]);
setup2.SetValue(i, j, SetupM2[NbTypes * i + j]);
}
}
int[] tp = new int[NbTasks];
IIntervalVar[] a = new IIntervalVar[NbTasks];
IIntervalVar[] a1 = new IIntervalVar[NbTasks];
IIntervalVar[] a2 = new IIntervalVar[NbTasks];
String name;
for (i = 0; i < NbTasks; ++i)
{
int type = TaskType[i];
int d = TaskDur[i];
tp[i] = type;
name = "A" + i + "_TP" + type;
a[i] = cp.IntervalVar(d, name);
IIntervalVar[] alt = new IIntervalVar[2];
name = "A" + i + "_M1_TP" + type;
a1[i] = cp.IntervalVar(name);
a1[i].SetOptional();
alt[0] = a1[i];
name = "A" + i + "_M2_TP" + type;
a2[i] = cp.IntervalVar(name);
a2[i].SetOptional();
alt[1] = a2[i];
cp.Add(cp.Alternative(a[i], alt));
}
IIntervalSequenceVar s1 = cp.IntervalSequenceVar(a1, tp);
IIntervalSequenceVar s2 = cp.IntervalSequenceVar(a2, tp);
cp.Add(cp.NoOverlap(s1, setup1, true));
cp.Add(cp.NoOverlap(s2, setup2, true));
IIntExpr nbLongSetups = cp.IntExpr();
for (i = 0; i < NbTasks; ++i)
{
int tpi = TaskType[i];
int[] isLongSetup1 = new int[NbTypes + 1];
int[] isLongSetup2 = new int[NbTypes + 1];
for (j = 0; j < NbTypes; ++j)
{
isLongSetup1[j] = (30 <= SetupM1[NbTypes * tpi + j]) ? 1 : 0;
isLongSetup2[j] = (30 <= SetupM2[NbTypes * tpi + j]) ? 1 : 0;
}
isLongSetup1[NbTypes] = 0; // Last on resource or resource not selected
isLongSetup2[NbTypes] = 0; // Last on resource or resource not selected
nbLongSetups = cp.Sum(nbLongSetups,
cp.Element(isLongSetup1, cp.TypeOfNext(s1, a1[i], NbTypes, NbTypes)));
nbLongSetups = cp.Sum(nbLongSetups,
cp.Element(isLongSetup2, cp.TypeOfNext(s2, a2[i], NbTypes, NbTypes)));
}
cp.Add(cp.Minimize(nbLongSetups));
cp.SetParameter(CP.IntParam.FailLimit, 100000);
cp.SetParameter(CP.IntParam.LogPeriod, 10000);
if (cp.Solve())
{
Console.WriteLine("Machine 1: ");
IIntervalVar x;
for (x = cp.GetFirst(s1); !x.Equals(cp.GetLast(s1)); x = cp.GetNext(s1, x))
{
Console.WriteLine(cp.GetDomain(x));
}
Console.WriteLine(cp.GetDomain(x));
Console.WriteLine("Machine 2: ");
for (x = cp.GetFirst(s2); !x.Equals(cp.GetLast(s2)); x = cp.GetNext(s2, x))
{
Console.WriteLine(cp.GetDomain(x));
}
Console.WriteLine(cp.GetDomain(x));
Console.WriteLine("Number of long transition times \t: " + cp.ObjValue);
}
else
{
Console.WriteLine("No solution found.");
}
}
catch (IloException e)
{
Console.WriteLine("Error: " + e);
}
}
public static void Main(String[] args)
{
String filename = "../../../../examples/data/jobshop_default.data";
int nbJobs, nbMachines;
if (args.Length > 0)
{
filename = args[0];
}
CP cp = new CP();
DataReader data = new DataReader(filename);
nbJobs = data.Next();
nbMachines = data.Next();
List <IIntExpr> ends = new List <IIntExpr>();
List <IIntervalVar>[] machines = new List <IIntervalVar> [nbMachines];
for (int j = 0; j < nbMachines; j++)
{
machines[j] = new List <IIntervalVar>();
}
for (int i = 0; i < nbJobs; i++)
{
IIntervalVar prec = cp.IntervalVar();
for (int j = 0; j < nbMachines; j++)
{
int m, d;
m = data.Next();
d = data.Next();
IIntervalVar ti = cp.IntervalVar(d);
machines[m].Add(ti);
if (j > 0)
{
cp.Add(cp.EndBeforeStart(prec, ti));
}
prec = ti;
}
ends.Add(cp.EndOf(prec));
}
for (int j = 0; j < nbMachines; j++)
{
cp.Add(cp.NoOverlap(machines[j].ToArray()));
}
IObjective objective = cp.Minimize(cp.Max(ends.ToArray()));
cp.Add(objective);
Console.WriteLine("Instance \t: " + filename);
if (cp.Solve())
{
Console.WriteLine("Makespan \t: " + cp.ObjValue);
}
else
{
Console.WriteLine("No solution found.");
}
}
public static INumExpr tardinessCost(IIntervalVar task, int dd, double weight)
{
return cp.Prod(weight, cp.Max(0, cp.Diff(cp.EndOf(task), dd)));
}
public static void Main(String[] args)
{
String filename = "../../../../examples/data/rcpsp_default.data";
int failLimit = 10000;
int nbTasks, nbResources;
if (args.Length > 0)
filename = args[0];
if (args.Length > 1)
failLimit = Convert.ToInt32(args[1]);
CP cp = new CP();
DataReader data = new DataReader(filename);
try
{
nbTasks = data.Next();
nbResources = data.Next();
List<IIntExpr> ends = new List<IIntExpr>();
ICumulFunctionExpr[] resources = new ICumulFunctionExpr[nbResources];
int[] capacities = new int[nbResources];
for (int j = 0; j < nbResources; j++)
{
capacities[j] = data.Next();
resources[j] = cp.CumulFunctionExpr();
}
IIntervalVar[] tasks = new IIntervalVar[nbTasks];
for (int i = 0; i < nbTasks; i++)
{
tasks[i] = cp.IntervalVar();
}
for (int i = 0; i < nbTasks; i++)
{
IIntervalVar task = tasks[i];
int d, nbSucc;
d = data.Next();
task.SizeMin = d;
task.SizeMax = d;
ends.Add(cp.EndOf(task));
for (int j = 0; j < nbResources; j++)
{
int q = data.Next();
if (q > 0)
resources[j].Add(cp.Pulse(task, q));
}
nbSucc = data.Next();
for (int s = 0; s < nbSucc; s++)
{
int succ = data.Next();
cp.Add(cp.EndBeforeStart(task, tasks[succ - 1]));
}
}
for (int j = 0; j < nbResources; j++)
{
cp.Add(cp.Le(resources[j], capacities[j]));
}
IObjective objective = cp.Minimize(cp.Max(ends.ToArray()));
cp.Add(objective);
cp.SetParameter(CP.IntParam.FailLimit, failLimit);
Console.WriteLine("Instance \t: " + filename);
if (cp.Solve())
{
Console.WriteLine("Makespan \t: " + cp.ObjValue);
}
else
{
Console.WriteLine("No solution found.");
}
}
catch (ILOG.Concert.Exception e)
{
Console.WriteLine(" ERROR: " + e);
}
}
public static void Main(String[] args)
{
String filename = "../../../../examples/data/openshop_default.data";
int failLimit = 10000;
if (args.Length > 0)
{
filename = args[0];
}
if (args.Length > 1)
{
failLimit = Convert.ToInt32(args[1]);
}
CP cp = new CP();
DataReader data = new DataReader(filename);
int nbJobs = data.Next();
int nbMachines = data.Next();
List <IIntervalVar>[] jobs = new List <IIntervalVar> [nbJobs];
for (int i = 0; i < nbJobs; i++)
{
jobs[i] = new List <IIntervalVar>();
}
List <IIntervalVar>[] machines = new List <IIntervalVar> [nbMachines];
for (int j = 0; j < nbMachines; j++)
{
machines[j] = new List <IIntervalVar>();
}
List <IIntExpr> ends = new List <IIntExpr>();
for (int i = 0; i < nbJobs; i++)
{
for (int j = 0; j < nbMachines; j++)
{
int pt = data.Next();
IIntervalVar ti = cp.IntervalVar(pt);
jobs[i].Add(ti);
machines[j].Add(ti);
ends.Add(cp.EndOf(ti));
}
}
for (int i = 0; i < nbJobs; i++)
{
cp.Add(cp.NoOverlap(jobs[i].ToArray()));
}
for (int j = 0; j < nbMachines; j++)
{
cp.Add(cp.NoOverlap(machines[j].ToArray()));
}
IObjective objective = cp.Minimize(cp.Max(ends.ToArray()));
cp.Add(objective);
cp.SetParameter(CP.IntParam.FailLimit, failLimit);
Console.WriteLine("Instance \t: " + filename);
if (cp.Solve())
{
Console.WriteLine("Makespan \t: " + cp.ObjValue);
}
else
{
Console.WriteLine("No solution found.");
}
}
private void CreateModel(String dataFile)
{
DataReader data = new DataReader(dataFile);
nbJobs = data.Next();
nbMachines = data.Next();
int[] rel = new int[nbJobs];
int[] due = new int[nbJobs];
costs = new int[nbMachines][];
int[][] dur = new int[nbMachines][];
for (int j = 0; j < nbMachines; j++)
{
costs[j] = new int[nbJobs];
dur[j] = new int[nbJobs];
}
for (int i = 0; i < nbJobs; i++)
rel[i] = data.Next();
for (int i = 0; i < nbJobs; i++)
due[i] = data.Next();
for (int j = 0; j < nbMachines; j++)
for (int i = 0; i < nbJobs; i++)
costs[j][i] = data.Next();
for (int j = 0; j < nbMachines; j++)
for (int i = 0; i < nbJobs; i++)
dur[j][i] = data.Next();
machines = new IIntervalVar[nbMachines][];
for (int j = 0; j < nbMachines; j++)
machines[j] = new IIntervalVar[nbJobs];
for (int i = 0; i < nbJobs; i++)
{
IIntervalVar job = cp.IntervalVar();
job.StartMin = rel[i];
job.EndMax = due[i];
job.Name = "Op" + i;
IIntervalVar[] jobm = new IIntervalVar[nbMachines];
for (int j = 0; j < nbMachines; j++)
{
jobm[j] = cp.IntervalVar(dur[j][i]);
jobm[j].Name = "Alt" + i + "_" + j + "_C" + costs[j][i];
jobm[j].SetOptional();
machines[j][i] = jobm[j];
}
cp.Add(cp.Alternative(job, jobm));
}
for (int j = 0; j < nbMachines; j++)
cp.Add(cp.NoOverlap(machines[j]));
}
public static void Main(String[] args)
{
try
{
CP cp = new CP();
ITransitionDistance setup1 = cp.TransitionDistance(NbTypes);
ITransitionDistance setup2 = cp.TransitionDistance(NbTypes);
int i, j;
for (i = 0; i < NbTypes; ++i)
{
for (j = 0; j < NbTypes; ++j)
{
int d1 = SetupM1[NbTypes * i + j];
if (d1 < 0)
{
d1 = CP.IntervalMax; // Forbidden transition
}
setup1.SetValue(i, j, d1);
int d2 = SetupM2[NbTypes * i + j];
if (d2 < 0)
{
d2 = CP.IntervalMax; // Forbidden transition
}
setup2.SetValue(i, j, d2);
}
}
int[] tp = new int[NbTasks];
IIntervalVar[] a = new IIntervalVar[NbTasks];
IIntervalVar[] a1 = new IIntervalVar[NbTasks];
IIntervalVar[] a2 = new IIntervalVar[NbTasks];
IIntExpr[] ends = new IIntExpr[NbTasks];
String name;
for (i = 0; i < NbTasks; ++i)
{
int type = TaskType[i];
int d1 = TaskDurM1[i];
int d2 = TaskDurM2[i];
tp[i] = type;
name = "A" + i + "_TP" + type;
a[i] = cp.IntervalVar(name);
IIntervalVar[] alt = new IIntervalVar[2];
name = "A" + i + "_M1_TP" + type;
a1[i] = cp.IntervalVar(d1, name);
a1[i].SetOptional();
alt[0] = a1[i];
name = "A" + i + "_M2_TP" + type;
a2[i] = cp.IntervalVar(d2, name);
a2[i].SetOptional();
alt[1] = a2[i];
cp.Add(cp.Alternative(a[i], alt));
ends[i] = cp.EndOf(a[i]);
}
IIntervalSequenceVar s1 = cp.IntervalSequenceVar(a1, tp);
IIntervalSequenceVar s2 = cp.IntervalSequenceVar(a2, tp);
cp.Add(cp.NoOverlap(s1, setup1, true));
cp.Add(cp.NoOverlap(s2, setup2, true));
cp.Add(cp.Minimize(cp.Max(ends)));
cp.SetParameter(CP.IntParam.FailLimit, 100000);
cp.SetParameter(CP.IntParam.LogPeriod, 10000);
if (cp.Solve())
{
Console.WriteLine("Machine 1: ");
IIntervalVar x;
for (x = cp.GetFirst(s1); !x.Equals(cp.GetLast(s1)); x = cp.GetNext(s1, x))
{
Console.WriteLine(cp.GetDomain(x));
}
Console.WriteLine(cp.GetDomain(x));
Console.WriteLine("Machine 2: ");
for (x = cp.GetFirst(s2); !x.Equals(cp.GetLast(s2)); x = cp.GetNext(s2, x))
{
Console.WriteLine(cp.GetDomain(x));
}
Console.WriteLine(cp.GetDomain(x));
Console.WriteLine("Makespan \t: " + cp.ObjValue);
}
else
{
Console.WriteLine("No solution found.");
}
}
catch (IloException e)
{
Console.WriteLine("Error: " + e);
}
}
public static void MakeHouse(
CP cp,
int id,
List<IIntExpr> ends,
List<IIntervalVar> allTasks,
List<IIntervalVar> joeTasks,
List<IIntervalVar> jimTasks
)
{
/// CREATE THE TIME-INTERVALS. ///
String name;
IIntervalVar[] tasks = new IIntervalVar[nbTasks];
for (int i = 0; i < nbTasks; i++)
{
name = "H" + id + "-" + taskNames[i];
tasks[i] = cp.IntervalVar(taskDurations[i], name);
allTasks.Add(tasks[i]);
}
/// ADDING PRECEDENCE CONSTRAINTS. ///
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[carpentry]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[plumbing]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[ceiling]));
cp.Add(cp.EndBeforeStart(tasks[carpentry], tasks[roofing]));
cp.Add(cp.EndBeforeStart(tasks[ceiling], tasks[painting]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[windows]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[windows], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[facade], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[garden], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[painting], tasks[moving]));
/// ADDING WORKER TASKS. ///
joeTasks.Add(tasks[masonry]);
joeTasks.Add(tasks[carpentry]);
jimTasks.Add(tasks[plumbing]);
jimTasks.Add(tasks[ceiling]);
joeTasks.Add(tasks[roofing]);
jimTasks.Add(tasks[painting]);
jimTasks.Add(tasks[windows]);
joeTasks.Add(tasks[facade]);
joeTasks.Add(tasks[garden]);
jimTasks.Add(tasks[moving]);
/// DEFINING MINIMIZATION OBJECTIVE ///
ends.Add(cp.EndOf(tasks[moving]));
}
public static INumExpr tardinessCost(IIntervalVar task, int dd, double weight)
{
return(cp.Prod(weight, cp.Max(0, cp.Diff(cp.EndOf(task), dd))));
}
public static void MakeHouse(
List <IIntervalVar> allTasks,
List <IIntervalVar> joeTasks,
List <IIntervalVar> jimTasks,
List <Int32> joeLocations,
List <Int32> jimLocations,
int loc,
int rd,
int dd,
double weight)
{
/* CREATE THE TIME-INTERVALS. */
String name = "H" + loc;
IIntervalVar[] tasks = new IIntervalVar[nbTasks];
for (int i = 0; i < nbTasks; i++)
{
name = "H" + loc + "-" + taskNames[i];
tasks[i] = cp.IntervalVar(taskDurations[i], name);
allTasks.Add(tasks[i]);
}
/* SPAN CONSTRAINT */
IIntervalVar house = cp.IntervalVar(name);
cp.Add(cp.Span(house, tasks));
/* ADDING TEMPORAL CONSTRAINTS. */
house.StartMin = rd;
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[carpentry]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[plumbing]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[ceiling]));
cp.Add(cp.EndBeforeStart(tasks[carpentry], tasks[roofing]));
cp.Add(cp.EndBeforeStart(tasks[ceiling], tasks[painting]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[windows]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[windows], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[facade], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[garden], tasks[moving]));
cp.Add(cp.EndBeforeStart(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 = cp.Sum(cost, tardinessCost(house, dd, weight));
cost = cp.Sum(cost, cp.LengthOf(house));
}
public static void MakeHouse(List <IIntervalVar> allTasks,
List <IIntervalVar>[] workerTasks,
int id,
int deadline)
{
/* CREATE THE INTERVAL VARIABLES. */
String name;
IIntervalVar[] tasks = new IIntervalVar[nbTasks];
IIntervalVar[,] taskMatrix = new IIntervalVar[nbTasks, nbWorkers];
for (int i = 0; i < nbTasks; i++)
{
name = "H" + id + "-" + taskNames[i];
tasks[i] = cp.IntervalVar(taskDurations[i], name);
/* ALLOCATING TASKS TO WORKERS. */
List <IIntervalVar> alttasks = new List <IIntervalVar>();
for (int w = 0; w < nbWorkers; w++)
{
if (HasSkill(w, i))
{
name = "H" + id + "-" + taskNames[i] + "-" + workerNames[w];
IIntervalVar wtask = cp.IntervalVar(taskDurations[i], name);
wtask.SetOptional();
alttasks.Add(wtask);
taskMatrix[i, w] = wtask;
workerTasks[w].Add(wtask);
allTasks.Add(wtask);
/* DEFINING MAXIMIZATION OBJECTIVE. */
skill = cp.Sum(skill, cp.Prod(SkillLevel(w, i), cp.PresenceOf(wtask)));
}
}
cp.Add(cp.Alternative(tasks[i], alttasks.ToArray()));
}
/* ADDING PRECEDENCE CONSTRAINTS. */
tasks[moving].EndMax = deadline;
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[carpentry]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[plumbing]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[ceiling]));
cp.Add(cp.EndBeforeStart(tasks[carpentry], tasks[roofing]));
cp.Add(cp.EndBeforeStart(tasks[ceiling], tasks[painting]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[windows]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[windows], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[facade], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[garden], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[painting], tasks[moving]));
/* ADDING SAME-WORKER CONSTRAINTS. */
cp.Add(cp.Add(cp.Equiv(cp.PresenceOf(taskMatrix[masonry, joe]),
cp.PresenceOf(taskMatrix[carpentry, joe]))));
cp.Add(cp.Add(cp.Equiv(cp.PresenceOf(taskMatrix[roofing, jack]),
cp.PresenceOf(taskMatrix[facade, jack]))));
cp.Add(cp.Add(cp.Equiv(cp.PresenceOf(taskMatrix[carpentry, joe]),
cp.PresenceOf(taskMatrix[roofing, joe]))));
cp.Add(cp.Add(cp.Equiv(cp.PresenceOf(taskMatrix[garden, jim]),
cp.PresenceOf(taskMatrix[moving, jim]))));
}
public static void Main(String[] args)
{
CP cp = new CP();
/* CREATE THE TIME-INTERVALS. */
IIntervalVar masonry = cp.IntervalVar(35, "masonry ");
IIntervalVar carpentry = cp.IntervalVar(15, "carpentry ");
IIntervalVar plumbing = cp.IntervalVar(40, "plumbing ");
IIntervalVar ceiling = cp.IntervalVar(15, "ceiling ");
IIntervalVar roofing = cp.IntervalVar(5, "roofing ");
IIntervalVar painting = cp.IntervalVar(10, "painting ");
IIntervalVar windows = cp.IntervalVar(5, "windows ");
IIntervalVar facade = cp.IntervalVar(10, "facade ");
IIntervalVar garden = cp.IntervalVar(5, "garden ");
IIntervalVar moving = cp.IntervalVar(5, "moving ");
/* ADDING TEMPORAL CONSTRAINTS. */
cp.Add(cp.EndBeforeStart(masonry, carpentry));
cp.Add(cp.EndBeforeStart(masonry, plumbing));
cp.Add(cp.EndBeforeStart(masonry, ceiling));
cp.Add(cp.EndBeforeStart(carpentry, roofing));
cp.Add(cp.EndBeforeStart(ceiling, painting));
cp.Add(cp.EndBeforeStart(roofing, windows));
cp.Add(cp.EndBeforeStart(roofing, facade));
cp.Add(cp.EndBeforeStart(plumbing, facade));
cp.Add(cp.EndBeforeStart(roofing, garden));
cp.Add(cp.EndBeforeStart(plumbing, garden));
cp.Add(cp.EndBeforeStart(windows, moving));
cp.Add(cp.EndBeforeStart(facade, moving));
cp.Add(cp.EndBeforeStart(garden, moving));
cp.Add(cp.EndBeforeStart(painting, moving));
/* DEFINING MINIMIZATION OBJECTIVE */
int useFunction = 1;
INumExpr cost = cp.NumExpr();
cost = cp.Sum(cost, EarlinessCost(masonry, 25, 200.0, useFunction));
cost = cp.Sum(cost, EarlinessCost(carpentry, 75, 300.0, useFunction));
cost = cp.Sum(cost, EarlinessCost(ceiling, 75, 100.0, useFunction));
cost = cp.Sum(cost, TardinessCost(moving, 100, 400.0, useFunction));
cp.Add(cp.Minimize(cost));
/* SOLVING. */
if (cp.Solve())
{
Console.WriteLine("Optimal Value: " + cp.ObjValue);
Console.WriteLine(cp.GetDomain(masonry));
Console.WriteLine(cp.GetDomain(carpentry));
Console.WriteLine(cp.GetDomain(plumbing));
Console.WriteLine(cp.GetDomain(ceiling));
Console.WriteLine(cp.GetDomain(roofing));
Console.WriteLine(cp.GetDomain(painting));
Console.WriteLine(cp.GetDomain(windows));
Console.WriteLine(cp.GetDomain(facade));
Console.WriteLine(cp.GetDomain(garden));
Console.WriteLine(cp.GetDomain(moving));
}
else
{
Console.WriteLine("No solution found. ");
}
}
public static void MakeHouse(CP cp,
int id,
List<IIntExpr> ends,
List<IIntervalVar> allTasks,
IStateFunction houseState)
{
/* CREATE THE TIME-INTERVALS. */
String name;
IIntervalVar[] tasks = new IIntervalVar[nbTasks];
for (int i = 0; i < nbTasks; i++)
{
name = "H" + id + "-" + taskNames[i];
tasks[i] = cp.IntervalVar(taskDurations[i], name);
workers = cp.Sum(workers, cp.Pulse(tasks[i], 1));
allTasks.Add(tasks[i]);
}
/* ADDING PRECEDENCE CONSTRAINTS */
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[carpentry]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[plumbing]));
cp.Add(cp.EndBeforeStart(tasks[masonry], tasks[ceiling]));
cp.Add(cp.EndBeforeStart(tasks[carpentry], tasks[roofing]));
cp.Add(cp.EndBeforeStart(tasks[ceiling], tasks[painting]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[windows]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[facade]));
cp.Add(cp.EndBeforeStart(tasks[roofing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[plumbing], tasks[garden]));
cp.Add(cp.EndBeforeStart(tasks[windows], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[facade], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[garden], tasks[moving]));
cp.Add(cp.EndBeforeStart(tasks[painting], tasks[moving]));
/* ADDING STATE CONSTRAINTS */
cp.Add(cp.AlwaysEqual(houseState, tasks[masonry], dirty));
cp.Add(cp.AlwaysEqual(houseState, tasks[carpentry], dirty));
cp.Add(cp.AlwaysEqual(houseState, tasks[plumbing], clean));
cp.Add(cp.AlwaysEqual(houseState, tasks[ceiling], clean));
cp.Add(cp.AlwaysEqual(houseState, tasks[roofing], dirty));
cp.Add(cp.AlwaysEqual(houseState, tasks[painting], clean));
cp.Add(cp.AlwaysEqual(houseState, tasks[windows], dirty));
/* MAKESPAN */
ends.Add(cp.EndOf(tasks[moving]));
}
