pfaure/Metaheuristiques
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Glouton SPT LPT SRPT LRPT OK

Browse source
This commit is contained in:
Paul Faure 2021-04-27 16:18:40 +02:00
parent 74543116eb
commit d97d8141a1
5 changed files with 160 additions and 6 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
src/main/java/jobshop/Instance.java
View file

@ -59,6 +59,14 @@ public final class Instance {
throw new RuntimeException("No task targeting machine "+wanted_machine+" on job "+job);
}
public Task nextTask(Task task) {
if (task.task < this.numTasks - 1) {
return new Task(task.job, task.task + 1);
} else {
return null;
}
}
/**
* Creates a new instance, with uninitialized durations and machines.
* This should no be called directly. Instead, Instance objects should be created with the

2
src/main/java/jobshop/MainTest.java
View file

@ -70,7 +70,7 @@ public class MainTest {
manualROInvalid.addTaskToMachine(1, new Task(1,0));
manualROInvalid.addTaskToMachine(2, new Task(0,2));
manualROInvalid.addTaskToMachine(2, new Task(1,2));
System.out.println("GANTT: " + manualROInvalid.toSchedule().get().asciiGantt());
//System.out.println("GANTT: " + manualROInvalid.toSchedule().get().asciiGantt());
} catch (IOException e) {
e.printStackTrace();

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

@ -2,11 +2,15 @@ package jobshop.solvers;
import jobshop.Instance;
import jobshop.Result;
import jobshop.encodings.ResourceOrder;
import jobshop.encodings.Schedule;
import jobshop.encodings.Task;
import java.util.ArrayList;
import java.util.Iterator;
import static jobshop.Result.ExitCause.ProvedOptimal;
/** An empty shell to implement a greedy solver. */
public class GreedySolver implements Solver {
@ -84,11 +88,15 @@ public class GreedySolver implements Solver {
Task current = iter.next();
if (this.prioritaire(instance, task, current)) {
trouve = true;
this.tachesRestantes.add(index, task);
} else {
index++;
}
}
this.tachesRestantes.add(index, task);
}
private Task getTask() {
return this.tachesRestantes.remove(0);
}
@Override
@ -97,18 +105,30 @@ public class GreedySolver implements Solver {
int i;
for (i=0; i<instance.numJobs; i++) {
try {
addTask(instance, new Task(i,0));
this.addTask(instance, new Task(i,0));
} catch (Exception e) {
System.out.println("ERREUR POLITIQUE DE PRIORITE INCONNUE");
System.exit(2);
}
}
Result result = null;
ResourceOrder resourceOrder = new ResourceOrder(instance);
Task task;
Task nextTask;
//Itérations
while (!this.tachesRestantes.isEmpty()) {
//TAF
task = this.getTask();
resourceOrder.addTaskToMachine(instance.machine(task), task);
nextTask = instance.nextTask(task);
if (nextTask != null) {
try {
this.addTask(instance, new Task(task.job, task.task + 1));
} catch (Exception e) {
System.out.println("ERREUR POLITIQUE DE PRIORITE INCONNUE");
System.exit(2);
}
}
}
return result;
return new Result (instance, resourceOrder.toSchedule(), ProvedOptimal);
}
}

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

@ -21,6 +21,13 @@ public interface Solver {
case "basic": return new BasicSolver();
case "random": return new RandomSolver();
case "spt": return new GreedySolver(GreedySolver.Priority.SPT);
case "lpt": return new GreedySolver(GreedySolver.Priority.LPT);
case "srpt": return new GreedySolver(GreedySolver.Priority.SRPT);
case "lrpt": return new GreedySolver(GreedySolver.Priority.LRPT);
case "est_spt": return new GreedySolver(GreedySolver.Priority.EST_SPT);
case "est_lpt": return new GreedySolver(GreedySolver.Priority.EST_LPT);
case "est_srpt": return new GreedySolver(GreedySolver.Priority.EST_SRPT);
case "est_lrpt": return new GreedySolver(GreedySolver.Priority.EST_LRPT);
// TODO: add new solvers
default: throw new RuntimeException("Unknown solver: "+ name);
}

