feat: add Recorder concept for components that record values

Author: metacosm

analysis/src/main/java/net/laprun/sustainability/power/analysis/Compute.java

@@ -8,28 +8,32 @@ public enum Compute {
     ;
 
     public static double standardDeviation(PowerMeasure measure, int componentIndex) {
-        return measure.getMeasuresFor(componentIndex).map(values -> {
-            final var samples = values.length;
-            if (samples <= 1) {
-                return 0.0;
-            }
-            final double mean = average(measure, componentIndex);
-            double geometricDeviationTotal = 0.0;
-            for (double value : values) {
-                double deviation = value - mean;
-                geometricDeviationTotal += (deviation * deviation);
-            }
-            return FastMath.sqrt(geometricDeviationTotal / (samples - 1));
-        }).orElse(0.0);
+        final var measures = measure.getMeasuresFor(componentIndex).toArray();
+        final var samples = measures.length;
+        if (samples <= 1) {
+            return 0.0;
+        }
+        final double mean = average(measures);
+        double geometricDeviationTotal = 0.0;
+        for (double value : measures) {
+            double deviation = value - mean;
+            geometricDeviationTotal += (deviation * deviation);
+        }
+        return FastMath.sqrt(geometricDeviationTotal / (samples - 1));
+    }
+
+    public static double average(double[] values) {
+        if (values == null || values.length == 0) {
+            return 0.0;
+        }
+        double sum = 0.0;
+        for (double value : values) {
+            sum += value;
+        }
+        return sum / values.length;
     }
 
     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);
+        return measure.getMeasuresFor(componentIndex).average().orElse(0.0);
     }
 }

measure/src/main/java/net/laprun/sustainability/power/analysis/Recorder.java

@@ -0,0 +1,7 @@
+package net.laprun.sustainability.power.analysis;
+
+import java.util.stream.DoubleStream;
+
+public interface Recorder {
+    DoubleStream measures();
+}

measure/src/main/java/net/laprun/sustainability/power/analysis/RegisteredSyntheticComponent.java

@@ -24,4 +24,8 @@ public double synthesizeFrom(double[] components, long timestamp) {
     public int computedIndex() {
         return computedIndex;
     }
+
+    public SyntheticComponent syntheticComponent() {
+        return syntheticComponent;
+    }
 }

measure/src/main/java/net/laprun/sustainability/power/measure/OngoingPowerMeasure.java

@@ -4,13 +4,11 @@
 import java.util.Arrays;
 import java.util.BitSet;
 import java.util.List;
-import java.util.Optional;
 import java.util.stream.DoubleStream;
-import java.util.stream.IntStream;
-import java.util.stream.Stream;
 
 import net.laprun.sustainability.power.SensorMetadata;
 import net.laprun.sustainability.power.analysis.Processors;
+import net.laprun.sustainability.power.analysis.Recorder;
 import net.laprun.sustainability.power.analysis.RegisteredSyntheticComponent;
 import net.laprun.sustainability.power.analysis.SyntheticComponent;
 
@@ -102,40 +100,24 @@ public Duration duration() {
     }
 
     @Override
