global: snapshot

crates/brk_computer/src/internal/multi/from_height/distribution.rs

@@ -0,0 +1,82 @@
+//! ComputedFromHeight using Distribution aggregation (no sum/cumulative).
+//!
+//! Use for block-based metrics where sum/cumulative would be misleading
+//! (e.g., activity counts that can't be deduplicated across blocks).
+
+use brk_error::Result;
+
+use brk_traversable::Traversable;
+use brk_types::{Height, Version};
+use derive_more::{Deref, DerefMut};
+use schemars::JsonSchema;
+use vecdb::{Database, EagerVec, Exit, ImportableVec, IterableCloneableVec, PcoVec};
+
+use crate::{ComputeIndexes, indexes};
+
+use crate::internal::{ComputedHeightDerivedDistribution, ComputedVecValue, NumericValue};
+
+#[derive(Clone, Deref, DerefMut, Traversable)]
+#[traversable(merge)]
+pub struct ComputedFromHeightDistribution<T>
+where
+    T: ComputedVecValue + PartialOrd + JsonSchema,
+{
+    #[traversable(rename = "base")]
+    pub height: EagerVec<PcoVec<Height, T>>,
+    #[deref]
+    #[deref_mut]
+    pub rest: ComputedHeightDerivedDistribution<T>,
+}
+
+const VERSION: Version = Version::ZERO;
+
+impl<T> ComputedFromHeightDistribution<T>
+where
+    T: NumericValue + JsonSchema,
+{
+    pub fn forced_import(
+        db: &Database,
+        name: &str,
+        version: Version,
+        indexes: &indexes::Vecs,
+    ) -> Result<Self> {
+        let v = version + VERSION;
+
+        let height: EagerVec<PcoVec<Height, T>> = EagerVec::forced_import(db, name, v)?;
+
+        let rest = ComputedHeightDerivedDistribution::forced_import(
+            db,
+            name,
+            height.boxed_clone(),
+            v,
+            indexes,
+        )?;
+
+        Ok(Self { height, rest })
+    }
+
+    pub fn compute_all<F>(
+        &mut self,
+        indexes: &indexes::Vecs,
+        starting_indexes: &ComputeIndexes,
+        exit: &Exit,
+        mut compute: F,
+    ) -> Result<()>
+    where
+        F: FnMut(&mut EagerVec<PcoVec<Height, T>>) -> Result<()>,
+    {
+        compute(&mut self.height)?;
+        self.compute_rest(indexes, starting_indexes, exit)
+    }
+
+    /// Compute rest from self.height (for stateful computation patterns).
+    pub fn compute_rest(
+        &mut self,
+        indexes: &indexes::Vecs,
+        starting_indexes: &ComputeIndexes,
+        exit: &Exit,
+    ) -> Result<()> {
+        self.rest
+            .derive_from(indexes, starting_indexes, &self.height, exit)
+    }
+}

crates/brk_computer/src/internal/multi/from_height/lazy_binary_computed_distribution.rs

@@ -0,0 +1,74 @@
+//! LazyBinaryComputedFromHeightDistribution - lazy binary transform with distribution stats.
+//!
+//! Height-level values are lazy: `transform(source1[h], source2[h])`.
+//! Uses Distribution aggregation (no sum/cumulative) - appropriate for ratios.
+
+use brk_error::Result;
+use brk_traversable::Traversable;
+use brk_types::{Height, Version};
+use derive_more::{Deref, DerefMut};
+use schemars::JsonSchema;
+use vecdb::{BinaryTransform, Database, Exit, IterableBoxedVec, IterableCloneableVec, LazyVecFrom2};
+
+use crate::{
+    ComputeIndexes, indexes,
+    internal::{ComputedHeightDerivedDistribution, ComputedVecValue, NumericValue},
+};
+
+const VERSION: Version = Version::ZERO;
+
+/// Lazy binary transform at height with distribution stats (no sum/cumulative).
+#[derive(Clone, Deref, DerefMut, Traversable)]
+#[traversable(merge)]
+pub struct LazyBinaryComputedFromHeightDistribution<T, S1T = T, S2T = T>
+where
+    T: ComputedVecValue + PartialOrd + JsonSchema,
+    S1T: ComputedVecValue,
+    S2T: ComputedVecValue,
+{
+    #[traversable(rename = "base")]
+    pub height: LazyVecFrom2<Height, T, Height, S1T, Height, S2T>,
+    #[deref]
+    #[deref_mut]
+    pub rest: ComputedHeightDerivedDistribution<T>,
+}
+
+impl<T, S1T, S2T> LazyBinaryComputedFromHeightDistribution<T, S1T, S2T>
+where
+    T: NumericValue + JsonSchema,
+    S1T: ComputedVecValue + JsonSchema,
+    S2T: ComputedVecValue + JsonSchema,
+{
+    pub fn forced_import<F: BinaryTransform<S1T, S2T, T>>(
+        db: &Database,
+        name: &str,
+        version: Version,
+        source1: IterableBoxedVec<Height, S1T>,
+        source2: IterableBoxedVec<Height, S2T>,
+        indexes: &indexes::Vecs,
+    ) -> Result<Self> {
+        let v = version + VERSION;
+
+        let height = LazyVecFrom2::transformed::<F>(name, v, source1, source2);
+
+        let rest = ComputedHeightDerivedDistribution::forced_import(
+            db,
+            name,
+            height.boxed_clone(),
+            v,
+            indexes,
+        )?;
+
+        Ok(Self { height, rest })
+    }
+
+    pub fn derive_from(
+        &mut self,
+        indexes: &indexes::Vecs,
+        starting_indexes: &ComputeIndexes,
+        exit: &Exit,
+    ) -> Result<()> {
+        self.rest
+            .derive_from(indexes, starting_indexes, &self.height, exit)
+    }
+}

crates/brk_computer/src/internal/multi/from_height/mod.rs

@@ -2,11 +2,13 @@ mod binary_full;
 mod binary_last;
 mod binary_sum;
 mod binary_sum_cum;
+mod distribution;
 mod full;
 mod last;
 mod lazy_distribution;
 mod lazy_full;
 mod lazy_transform_distribution;
+mod lazy_binary_computed_distribution;
 mod lazy_binary_computed_full;
 mod lazy_binary_computed_last;
 mod lazy_binary_computed_sum;
@@ -35,11 +37,13 @@ pub use binary_full::*;
 pub use binary_last::*;
 pub use binary_sum::*;
 pub use binary_sum_cum::*;
+pub use distribution::*;
 pub use full::*;
 pub use last::*;
 pub use lazy_distribution::*;
 pub use lazy_full::*;
 pub use lazy_transform_distribution::*;
+pub use lazy_binary_computed_distribution::*;
 pub use lazy_binary_computed_full::*;
 pub use lazy_binary_computed_last::*;
 pub use lazy_binary_computed_sum::*;