Debug discrete precomputed resources

contrib/src/main/java/gov/nasa/jpl/aerie/contrib/streamline/modeling/discrete/DiscreteResources.java

@@ -3,6 +3,7 @@
 import gov.nasa.jpl.aerie.contrib.streamline.core.*;
 import gov.nasa.jpl.aerie.contrib.streamline.core.CellRefV2.CommutativityTestInput;
 import gov.nasa.jpl.aerie.contrib.streamline.core.monads.ResourceMonad;
+import gov.nasa.jpl.aerie.contrib.streamline.modeling.clocks.Clock;
 import gov.nasa.jpl.aerie.contrib.streamline.modeling.discrete.monads.DiscreteDynamicsMonad;
 import gov.nasa.jpl.aerie.contrib.streamline.modeling.discrete.monads.DiscreteMonad;
 import gov.nasa.jpl.aerie.contrib.streamline.modeling.discrete.monads.DiscreteResourceMonad;
@@ -27,6 +28,8 @@
 import static gov.nasa.jpl.aerie.contrib.streamline.core.Reactions.every;
 import static gov.nasa.jpl.aerie.contrib.streamline.core.Reactions.whenever;
 import static gov.nasa.jpl.aerie.contrib.streamline.core.Resources.*;
+import static gov.nasa.jpl.aerie.contrib.streamline.core.monads.ResourceMonad.bind;
+import static gov.nasa.jpl.aerie.contrib.streamline.core.monads.ResourceMonad.pure;
 import static gov.nasa.jpl.aerie.contrib.streamline.debugging.Dependencies.addDependency;
 import static gov.nasa.jpl.aerie.contrib.streamline.debugging.Naming.*;
 import static gov.nasa.jpl.aerie.contrib.streamline.modeling.clocks.ClockResources.clock;