-    public Optional<double[]> getMeasuresFor(int component) {
-        return measuresFor(component, samples);
-    }
-
-    Optional<double[]> measuresFor(int component, int upToIndex) {
+    public DoubleStream getMeasuresFor(int component) {
         if (nonZeroComponents.get(component)) {
-            final var dest = new double[upToIndex];
-            System.arraycopy(measures[component], 0, dest, 0, upToIndex);
-            return Optional.of(dest);
+            return Arrays.stream(measures[component], 0, samples);
         } else {
-            return Optional.empty();
+            final var match = syntheticComponents.stream()
+                    .filter(rsc -> targetComponentExistsAndIsRecorder(component, rsc))
+                    .map(rsc -> (Recorder) rsc.syntheticComponent())
+                    .findFirst()
+                    .orElse(null);
+            if (match != null) {
+                return match.measures();
+            }
         }
+        return DoubleStream.empty();
     }
 
-    @Override
-    public Stream<TimestampedValue> streamTimestampedMeasuresFor(int component, int upToIndex) {
-        final var componentMeasures = measures[component];
-        return indicesFor(component, upToIndex)
-                .mapToObj(index -> new TimestampedValue(timestamps[index], componentMeasures[index]));
-    }
-
-    @Override
-    public DoubleStream streamMeasuresFor(int component, int upToIndex) {
-        final var componentMeasures = measures[component];
-        return indicesFor(component, upToIndex).mapToDouble(index -> componentMeasures[index]);
-    }
-
-    IntStream indicesFor(int component, int upToIndex) {
-        upToIndex = Math.min(upToIndex, samples - 1);
-        if (upToIndex >= 0 && nonZeroComponents.get(component)) {
-            return IntStream.range(0, upToIndex);
-        } else {
-            return IntStream.empty();
-        }
+    private static boolean targetComponentExistsAndIsRecorder(int component, RegisteredSyntheticComponent rsc) {
+        return component == rsc.computedIndex() && rsc.syntheticComponent() instanceof Recorder;
     }
 
     @Override

measure/src/main/java/net/laprun/sustainability/power/measure/PowerMeasure.java

@@ -1,9 +1,7 @@
 package net.laprun.sustainability.power.measure;
 
 import java.time.Duration;
-import java.util.Optional;
 import java.util.stream.DoubleStream;
-import java.util.stream.Stream;
 
 import net.laprun.sustainability.power.SensorMetadata;
 import net.laprun.sustainability.power.analysis.ComponentProcessor;
@@ -26,14 +24,10 @@ static String asString(PowerMeasure measure) {
 
     SensorMetadata metadata();
 
-    Optional<double[]> getMeasuresFor(int component);
+    DoubleStream getMeasuresFor(int component);
 
     TimestampedMeasures getNthTimestampedMeasures(int n);
 
-    Stream<TimestampedValue> streamTimestampedMeasuresFor(int component, int upToIndex);
-
-    DoubleStream streamMeasuresFor(int component, int upToIndex);
-
     record TimestampedValue(long timestamp, double value) {
     }
 

measure/src/main/java/net/laprun/sustainability/power/measure/StoppedPowerMeasure.java

@@ -1,9 +1,7 @@
 package net.laprun.sustainability.power.measure;
 
 import java.time.Duration;
-import java.util.Optional;
 import java.util.stream.DoubleStream;
-import java.util.stream.Stream;
 
 import net.laprun.sustainability.power.SensorMetadata;
 
@@ -38,20 +36,8 @@ public SensorMetadata metadata() {
     }
 
     @Override
-    public Optional<double[]> getMeasuresFor(int component) {
-        return measure.measuresFor(component, samples);
-    }
-
-    @Override
-    public Stream<TimestampedValue> streamTimestampedMeasuresFor(int component, int upToIndex) {
-        upToIndex = ensureIndex(upToIndex);
-        return measure.streamTimestampedMeasuresFor(component, upToIndex);
-    }
-
-    @Override
-    public DoubleStream streamMeasuresFor(int component, int upToIndex) {
-        upToIndex = ensureIndex(upToIndex);
-        return measure.streamMeasuresFor(component, upToIndex);
+    public DoubleStream getMeasuresFor(int component) {
+        return measure.getMeasuresFor(component).limit(samples);
     }
 
     @Override

measure/src/test/java/net/laprun/sustainability/power/measure/OngoingPowerMeasureTest.java

@@ -52,8 +52,8 @@ void testBasics() {
         components[2] = m3c3;
         measure.recordMeasure(components);
 
-        assertThat(measure.getMeasuresFor(0)).hasValue(new double[] { m1c1, m2c1, m3c1 });
-        assertThat(measure.getMeasuresFor(1)).hasValue(new double[] { m1c2, m2c2, m3c2 });
+        assertThat(measure.getMeasuresFor(0)).contains(m1c1, m2c1, m3c1);
+        assertThat(measure.getMeasuresFor(1)).contains(m1c2, m2c2, m3c2);
         assertThat(measure.getMeasuresFor(2)).isEmpty();
 
         var measures = measure.getNthTimestampedMeasures(0);