Add FMode::comparatorMove and improve FMode tests

mork-optimization · Jun 24, 2024 · d9483b2 · d9483b2
1 parent 65ffc29
commit d9483b2
Show file tree

Hide file tree

Showing 5 changed files with 170 additions and 6 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -3,6 +3,7 @@
 - (New) Add support for instance index files, for more info see the docs, inside the Features -> Instance Manager section.
 - (New) Added Solution::notifyUpdate(long), the difference with the existing Solution::notifyUpdate() is that users may notify that the solution was last updated at a different time
 - (New) Added Solution::lastExecutesMovesAsString(): generate a string representation of the last executed moves, useful when something goes wrong.
+- (New) Added FMode::comparatorMove(): returns a comparator that sorts moves from best to worse, taking into account if we are maximizing or minimizing.
 - (Fix) #239: Metrics tracking did not work in some circumstances when autoconfig was disabled but Irace was manually enabled.
 - (Fix) Always execute user provided solution validator after each (instance, algorithm, repetition) if the validator is available
 - More coming soon!

diff --git a/common/src/main/java/es/urjc/etsii/grafo/algorithms/FMode.java b/common/src/main/java/es/urjc/etsii/grafo/algorithms/FMode.java
@@ -1,5 +1,6 @@
 package es.urjc.etsii.grafo.algorithms;
 
+import es.urjc.etsii.grafo.solution.Move;
 import es.urjc.etsii.grafo.solution.Solution;
 import es.urjc.etsii.grafo.util.DoubleComparator;
 
@@ -30,7 +31,13 @@ public boolean improves(double a) {
 
         @Override
         public Comparator<Solution<?,?>> comparator() {
-            Comparator<Solution<?,?>> c = Comparator.comparing(Solution::getScore);
+            Comparator<Solution<?,?>> c = Comparator.comparingDouble(Solution::getScore);
+            return c.reversed();
+        }
+
+        @Override
+        public Comparator<Move<?, ?>> comparatorMove() {
+            Comparator<Move<?,?>> c = Comparator.comparingDouble(Move::getValue);
             return c.reversed();
         }
     },
@@ -56,7 +63,13 @@ public boolean improves(double a) {
 
         @Override
         public Comparator<Solution<?,?>> comparator() {
-            return Comparator.comparing(Solution::getScore);
+            return Comparator.comparingDouble(Solution::getScore);
+        }
+
+
+        @Override
+        public Comparator<Move<?, ?>> comparatorMove() {
+            return Comparator.comparingDouble(Move::getValue);
         }
     };
 
@@ -88,4 +101,10 @@ public Comparator<Solution<?,?>> comparator() {
      * @return a new comparator
      */
     public abstract Comparator<Solution<?,?>> comparator();
+
+    /**
+     * Returns a comparator that sorts moves from best to worst
+     * @return a new comparator
+     */
+    public abstract Comparator<Move<?,?>> comparatorMove();
 }
