MaJ sujet + quelques implementation supplémentaires

README.md

@@ -81,7 +81,18 @@ This notably ensures that sources have been recompiled whenever necessary.
 
 ## IDE Support
 
-Most IDEs should provide support for importing gradle projects.
+Most IDEs should provide support for importing gradle projects. However, our experience has been best with IntelliJ so far and we would recommend it.
 
-- **Eclipse**: https://www.vogella.com/tutorials/EclipseGradle/article.html
-- **IntelliJ**: https://www.jetbrains.com/help/idea/gradle.html#gradle_import_project_start
+#### IntelliJ
+
+IntelliJ has worked best, with out of the box support for the import of gradle projets:
+https://www.jetbrains.com/help/idea/gradle.html#gradle_import_project_start
+
+
+#### Eclipse
+
+Most technical problems have been related to the use of Eclipse so we don't recommend using it unless you have a good reason to.
+We have however configured gradle to allow generating an eclipse configuration like so : 
+```
+./gradlew eclipseClean eclipse
+```

build.gradle

@@ -1,6 +1,7 @@
 plugins {
     id 'java'
     id 'application'
+    id 'eclipse'
 }
 
 group 'jobshop'

src/main/java/jobshop/DebuggingMain.java

@@ -0,0 +1,42 @@
+package jobshop;
+
+import jobshop.encodings.JobNumbers;
+
+import java.io.IOException;
+import java.nio.file.Paths;
+
+public class DebuggingMain {
+
+    public static void main(String[] args) {
+        try {
+            // load the aaa1 instance
+            Instance instance = Instance.fromFile(Paths.get("instances/aaa1"));
+
+            // construit une solution dans la représentation par
+            // numéro de jobs : [0 1 1 0 0 1]
+            // Note : cette solution a aussi été vue dans les exercices (section 3.3)
+            //        mais on commençait à compter à 1 ce qui donnait [1 2 2 1 1 2]
+            JobNumbers enc = new JobNumbers(instance);
+            enc.jobs[enc.nextToSet++] = 0;
+            enc.jobs[enc.nextToSet++] = 1;
+            enc.jobs[enc.nextToSet++] = 1;
+            enc.jobs[enc.nextToSet++] = 0;
+            enc.jobs[enc.nextToSet++] = 0;
+            enc.jobs[enc.nextToSet++] = 1;
+
+            System.out.println("\nENCODING: " + enc);
+
+            Schedule sched = enc.toSchedule();
+            // TODO: make it print something meaningful
+            // by implementing the toString() method
+            System.out.println("SCHEDULE: " + sched);
+            System.out.println("VALID: " + sched.isValid());
+            System.out.println("MAKESPAN: " + sched.makespan());
+
+        } catch (IOException e) {
+            e.printStackTrace();
+            System.exit(1);
+        }
+
+    }
+}

src/main/java/jobshop/Instance.java

@@ -28,6 +28,7 @@ public class Instance {
         return machines[job][task];
     }
 
