global: averages + ratio datasets

crates/brk_core/src/structs/cents.rs

@@ -1,4 +1,4 @@
-use std::ops::{Add, Div};
+use std::ops::{Add, Div, Mul};
 
 use serde::Serialize;
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
@@ -74,3 +74,10 @@ impl From<Cents> for u128 {
         value.0 as u128
     }
 }
+
+impl Mul<Cents> for Cents {
+    type Output = Cents;
+    fn mul(self, rhs: Cents) -> Self::Output {
+        Self(self.0 * rhs.0)
+    }
+}

crates/brk_core/src/structs/date.rs

@@ -14,6 +14,7 @@ impl Date {
     pub const INDEX_ZERO_: Date_ = Date_::constant(2009, 1, 3);
     pub const INDEX_ONE: Self = Self(20090109);
     pub const INDEX_ONE_: Date_ = Date_::constant(2009, 1, 9);
+    pub const MIN_RATIO: Self = Self(20120101);
 
     pub fn new(year: u16, month: u8, day: u8) -> Self {
         Self(year as u32 * 1_00_00 + month as u32 * 1_00 + day as u32)

crates/brk_core/src/structs/dollars.rs

@@ -1,10 +1,13 @@
-use std::ops::{Add, Div, Mul};
+use std::{
+    f64,
+    ops::{Add, Div, Mul},
+};
 
 use derive_deref::Deref;
 use serde::Serialize;
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
-use super::{Bitcoin, Cents, Close, Sats};
+use super::{Bitcoin, Cents, Close, Sats, StoredF32};
 
 #[derive(
     Debug,
@@ -75,6 +78,13 @@ impl Add for Dollars {
     }
 }
 
+impl Div<Dollars> for Dollars {
+    type Output = StoredF32;
+    fn div(self, rhs: Dollars) -> Self::Output {
+        StoredF32::from((self.0 / rhs.0) as f32)
+    }
+}
+
 impl Div<usize> for Dollars {
     type Output = Self;
     fn div(self, rhs: usize) -> Self::Output {
@@ -100,6 +110,17 @@ impl Mul<Bitcoin> for Dollars {
     }
 }
 
+impl Mul<StoredF32> for Dollars {
+    type Output = Self;
+    fn mul(self, rhs: StoredF32) -> Self::Output {
+        if rhs.is_nan() {
+            Self(f64::NAN)
+        } else {
+            Self::from(Cents::from(Self::from(self.0 * *rhs as f64)))
+        }
+    }
+}
+
 impl From<u128> for Dollars {
     fn from(value: u128) -> Self {
         Self::from(Cents::from(value))

crates/brk_core/src/structs/mod.rs

@@ -24,6 +24,7 @@ mod outputtypeindex;
 mod quarterindex;
 mod rawlocktime;
 mod sats;
+mod stored_f32;
 mod stored_f64;
 mod stored_u32;
 mod stored_u64;
@@ -67,6 +68,7 @@ pub use outputtypeindex::*;
 pub use quarterindex::*;
 pub use rawlocktime::*;
 pub use sats::*;
+pub use stored_f32::*;
 pub use stored_f64::*;
 pub use stored_u8::*;
 pub use stored_u32::*;
@@ -83,3 +85,5 @@ pub use vout::*;
 pub use weekindex::*;
 pub use weight::*;
 pub use yearindex::*;
+
+pub use rlimit;

crates/brk_core/src/structs/stored_f32.rs

@@ -0,0 +1,106 @@
+use std::ops::{Add, Div, Mul, Sub};
+
+use derive_deref::Deref;
+use serde::Serialize;
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::CheckedSub;
+
+use super::Dollars;
+
+#[derive(
+    Debug,
+    Deref,
+    Default,
+    Clone,
+    Copy,
+    PartialEq,
+    PartialOrd,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct StoredF32(f32);
+
+impl From<f32> for StoredF32 {
+    fn from(value: f32) -> Self {
+        Self(value)
+    }
+}
+
+impl From<f64> for StoredF32 {
+    fn from(value: f64) -> Self {
+        Self(value as f32)
+    }
+}
+
+impl From<usize> for StoredF32 {
+    fn from(value: usize) -> Self {
+        Self(value as f32)
+    }
+}
+
+impl CheckedSub<StoredF32> for StoredF32 {
+    fn checked_sub(self, rhs: Self) -> Option<Self> {
+        Some(Self(self.0 - rhs.0))
+    }
+}
+
+impl Div<usize> for StoredF32 {
+    type Output = Self;
+    fn div(self, rhs: usize) -> Self::Output {
+        Self(self.0 / rhs as f32)
+    }
+}
+
+impl Add for StoredF32 {
+    type Output = Self;
+    fn add(self, rhs: Self) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}
+
+impl From<StoredF32> for f32 {
+    fn from(value: StoredF32) -> Self {
+        value.0
+    }
+}
+
+impl Eq for StoredF32 {}
+
+#[allow(clippy::derive_ord_xor_partial_ord)]
+impl Ord for StoredF32 {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.0.partial_cmp(&other.0).unwrap()
+    }
+}
+
+impl Div<Dollars> for StoredF32 {
+    type Output = Self;
+    fn div(self, rhs: Dollars) -> Self::Output {
+        Self::from(self.0 as f64 / *rhs)
+    }
+}
+
+impl Mul<usize> for StoredF32 {
+    type Output = Self;
+    fn mul(self, rhs: usize) -> Self::Output {
+        Self(self.0 * rhs as f32)
+    }
+}
+
+impl Mul<StoredF32> for usize {
+    type Output = StoredF32;
+    fn mul(self, rhs: StoredF32) -> Self::Output {
+        StoredF32(self as f32 * rhs.0)
+    }
+}
+
+impl Sub<StoredF32> for StoredF32 {
+    type Output = Self;
+    fn sub(self, rhs: StoredF32) -> Self::Output {
+        Self(self.0 - rhs.0)
+    }
+}