[PR] Merge pull request #67 from CSC207-2022F-UofT/progress-speed-test

Test progress speed classes

Author: hykilpikonna

src/main/java/org/hydev/mcpm/client/interaction/ProgressSpeedCalculator.java

@@ -1,6 +1,8 @@
 package org.hydev.mcpm.client.interaction;
 
 import org.hydev.mcpm.utils.Pair;
+import org.hydev.mcpm.utils.arrays.FixedWindowSum;
+import org.hydev.mcpm.utils.arrays.SlidingWindow;
 
 import java.util.ArrayDeque;
 import java.util.Queue;
@@ -16,30 +18,40 @@
  * @since 2022-11-19
  */
 public class ProgressSpeedCalculator implements ProgressSpeedBoundary {
-    private final Queue<Pair<Long, Long>> queue = new ArrayDeque<>();
+    private final FixedWindowSum windowSum;
     private final long window;
     private final long start;
 
     private long total = 0; // total to calculate inc in setProgress
     private long sum = 0; // sliding window sum
 
     /**
+     * Construct a ProgressSpeedCalculator with a window size.
      *
      * @param window Time length of the window to calculate speed over, in nanoseconds
      */
     public ProgressSpeedCalculator(long window) {
-        start = System.nanoTime();
+        this(window, new SlidingWindow().setWindowSize(window));
+    }
+
+    /**
+     * Construct a ProgressSpeedCalculator with the specified FixedWindowSum to calculate speed.
+     * Window speed should be in nanoseconds.
+     *
+     * @param window window size of the given windowSum
+     * @param windowSum the FixedWindowSum used to calculate speed
+     */
+    public ProgressSpeedCalculator(long window, FixedWindowSum windowSum) {
         this.window = window;
+        start = System.nanoTime();
+        this.windowSum = windowSum;
     }
 
 
     @Override
     public double getSpeed() {
         long time = System.nanoTime();
-        while (!queue.isEmpty() && queue.peek().k() < time - window) { // remove all elements that are too old
-            var e = queue.remove();
-            sum -= e.v(); // update sliding window sum
-        }
+        long sum = windowSum.sum(time);
         long dt = Math.min(window, time - start);
         return sum / (dt / 1e9);
     }
@@ -55,7 +67,6 @@ public void setProgress(long progress) {
 
     @Override
     public void incProgress(long inc) {
-        queue.add(new Pair<>(System.nanoTime(), inc));
-        sum += inc;
+        windowSum.add(System.nanoTime(), inc);
     }
 }

src/main/java/org/hydev/mcpm/utils/arrays/FixedWindowSum.java

@@ -0,0 +1,45 @@
+package org.hydev.mcpm.utils.arrays;
+
+/**
+ * A data structure supporting appending of index-value pairs
+ * and querying the sum of all values in a fixed window size.
+ * This only supports addition non-decreasing index pairs, and queries of non-increasing indices,
+ * and queries of a fixed window size.
+ *
+ * @author Peter (https://github.com/MstrPikachu)
+ * @since 2022-11-21
+ */
+public interface FixedWindowSum {
+
+    /**
+     * Set the size of the window. After creating an instance, start by calling this and only call it at most once.
+     *
+     * @param window size of the window
+     * @return this object for fluent access
+     */
+    FixedWindowSum setWindowSize(long window);
+
+    /**
+     * Add an index-value pair to the window.
+     *
+     * @param index the index of the pair
+     * @param val value to add to data structure
+     */
+    void add(long index, long val);
+
+    /**
+     * Query the sum of all values that have an index within the window size (exclusive)
+     * that ends at the index of the most recent addition / query.
+     *
+     * @return the result of the query
+     */
+    long sum();
+
+    /**
+     * Query the sum of all values that have an index within the window size (exclusive) that ends at the given index.
+     *
+     * @param index the given index
+     * @return the result of the query
+     */
+    long sum(long index);
+}

src/main/java/org/hydev/mcpm/utils/arrays/SlidingWindow.java

@@ -0,0 +1,55 @@
+package org.hydev.mcpm.utils.arrays;
+
+import org.hydev.mcpm.utils.Pair;
+
+import java.util.ArrayDeque;
+import java.util.Queue;
+
+/**
+ * An implementation of FixedWindowSum using a queue.
+ *
+ * @author Peter (https://github.com/MstrPikachu)
+ * @since 2022-11-21
+ */
+public class SlidingWindow implements FixedWindowSum {
+    private long sum;
+    private long window;
+    private final Queue<Pair<Long, Long>> queue = new ArrayDeque<>();
+
+    @Override
+    public FixedWindowSum setWindowSize(long window) {
+        this.window = window;
+        return this;
+    }
+
+    @Override
+    public void add(long index, long inc) {
+        queue.add(new Pair<>(index, inc));
+        sum += inc; // increase sum after adding a new value
+        restore(index);
+    }
+
+    @Override
+    public long sum() {
+        return sum;
+    }
+
+    @Override
+    public long sum(long index) {
+        restore(index);
+        return sum;
+    }
+
+    /**
+     * Restore the invariant that all values in the queue are within the window
+     *
+     * @param index index of the newest query/insert
+     */
+    private void restore(long index) {
+        // remove values outside the window, O(1) amortized
+        while (!queue.isEmpty() && queue.peek().getKey() < index - window) {
+            var element = queue.poll(); // remove the oldest value if it is outside the window
+            sum -= element.getValue(); // decrement sum after removing values
+        }
+    }
+}

src/test/java/org/hydev/mcpm/utils/arrays/SlidingWindowTest.java

@@ -0,0 +1,47 @@
+package org.hydev.mcpm.utils.arrays;
+
+import org.hydev.mcpm.utils.Pair;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.Random;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class SlidingWindowTest {
+
+    ArrayList<Pair<Long, Long>> arr;
+    SlidingWindow slidingWindow;
+    long window;
+
+
+    long naiveSum(long index) {
+        long ret = 0;
+        for (int i = arr.size() - 1; i >= 0; i--) {
+            if (arr.get(i).getKey() < index - window)
+                break;
+            ret += arr.get(i).getValue();
+        }
+        return ret;
+    }
+
+    @Test
+    void testAll() {
+        Random r = new Random();
+        for (int window = 1; window <= 5001; window += 5) {
+            this.window = window;
+            long cur = 0;
+            arr = new ArrayList<>();
+            slidingWindow = new SlidingWindow();
+            slidingWindow.setWindowSize(window);
+            for (int i = 0; i < 1000; i++) {
+                long x = r.nextLong();
+                int ind = Math.abs(r.nextInt());
+                cur += ind;
+                arr.add(new Pair<>(cur, x));
+                slidingWindow.add(cur, x);
+                assertEquals(slidingWindow.sum(cur), naiveSum(cur));
+            }
+        }
+    }
+}