global: adding semester + making coarser intervals computed instead of eager

crates/brk_core/src/structs/bitcoin.rs

@@ -1,6 +1,6 @@
 use std::{
     cmp::Ordering,
-    ops::{Add, Div, Mul},
+    ops::{Add, AddAssign, Div, Mul},
 };
 
 use serde::Serialize;
@@ -20,6 +20,12 @@ impl Add for Bitcoin {
     }
 }
 
+impl AddAssign for Bitcoin {
+    fn add_assign(&mut self, rhs: Self) {
+        *self = *self + rhs
+    }
+}
+
 impl Mul for Bitcoin {
     type Output = Self;
     fn mul(self, rhs: Self) -> Self::Output {

crates/brk_core/src/structs/date.rs

@@ -31,6 +31,10 @@ impl Date {
     pub fn day(&self) -> u8 {
         (self.0 % 1_00) as u8
     }
+
+    pub fn into_jiff(self) -> Date_ {
+        self.into()
+    }
 }
 
 impl Default for Date {

crates/brk_core/src/structs/dateindex.rs

@@ -3,11 +3,14 @@ use std::{
     ops::{Add, Rem},
 };
 
+use jiff::Span;
 use serde::Serialize;
-// use color_eyre::eyre::eyre;
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
-use crate::{CheckedSub, Error, Printable};
+use crate::{
+    CheckedSub, DecadeIndex, Error, FromCoarserIndex, MonthIndex, Printable, QuarterIndex,
+    SemesterIndex, WeekIndex, YearIndex,
+};
 
 use super::Date;
 
@@ -103,3 +106,135 @@ impl Printable for DateIndex {
         &["d", "date", "dateindex"]
     }
 }
+
+impl FromCoarserIndex<WeekIndex> for DateIndex {
+    fn min_from(coarser: WeekIndex) -> usize {
+        let coarser = usize::from(coarser);
+        if coarser == 0 {
+            0
+        } else if coarser == 1 {
+            1
+        } else {
+            4 + (coarser - 1) * 7
+        }
+    }
+
+    fn max_from(coarser: WeekIndex) -> usize {
+        let coarser = usize::from(coarser);
+        if coarser == 0 {
+            0
+        } else if coarser == 1 {
+            3
+        } else {
+            3 + coarser * 7
+        }
+    }
+}
+
+impl FromCoarserIndex<MonthIndex> for DateIndex {
+    fn min_from(coarser: MonthIndex) -> usize {
+        let coarser = u16::from(coarser);
+        if coarser == 0 {
+            0
+        } else {
+            let d = Date::new(2009, 1, 1)
+                .into_jiff()
+                .checked_add(Span::new().months(coarser))
+                .unwrap();
+            DateIndex::try_from(Date::from(d)).unwrap().into()
+        }
+    }
+
+    fn max_from(coarser: MonthIndex) -> usize {
+        let d = Date::new(2009, 1, 31)
+            .into_jiff()
+            .checked_add(Span::new().months(u16::from(coarser)))
+            .unwrap();
+        DateIndex::try_from(Date::from(d)).unwrap().into()
+    }
+}
+
+impl FromCoarserIndex<QuarterIndex> for DateIndex {
+    fn min_from(coarser: QuarterIndex) -> usize {
+        let coarser = u16::from(coarser);
+        if coarser == 0 {
+            0
+        } else {
+            let d = Date::new(2009, 1, 1)
+                .into_jiff()
+                .checked_add(Span::new().months(3 * coarser))
+                .unwrap();
+            DateIndex::try_from(Date::from(d)).unwrap().into()
+        }
+    }
+
+    fn max_from(coarser: QuarterIndex) -> usize {
+        let d = Date::new(2009, 3, 31)
+            .into_jiff()
+            .checked_add(Span::new().months(3 * u16::from(coarser)))
+            .unwrap();
+        DateIndex::try_from(Date::from(d)).unwrap().into()
+    }
+}
+
+impl FromCoarserIndex<SemesterIndex> for DateIndex {
+    fn min_from(coarser: SemesterIndex) -> usize {
+        let coarser = u16::from(coarser);
+        if coarser == 0 {
+            0
+        } else {
+            let d = Date::new(2009, 1, 1)
+                .into_jiff()
+                .checked_add(Span::new().months(6 * coarser))
+                .unwrap();
+            DateIndex::try_from(Date::from(d)).unwrap().into()
+        }
+    }
+
+    fn max_from(coarser: SemesterIndex) -> usize {
+        let d = Date::new(2009, 5, 31)
+            .into_jiff()
+            .checked_add(Span::new().months(1 + 6 * u16::from(coarser)))
+            .unwrap();
+        DateIndex::try_from(Date::from(d)).unwrap().into()
+    }
+}
+
+impl FromCoarserIndex<YearIndex> for DateIndex {
+    fn min_from(coarser: YearIndex) -> usize {
+        let coarser = u16::from(coarser);
+        if coarser == 0 {
+            0
+        } else {
+            Self::try_from(Date::new(2009 + coarser, 1, 1))
+                .unwrap()
+                .into()
+        }
+    }
+
+    fn max_from(coarser: YearIndex) -> usize {
+        Self::try_from(Date::new(2009 + u16::from(coarser), 12, 31))
+            .unwrap()
+            .into()
+    }
+}
+
+impl FromCoarserIndex<DecadeIndex> for DateIndex {
+    fn min_from(coarser: DecadeIndex) -> usize {
+        let coarser = u16::from(coarser);
+        if coarser == 0 {
+            0
+        } else {
+            Self::try_from(Date::new(2000 + 10 * coarser, 1, 1))
+                .unwrap()
+                .into()
+        }
+    }
+
+    fn max_from(coarser: DecadeIndex) -> usize {
+        let coarser = u16::from(coarser);
+        Self::try_from(Date::new(2009 + (10 * coarser), 12, 31))
+            .unwrap()
+            .into()
+    }
+}

crates/brk_core/src/structs/decadeindex.rs

@@ -31,6 +31,18 @@ impl From<u8> for DecadeIndex {
     }
 }
 
+impl From<DecadeIndex> for u8 {
+    fn from(value: DecadeIndex) -> Self {
+        value.0
+    }
+}
+
+impl From<DecadeIndex> for u16 {
+    fn from(value: DecadeIndex) -> Self {
+        value.0 as u16
+    }
+}
+
 impl From<usize> for DecadeIndex {
     fn from(value: usize) -> Self {
         Self(value as u8)

crates/brk_core/src/structs/difficultyepoch.rs

@@ -1,6 +1,6 @@
 use std::{
     fmt::Debug,
-    ops::{Add, Div},
+    ops::{Add, AddAssign, Div},
 };
 
 use serde::{Deserialize, Serialize};
@@ -54,6 +54,12 @@ impl Add for DifficultyEpoch {
     }
 }
 
+impl AddAssign for DifficultyEpoch {
+    fn add_assign(&mut self, rhs: Self) {
+        *self = *self + rhs
+    }
+}
+
 impl Add<usize> for DifficultyEpoch {
     type Output = Self;
 

crates/brk_core/src/structs/feerate.rs

@@ -1,6 +1,6 @@
 use std::{
     cmp::Ordering,
-    ops::{Add, Div},
+    ops::{Add, AddAssign, Div},
 };
 
 use serde::Serialize;
@@ -35,6 +35,12 @@ impl Add for Feerate {
     }
 }
 
+impl AddAssign for Feerate {
+    fn add_assign(&mut self, rhs: Self) {
+        *self = *self + rhs
+    }
+}
+
 impl Div<usize> for Feerate {
     type Output = Self;
     fn div(self, rhs: usize) -> Self::Output {

crates/brk_core/src/structs/halvingepoch.rs

@@ -1,6 +1,6 @@
 use std::{
     fmt::Debug,
-    ops::{Add, Div},
+    ops::{Add, AddAssign, Div},
 };
 
 use serde::{Deserialize, Serialize};
@@ -60,6 +60,12 @@ impl Add for HalvingEpoch {
     }
 }
 
+impl AddAssign for HalvingEpoch {
+    fn add_assign(&mut self, rhs: Self) {
+        *self = *self + rhs
+    }
+}
+
 impl Add<usize> for HalvingEpoch {
     type Output = Self;
 

crates/brk_core/src/structs/mod.rs

@@ -33,6 +33,7 @@ mod p2wshaddressindex;
 mod quarterindex;
 mod rawlocktime;
 mod sats;
+mod semesterindex;
 mod stored_f32;
 mod stored_f64;
 mod stored_u32;
@@ -90,6 +91,7 @@ pub use p2wshaddressindex::*;
 pub use quarterindex::*;
 pub use rawlocktime::*;
 pub use sats::*;
+pub use semesterindex::*;
 pub use stored_f32::*;
 pub use stored_f64::*;
 pub use stored_u8::*;

crates/brk_core/src/structs/monthindex.rs

@@ -31,6 +31,12 @@ impl From<u16> for MonthIndex {
     }
 }
 
+impl From<MonthIndex> for u16 {
+    fn from(value: MonthIndex) -> Self {
+        value.0
+    }
+}
+
 impl From<usize> for MonthIndex {
     fn from(value: usize) -> Self {
         Self(value as u16)

crates/brk_core/src/structs/ohlc.rs

@@ -1,4 +1,4 @@
-use std::ops::{Add, Div};
+use std::ops::{Add, AddAssign, Div};
 
 use derive_deref::{Deref, DerefMut};
 use serde::{Serialize, Serializer, ser::SerializeTuple};
@@ -236,6 +236,15 @@ where
     }
 }
 
+impl<T> AddAssign for Open<T>
+where
+    T: Add<Output = T> + Clone,
+{
+    fn add_assign(&mut self, rhs: Self) {
+        **self = self.0.clone() + rhs.0
+    }
+}
+
 impl<T> Div<usize> for Open<T>
 where
     T: Div<usize, Output = T>,
@@ -324,6 +333,15 @@ where
     }
 }
 
+impl<T> AddAssign for High<T>
+where
+    T: Add<Output = T> + Clone,
+{
+    fn add_assign(&mut self, rhs: Self) {
+        **self = self.0.clone() + rhs.0
+    }
+}
+
 impl<T> Div<usize> for High<T>
 where
     T: Div<usize, Output = T>,
@@ -412,6 +430,15 @@ where
     }
 }
 
