rlacroix/Metaheuristiques-Lacroix-Lejeune
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

SPT and LRPT finished and tested

Browse source
This commit is contained in:
alejeune 2023-03-20 08:57:27 +01:00
parent 26a5ad00fe
commit ef450f2b98
2 changed files with 67 additions and 11 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

77
src/main/java/jobshop/solvers/GreedySolver.java
View file

@ -34,7 +34,12 @@ public class GreedySolver implements Solver {
return instance.duration(t);
}
private Integer heuristiqueLRPT(Task t, Instance instance){
return instance.duration(t);
int sum = 0;
// we sum all durations starting at the current tasks' in the job
for (int i = t.task; i < instance.numTasks; i++){
sum += instance.duration(t.job, i);
}
return sum;
}
private Integer heuristiqueEST_SPT(Task t, Instance instance){
return instance.duration(t);
@ -58,30 +63,72 @@ public class GreedySolver implements Solver {
.sorted(Comparator.comparing(e -> heuristiqueSPT(e, instance)))
.toArray(Task[]::new)[0]
);
break;
case LPT:
break;
// TODO
return(
lTask.stream()
.sorted(Comparator.comparing(e -> heuristiqueSPT(e, instance)))
.toArray(Task[]::new)[0]
);
case SRPT:
break;
// TODO
return(
lTask.stream()
.sorted(Comparator.comparing(e -> heuristiqueSPT(e, instance)))
.toArray(Task[]::new)[0]
);
case LRPT:
break;
return(
lTask.stream()
.max(Comparator.comparing(e -> heuristiqueLRPT(e, instance)))
.get() // it returns an optional
);
case EST_SPT:
break;
// TODO
return(
lTask.stream()
.sorted(Comparator.comparing(e -> heuristiqueSPT(e, instance)))
.toArray(Task[]::new)[0]
);
case EST_LPT:
break;
// TODO
return(
lTask.stream()
.sorted(Comparator.comparing(e -> heuristiqueSPT(e, instance)))
.toArray(Task[]::new)[0]
);
case EST_SRPT:
break;
// TODO
return(
lTask.stream()
.sorted(Comparator.comparing(e -> heuristiqueSPT(e, instance)))
.toArray(Task[]::new)[0]
);
case EST_LRPT:
break;
// TODO
return(
lTask.stream()
.sorted(Comparator.comparing(e -> heuristiqueSPT(e, instance)))
.toArray(Task[]::new)[0]
);
}
return null;
}
@Override
public Optional<Schedule> solve(Instance instance, long deadline) {
// keeps track of the next time the machine is free
int[] statusMachines = new int[instance.numMachines];
// keeps track of the next time the job is free
int[] statusJobs = new int[instance.numJobs];
Arrays.fill(statusMachines,0);
Arrays.fill(statusJobs,0);
ArrayList<Task> possibleTasks = new ArrayList<>();
int time ;
Schedule schedule = new Schedule(instance);
ArrayList<Task> possibleTasks = new ArrayList<>();
/* Initialization */
for (int i = 0; i < instance.numJobs; i++){
possibleTasks.add(new Task(i, 0));
@ -91,12 +138,20 @@ public class GreedySolver implements Solver {
while(possibleTasks.size() > 0){
Task task = min(possibleTasks,instance);
possibleTasks.remove(task);
// TODO : Add task to the solution
// Update schedule
time = Integer.max(statusMachines[instance.machine(task)], statusJobs[task.job]);
schedule.setStartTime(task.job, task.task, time);
// recalculate next free time for job/machine
statusMachines[instance.machine(task)] = time + instance.duration(task);
statusJobs[task.job] = time + instance.duration(task);
if ((task.task + 1) < instance.numTasks){
possibleTasks.add(new Task(task.job, task.task+1));
}
}
return Optional.of(schedule);
}

1
src/main/java/jobshop/solvers/Solver.java
View file

@ -22,6 +22,7 @@ public interface Solver {
switch (name) {
case "basic": return new BasicSolver();
case "spt": return new GreedySolver(GreedySolver.Priority.SPT);
case "lrpt": return new GreedySolver(GreedySolver.Priority.LRPT);
// TODO: add new solvers
default: throw new RuntimeException("Unknown solver: "+ name);
}