Add ExtensionCode record in KMR.

Author: ref-humbold

src/main/java/com/github/refhumbold/algolib/maths/Fraction.java

@@ -254,10 +254,9 @@ public double doubleValue()
     @Override
     public int compareTo(Number number)
     {
-        if(number instanceof Fraction)
-            return compare((Fraction)number);
-
-        return Double.compare(doubleValue(), number.doubleValue());
+        return number instanceof Fraction
+               ? compare((Fraction)number)
+               : Double.compare(doubleValue(), number.doubleValue());
     }
 
     private int compare(Fraction f)

src/main/java/com/github/refhumbold/algolib/text/BaseWordsMap.java

@@ -1,6 +1,5 @@
 package com.github.refhumbold.algolib.text;
 
-import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -91,34 +90,35 @@ public Pair<Integer, Integer> getCode(int startIndex, int endIndex)
     private void create()
     {
         int codeValue = extend(1, 0,
-                (i, length) -> new int[]{ text.charAt(i), 1 + text.charAt(i), i, i + length });
+                (i, length) -> new ExtensionCode(text.charAt(i), 1 + text.charAt(i), i));
 
         for(int currentLength = 2; currentLength <= text.length(); currentLength *= 2)
             codeValue = extend(currentLength, codeValue,
-                    (i, length) -> new int[]{ factors.get(Pair.of(i, i + length / 2)),
-                            factors.get(Pair.of(i + length / 2, i + length)), i, i + length });
+                    (i, length) -> new ExtensionCode(factors.get(Pair.of(i, i + length / 2)),
+                            factors.get(Pair.of(i + length / 2, i + length)), i));
     }
 
     // Encodes substring of given length using already counted factors.
-    private int extend(int length, int codeValue, BiFunction<Integer, Integer, int[]> func)
+    private int extend(int length, int codeValue, BiFunction<Integer, Integer, ExtensionCode> func)
     {
         ComparablePair<Integer, Integer> previousCode = ComparablePair.of(0, 0);
-        List<int[]> codes = IntStream.range(0, text.length() - length + 1)
-                                     .mapToObj(i -> func.apply(i, length))
-                                     .sorted(new CodesComparator())
-                                     .toList();
+        List<ExtensionCode> codes = IntStream.range(0, text.length() - length + 1)
+                                             .mapToObj(i -> func.apply(i, length))
+                                             .sorted()
+                                             .toList();
 
-        for(int[] code : codes)
+        for(ExtensionCode code : codes)
         {
-            ComparablePair<Integer, Integer> codePair = ComparablePair.of(code[0], code[1]);
+            ComparablePair<Integer, Integer> codePair =
+                    ComparablePair.of(code.prefixCode, code.suffixCode);
 
             if(!Objects.equals(previousCode, codePair))
             {
                 ++codeValue;
                 previousCode = codePair;
             }
 
-            factors.put(Pair.of(code[2], code[3]), codeValue);
+            factors.put(Pair.of(code.index, code.index + length), codeValue);
         }
 
         return codeValue;
@@ -138,17 +138,23 @@ private int getMaxLength(int n)
         return prev;
     }
 
-    private static class CodesComparator
-            implements Comparator<int[]>
+    private record ExtensionCode(int prefixCode, int suffixCode, int index)
+            implements Comparable<ExtensionCode>
     {
         @Override
-        public int compare(int[] a1, int[] a2)
+        public int compareTo(ExtensionCode code)
         {
-            return IntStream.range(0, Math.min(a1.length, a2.length))
-                            .map(i -> Integer.compare(a1[i], a2[i]))
-                            .filter(compareInts -> compareInts != 0)
-                            .findFirst()
-                            .orElse(0);
+            int comparePrefixCodes = Integer.compare(prefixCode, code.prefixCode);
+
+            if(comparePrefixCodes != 0)
+                return comparePrefixCodes;
+
+            int compareSuffixCodes = Integer.compare(suffixCode, code.suffixCode);
+
+            if(compareSuffixCodes != 0)
+                return compareSuffixCodes;
+
+            return Integer.compare(index, code.index);
         }
     }
 }