+impl<T> AddAssign for Low<T>
+where
+    T: Add<Output = T> + Clone,
+{
+    fn add_assign(&mut self, rhs: Self) {
+        **self = self.0.clone() + rhs.0
+    }
+}
+
 impl<T> Div<usize> for Low<T>
 where
     T: Div<usize, Output = T>,
@@ -515,6 +542,15 @@ where
     }
 }
 
+impl<T> AddAssign for Close<T>
+where
+    T: Add<Output = T> + Clone,
+{
+    fn add_assign(&mut self, rhs: Self) {
+        **self = self.0.clone() + rhs.0
+    }
+}
+
 impl<T> Div<usize> for Close<T>
 where
     T: Div<usize, Output = T>,

crates/brk_core/src/structs/quarterindex.rs

@@ -37,6 +37,12 @@ impl From<usize> for QuarterIndex {
     }
 }
 
+impl From<QuarterIndex> for u16 {
+    fn from(value: QuarterIndex) -> Self {
+        value.0
+    }
+}
+
 impl From<QuarterIndex> for usize {
     fn from(value: QuarterIndex) -> Self {
         value.0 as usize

crates/brk_core/src/structs/semesterindex.rs

@@ -0,0 +1,80 @@
+use std::{fmt::Debug, ops::Add};
+
+use serde::{Deserialize, Serialize};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::{CheckedSub, Printable};
+
+use super::MonthIndex;
+
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Default,
+    Serialize,
+    Deserialize,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+)]
+pub struct SemesterIndex(u16);
+
+impl From<u16> for SemesterIndex {
+    fn from(value: u16) -> Self {
+        Self(value)
+    }
+}
+
+impl From<usize> for SemesterIndex {
+    fn from(value: usize) -> Self {
+        Self(value as u16)
+    }
+}
+
+impl From<SemesterIndex> for u16 {
+    fn from(value: SemesterIndex) -> Self {
+        value.0
+    }
+}
+
+impl From<SemesterIndex> for usize {
+    fn from(value: SemesterIndex) -> Self {
+        value.0 as usize
+    }
+}
+
+impl Add<usize> for SemesterIndex {
+    type Output = Self;
+
+    fn add(self, rhs: usize) -> Self::Output {
+        Self::from(self.0 + rhs as u16)
+    }
+}
+
+impl From<MonthIndex> for SemesterIndex {
+    fn from(value: MonthIndex) -> Self {
+        Self((usize::from(value) / 6) as u16)
+    }
+}
+
+impl CheckedSub for SemesterIndex {
+    fn checked_sub(self, rhs: Self) -> Option<Self> {
+        self.0.checked_sub(rhs.0).map(Self)
+    }
+}
+
+impl Printable for SemesterIndex {
+    fn to_string() -> &'static str {
+        "semesterindex"
+    }
+
+    fn to_possible_strings() -> &'static [&'static str] {
+        &["s", "semester", "semesterindex"]
+    }
+}

