mstlo-python 0.2.1__tar.gz → 0.2.2__tar.gz

{mstlo_python-0.2.1 → mstlo_python-0.2.2}/Cargo.lock

@@ -594,7 +594,7 @@ dependencies = [
 
 [[package]]
 name = "mstlo"
-version = "0.2.1"
+version = "0.2.2"
 dependencies = [
  "criterion",
  "csv",
@@ -612,7 +612,7 @@ dependencies = [
 
 [[package]]
 name = "mstlo-macros"
-version = "0.2.1"
+version = "0.2.2"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -621,7 +621,7 @@ dependencies = [
 
 [[package]]
 name = "mstlo-python"
-version = "0.2.1"
+version = "0.2.2"
 dependencies = [
  "mstlo",
  "pyo3",

{mstlo_python-0.2.1 → mstlo_python-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mstlo-python
-Version: 0.2.1
+Version: 0.2.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9

{mstlo_python-0.2.1 → mstlo_python-0.2.2}/mstlo/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mstlo"
-version = "0.2.1"
+version = "0.2.2"
 edition = "2024"
 description = "A Rust library for online monitoring of Signal Temporal Logic (STL) specifications."
 license-file = "LICENSE"
@@ -13,7 +13,7 @@ categories = ["science", "mathematics"]
 
 [dependencies]
 dyn-clone = "1.0.20"
-mstlo-macros = { version = "0.2.1", path = "mstlo-macros" }
+mstlo-macros = { version = "0.2.2", path = "mstlo-macros" }
 
 [dev-dependencies]
 proptest = "1.11.0"

{mstlo_python-0.2.1 → mstlo_python-0.2.2}/mstlo/mstlo-macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mstlo-macros"
-version = "0.2.1"
+version = "0.2.2"
 edition = "2024"
 description = "Procedural macros for the mstlo online Signal Temporal Logic (STL) monitoring library."
 license-file = "LICENSE"

{mstlo_python-0.2.1 → mstlo_python-0.2.2}/mstlo/src/core.rs

@@ -68,15 +68,6 @@ pub trait StlOperatorTrait<T: Clone>: DynClone + Display + SignalIdentifier {
     /// The default implementation is a no-op, suitable for stateless operators like `Atomic`.
     fn reset(&mut self) {}
 
-    /// The timestamp through which this operator's output stream is gap-free, or `None`
-    /// if it has no gaps.
-    ///
-    /// Eager `And`/`Or` can emit ahead of an earlier breakpoint that arrives later.
-    /// Consumers only close windows up to this bound.
-    fn known_through(&self) -> Option<Duration> {
-        None
-    }
-
     /// Returns estimated total memory (stack + heap) in bytes consumed by this
     /// operator and all its children recursively.
     ///

{mstlo_python-0.2.1 → mstlo_python-0.2.2}/mstlo/src/operators/binary_operators.rs

@@ -10,7 +10,7 @@ use crate::core::{
     Reach, RobustnessSemantics, SignalIdentifier, StlOperatorAndSignalIdentifier, StlOperatorTrait,
 };
 use crate::ring_buffer::{RingBufferTrait, Step, guarded_prune};
-use std::collections::{HashSet, VecDeque};
+use std::collections::HashSet;
 use std::fmt::{Debug, Display};
 use std::time::Duration;
 
@@ -19,16 +19,47 @@ fn joint_frontier(left: Option<Duration>, right: Option<Duration>) -> Option<Dur
     Some(left?.min(right?))
 }
 
-/// Caps a frontier by what the operand reports as gap-free; see
-/// [`StlOperatorTrait::known_through`].
+/// How far eager output is settled: the joint frontier, extended for as long as the
+/// leading operand holds `short_circuit_val` without interruption from there on.
 ///
-/// This bound can decrease, so apply it after taking the max with the newest emitted
-/// timestamp.
-fn clamp_to_known(frontier: Option<Duration>, known: Option<Duration>) -> Option<Duration> {
-    match known {
-        Some(bound) => Some(frontier?.min(bound)),
-        None => frontier,
+/// The lagging operand cannot change the output over that stretch.
+fn eager_known_through<C, Y>(
+    left: (&C, Option<Duration>),
+    right: (&C, Option<Duration>),
+    short_circuit_val: Y,
+) -> Option<Duration>
+where
+    C: RingBufferTrait<Value = Y>,
+    Y: PartialEq,
+{
+    let (cache, frontier) = if left.1 > right.1 { left } else { right };
+    // Until the lagging operand reports at all, the stretch starts at the leading
+    // operand's first entry: nothing is pruned before then, and the output is undefined
+    // earlier.
+    let joint = joint_frontier(left.1, right.1).or_else(|| {
+        cache
+            .iter()
+            .next()
+            .filter(|entry| entry.value == short_circuit_val)
+            .map(|entry| entry.timestamp)
+    })?;
+    let held_at_joint = cache
+        .partition_point(|entry| entry.timestamp <= joint)
+        .saturating_sub(1);
+
+    let mut known = joint;
+    let mut covered = joint;
+    for entry in cache.iter().skip(held_at_joint) {
+        if entry.timestamp > covered
+            || Some(entry.timestamp) > frontier
+            || entry.value != short_circuit_val
+        {
+            break;
+        }
+        known = known.max(entry.timestamp);
+        covered = entry.held_until;
     }
+    Some(known)
 }
 
 /// Whether `ts` lies inside the region both operands have reported on.
@@ -38,14 +69,13 @@ fn within(joint: Option<Duration>, ts: Duration) -> bool {
 
 /// Settles the emission watermark for eager mode after a batch of output.
 ///
-/// Advances it to the newest output at or below the joint frontier. Timestamps
-/// short-circuited past that frontier are recorded separately, since the lagging operand
-/// can still deliver an earlier breakpoint.
+/// Advances it to the newest output at or below the joint frontier. Outputs
+/// short-circuited past that frontier do not move it, since the lagging operand still has
+/// to be read there.
 fn settle_eager_watermark<Y>(
     output: &[Step<Y>],
     joint: Option<Duration>,
     last_eval_time: &mut Option<Duration>,
-    answered_beyond_joint: &mut VecDeque<Duration>,
 ) {
     if let Some(eval_time) = output
         .iter()
@@ -54,18 +84,6 @@ fn settle_eager_watermark<Y>(
     {
         *last_eval_time = Some(eval_time);
     }
-
-    answered_beyond_joint.extend(
-        output
-            .iter()
-            .map(|step| step.timestamp)
-            .filter(|ts| !within(joint, *ts)),
-    );
-
-    // Timestamps the watermark has caught up with no longer need tracking.
-    if let Some(last) = *last_eval_time {
-        answered_beyond_joint.retain(|ts| *ts > last);
-    }
 }
 
 /// One side of a binary operator: the cache of what that operand has emitted.
@@ -73,14 +91,22 @@ struct Operand<'a, C> {
     cache: &'a C,
     /// Newest timestamp the operand has produced a value for.
     frontier: Option<Duration>,
-    /// The operand's [`StlOperatorTrait::get_max_lookahead`].
-    lookahead: Duration,
+    /// Newest timestamp the operand has produced a *final* value for. Under RoSI a
+    /// non-final interval may still be refined, so a held value past this mark is
+    /// re-masked (see [`read_operand`]).
+    settled: Option<Duration>,
+    /// The operand's [`StlOperatorTrait::reach`], used to mask RoSI bounds.
+    reach: Reach,
 }
 
 /// Reads the operand's value at `ts` from its cache under zero-order hold.
 ///
-/// `None` past the operand's frontier. Under RoSI, a `ts` within `lookahead` of the
-/// frontier may still be refined and reads as [`RobustnessSemantics::unknown`].
+/// `None` past the operand's frontier. Under RoSI, a value held from an earlier entry
+/// (`entry.timestamp < ts`) is only trusted where the operand has settled; past that
+/// mark its bounds whose [`Reach`] lag has not elapsed are widened to
+/// [`RobustnessSemantics::unknown`]. A fresh emission at `ts`, or one within the settled
+/// region, is used as-is, so a settled bound (e.g. a positive `F` lower bound read by an
+/// `or`) is never discarded.
 ///
 /// `newest` is the operand's newest entry at or before `ts`, tracked by the caller's walk.
 fn read_operand<C, Y, const IS_ROSI: bool>(
@@ -92,19 +118,12 @@ where
     C: RingBufferTrait<Value = Y>,
     Y: RobustnessSemantics + Copy,
 {
-    if !within(operand.frontier, ts) {
-        return None;
-    }
-    if IS_ROSI
-        && operand
-            .frontier
-            .is_some_and(|bound| ts + operand.lookahead > bound)
-    {
-        return Some(Y::unknown());
+    let frontier = operand.frontier.filter(|bound| ts <= *bound)?;
+    let entry = newest.filter(|entry| entry.held_until > ts)?;
+    if IS_ROSI && entry.timestamp < ts && operand.settled.is_none_or(|settled| ts > settled) {
+        return Some(operand.reach.mask(entry.value, ts, frontier));
     }
-    newest
-        .filter(|entry| entry.held_until > ts)
-        .map(|entry| entry.value)
+    Some(entry.value)
 }
 
 /// A unified binary processor that handles Delayed, Eager, and Refinable (RoSI) semantics correctly.
@@ -113,7 +132,8 @@ where
 /// operand under zero-order hold.
 ///
 /// A timestamp is answered once both operands are known there. Eager mode may also
-/// short-circuit on one operand alone past the joint frontier, in timestamp order.
+/// short-circuit on one operand alone past the joint frontier, but only as far as
+/// [`eager_known_through`], so output is always emitted in timestamp order.
 fn process_binary<C, Y, F, const IS_EAGER: bool, const IS_ROSI: bool>(
     left: &Operand<'_, C>,
     right: &Operand<'_, C>,
@@ -137,6 +157,16 @@ where
     let Some(horizon) = horizon else {
         return output_robustness;
     };
+    // Eager only short-circuits past the joint frontier over this stretch, so the lagging
+    // operand can never deliver a breakpoint that changes an earlier output.
+    let settled = match short_circuit_val {
+        Some(value) if IS_EAGER && !IS_ROSI => eager_known_through(
+            (left.cache, left.frontier),
+            (right.cache, right.frontier),
+            value,
+        ),
+        _ => None,
+    };
 
     // Skip breakpoints already answered. RoSI passes `None`, since it refines past outputs.
     let l_skip = start_after.map_or(0, |ts| {
@@ -182,7 +212,7 @@ where
             (Some(_), None) | (None, Some(_)) if joint.is_some_and(|frontier| ts <= frontier) => {}
             // Eager past the joint frontier: short-circuit if possible, otherwise wait.
             (Some(value), None) | (None, Some(value)) => {
-                if short_circuit_val != Some(value) {
+                if short_circuit_val != Some(value) || settled.is_none_or(|bound| ts > bound) {
                     break;
                 }
                 output_robustness.push(Step::new("output", value, ts));
@@ -204,12 +234,14 @@ pub struct And<T, C, Y, const IS_EAGER: bool, const IS_ROSI: bool> {
     left_cache: C,
     right_cache: C,
     last_eval_time: Option<Duration>,
-    /// Timestamps eager answered ahead of the joint frontier; see
-    /// [`settle_eager_watermark`].
-    answered_beyond_joint: VecDeque<Duration>,
     /// Newest timestamp each operand has produced a value for.
     left_frontier: Option<Duration>,
     right_frontier: Option<Duration>,
+    /// Newest timestamp each operand has produced a *final* value for.
+    left_settled: Option<Duration>,
+    right_settled: Option<Duration>,
+    /// Eager only: see [`eager_known_through`].
+    known: Option<Duration>,
     left_signals_set: HashSet<&'static str>,
     right_signals_set: HashSet<&'static str>,
     max_lookahead: Duration,
@@ -237,9 +269,11 @@ impl<T, C, Y, const IS_EAGER: bool, const IS_ROSI: bool> And<T, C, Y, IS_EAGER,
             left_cache: left_cache.unwrap_or_else(|| C::new()),
             right_cache: right_cache.unwrap_or_else(|| C::new()),
             last_eval_time: None,
-            answered_beyond_joint: VecDeque::new(),
             left_frontier: None,
             right_frontier: None,
+            left_settled: None,
+            right_settled: None,
+            known: None,
             left_signals_set: HashSet::new(),
             right_signals_set: HashSet::new(),
             max_lookahead,
@@ -264,19 +298,10 @@ where
         self.left.reach().join(self.right.reach())
     }
 
-    /// Eager output is gap-free up to the joint frontier. Other modes have no gaps.
-    fn known_through(&self) -> Option<Duration> {
-        if !IS_EAGER || IS_ROSI {
-            return None;
-        }
-        Some(joint_frontier(self.left_frontier, self.right_frontier).unwrap_or(Duration::ZERO))
-    }
-
     fn total_size(&self) -> usize {
         std::mem::size_of::<Self>()
             + self.left_cache.heap_size()
             + self.right_cache.heap_size()
-            + self.answered_beyond_joint.capacity() * std::mem::size_of::<Duration>()
             + self.left_signals_set.capacity() * (std::mem::size_of::<&str>() + 1)
             + self.right_signals_set.capacity() * (std::mem::size_of::<&str>() + 1)
             + self.left.total_size()
@@ -287,9 +312,11 @@ where
         self.left_cache.clear();
         self.right_cache.clear();
         self.last_eval_time = None;
-        self.answered_beyond_joint.clear();
         self.left_frontier = None;
         self.right_frontier = None;
+        self.left_settled = None;
+        self.right_settled = None;
+        self.known = None;
         self.left.reset();
         self.right.reset();
     }
@@ -324,8 +351,10 @@ where
         if let Some(last) = left_updates.last() {
             self.left_frontier = self.left_frontier.max(Some(last.timestamp));
         }
-        self.left_frontier = clamp_to_known(self.left_frontier, self.left.known_through());
         for update in &left_updates {
+            if update.value.is_final() {
+                self.left_settled = self.left_settled.max(Some(update.timestamp));
+            }
             if check_relevance(update.timestamp, self.last_eval_time)
                 && !self.left_cache.update_step(update.clone())
             {
@@ -344,8 +373,10 @@ where
         if let Some(last) = right_updates.last() {
             self.right_frontier = self.right_frontier.max(Some(last.timestamp));
         }
-        self.right_frontier = clamp_to_known(self.right_frontier, self.right.known_through());
         for update in &right_updates {
+            if update.value.is_final() {
+                self.right_settled = self.right_settled.max(Some(update.timestamp));
+            }
             if check_relevance(update.timestamp, self.last_eval_time)
                 && !self.right_cache.update_step(update.clone())
             {
@@ -358,12 +389,14 @@ where
             &Operand {
                 cache: &self.left_cache,
                 frontier: self.left_frontier,
-                lookahead: self.left.get_max_lookahead(),
+                settled: self.left_settled,
+                reach: self.left.reach(),
             },
             &Operand {
                 cache: &self.right_cache,
                 frontier: self.right_frontier,
-                lookahead: self.right.get_max_lookahead(),
+                settled: self.right_settled,
+                reach: self.right.reach(),
             },
             if IS_ROSI { None } else { self.last_eval_time },
             Y::and,
@@ -375,13 +408,17 @@ where
             output.retain(|step| step.timestamp > last_time);
         }
 
-        // Drop repeats of timestamps already short-circuited beyond the joint frontier.
-        if IS_EAGER && !IS_ROSI && !self.answered_beyond_joint.is_empty() {
-            output.retain(|step| !self.answered_beyond_joint.contains(&step.timestamp));
-        }
-
         let lookahead = self.get_max_lookahead();
         let joint = joint_frontier(self.left_frontier, self.right_frontier);
+        if IS_EAGER && !IS_ROSI {
+            // A late breakpoint inside the settled stretch repeats the held value.
+            output.retain(|step| self.known.is_none_or(|known| step.timestamp > known));
+            self.known = eager_known_through(
+                (&self.left_cache, self.left_frontier),
+                (&self.right_cache, self.right_frontier),
+                Y::atomic_false(),
+            );
+        }
 
         // we protect up to the minimum of the last known timestamps minus lookahead
         // we can safely prune it if both sides have verdict and are beyond lookahead
@@ -397,12 +434,7 @@ where
                 self.last_eval_time = Some(eval_time);
             }
         } else if IS_EAGER {
-            settle_eager_watermark(
-                &output,
-                joint,
-                &mut self.last_eval_time,
-                &mut self.answered_beyond_joint,
-            );
+            settle_eager_watermark(&output, joint, &mut self.last_eval_time);
         } else {
             // For delayed/bool, we track the *end* because everything before is finalized
             if let Some(eval_time) = output.last().map(|step| step.timestamp) {
@@ -440,12 +472,14 @@ pub struct Or<T, C, Y, const IS_EAGER: bool, const IS_ROSI: bool> {
     left_cache: C,
     right_cache: C,
     last_eval_time: Option<Duration>,
-    /// Timestamps eager answered ahead of the joint frontier; see
-    /// [`settle_eager_watermark`].
-    answered_beyond_joint: VecDeque<Duration>,
     /// Newest timestamp each operand has produced a value for.
     left_frontier: Option<Duration>,
     right_frontier: Option<Duration>,
+    /// Newest timestamp each operand has produced a *final* value for.
+    left_settled: Option<Duration>,
+    right_settled: Option<Duration>,
+    /// Eager only: see [`eager_known_through`].
+    known: Option<Duration>,
     left_signals_set: HashSet<&'static str>,
     right_signals_set: HashSet<&'static str>,
     max_lookahead: Duration,
@@ -473,9 +507,11 @@ impl<T, C, Y, const IS_EAGER: bool, const IS_ROSI: bool> Or<T, C, Y, IS_EAGER, I
             left_cache: left_cache.unwrap_or_else(|| C::new()),
             right_cache: right_cache.unwrap_or_else(|| C::new()),
             last_eval_time: None,
-            answered_beyond_joint: VecDeque::new(),
             left_frontier: None,
             right_frontier: None,
+            left_settled: None,
+            right_settled: None,
+            known: None,
             left_signals_set: HashSet::new(),
             right_signals_set: HashSet::new(),
             max_lookahead,
@@ -500,19 +536,10 @@ where
         self.left.reach().join(self.right.reach())
     }
 
-    /// Eager output is gap-free up to the joint frontier. Other modes have no gaps.
-    fn known_through(&self) -> Option<Duration> {
-        if !IS_EAGER || IS_ROSI {
-            return None;
-        }
-        Some(joint_frontier(self.left_frontier, self.right_frontier).unwrap_or(Duration::ZERO))
-    }
-
     fn total_size(&self) -> usize {
         std::mem::size_of::<Self>()
             + self.left_cache.heap_size()
             + self.right_cache.heap_size()
-            + self.answered_beyond_joint.capacity() * std::mem::size_of::<Duration>()
             + self.left_signals_set.capacity() * (std::mem::size_of::<&str>() + 1)
             + self.right_signals_set.capacity() * (std::mem::size_of::<&str>() + 1)
             + self.left.total_size()
@@ -523,9 +550,11 @@ where
         self.left_cache.clear();
         self.right_cache.clear();
         self.last_eval_time = None;
-        self.answered_beyond_joint.clear();
         self.left_frontier = None;
         self.right_frontier = None;
+        self.left_settled = None;
+        self.right_settled = None;
+        self.known = None;
         self.left.reset();
         self.right.reset();
     }
@@ -560,8 +589,10 @@ where
         if let Some(last) = left_updates.last() {
             self.left_frontier = self.left_frontier.max(Some(last.timestamp));
         }
-        self.left_frontier = clamp_to_known(self.left_frontier, self.left.known_through());
         for update in &left_updates {
+            if update.value.is_final() {
+                self.left_settled = self.left_settled.max(Some(update.timestamp));
+            }
             if check_relevance(update.timestamp, self.last_eval_time)
                 && !self.left_cache.update_step(update.clone())
             {
@@ -580,8 +611,10 @@ where
         if let Some(last) = right_updates.last() {
             self.right_frontier = self.right_frontier.max(Some(last.timestamp));
         }
-        self.right_frontier = clamp_to_known(self.right_frontier, self.right.known_through());
         for update in &right_updates {
+            if update.value.is_final() {
+                self.right_settled = self.right_settled.max(Some(update.timestamp));
+            }
             if check_relevance(update.timestamp, self.last_eval_time)
                 && !self.right_cache.update_step(update.clone())
             {
@@ -594,12 +627,14 @@ where
             &Operand {
                 cache: &self.left_cache,
                 frontier: self.left_frontier,
-                lookahead: self.left.get_max_lookahead(),
+                settled: self.left_settled,
+                reach: self.left.reach(),
             },
             &Operand {
                 cache: &self.right_cache,
                 frontier: self.right_frontier,
-                lookahead: self.right.get_max_lookahead(),
+                settled: self.right_settled,
+                reach: self.right.reach(),
             },
             if IS_ROSI { None } else { self.last_eval_time },
             Y::or,
@@ -611,13 +646,17 @@ where
             output.retain(|step| step.timestamp > last_time);
         }
 
-        // Drop repeats of timestamps already short-circuited beyond the joint frontier.
-        if IS_EAGER && !IS_ROSI && !self.answered_beyond_joint.is_empty() {
-            output.retain(|step| !self.answered_beyond_joint.contains(&step.timestamp));
-        }
-
         let lookahead = self.get_max_lookahead();
         let joint = joint_frontier(self.left_frontier, self.right_frontier);
+        if IS_EAGER && !IS_ROSI {
+            // A late breakpoint inside the settled stretch repeats the held value.
+            output.retain(|step| self.known.is_none_or(|known| step.timestamp > known));
+            self.known = eager_known_through(
+                (&self.left_cache, self.left_frontier),
+                (&self.right_cache, self.right_frontier),
+                Y::atomic_true(),
+            );
+        }
 
         // we protect up to the minimum of the last known timestamps minus lookahead
         // we can safely prune it if both sides have verdict and are beyond lookahead
@@ -633,12 +672,7 @@ where
                 self.last_eval_time = Some(eval_time);
             }
         } else if IS_EAGER {
-            settle_eager_watermark(
-                &output,
-                joint,
-                &mut self.last_eval_time,
-                &mut self.answered_beyond_joint,
-            );
+            settle_eager_watermark(&output, joint, &mut self.last_eval_time);
         } else {
             // For delayed/bool, we track the *end* because everything before is finalized
             if let Some(eval_time) = output.last().map(|step| step.timestamp) {

{mstlo_python-0.2.1 → mstlo_python-0.2.2}/mstlo/src/operators/not_operator.rs

@@ -58,11 +58,6 @@ where
         self.operand.reset();
     }
 
-    /// Negation is pointwise, so this stream has exactly the operand's holes.
-    fn known_through(&self) -> Option<Duration> {
-        self.operand.known_through()
-    }
-
     /// Updates the child operator and negates each produced value.
     fn update(&mut self, step: &Step<T>) -> Vec<Step<Self::Output>> {
         let operand_updates = self.operand.update(step);