diff --git a/common/src/main/java/es/urjc/etsii/grafo/testutil/TestMove.java b/common/src/main/java/es/urjc/etsii/grafo/testutil/TestMove.java
@@ -3,12 +3,28 @@
 import es.urjc.etsii.grafo.algorithms.FMode;
 import es.urjc.etsii.grafo.solution.Move;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Objects;
 
 public class TestMove extends Move<TestSolution, TestInstance> {
     private final double score;
     private final FMode fmode;
 
+    public static List<TestMove> generateSeq(int... data){
+        return generateSeq("TestInstance", data);
+    }
+
+    public static List<TestMove> generateSeq(String instanceName, int... data){
+        var testInstance = new TestInstance(instanceName);
+        var testSolution = new TestSolution(testInstance);
+        var moves = new ArrayList<TestMove>();
+        for(var i: data){
+            moves.add(new TestMove(testSolution, i));
+        }
+        return moves;
+    }
+
     public TestMove(TestSolution solution, double score, FMode fmode) {
         super(solution);
         this.score = score;

diff --git a/common/src/main/java/es/urjc/etsii/grafo/testutil/TestSolution.java b/common/src/main/java/es/urjc/etsii/grafo/testutil/TestSolution.java
@@ -2,11 +2,17 @@
 
 import es.urjc.etsii.grafo.solution.Solution;
 
-import java.util.*;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
 import java.util.function.Function;
 
 public class TestSolution extends Solution<TestSolution, TestInstance> {
 
+    public static TestSolution[] from(double... scores) {
+        return from(new TestInstance("TestInstance"), scores);
+    }
+
     public static TestSolution[] from(TestInstance instance, double... scores) {
         var solutions = new TestSolution[scores.length];
         for (int i = 0; i < scores.length; i++) {
@@ -57,7 +63,7 @@ public double getScore() {
         return this.score;
     }
 
-    public void setScore(double score){
+    public void setScore(double score) {
         this.score = score;
     }
 
@@ -71,11 +77,11 @@ public String toString() {
         return "TestSolution";
     }
 
-    public void setTTB(long ttb){
+    public void setTTB(long ttb) {
         this.lastModifiedTime = ttb;
     }
 
-    public void resetTTB(){
+    public void resetTTB() {
         this.lastModifiedTime = Integer.MIN_VALUE;
     }
 

diff --git a/common/src/test/java/es/urjc/etsii/grafo/algorithms/FModeTest.java b/common/src/test/java/es/urjc/etsii/grafo/algorithms/FModeTest.java
@@ -0,0 +1,122 @@
+package es.urjc.etsii.grafo.algorithms;
+
+import es.urjc.etsii.grafo.testutil.TestMove;
+import es.urjc.etsii.grafo.testutil.TestSolution;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class FModeTest {
+
+    @Test
+    void minimizeMoveComp(){
+        var data = TestMove.generateSeq(-1, 7, 3, 9);
+        data.sort(FMode.MINIMIZE.comparatorMove());
+        assertEquals(-1, data.get(0).getValue());
+        assertEquals(3, data.get(1).getValue());
+        assertEquals(7, data.get(2).getValue());
+        assertEquals(9, data.get(3).getValue());
+    }
+
+    @Test
+    void maximizeMoveComp(){
+        var data = TestMove.generateSeq(-1, 7, 3, 9);
+        data.sort(FMode.MAXIMIZE.comparatorMove());
+        assertEquals(9, data.get(0).getValue());
+        assertEquals(7, data.get(1).getValue());
+        assertEquals(3, data.get(2).getValue());
+        assertEquals(-1, data.get(3).getValue());
+    }
+
+    @Test
+    void minimizeSolComp(){
+        var data = TestSolution.from(-1, 7, 3, 9);
+        Arrays.sort(data, FMode.MINIMIZE.comparator());
+        assertEquals(-1, data[0].getScore());
+        assertEquals(3, data[1].getScore());
+        assertEquals(7, data[2].getScore());
+        assertEquals(9, data[3].getScore());
+    }
+
+    @Test
+    void maximizeSolComp(){
+        var data = TestSolution.from(-1, 7, 3, 9);
+        Arrays.sort(data, FMode.MAXIMIZE.comparator());
+        assertEquals(9, data[0].getScore());
+        assertEquals(7, data[1].getScore());
+        assertEquals(3, data[2].getScore());
+        assertEquals(-1, data[3].getScore());
+    }
+
+    @Test
+    void minimizeImproves(){
+        assertTrue(FMode.MINIMIZE.improves(-0.01));
+        assertTrue(FMode.MINIMIZE.improves(-1));
+        assertTrue(FMode.MINIMIZE.improves(Integer.MIN_VALUE));
+        assertFalse(FMode.MINIMIZE.improves(0));
+        assertFalse(FMode.MINIMIZE.improves(-0.000000000000000000000000000000000000000000000000001D));
+        assertFalse(FMode.MINIMIZE.improves(7));
+        assertFalse(FMode.MINIMIZE.improves(Integer.MAX_VALUE));
+    }
+
+    @Test
+    void maximizeImproves(){
+        assertFalse(FMode.MAXIMIZE.improves(-0.01));
+        assertFalse(FMode.MAXIMIZE.improves(-1));
+        assertFalse(FMode.MAXIMIZE.improves(Integer.MIN_VALUE));
+        assertFalse(FMode.MAXIMIZE.improves(0));
+        assertFalse(FMode.MAXIMIZE.improves(-0.000000000000000000000000000000000000000000000000001D));
+        assertTrue(FMode.MAXIMIZE.improves(7));
+        assertTrue(FMode.MAXIMIZE.improves(Integer.MAX_VALUE));
+    }
+
+    @Test
+    void minimizeIsBetter(){
+        assertTrue(FMode.MINIMIZE.isBetter(-1, 0));
+        assertFalse(FMode.MINIMIZE.isBetter(1, 0));
+        assertFalse(FMode.MINIMIZE.isBetter(-1, -1));
+        assertFalse(FMode.MINIMIZE.isBetter(0, 0));
+        assertTrue(FMode.MINIMIZE.isBetter(Integer.MIN_VALUE, Integer.MAX_VALUE));
+        assertFalse(FMode.MINIMIZE.isBetter(Integer.MAX_VALUE, Integer.MIN_VALUE));
+        assertTrue(FMode.MINIMIZE.isBetter(123, 123.1));
+        assertFalse(FMode.MINIMIZE.isBetter(0, 0.0000000000000000000000000000001D));
+    }
+
+    @Test
+    void maximizeIsBetter(){
+        assertFalse(FMode.MAXIMIZE.isBetter(-1, 0));
+        assertTrue(FMode.MAXIMIZE.isBetter(1, 0));
+        assertFalse(FMode.MAXIMIZE.isBetter(-1, -1));
+        assertFalse(FMode.MAXIMIZE.isBetter(0, 0));
+        assertFalse(FMode.MAXIMIZE.isBetter(Integer.MIN_VALUE, Integer.MAX_VALUE));
+        assertTrue(FMode.MAXIMIZE.isBetter(Integer.MAX_VALUE, Integer.MIN_VALUE));
+        assertTrue(FMode.MAXIMIZE.isBetter(123.1, 123));
+        assertFalse(FMode.MAXIMIZE.isBetter(0.0000000000000000000000000000001D, 0));
+    }
+
+    @Test
+    void minimizeIsBetterEq(){
+        assertTrue(FMode.MINIMIZE.isBetterOrEqual(-1, 0));
+        assertFalse(FMode.MINIMIZE.isBetterOrEqual(1, 0));
+        assertTrue(FMode.MINIMIZE.isBetterOrEqual(-1, -1));
+        assertTrue(FMode.MINIMIZE.isBetterOrEqual(0, 0));
+        assertTrue(FMode.MINIMIZE.isBetterOrEqual(Integer.MIN_VALUE, Integer.MAX_VALUE));
+        assertFalse(FMode.MINIMIZE.isBetterOrEqual(Integer.MAX_VALUE, Integer.MIN_VALUE));
+        assertTrue(FMode.MINIMIZE.isBetterOrEqual(123, 123.1));
+        assertTrue(FMode.MINIMIZE.isBetterOrEqual(0, 0.0000000000000000000000000000001D));
+    }
+
+    @Test
+    void maximizeIsBetterEq(){
+        assertFalse(FMode.MAXIMIZE.isBetterOrEqual(-1, 0));
+        assertTrue(FMode.MAXIMIZE.isBetterOrEqual(1, 0));
+        assertTrue(FMode.MAXIMIZE.isBetterOrEqual(-1, -1));
+        assertTrue(FMode.MAXIMIZE.isBetterOrEqual(0, 0));
+        assertFalse(FMode.MAXIMIZE.isBetterOrEqual(Integer.MIN_VALUE, Integer.MAX_VALUE));
+        assertTrue(FMode.MAXIMIZE.isBetterOrEqual(Integer.MAX_VALUE, Integer.MIN_VALUE));
+        assertTrue(FMode.MAXIMIZE.isBetterOrEqual(123.1, 123));
+        assertTrue(FMode.MAXIMIZE.isBetterOrEqual(0.0000000000000000000000000000001D, 0));
+    }
+}