crates/brk_core/src/structs/stored_f32.rs

@@ -1,7 +1,7 @@
 use core::panic;
 use std::{
     cmp::Ordering,
-    ops::{Add, Div, Mul, Sub},
+    ops::{Add, AddAssign, Div, Mul, Sub},
 };
 
 use derive_deref::Deref;
@@ -70,6 +70,12 @@ impl Add for StoredF32 {
     }
 }
 
+impl AddAssign for StoredF32 {
+    fn add_assign(&mut self, rhs: Self) {
+        *self = *self + rhs
+    }
+}
+
 impl From<StoredF32> for f32 {
     fn from(value: StoredF32) -> Self {
         value.0

crates/brk_core/src/structs/stored_f64.rs

@@ -1,7 +1,7 @@
 use std::{
     cmp::Ordering,
     f64,
-    ops::{Add, Div, Mul},
+    ops::{Add, AddAssign, Div, Mul},
 };
 
 use derive_deref::Deref;
@@ -65,6 +65,12 @@ impl Add for StoredF64 {
     }
 }
 
+impl AddAssign for StoredF64 {
+    fn add_assign(&mut self, rhs: Self) {
+        *self = *self + rhs
+    }
+}
+
 impl From<StoredF64> for f64 {
     fn from(value: StoredF64) -> Self {
         value.0

crates/brk_core/src/structs/stored_u32.rs

@@ -1,4 +1,4 @@
-use std::ops::{Add, Div};
+use std::ops::{Add, AddAssign, Div};
 
 use derive_deref::Deref;
 use serde::Serialize;
@@ -73,6 +73,12 @@ impl Add for StoredU32 {
     }
 }
 
+impl AddAssign for StoredU32 {
+    fn add_assign(&mut self, rhs: Self) {
+        *self = *self + rhs
+    }
+}
+
 impl From<f64> for StoredU32 {
     fn from(value: f64) -> Self {
         if value < 0.0 || value > u32::MAX as f64 {

crates/brk_core/src/structs/stored_u64.rs

@@ -1,4 +1,4 @@
-use std::ops::{Add, Div};
+use std::ops::{Add, AddAssign, Div};
 
 use derive_deref::Deref;
 use serde::Serialize;
@@ -65,6 +65,12 @@ impl Add for StoredU64 {
     }
 }
 
+impl AddAssign for StoredU64 {
+    fn add_assign(&mut self, rhs: Self) {
+        *self = *self + rhs
+    }
+}
+
 impl From<f64> for StoredU64 {
     fn from(value: f64) -> Self {
         if value < 0.0 || value > u32::MAX as f64 {

crates/brk_core/src/structs/stored_u8.rs

@@ -1,4 +1,4 @@
-use std::ops::{Add, Div};
+use std::ops::{Add, AddAssign, Div};
 
 use derive_deref::Deref;
 use serde::Serialize;
@@ -66,6 +66,12 @@ impl Add for StoredU8 {
     }
 }
 
+impl AddAssign for StoredU8 {
+    fn add_assign(&mut self, rhs: Self) {
+        *self = *self + rhs
+    }
+}
+
 impl From<f64> for StoredU8 {
     fn from(value: f64) -> Self {
         if value < 0.0 || value > u32::MAX as f64 {

crates/brk_core/src/structs/stored_usize.rs

@@ -1,4 +1,4 @@
-use std::ops::{Add, Div};
+use std::ops::{Add, AddAssign, Div};
 
 use derive_deref::{Deref, DerefMut};
 use serde::Serialize;
@@ -71,6 +71,12 @@ impl Add for StoredUsize {
     }
 }
 
+impl AddAssign for StoredUsize {
+    fn add_assign(&mut self, rhs: Self) {
+        *self = *self + rhs
+    }
+}
+
 impl From<f64> for StoredUsize {
     fn from(value: f64) -> Self {
         if value < 0.0 || value > u32::MAX as f64 {

crates/brk_core/src/structs/timestamp.rs

@@ -1,6 +1,6 @@
 use std::{
     cmp::Ordering,
-    ops::{Add, Div},
+    ops::{Add, AddAssign, Div},
 };
 
 use derive_deref::Deref;
@@ -142,6 +142,12 @@ impl Add for Timestamp {
     }
 }
 
+impl AddAssign for Timestamp {
+    fn add_assign(&mut self, rhs: Self) {
+        *self = *self + rhs
+    }
+}
+
 impl From<f64> for Timestamp {
     fn from(value: f64) -> Self {
         if value < 0.0 || value > u32::MAX as f64 {

crates/brk_core/src/structs/version.rs

@@ -65,6 +65,12 @@ impl Version {
     }
 }
 
+impl From<Version> for u64 {
+    fn from(value: Version) -> u64 {
+        value.0
+    }
+}
+
 impl From<u64> for Version {
     fn from(value: u64) -> Self {
         Self(value)

crates/brk_core/src/structs/weekindex.rs

@@ -31,6 +31,12 @@ impl From<u16> for WeekIndex {
     }
 }
 
+impl From<WeekIndex> for u16 {
+    fn from(value: WeekIndex) -> Self {
+        value.0
+    }
+}
+
 impl From<usize> for WeekIndex {
     fn from(value: usize) -> Self {
         Self(value as u16)
@@ -68,7 +74,6 @@ impl From<Date> for WeekIndex {
             let d = jiff::civil::Date::new(year, 6, 6).unwrap();
             let i = d.iso_week_date();
             let w = i.weeks_in_year();
-            // dbg!(d, w);
             week += w as u16;
             year += 1;
         }

crates/brk_core/src/structs/weight.rs

@@ -1,4 +1,4 @@
-use std::ops::{Add, Div};
+use std::ops::{Add, AddAssign, Div};
 
 use derive_deref::Deref;
 use serde::Serialize;
@@ -58,6 +58,12 @@ impl Add for Weight {
     }
 }
 
+impl AddAssign for Weight {
+    fn add_assign(&mut self, rhs: Self) {
+        *self = *self + rhs
+    }
+}
+
 impl Div<usize> for Weight {
     type Output = Self;
     fn div(self, rhs: usize) -> Self::Output {