refactor: move average out of measure and into compute / processor

metacosm · metacosm · commit e6f9b9c4dda3 · 2024-12-02T17:09:20.000+01:00
diff --git a/analysis/src/main/java/net/laprun/sustainability/power/analysis/Compute.java b/analysis/src/main/java/net/laprun/sustainability/power/analysis/Compute.java
@@ -9,17 +9,27 @@ public enum Compute {
 
     public static double standardDeviation(PowerMeasure measure, int componentIndex) {
         return measure.getMeasuresFor(componentIndex).map(values -> {
-            final var samples = measure.numberOfSamples();
+            final var samples = values.length;
             if (samples <= 1) {
                 return 0.0;
             }
-            final double mean = measure.averagesPerComponent()[componentIndex];
+            final double mean = average(measure, componentIndex);
             double geometricDeviationTotal = 0.0;
-            for (int index = 0; index < samples; index++) {
-                double deviation = values[index] - mean;
+            for (double value : values) {
+                double deviation = value - mean;
                 geometricDeviationTotal += (deviation * deviation);
             }
             return FastMath.sqrt(geometricDeviationTotal / (samples - 1));
         }).orElse(0.0);
     }
+
+    public static double average(PowerMeasure measure, int componentIndex) {
+        return measure.getMeasuresFor(componentIndex).map(values -> {
+            double sum = 0.0;
+            for (double value : values) {
+                sum += value;
+            }
+            return sum / values.length;
+        }).orElse(0.0);
+    }
 }
diff --git a/analysis/src/main/java/net/laprun/sustainability/power/analysis/MeanComponentProcessor.java b/analysis/src/main/java/net/laprun/sustainability/power/analysis/MeanComponentProcessor.java
@@ -0,0 +1,13 @@
+package net.laprun.sustainability.power.analysis;
+
+public class MeanComponentProcessor implements ComponentProcessor {
+    private double mean;
+    private int count;
+
+    @Override
+    public void recordComponentValue(double value, long timestamp) {
+        final var previousSize = count;
+        count++;
+        mean = mean == 0 ? value : (previousSize * mean + value) / count;
+    }
+}
diff --git a/analysis/src/test/java/ComputeTest.java b/analysis/src/test/java/ComputeTest.java
@@ -50,8 +50,8 @@ void standardDeviationShouldWork() {
         components[2] = m3c3;
         measure.recordMeasure(components);
 
-        final var c1Avg = measure.averagesPerComponent()[0];
-        final var c2Avg = measure.averagesPerComponent()[1];
+        final var c1Avg = Compute.average(measure, 0);
+        final var c2Avg = Compute.average(measure, 1);
         final var stdVarForC1 = Math
                 .sqrt((Math.pow(m1c1 - c1Avg, 2) + Math.pow(m2c1 - c1Avg, 2) + Math.pow(m3c1 - c1Avg, 2)) / (3 - 1));
         final var stdVarForC2 = Math
@@ -64,4 +64,47 @@ void standardDeviationShouldWork() {
         assertEquals(0, Compute.standardDeviation(measure, 2), 0.0001,
                 "Standard Deviation did not match the expected value");
     }
+
+    @Test
+    void averageShouldWork() {
+        final var random = Random.from(RandomGenerator.getDefault());
+        final var m1c1 = random.nextDouble();
+        final var m1c2 = random.nextDouble();
+        final var m1c3 = 0.0;
+        final var m2c1 = random.nextDouble();
+        final var m2c2 = random.nextDouble();
+        final var m2c3 = 0.0;
+        final var m3c1 = random.nextDouble();
+        final var m3c2 = random.nextDouble();
+        final var m3c3 = 0.0;
+
+        final var measure = new OngoingPowerMeasure(metadata);
+
+        final var components = new double[metadata.componentCardinality()];
+        components[0] = m1c1;
+        components[1] = m1c2;
+        components[2] = m1c3;
+        measure.recordMeasure(components);
+
+        components[0] = m2c1;
+        components[1] = m2c2;
+        components[2] = m2c3;
+        measure.recordMeasure(components);
+
+        components[0] = m3c1;
+        components[1] = m3c2;
+        components[2] = m3c3;
+        measure.recordMeasure(components);
+
+        final var c1Avg = Compute.average(measure, 0);
+        final var c2Avg = Compute.average(measure, 1);
+        final var c3Avg = Compute.average(measure, 2);
+
+        assertEquals((m1c1 + m2c1 + m3c1) / 3, c1Avg, 0.0001,
+                "Average did not match the expected value");
+        assertEquals((m1c2 + m2c2 + m3c2) / 3, c2Avg, 0.0001,
+                "Average did not match the expected value");
+        assertEquals(0, c3Avg, 0.0001,
+                "Average did not match the expected value");
+    }
 }
diff --git a/measure/src/main/java/net/laprun/sustainability/power/measure/Compute.java b/measure/src/main/java/net/laprun/sustainability/power/measure/Compute.java
@@ -0,0 +1,24 @@
+package net.laprun.sustainability.power.measure;
+
+public enum Compute {
+    ;
+
+    public static double sumOfComponents(double[] recorded) {
+        var componentSum = 0.0;
+        for (double value : recorded) {
+            componentSum += value;
+        }
+        return componentSum;
+    }
+
+    public static double sumOfSelectedComponents(double[] recorded, int... indices) {
+        if (indices == null || indices.length == 0) {
+            return sumOfComponents(recorded);
+        }
+        var componentSum = 0.0;
+        for (int index : indices) {
+            componentSum += recorded[index];
+        }
+        return componentSum;
+    }
+}
diff --git a/measure/src/main/java/net/laprun/sustainability/power/measure/OngoingPowerMeasure.java b/measure/src/main/java/net/laprun/sustainability/power/measure/OngoingPowerMeasure.java
@@ -12,7 +12,6 @@ public class OngoingPowerMeasure implements PowerMeasure {
     private static final int DEFAULT_SIZE = 32;
     private final SensorMetadata sensorMetadata;
     private final long startedAt;
-    private final double[] averages;
     private final BitSet nonZeroComponents;
     private final int[] totalComponents;
     private final int totalIndex;
@@ -34,7 +33,6 @@ public OngoingPowerMeasure(SensorMetadata sensorMetadata, ComponentProcessor...
         measures = new double[measuresNb][DEFAULT_SIZE];
         timestamps = new long[DEFAULT_SIZE];
         totalIndex = numComponents;
-        averages = new double[measuresNb];
         // we don't need to record the total component as a non-zero component since it's almost never zero and we compute the std dev separately
         nonZeroComponents = new BitSet(numComponents);
         totalComponents = sensorMetadata.totalComponents();
@@ -61,16 +59,12 @@ public void recordMeasure(double[] components) {
                 nonZeroComponents.set(component);
             }
             recordComponentValue(component, componentValue);
-            averages[component] = averages[component] == 0 ? componentValue
-                    : (previousSize * averages[component] + componentValue) / samples;
         }
 
         // record min / max totals
-        final var recordedTotal = PowerMeasure.sumOfSelectedComponents(components, totalComponents);
+        final var recordedTotal = Compute.sumOfSelectedComponents(components, totalComponents);
         recordComponentValue(totalIndex, recordedTotal);
         accumulatedTotal += recordedTotal;
-        averages[components.length] = averages[components.length] == 0 ? recordedTotal
-                : (previousSize * averages[components.length] + recordedTotal) / samples;
         if (recordedTotal < minTotal) {
             minTotal = recordedTotal;
         }
@@ -119,11 +113,6 @@ public double maxMeasuredTotal() {
         return maxTotal;
     }
 
-    @Override
-    public double[] averagesPerComponent() {
-        return averages;
-    }
-
     @Override
     public Optional<double[]> getMeasuresFor(int component) {
         if (nonZeroComponents.get(component)) {
diff --git a/measure/src/main/java/net/laprun/sustainability/power/measure/PowerMeasure.java b/measure/src/main/java/net/laprun/sustainability/power/measure/PowerMeasure.java
@@ -7,32 +7,14 @@
 import net.laprun.sustainability.power.analysis.ComponentProcessor;
 
 public interface PowerMeasure {
-    private static double sumOfComponents(double[] recorded) {
-        var componentSum = 0.0;
-        for (double value : recorded) {
-            componentSum += value;
-        }
-        return componentSum;
-    }
-
-    static double sumOfSelectedComponents(double[] recorded, int... indices) {
-        if (indices == null || indices.length == 0) {
-            return sumOfComponents(recorded);
-        }
-        var componentSum = 0.0;
-        for (int index : indices) {
-            componentSum += recorded[index];
-        }
-        return componentSum;
-    }
 
     @SuppressWarnings("unused")
     static String asString(PowerMeasure measure) {
         final var durationInSeconds = measure.duration().getSeconds();
         final var samples = measure.numberOfSamples();
         final var measuredMilliWatts = measure.total();
-        return String.format("%s / avg: %s [min: %.3f, max: %.3f] (%ds, %s samples)",
-                readableWithUnit(measuredMilliWatts), readableWithUnit(measure.average()),
+        return String.format("%s [min: %.3f, max: %.3f] (%ds, %s samples)",
+                readableWithUnit(measuredMilliWatts),
                 measure.minMeasuredTotal(), measure.maxMeasuredTotal(), durationInSeconds, samples);
     }
 
@@ -46,16 +28,10 @@ static String readableWithUnit(double milliWatts) {
 
     Duration duration();
 
-    default double average() {
-        return total() / numberOfSamples();
-    }
-
     double total();
 
     SensorMetadata metadata();
 
-    double[] averagesPerComponent();
-
     double minMeasuredTotal();
 
     double maxMeasuredTotal();
diff --git a/measure/src/main/java/net/laprun/sustainability/power/measure/StoppedPowerMeasure.java b/measure/src/main/java/net/laprun/sustainability/power/measure/StoppedPowerMeasure.java
@@ -14,7 +14,6 @@ public class StoppedPowerMeasure implements PowerMeasure {
     private final double total;
     private final double min;
     private final double max;
-    private final double[] averages;
     private final double[][] measures;
     private final ComponentProcessor[] processors;
 
@@ -24,7 +23,6 @@ public StoppedPowerMeasure(PowerMeasure powerMeasure) {
         this.total = powerMeasure.total();
         this.min = powerMeasure.minMeasuredTotal();
         this.max = powerMeasure.maxMeasuredTotal();
-        this.averages = powerMeasure.averagesPerComponent();
         this.samples = powerMeasure.numberOfSamples();
         final var cardinality = metadata().componentCardinality();
         measures = new double[cardinality][samples];
@@ -54,11 +52,6 @@ public double total() {
         return total;
     }
 
-    @Override
-    public double[] averagesPerComponent() {
-        return averages;
-    }
-
     @Override
     public int numberOfSamples() {
         return samples;
diff --git a/measure/src/test/java/net/laprun/sustainability/power/measure/OngoingPowerMeasureTest.java b/measure/src/test/java/net/laprun/sustainability/power/measure/OngoingPowerMeasureTest.java
@@ -57,14 +57,7 @@ void testBasics() {
         assertThat(measure.getMeasuresFor(2)).isEmpty();
 
         assertEquals(m1c1 + m1c2 + m1c3 + m2c1 + m2c2 + m2c3 + m3c1 + m3c2 + m3c3, measure.total());
-        assertEquals((m1c1 + m1c2 + m1c3 + m2c1 + m2c2 + m2c3 + m3c1 + m3c2 + m3c3) / 3, measure.average());
         assertEquals(Stream.of(m1total, m2total, m3total).min(Double::compareTo).orElseThrow(), measure.minMeasuredTotal());
         assertEquals(Stream.of(m1total, m2total, m3total).max(Double::compareTo).orElseThrow(), measure.maxMeasuredTotal());
-        final var c1Avg = measure.averagesPerComponent()[0];
-        final var c2Avg = measure.averagesPerComponent()[1];
-        final var c3Avg = measure.averagesPerComponent()[2];
-        assertEquals((m1c1 + m2c1 + m3c1) / 3, c1Avg);
-        assertEquals((m1c2 + m2c2 + m3c2) / 3, c2Avg);
-        assertEquals(0, c3Avg);
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -57,14 +57,7 @@ void testBasics() {`
`57`	`57`	`assertThat(measure.getMeasuresFor(2)).isEmpty();`
`58`	`58`
`59`	`59`	`assertEquals(m1c1 + m1c2 + m1c3 + m2c1 + m2c2 + m2c3 + m3c1 + m3c2 + m3c3, measure.total());`
`60`		`- assertEquals((m1c1 + m1c2 + m1c3 + m2c1 + m2c2 + m2c3 + m3c1 + m3c2 + m3c3) / 3, measure.average());`
`61`	`60`	`assertEquals(Stream.of(m1total, m2total, m3total).min(Double::compareTo).orElseThrow(), measure.minMeasuredTotal());`
`62`	`61`	`assertEquals(Stream.of(m1total, m2total, m3total).max(Double::compareTo).orElseThrow(), measure.maxMeasuredTotal());`
`63`		`- final var c1Avg = measure.averagesPerComponent()[0];`
`64`		`- final var c2Avg = measure.averagesPerComponent()[1];`
`65`		`- final var c3Avg = measure.averagesPerComponent()[2];`
`66`		`- assertEquals((m1c1 + m2c1 + m3c1) / 3, c1Avg);`
`67`		`- assertEquals((m1c2 + m2c2 + m3c2) / 3, c2Avg);`
`68`		`- assertEquals(0, c3Avg);`
`69`	`62`	`}`
`70`	`63`	`}`