@@ -122,13 +125,13 @@ public static <V, T extends Dynamics<Duration, T>> Resource<Discrete<V>> sampled
   public static <V> Resource<Discrete<V>> precomputed(
       final V valueBeforeFirstEntry, final NavigableMap<Duration, V> segments) {
     var clock = clock();
-    return ResourceMonad.bind(clock, clock$ -> {
+    return signalling(bind(clock, (Clock clock$) -> {
       var t = clock$.extract();
       var entry = segments.floorEntry(t);
       var value = entry == null ? valueBeforeFirstEntry : entry.getValue();
       var nextTime = expiry(Optional.ofNullable(segments.higherKey(t)));
-      return ResourceMonad.pure(expiring(discrete(value), nextTime.minus(t)));
-    });
+      return pure(expiring(discrete(value), nextTime.minus(t)));
+    }));
   }
 
   /**
@@ -246,7 +249,7 @@ public static Resource<Discrete<Boolean>> not(Resource<Discrete<Boolean>> operan
    * Resource-level if-then-else logic.
    */
   public static <D> Resource<D> choose(Resource<Discrete<Boolean>> condition, Resource<D> thenCase, Resource<D> elseCase) {
-    var result = ResourceMonad.bind(condition, c -> c.extract() ? thenCase : elseCase);
+    var result = bind(condition, c -> c.extract() ? thenCase : elseCase);
     // Manually add dependencies, since short-circuiting will break automatic dependency tracking.
     addDependency(result, thenCase);
     addDependency(result, elseCase);

contrib/src/main/java/gov/nasa/jpl/aerie/contrib/streamline/modeling/polynomial/PolynomialResources.java

@@ -486,7 +486,7 @@ public static Resource<Discrete<Boolean>> lessThanOrEquals(Resource<Polynomial>
    *             The next entry in the map is the exclusive upper bound of that range.
    */
   public static <A> Resource<Discrete<A>> binned(Resource<Polynomial> p, Resource<Discrete<NavigableMap<Double, A>>> bins) {
-    return signalling(ResourceMonad.bind(p, bins, (p$, bins$) -> {
+    return signalling(bind(p, bins, (Polynomial p$, Discrete<NavigableMap<Double, A>> bins$) -> {
       var entry = bins$.extract().floorEntry(p$.extract());
       if (entry == null) {
         throw new IllegalStateException(

contrib/src/test/java/gov/nasa/jpl/aerie/contrib/streamline/modeling/discrete/PrecomputedTest.java

@@ -0,0 +1,140 @@
+package gov.nasa.jpl.aerie.contrib.streamline.modeling.discrete;
+
+import gov.nasa.jpl.aerie.contrib.streamline.core.Resource;
+import gov.nasa.jpl.aerie.contrib.streamline.core.Resources;
+import gov.nasa.jpl.aerie.merlin.framework.Registrar;
+import gov.nasa.jpl.aerie.merlin.framework.junit.MerlinExtension;
+import gov.nasa.jpl.aerie.merlin.protocol.types.Duration;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.api.TestInstance.Lifecycle;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import java.time.Instant;
+import java.util.Map;
+import java.util.TreeMap;
+
+import static gov.nasa.jpl.aerie.contrib.streamline.core.Resources.currentValue;
+import static gov.nasa.jpl.aerie.contrib.streamline.modeling.discrete.DiscreteResources.precomputed;
+import static gov.nasa.jpl.aerie.merlin.framework.ModelActions.delay;
+import static gov.nasa.jpl.aerie.merlin.protocol.types.Duration.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests for {@link DiscreteResources#precomputed}
+ */
+@ExtendWith(MerlinExtension.class)
+@TestInstance(Lifecycle.PER_CLASS)
+public class PrecomputedTest {
+    public PrecomputedTest(final Registrar registrar) {
+        Resources.init();
+    }
+
+    final Resource<Discrete<Integer>> precomputedAsAConstant =
+            precomputed(4, new TreeMap<>());
+    @Test
+    void precomputed_with_no_transitions_uses_default_value_forever() {
+        assertEquals(4, currentValue(precomputedAsAConstant));
+        delay(HOUR);
+        assertEquals(4, currentValue(precomputedAsAConstant));
+        delay(HOUR);
+        assertEquals(4, currentValue(precomputedAsAConstant));
+    }
+
+    final Resource<Discrete<Integer>> precomputedWithOneTransitionInFuture =
+            precomputed(0, new TreeMap<>(Map.of(MINUTE, 10)));
+    @Test
+    void precomputed_with_transition_in_future_changes_at_that_time() {
+        assertEquals(0, currentValue(precomputedWithOneTransitionInFuture));
+        assertTransition(precomputedWithOneTransitionInFuture, MINUTE, 10);
+        delay(HOUR);
+        assertEquals(10, currentValue(precomputedWithOneTransitionInFuture));
+        delay(HOUR);
+        assertEquals(10, currentValue(precomputedWithOneTransitionInFuture));
+    }
+
+    final Resource<Discrete<Integer>> precomputedWithOneTransitionInPast =
+            precomputed(0, new TreeMap<>(Map.of(duration(-1, MINUTE), 10)));
+    @Test
+    void precomputed_with_transition_in_past_uses_that_value_forever() {
+        assertEquals(10, currentValue(precomputedWithOneTransitionInPast));
+        delay(HOUR);
+        assertEquals(10, currentValue(precomputedWithOneTransitionInPast));
+        delay(HOUR);
+        assertEquals(10, currentValue(precomputedWithOneTransitionInPast));
+    }
+
+    final Resource<Discrete<Integer>> precomputedWithMultipleTransitionsInFuture =
+            precomputed(0, new TreeMap<>(Map.of(
+                    duration(2, MINUTE), 5,
+                    duration(5, MINUTE), 10,
+                    duration(6, MINUTE), 15)));
+    @Test
+    void precomputed_with_multiple_transitions_in_future_goes_through_each_in_turn() {
+        assertEquals(0, currentValue(precomputedWithMultipleTransitionsInFuture));
+        assertTransition(precomputedWithMultipleTransitionsInFuture, duration(2, MINUTE), 5);
+        assertTransition(precomputedWithMultipleTransitionsInFuture, duration(3, MINUTE), 10);
+        assertTransition(precomputedWithMultipleTransitionsInFuture, duration(1, MINUTE), 15);
+        delay(HOUR);
+        assertEquals(15, currentValue(precomputedWithMultipleTransitionsInFuture));
+        delay(HOUR);
+        assertEquals(15, currentValue(precomputedWithMultipleTransitionsInFuture));
+    }
+
+    final Resource<Discrete<Integer>> precomputedWithMultipleTransitionsInPast =
+            precomputed(0, new TreeMap<>(Map.of(
+                    duration(-2, MINUTE), 5,
+                    duration(-5, MINUTE), 10,
+                    duration(-6, MINUTE), 15)));
+    @Test
+    void precomputed_with_multiple_transition_in_past_uses_last_value_forever() {
+        assertEquals(5, currentValue(precomputedWithMultipleTransitionsInPast));
+        delay(HOUR);
+        assertEquals(5, currentValue(precomputedWithMultipleTransitionsInPast));
+        delay(HOUR);
+        assertEquals(5, currentValue(precomputedWithMultipleTransitionsInPast));
+    }
+
+    final Resource<Discrete<Integer>> precomputedWithTransitionsInPastAndFuture =
+            precomputed(0, new TreeMap<>(Map.of(
+                    duration(-5, MINUTE), 25,
+                    duration(-2, MINUTE), 5,
+                    duration(5, MINUTE), 10,
+                    duration(6, MINUTE), 15)));
+    @Test
+    void precomputed_with_transitions_in_past_and_future_chooses_starting_value_and_changes_later() {
+        assertEquals(5, currentValue(precomputedWithTransitionsInPastAndFuture));
+        assertTransition(precomputedWithTransitionsInPastAndFuture, duration(5, MINUTE), 10);
+        assertTransition(precomputedWithTransitionsInPastAndFuture, duration(1, MINUTE), 15);
+        delay(HOUR);
+        assertEquals(15, currentValue(precomputedWithTransitionsInPastAndFuture));
+        delay(HOUR);
+        assertEquals(15, currentValue(precomputedWithTransitionsInPastAndFuture));
+    }
+
+    final Resource<Discrete<Integer>> precomputedWithInstantKeys =
+            precomputed(0, new TreeMap<>(Map.of(
+                    Instant.parse("2023-10-17T23:55:00Z"), 25,
+                    Instant.parse("2023-10-17T23:58:00Z"), 5,
+                    Instant.parse("2023-10-18T00:05:00Z"), 10,
+                    Instant.parse("2023-10-18T00:06:00Z"), 15)),
+                    Instant.parse("2023-10-18T00:00:00Z"));
+    @Test
+    void precomputed_with_instant_keys_behaves_identically_to_equivalent_duration_offsets() {
+        assertEquals(5, currentValue(precomputedWithInstantKeys));
+        assertTransition(precomputedWithInstantKeys, duration(5, MINUTE), 10);
+        assertTransition(precomputedWithInstantKeys, duration(1, MINUTE), 15);
+        delay(HOUR);
+        assertEquals(15, currentValue(precomputedWithInstantKeys));
+        delay(HOUR);
+        assertEquals(15, currentValue(precomputedWithInstantKeys));
+    }
+
+    private <A> void assertTransition(Resource<Discrete<A>> resource, Duration transitionDelay, A expectedValue) {
+        A startValue = currentValue(resource);
+        delay(transitionDelay.minus(EPSILON));
+        assertEquals(startValue, currentValue(resource));
+        delay(EPSILON);
+        assertEquals(expectedValue, currentValue(resource));
+    }
+}