119
src/test/java/jobshop/solvers/GreedySolverTest.java Normal file
View file

@ -0,0 +1,119 @@
package jobshop.solvers;
import jobshop.BestKnownResults;
import jobshop.Instance;
import jobshop.Result;
import org.junit.Test;
import java.io.IOException;
import java.nio.file.Paths;
import java.util.List;
import java.util.stream.Collectors;
import static jobshop.solvers.GreedySolver.Priority.*;
public class GreedySolverTest {
@Test
public void testSPT() {
List<String> instancesNames = BestKnownResults.instancesMatching("la");
instancesNames.addAll(BestKnownResults.instancesMatching("ft"));
List<Instance> instances = instancesNames.stream().map(name -> {
Instance instance = null;
try {
instance = Instance.fromFile(Paths.get("instances/", name));
} catch (IOException e) {
e.printStackTrace();
}
return instance;
}).collect(Collectors.toList());
GreedySolver solver = new GreedySolver(SPT);
Result result;
for (int i = 0; i < instances.size(); i++) {
result = solver.solve(instances.get(i), 100000);
assert result.schedule.get().isValid();
if (BestKnownResults.isKnown(instancesNames.get(i))) {
assert result.schedule.get().makespan() >= BestKnownResults.of(instancesNames.get(i));
}
}
}
@Test
public void testLPT() throws IOException {
List<String> instancesNames = BestKnownResults.instancesMatching("la");
instancesNames.addAll(BestKnownResults.instancesMatching("ft"));
List<Instance> instances = instancesNames.stream().map(name -> {
Instance instance = null;
try {
instance = Instance.fromFile(Paths.get("instances/", name));
} catch (IOException e) {
e.printStackTrace();
}
return instance;
}).collect(Collectors.toList());
GreedySolver solver = new GreedySolver(LPT);
Result result;
for (int i = 0; i < instances.size(); i++) {
result = solver.solve(instances.get(i), 100000);
assert result.schedule.get().isValid();
if (BestKnownResults.isKnown(instancesNames.get(i))) {
assert result.schedule.get().makespan() >= BestKnownResults.of(instancesNames.get(i));
}
}
}
@Test
public void testSRPT() throws IOException {
List<String> instancesNames = BestKnownResults.instancesMatching("la");
instancesNames.addAll(BestKnownResults.instancesMatching("ft"));
List<Instance> instances = instancesNames.stream().map(name -> {
Instance instance = null;
try {
instance = Instance.fromFile(Paths.get("instances/", name));
} catch (IOException e) {
e.printStackTrace();
}
return instance;
}).collect(Collectors.toList());
GreedySolver solver = new GreedySolver(SRPT);
Result result;
for (int i = 0; i < instances.size(); i++) {
result = solver.solve(instances.get(i), 100000);
assert result.schedule.get().isValid();
if (BestKnownResults.isKnown(instancesNames.get(i))) {
assert result.schedule.get().makespan() >= BestKnownResults.of(instancesNames.get(i));
}
}
}
@Test
public void testLRPT() throws IOException {
List<String> instancesNames = BestKnownResults.instancesMatching("la");
instancesNames.addAll(BestKnownResults.instancesMatching("ft"));
List<Instance> instances = instancesNames.stream().map(name -> {
Instance instance = null;
try {
instance = Instance.fromFile(Paths.get("instances/", name));
} catch (IOException e) {
e.printStackTrace();
}
return instance;
}).collect(Collectors.toList());
GreedySolver solver = new GreedySolver(LRPT);
Result result;
for (int i = 0; i < instances.size(); i++) {
result = solver.solve(instances.get(i), 100000);
assert result.schedule.get().isValid();
if (BestKnownResults.isKnown(instancesNames.get(i))) {
assert result.schedule.get().makespan() >= BestKnownResults.of(instancesNames.get(i));
}
}
}
}