约束编程

Question

我尝试在 IBM CPLEX ILOG 中编写调度问题。这里我得到一个错误

根据图片来看noOverlap函数不存在

Answer 1

以下作品：

.mod

using CP;
int N=...; 
int M=...; 
int R=...; 
// Data Structures
range Jobs = 0..N; // Including dummy job 0
range Machines = 0..M;
range Resources = 1..R;

// Parameters (to be defined based on your data)
int processingTime[Jobs][Machines] = ...;
int readyTime[Jobs] = ...;
int setupTime [Jobs][Jobs][Machines]= ...;
int resourceNeed[Jobs][Resources] = ...;
int resourceAvail[Resources] =...;
int machineEligibility[Jobs][Machines] = ...; // 1 if eligible, 0 otherwise
int LB = ...; // Lower bound for Cmax
tuple Precedence {int pred; int succ;}
setof(Precedence) precedenceConstraints = ...; // Define precedence constraints

// Decision Variables
dvar interval Xim[Jobs][Machines] optional size processingTime[N][M]; // Optional interval for each job on each machine
dvar interval Zi[Jobs] size processingTime[N][M]; // Interval for each job i
dvar sequence seqMachines[Machines] in all(i in Jobs, j in Machines : machineEligibility[i][j] == 1) Xim[i][j]; // Sequence of jobs on each machine

// Decision Expressions
dexpr int Cmax = max(i in Jobs) endOf(Zi[i]);

// Objective
minimize Cmax;

// Constraints
subject to {
  // Constraint (3): Each job is assigned to exactly one eligible machine
  forall(i in Jobs)
    alternative(Zi[i], all(j in Machines : machineEligibility[i][j] == 1) Xim[i][j]);

  // Constraint (4): Presence of dummy job
  forall(j in Machines)
    presenceOf(Xim[0][j]);

  // Constraint (6): Dummy job is the first job
//  forall(j in Machines)
//    first(seqMachines[j], Xim[0][j]);

  // Constraint (7): No overlap and setup times
  forall(j in Machines)
    noOverlap(seqMachines[j]);

  // Constraint (8): Precedence relations
  forall(p in precedenceConstraints)
    endBeforeStart(Zi[p.pred], Zi[p.succ]);

  // Constraint (9): Job start times
  forall(i in Jobs, j in Machines : machineEligibility[i][j] == 1)
    startOf(Xim[i][j]) >= readyTime[i] + typeOfPrev(seqMachines[j], Xim[i][j], 0, 0)+ setupTime[typeOfPrev(seqMachines[j], Xim[i][j], 0, 0)][i][j];

//  // Constraint (10): Cumulative resource constraint
//  forall(v in Resources)
//    cumulative(Zi, resourceNeed[0][v], resourceAvail[v]);
//
//// Constraint (11): Machine usage constraint
//forall(m in Machines)
//  cumulative(all(i in Jobs : machineEligibility[i][m] == 1) pulse(Xim[i][m], 1), 1);


  // Constraint (12): Earliest start time of a job
  // Constraint (12): Earliest start time of a job based on precedence
// Constraint (12): Earliest start time of a job based on precedence
forall(i in Jobs)
    startOf(Zi[i]) >= max(p in precedenceConstraints: p.succ == i) endOf(Zi[p.pred]);


  // Constraint (13): Cmax greater than or equal to lower bound
  Cmax >= LB;
  
  
}

// Execute and print results
execute {
  cp.startNewSearch();
  while (cp.next()) {
    writeln("Solution:");
    for(var i in Jobs) {
      if (cp.isPresent(Zi[i]))
        writeln("Job ", i, ": Start = ", cp.startOf(Zi[i]), ", End = ", cp.endOf(Zi[i]));
    }
  }
  cp.endSearch();
}

.dat

N = 3; M = 2; R = 1; 

processingTime = [ [0, 0]]; //, // Dummy job 0 [3, 4], // Job 1 [2, 3] // Job 2 ]; 

readyTime = [0, 1, 2]; 

setupTime = [ [[0, 0, 0], [0, 1, 2], [0, 1, 1]],
 [[0, 0, 0], [0, 1, 2], [0, 1, 1]], 
[[0, 0, 0], [0, 1, 2], [0, 1, 1]] ];

 resourceNeed = [ [0]]; // Job 0 [2], // Job 1 [1] // ]; 

resourceAvail = []; 

machineEligibility = [ [1, 1], [1, 0], [0, 1] ]; 

precedenceConstraints = {<1, 2>}; 

LB = 5;