+    /** among the tasks of the given job, returns the task index that uses the given machine. */
     public int task_with_machine(int job, int wanted_machine) {
         for(int task = 0 ; task < numTasks ; task++) {
             if(machine(job, task) == wanted_machine)

src/main/java/jobshop/encodings/JobNumbers.java

@@ -49,4 +49,9 @@ public class JobNumbers extends Encoding {
 
         return new Schedule(instance, startTimes);
     }
+
+    @Override
+    public String toString() {
+        return Arrays.toString(Arrays.copyOfRange(jobs,0, nextToSet));
+    }
 }

src/main/java/jobshop/encodings/Task.java

@@ -0,0 +1,41 @@
+package jobshop.encodings;
+
+import java.util.Objects;
+
+/** Represents a task (job,task) of an jobshop problem.
+ *
+ * Example : (2, 3) repesents the fourth task of the third job. (remeber that we tart counting at 0)
+ * */
+public final class Task {
+
+    /** Identifier of the job */
+    public final int job;
+
+    /** Index of the task inside the job. */
+    public final int task;
+
+
+    public Task(int job, int task) {
+        this.job = job;
+        this.task = task;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Task task1 = (Task) o;
+        return job == task1.job &&
+                task == task1.task;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(job, task);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + job +", " + task + '}';
+    }
+}

sujet/sujet.md

@@ -89,23 +89,32 @@ Deux solveurs très simples basés sur une représentation par numéro de job. L
 
 ## À faire : manipulation de représentations
 
-Ouvrez la méthode `EncodingTests.testJobNumbers()`. 
+Ouvrez la méthode `DebuggingMain.main()`. 
 
- - Pour les deux solutions en représentation par numéro de job, calculez (à la main) les dates de début de chaque tâche
- - implémentez la méthode `toString()` de la classe `Schedule` pour afficher les dates dé début de chaque tâche dans un schedule.
+ - Pour la solutions en représentation par numéro de job donnée, calculez (à la main) les dates de début de chaque tâche
+ - implémentez la méthode `toString()` de la classe `Schedule` pour afficher les dates de début de chaque tâche dans un schedule.
  - Vérifiez que ceci correspond bien aux calculs que vous aviez fait à la main.
  
 Création d'une nouvelle representation par ordre de passage sur les ressources : 
 
-- Créer une classe `jobshop.encodings.ResourceOrder` qui contient la représentation par ordre de passage sur ressources vue dans les exercices.
-- Pour cette classe, implémentez la méthode `toSchedule()` qui permet d'extraire une représentation directe.  
-- Ajouter des tests dans `src/test/java/jobshop` permettant de vérifier que vos méthodes fonctionnent bien pour les exemples traités en cours (instance `aaa1`).
-Vous pouvez pour cela vous inspirer et ajouter des cas de test à `EncodingTests`. 
+- Créer une classe `jobshop.encodings.ResourceOrder` qui contient la représentation par ordre de passage sur ressources vue dans les exercices (section 3.2). Il s'agit ici d'une reprsentation sous forme de matrice où chaque ligne correspond à une machine, et sur cette ligne se trouvent les tâches qui s'exécutent dessus dans leur ordre de passage. Pour la representation d'une tâche dans la matrice, vous pouvez utiliser la classe `jobshop.encodings.Task` qui vous est fournie.
+
+- Pour cette classe, implémentez la méthode `toSchedule()` qui permet d'extraire une représentation directe. 
+Pour l'implémentation de cette méthode `toSchedule()`, il vous faut construire un schedule qui associe à chaque tâche une date de début (vous pouvez regardez l'implémentation pour `JobNums` pour en comprendre le principe).
+Pour construire ce schedule il faudra que vous mainteniez une liste des tâches qui ont été schédulé. Cette liste est initialement vide.
+À chaque itération de l'algorithme, on identifie les tâches executables. Une tâche est executable si 
+
+     - son prédecesseur sur le job a été schedulé (si c'est la tache (1, 3), il faut que les tâches (1,1) et (1,2) aient été schédulée)
+     - son prédecesseur sur la ressource a été schedulé (l'ordre sur passage sur les ressources est précisement ce qui vous est donné par cette représentation).
+ 
+- Ajouter des tests dans `src/test/java/jobshop` permettant de vérifier que vos méthodes fonctionnent bien pour les exemples traités en cours (instance `aaa1`). Vous pouvez pour cela vous inspirer et ajouter des cas de test à `EncodingTests`. 
+
+
 
 Changement de représentation : 
 
 - pour les deux représentations `ResourceOrder` et `JobNums`, créez des méthodes permettant de créer cette représentation depuis un `Schedule`.
-- utilisez là pour tester la conversion de `ResourceOrder` vers `JobNums` et vice-versa.
+- utilisez la pour tester la conversion de `ResourceOrder` vers `JobNums` et vice-versa.
 
 
 # Heuristiques gloutonne