Fix OverclockCalculator (#2901)

Co-authored-by: Martin Robertz <dream-master@gmx.net>

1 files changed, 116 insertions, 50 deletions

diff --git a/src/test/java/gregtech/overclock/GT_OverclockCalculator_UnitTest.java b/src/test/java/gregtech/overclock/GT_OverclockCalculator_UnitTest.java
index e1560b27cb..6056b00c73 100644
--- a/src/test/java/gregtech/overclock/GT_OverclockCalculator_UnitTest.java
+++ b/src/test/java/gregtech/overclock/GT_OverclockCalculator_UnitTest.java
@@ -4,6 +4,8 @@ import static gregtech.api.enums.GT_Values.V;
 import static gregtech.api.enums.GT_Values.VP;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
+import java.util.function.Function;
+
 import org.junit.jupiter.api.Test;
 
 import gregtech.api.enums.TierEU;
@@ -26,7 +28,7 @@ class GT_OverclockCalculator_UnitTest {
             .setRecipeHeat(1800)
             .setMachineHeat(1800 * 5)
             .calculate();
-        assertEquals(1024 >> 8, calculator.getDuration(), messageDuration);
+        assertEquals(1024 / Math.pow(4, 4), calculator.getDuration(), messageDuration);
         assertEquals(correctConsumption, calculator.getConsumption(), messageEUt);
     }
 
@@ -42,7 +44,7 @@ class GT_OverclockCalculator_UnitTest {
             .setRecipeHeat(1800)
             .setMachineHeat(2700)
             .calculate();
-        assertEquals(1024 >> 4, calculator.getDuration(), messageDuration);
+        assertEquals(1024 / Math.pow(2, 4), calculator.getDuration(), messageDuration);
         assertEquals(correctConsumption, calculator.getConsumption(), messageEUt);
     }
 
@@ -56,7 +58,7 @@ class GT_OverclockCalculator_UnitTest {
             .setRecipeHeat(1800)
             .setMachineHeat(1800)
             .calculate();
-        assertEquals(1024 >> 4, calculator.getDuration(), messageDuration);
+        assertEquals(1024 / Math.pow(2, 4), calculator.getDuration(), messageDuration);
         assertEquals(VP[5], calculator.getConsumption(), messageEUt);
     }
 
@@ -72,7 +74,7 @@ class GT_OverclockCalculator_UnitTest {
             .setRecipeHeat(1800)
             .setMachineHeat(3600)
             .calculate();
-        assertEquals(1024 >> 5, calculator.getDuration(), messageDuration);
+        assertEquals(1024 / (Math.pow(4, 1) * Math.pow(2, 3)), calculator.getDuration(), messageDuration);
         assertEquals(correctConsumption, calculator.getConsumption(), messageEUt);
     }
 
@@ -82,7 +84,7 @@ class GT_OverclockCalculator_UnitTest {
             .setEUt(V[6])
             .setDuration(1024)
             .calculate();
-        assertEquals(1024 >> 5, calculator.getDuration(), messageDuration);
+        assertEquals(1024 / Math.pow(2, 5), calculator.getDuration(), messageDuration);
         assertEquals(VP[6], calculator.getConsumption(), messageEUt);
     }
 
@@ -93,7 +95,7 @@ class GT_OverclockCalculator_UnitTest {
             .setDuration(2048)
             .enablePerfectOC()
             .calculate();
-        assertEquals(2048 >> 10, calculator.getDuration(), messageDuration);
+        assertEquals(2048 / Math.pow(4, 5), calculator.getDuration(), messageDuration);
         assertEquals(VP[6], calculator.getConsumption(), messageEUt);
     }
 
@@ -109,7 +111,7 @@ class GT_OverclockCalculator_UnitTest {
             .setRecipeHeat(486)
             .setMachineHeat(3900)
             .calculate();
-        assertEquals(2048 >> 6, calculator.getDuration(), messageDuration);
+        assertEquals(2048 / (Math.pow(4, 1) * Math.pow(2, 4)), calculator.getDuration(), messageDuration);
         assertEquals(correctConsumption, calculator.getConsumption(), messageEUt);
     }
 
@@ -121,7 +123,7 @@ class GT_OverclockCalculator_UnitTest {
             .setDuration(1024)
             .setAmperageOC(true)
             .calculate();
-        assertEquals(1024 >> 6, calculator.getDuration(), messageDuration);
+        assertEquals(1024 / Math.pow(2, 6), calculator.getDuration(), messageDuration);
         assertEquals(VP[7], calculator.getConsumption(), messageEUt);
     }
 
@@ -133,8 +135,8 @@ class GT_OverclockCalculator_UnitTest {
             .setDuration(1024)
             .setAmperageOC(true)
             .calculate();
-        assertEquals(1024 >> 6, calculator.getDuration(), messageDuration);
-        assertEquals(VP[0] << 12, calculator.getConsumption(), messageEUt);
+        assertEquals(1024 / Math.pow(2, 6), calculator.getDuration(), messageDuration);
+        assertEquals(VP[0] * Math.pow(4, 6), calculator.getConsumption(), messageEUt);
     }
 
     @Test
@@ -145,7 +147,7 @@ class GT_OverclockCalculator_UnitTest {
             .setDuration(1024)
             .setAmperageOC(true)
             .calculate();
-        assertEquals(1024 >> 9, calculator.getDuration(), messageDuration);
+        assertEquals(1024 / Math.pow(2, 9), calculator.getDuration(), messageDuration);
         assertEquals(VP[10], calculator.getConsumption(), messageEUt);
     }
 
@@ -157,7 +159,7 @@ class GT_OverclockCalculator_UnitTest {
             .setDuration(1024)
             .setAmperageOC(true)
             .calculate();
-        assertEquals(1024 >> 9, calculator.getDuration(), messageDuration);
+        assertEquals(1024 / Math.pow(2, 9), calculator.getDuration(), messageDuration);
         assertEquals(VP[10], calculator.getConsumption(), messageEUt);
     }
 
@@ -170,7 +172,7 @@ class GT_OverclockCalculator_UnitTest {
             .setParallel(16)
             .setAmperageOC(true)
             .calculate();
-        assertEquals(1024 >> 6, calculator.getDuration(), messageDuration);
+        assertEquals(1024 / Math.pow(2, 6), calculator.getDuration(), messageDuration);
         assertEquals(VP[9], calculator.getConsumption(), messageEUt);
     }
 
@@ -184,7 +186,7 @@ class GT_OverclockCalculator_UnitTest {
             .setAmperageOC(true)
             .enablePerfectOC()
             .calculate();
-        assertEquals(4096 >> 12, calculator.getDuration(), messageDuration);
+        assertEquals(4096 / Math.pow(4, 6), calculator.getDuration(), messageDuration);
         assertEquals(VP[9], calculator.getConsumption(), messageEUt);
     }
 
@@ -197,7 +199,7 @@ class GT_OverclockCalculator_UnitTest {
             .setParallel(16)
             .setAmperageOC(true)
             .calculate();
-        assertEquals(1024 >> 7, calculator.getDuration(), messageDuration);
+        assertEquals(1024 / Math.pow(2, 7), calculator.getDuration(), messageDuration);
         assertEquals(VP[10], calculator.getConsumption(), messageEUt);
     }
 
@@ -208,7 +210,7 @@ class GT_OverclockCalculator_UnitTest {
             .setDuration(1024)
             .setParallel(8)
             .calculate();
-        assertEquals(1024 >> 5, calculator.getDuration(), messageDuration);
+        assertEquals(1024 / Math.pow(2, 5), calculator.getDuration(), messageDuration);
         assertEquals(VP[6] * 8, calculator.getConsumption(), messageEUt);
     }
 
@@ -221,7 +223,7 @@ class GT_OverclockCalculator_UnitTest {
             .setParallel(8)
             .setAmperageOC(true)
             .calculate();
-        assertEquals(1024 >> 9, calculator.getDuration(), messageDuration);
+        assertEquals(1024 / Math.pow(2, 9), calculator.getDuration(), messageDuration);
         assertEquals(VP[6] * 8 * 256, calculator.getConsumption(), messageEUt);
     }
 
@@ -231,7 +233,7 @@ class GT_OverclockCalculator_UnitTest {
             .setEUt(V[6])
             .setDuration(77)
             .calculate();
-        assertEquals(77 >> 5, calculator.getDuration(), messageDuration);
+        assertEquals((int) (77 / Math.pow(2, 5)), calculator.getDuration(), messageDuration);
         assertEquals(VP[6], calculator.getConsumption(), messageEUt);
     }
 
@@ -253,7 +255,7 @@ class GT_OverclockCalculator_UnitTest {
             .setEUtDiscount(0.9f)
             .setDuration(1024)
             .calculate();
-        assertEquals(1024 >> 5, calculator.getDuration(), messageDuration);
+        assertEquals(1024 / Math.pow(2, 5), calculator.getDuration(), messageDuration);
         assertEquals(correctConsumption, calculator.getConsumption(), messageEUt);
     }
 
@@ -266,7 +268,7 @@ class GT_OverclockCalculator_UnitTest {
             .setDuration(1024)
             .enablePerfectOC()
             .calculate();
-        assertEquals(1024 >> 10, calculator.getDuration(), messageDuration);
+        assertEquals(1024 / Math.pow(4, 5), calculator.getDuration(), messageDuration);
         assertEquals(correctConsumption, calculator.getConsumption(), messageEUt);
     }
 
@@ -277,7 +279,7 @@ class GT_OverclockCalculator_UnitTest {
             .setSpeedBoost(0.9f)
             .setDuration(1024)
             .calculate();
-        assertEquals((int) (1024 * 0.9f) >> 5, calculator.getDuration(), messageDuration);
+        assertEquals((int) (1024 * 0.9f / Math.pow(2, 5)), calculator.getDuration(), messageDuration);
         assertEquals(VP[6], calculator.getConsumption(), messageEUt);
     }
 
@@ -289,7 +291,7 @@ class GT_OverclockCalculator_UnitTest {
             .setDuration(2048)
             .enablePerfectOC()
             .calculate();
-        assertEquals((int) (2048 * 0.9f) >> 10, calculator.getDuration(), messageDuration);
+        assertEquals((int) ((2048 * 0.9f) / Math.pow(4, 5)), calculator.getDuration(), messageDuration);
         assertEquals(VP[6], calculator.getConsumption(), messageEUt);
     }
 
@@ -326,17 +328,17 @@ class GT_OverclockCalculator_UnitTest {
         assertEquals(1, calculator.getDuration(), messageDuration);
 
         /*
-         * duration with speedboost = 5
-         * log_2(5) ~ 2.3;
+         * duration with speedboost = 4.4
+         * log_2(5) ~ 2.14;
          * round up to 3 to reach one tick duration
          */
         int overclocksTillOneTick = 3;
         int overclocksBeyondOneTick = 2;
 
         // 3 overclocks, each gives 4x consumption growth per tick (1920)
-        long targetEUt = VP[1] << 2 * overclocksTillOneTick;
+        long targetEUt = (long) (VP[1] * Math.pow(4, overclocksTillOneTick));
         // 2 remaining overclocks are beyond 1 tick, each provides 2x comsumption discount (480)
-        targetEUt >>= overclocksBeyondOneTick;
+        targetEUt /= Math.pow(2, overclocksBeyondOneTick);
 
         assertEquals(targetEUt, calculator.getConsumption(), messageEUt);
     }
@@ -352,17 +354,17 @@ class GT_OverclockCalculator_UnitTest {
             .calculate();
 
         /*
-         * duration with speedboost = 18
-         * log_4(18) ~ 2.08;
+         * duration with speedboost = 17.6
+         * log_4(18) ~ 2.06;
          * round up to 3 to reach one tick duration
          */
         int overclocksTillOneTick = 3;
         int overclocksBeyondOneTick = 2;
 
         // 3 overclocks, each gives 4x consumption growth per tick (1920)
-        long targetEUt = VP[1] << 2 * overclocksTillOneTick;
+        long targetEUt = (long) (VP[1] * Math.pow(4, overclocksTillOneTick));
         // 2 remaining overclocks are beyond 1 tick, each provides 4x comsumption discount (120)
-        targetEUt >>= 2 * overclocksBeyondOneTick;
+        targetEUt /= Math.pow(4, overclocksBeyondOneTick);
 
         assertEquals(targetEUt, calculator.getConsumption(), messageEUt);
         assertEquals(1, calculator.getDuration(), messageDuration);
@@ -376,7 +378,7 @@ class GT_OverclockCalculator_UnitTest {
             .setEUtDiscount(0.9f)
             .setDuration(1024)
             .calculate();
-        assertEquals(1024 >> 5, calculator.getDuration(), messageDuration);
+        assertEquals(1024 / Math.pow(2, 5), calculator.getDuration(), messageDuration);
         assertEquals(correctConsumption, calculator.getConsumption(), messageEUt);
     }
 
@@ -389,7 +391,7 @@ class GT_OverclockCalculator_UnitTest {
             .setParallel(14)
             .setDuration(1024)
             .calculate();
-        assertEquals(1024 >> 3, calculator.getDuration(), messageDuration);
+        assertEquals(1024 / Math.pow(2, 3), calculator.getDuration(), messageDuration);
         assertEquals(correctConsumption, calculator.getConsumption(), messageEUt);
     }
 
@@ -413,7 +415,7 @@ class GT_OverclockCalculator_UnitTest {
             .setDuration(30)
             .calculate();
         assertEquals(1, calculator.getDuration(), messageDuration);
-        assertEquals(16 << 14, calculator.getConsumption(), messageEUt);
+        assertEquals(16 * Math.pow(4, 7), calculator.getConsumption(), messageEUt);
     }
 
     @Test
@@ -422,10 +424,12 @@ class GT_OverclockCalculator_UnitTest {
             .setParallel(56)
             .setAmperage(1)
             .setAmperageOC(true)
-            .setSpeedBoost(1f / 6f)
-            .setEUt(V[14])
-            .setDuration(56);
-        assertEquals((24 * 56) << 20, calculator.calculateEUtConsumptionUnderOneTick(56, 6144));
+            .setSpeedBoost(1f / 6.01f) // If we set this to 1/6 we will get 11 overclocks because of float imprecision.
+            .setEUt(V[14] * 1_048_576)
+            .setDuration(56)
+            .setCurrentParallel(6144)
+            .calculate();
+        assertEquals((24 * 56) * Math.pow(4, 10), calculator.getConsumption());
     }
 
     @Test
@@ -441,10 +445,36 @@ class GT_OverclockCalculator_UnitTest {
             .setMachineHeat(15500)
             .setEUt(V[12] * 1_048_576)
             .setDuration(250);
-        assertEquals(
-            Math.ceil((((long) 1920 * 256) << 28) * heatDiscount),
-            calculator
-                .calculateEUtConsumptionUnderOneTick(256, (int) (256 / calculator.calculateDurationUnderOneTick())));
+        calculator.setCurrentParallel((int) (256 / calculator.calculateDurationUnderOneTick()))
+            .calculate();
+        assertEquals(Math.ceil((((long) 1920 * 256) * Math.pow(4, 14)) * heatDiscount), calculator.getConsumption());
+    }
+
+    @Test
+    void testCorrectOverclockWhenCurrentParallelLessThanOriginalParallel() {
+        GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(24)
+            .setParallel(64)
+            .setAmperage(1)
+            .setAmperageOC(true)
+            .setEUt(V[6])
+            .setDuration(56)
+            .setCurrentParallel(16)
+            .calculate();
+        assertEquals(56 / Math.pow(2, 3), calculator.getDuration());
+        assertEquals((24 * 16) * Math.pow(4, 3), calculator.getConsumption());
+    }
+
+    @Test
+    void stopsCorrectlyWhenOverclockingUnderOneTick() {
+        GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[2])
+            .setEUt(V[9])
+            .setParallel(4)
+            .setDuration(10)
+            .setAmperageOC(false)
+            .setAmperage(16)
+            .setCurrentParallel(16)
+            .calculate();
+        assertEquals((VP[2] * 4) * Math.pow(4, 6), calculator.getConsumption());
     }
 
     @Test
@@ -475,7 +505,7 @@ class GT_OverclockCalculator_UnitTest {
             .setAmperageOC(false)
             .setAmperage(16)
             .calculate();
-        assertEquals((32 * 64), calculator.getConsumption(), messageEUt);
+        assertEquals(32 * 64, calculator.getConsumption(), messageEUt);
     }
 
     @Test
@@ -499,7 +529,7 @@ class GT_OverclockCalculator_UnitTest {
             .setAmperageOC(false)
             .setAmperage(16)
             .calculate();
-        assertEquals((8 << 4) * 16, calculator.getConsumption(), messageEUt);
+        assertEquals((8 * 16) * Math.pow(4, 2), calculator.getConsumption(), messageEUt);
     }
 
     @Test
@@ -510,7 +540,7 @@ class GT_OverclockCalculator_UnitTest {
             .setDuration(20)
             .setAmperageOC(false)
             .calculate();
-        assertEquals((8 << 2) * 16, calculator.getConsumption(), messageEUt);
+        assertEquals((8 * 16) * Math.pow(4, 1), calculator.getConsumption(), messageEUt);
     }
 
     @Test
@@ -522,7 +552,7 @@ class GT_OverclockCalculator_UnitTest {
             .setAmperage(64)
             .setAmperageOC(false)
             .calculate();
-        assertEquals((7 << 4) * 64, calculator.getConsumption(), messageEUt);
+        assertEquals((7 * 64) * Math.pow(4, 2), calculator.getConsumption(), messageEUt);
     }
 
     @Test
@@ -534,7 +564,7 @@ class GT_OverclockCalculator_UnitTest {
             .setAmperage(19)
             .setAmperageOC(false)
             .calculate();
-        assertEquals((7 << 4) * 19, calculator.getConsumption(), messageEUt);
+        assertEquals((7 * 19) * Math.pow(4, 2), calculator.getConsumption(), messageEUt);
     }
 
     @Test
@@ -546,7 +576,7 @@ class GT_OverclockCalculator_UnitTest {
             .setAmperage(25)
             .setAmperageOC(false)
             .calculate();
-        assertEquals((7 << 4) * 29, calculator.getConsumption(), messageEUt);
+        assertEquals((7 * 29) * Math.pow(4, 2), calculator.getConsumption(), messageEUt);
     }
 
     @Test
@@ -556,8 +586,9 @@ class GT_OverclockCalculator_UnitTest {
             .setParallel(64)
             .setDuration(300)
             .setAmperage(64)
-            .setAmperageOC(false);
-        assertEquals(TierEU.LuV * 64, calculator.calculateEUtConsumptionUnderOneTick(64, 64), messageEUt);
+            .setAmperageOC(false)
+            .calculate();
+        assertEquals(TierEU.LuV * 64, calculator.getConsumption(), messageEUt);
     }
 
     @Test
@@ -568,7 +599,7 @@ class GT_OverclockCalculator_UnitTest {
             .setDuration(1024)
             .setEUtIncreasePerOC(4.1)
             .calculate();
-        assertEquals(1024 >> 5, calculator.getDuration(), messageDuration);
+        assertEquals(1024 / Math.pow(2, 5), calculator.getDuration(), messageDuration);
         assertEquals(expectedEUt, calculator.getConsumption(), messageEUt);
     }
 
@@ -585,6 +616,41 @@ class GT_OverclockCalculator_UnitTest {
     }
 
     @Test
+    void overclockWithCustomEutIncreasePerOCSupplier() {
+        Function<Integer, Double> laserOC = overclockCount -> overclockCount <= 5 ? 4
+            : (4 + 0.3 * (overclockCount - 5));
+        GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1])
+            .setEUt(V[6])
+            .setAmperageOC(true)
+            .setAmperage(1024)
+            .setDuration(1024)
+            .setEutIncreasePerOCSupplier(laserOC)
+            .calculate();
+        assertEquals(5 + 4, calculator.getPerformedOverclocks());
+        assertEquals(1024 / Math.pow(2, 9), calculator.getDuration());
+        assertEquals((int) (VP[1] * Math.pow(4, 5) * 4.3 * 4.6 * 4.9 * 5.2), calculator.getConsumption());
+    }
+
+    @Test
+    void overclockUnderOneTickWithCustomEutIncreasePerOCSupplier() {
+        Function<Integer, Double> laserOC = overclockCount -> overclockCount <= 5 ? 4
+            : (4 + 0.3 * (overclockCount - 5));
+        GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1])
+            .setEUt(V[6])
+            .setAmperageOC(true)
+            .setAmperage(4000)
+            .setDuration(64)
+            .setEutIncreasePerOCSupplier(laserOC);
+
+        assertEquals(Math.pow(2, 10) / 64, (int) (1 / calculator.calculateDurationUnderOneTick()));
+
+        calculator.calculate();
+
+        assertEquals(5 + 5, calculator.getPerformedOverclocks());
+        assertEquals((int) (VP[1] * Math.pow(4, 5) * 4.3 * 4.6 * 4.9 * 5.2 * 5.5), calculator.getConsumption());
+    }
+
+    @Test
     void slightlyOverOneAmpRecipeWorksWithSingleEnergyHatch() {
         GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(614400)
             .setEUt(TierEU.UV)