brk: first commit

_src/parser/datasets/subs/capitalization.rs

@@ -0,0 +1,123 @@
+use allocative::Allocative;
+use struct_iterable::Iterable;
+
+use crate::{
+    parser::{
+        datasets::{AnyDataset, ComputeData, InsertData, MinInitialStates},
+        states::CapitalizationState,
+    },
+    structs::{BiMap, Config, MapKind, MapPath},
+    utils::ONE_MONTH_IN_DAYS,
+};
+
+use super::RatioDataset;
+
+#[derive(Allocative, Iterable)]
+pub struct CapitalizationDataset {
+    min_initial_states: MinInitialStates,
+
+    pub realized_cap: BiMap<f32>,
+    pub realized_price: BiMap<f32>,
+    realized_cap_1m_net_change: BiMap<f32>,
+    realized_price_ratio: RatioDataset,
+}
+
+impl CapitalizationDataset {
+    pub fn import(
+        path: &MapPath,
+        name: &Option<String>,
+        config: &Config,
+    ) -> color_eyre::Result<Self> {
+        let f = |s: &str| {
+            if let Some(name) = name {
+                path.join(&format!("{name}/{s}"))
+            } else {
+                path.join(s)
+            }
+        };
+
+        let mut s = Self {
+            min_initial_states: MinInitialStates::default(),
+
+            // ---
+            // Inserted
+            // ---
+            realized_cap: BiMap::new_bin(1, MapKind::Inserted, &f("realized_cap")),
+
+            // ---
+            // Computed
+            // ---
+            realized_cap_1m_net_change: BiMap::new_bin(
+                1,
+                MapKind::Computed,
+                &f("realized_cap_1m_net_change"),
+            ),
+            realized_price: BiMap::new_bin(1, MapKind::Computed, &f("realized_price")),
+            realized_price_ratio: RatioDataset::import(
+                path,
+                &format!(
+                    "{}realized_price",
+                    name.as_ref().map_or("".to_owned(), |n| format!("{n}-"))
+                ),
+                config,
+            )?,
+        };
+
+        s.min_initial_states
+            .consume(MinInitialStates::compute_from_dataset(&s, config));
+
+        Ok(s)
+    }
+
+    pub fn insert(
+        &mut self,
+        &InsertData {
+            height,
+            date,
+            is_date_last_block,
+            ..
+        }: &InsertData,
+        state: &CapitalizationState,
+    ) {
+        let realized_cap = self
+            .realized_cap
+            .height
+            .insert(height, state.realized_cap().to_dollar() as f32);
+
+        if is_date_last_block {
+            self.realized_cap.date.insert(date, realized_cap);
+        }
+    }
+
+    pub fn compute(
+        &mut self,
+        compute_data: &ComputeData,
+        closes: &mut BiMap<f32>,
+        cohort_supply: &mut BiMap<f64>,
+    ) {
+        let &ComputeData { heights, dates, .. } = compute_data;
+
+        self.realized_price.multi_insert_divide(
+            heights,
+            dates,
+            &mut self.realized_cap,
+            cohort_supply,
+        );
+
+        self.realized_cap_1m_net_change.multi_insert_net_change(
+            heights,
+            dates,
+            &mut self.realized_cap,
+            ONE_MONTH_IN_DAYS,
+        );
+
+        self.realized_price_ratio
+            .compute(compute_data, closes, &mut self.realized_price);
+    }
+}
+
+impl AnyDataset for CapitalizationDataset {
+    fn get_min_initial_states(&self) -> &MinInitialStates {
+        &self.min_initial_states
+    }
+}

_src/parser/datasets/subs/input.rs

@@ -0,0 +1,86 @@
+use allocative::Allocative;
+use struct_iterable::Iterable;
+
+use crate::{
+    parser::{
+        datasets::{AnyDataset, InsertData, MinInitialStates},
+        states::InputState,
+    },
+    structs::{BiMap, Config, DateMap, HeightMap, MapKind, MapPath},
+};
+
+#[derive(Allocative, Iterable)]
+pub struct InputSubDataset {
+    min_initial_states: MinInitialStates,
+
+    // Inserted
+    pub count: BiMap<u64>,
+    pub volume: HeightMap<f64>,
+    pub volume_1d_sum: DateMap<f64>,
+    // Computed
+    // add inputs_per_second
+}
+
+impl InputSubDataset {
+    pub fn import(
+        path: &MapPath,
+        name: &Option<String>,
+        config: &Config,
+    ) -> color_eyre::Result<Self> {
+        let f = |s: &str| {
+            if let Some(name) = name {
+                path.join(&format!("{name}/{s}"))
+            } else {
+                path.join(s)
+            }
+        };
+
+        let mut s = Self {
+            min_initial_states: MinInitialStates::default(),
+
+            // ---
+            // Inserted
+            // ---
+            count: BiMap::new_bin(1, MapKind::Inserted, &f("input_count")),
+            volume: HeightMap::new_bin(1, MapKind::Inserted, &f("input_volume")),
+            volume_1d_sum: DateMap::new_bin(1, MapKind::Inserted, &f("input_volume_1d_sum")),
+        };
+
+        s.min_initial_states
+            .consume(MinInitialStates::compute_from_dataset(&s, config));
+
+        Ok(s)
+    }
+
+    pub fn insert(
+        &mut self,
+        &InsertData {
+            height,
+            date,
+            is_date_last_block,
+            date_blocks_range,
+            ..
+        }: &InsertData,
+        state: &InputState,
+    ) {
+        let count = self
+            .count
+            .height
+            .insert(height, state.count().round() as u64);
+
+        self.volume.insert(height, state.volume().to_btc());
+
+        if is_date_last_block {
+            self.count.date.insert(date, count);
+
+            self.volume_1d_sum
+                .insert(date, self.volume.sum_range(date_blocks_range));
+        }
+    }
+}
+
+impl AnyDataset for InputSubDataset {
+    fn get_min_initial_states(&self) -> &MinInitialStates {
+        &self.min_initial_states
+    }
+}

_src/parser/datasets/subs/mod.rs

@@ -0,0 +1,90 @@
+use allocative::Allocative;
+
+mod capitalization;
+mod input;
+mod price_paid;
+mod ratio;
+mod realized;
+mod recap;
+mod supply;
+mod unrealized;
+mod utxo;
+
+pub use capitalization::*;
+pub use input::*;
+pub use price_paid::*;
+pub use ratio::*;
+pub use realized::*;
+pub use recap::*;
+use struct_iterable::Iterable;
+pub use supply::*;
+pub use unrealized::*;
+pub use utxo::*;
+
+use crate::{
+    parser::datasets::AnyDataset,
+    structs::{Config, MapPath},
+};
+
+use super::AnyDatasetGroup;
+
+#[derive(Allocative, Iterable)]
+pub struct SubDataset {
+    pub capitalization: CapitalizationDataset,
+    pub input: InputSubDataset,
+    // pub output: OutputSubDataset,
+    pub price_paid: PricePaidSubDataset,
+    pub realized: RealizedSubDataset,
+    pub supply: SupplySubDataset,
+    pub unrealized: UnrealizedSubDataset,
+    pub utxo: UTXOSubDataset,
+}
+
+impl SubDataset {
+    pub fn import(
+        parent_path: &MapPath,
+        name: &Option<String>,
+        config: &Config,
+    ) -> color_eyre::Result<Self> {
+        let s = Self {
+            capitalization: CapitalizationDataset::import(parent_path, name, config)?,
+            input: InputSubDataset::import(parent_path, name, config)?,
+            // output: OutputSubDataset::import(parent_path)?,
+            price_paid: PricePaidSubDataset::import(parent_path, name, config)?,
+            realized: RealizedSubDataset::import(parent_path, name, config)?,
+            supply: SupplySubDataset::import(parent_path, name, config)?,
+            unrealized: UnrealizedSubDataset::import(parent_path, name, config)?,
+            utxo: UTXOSubDataset::import(parent_path, name, config)?,
+        };
+
+        Ok(s)
+    }
+}
+
+impl AnyDatasetGroup for SubDataset {
+    fn as_vec(&self) -> Vec<&(dyn AnyDataset + Send + Sync)> {
+        vec![
+            &self.capitalization,
+            &self.price_paid,
+            &self.realized,
+            &self.supply,
+            &self.unrealized,
+            &self.utxo,
+            &self.input,
+            // &self.output,
+        ]
+    }
+
+    fn as_mut_vec(&mut self) -> Vec<&mut dyn AnyDataset> {
+        vec![
+            &mut self.capitalization,
+            &mut self.price_paid,
+            &mut self.realized,
+            &mut self.supply,
+            &mut self.unrealized,
+            &mut self.utxo,
+            &mut self.input,
+            // &mut self.output,
+        ]
+    }
+}

_src/parser/datasets/subs/output.rs

@@ -0,0 +1,87 @@
+use crate::{
+    datasets::{AnyDataset, ComputeData, InsertData, MinInitialStates},
+    states::OutputState,
+    structs::{AnyBiMap, BiMap},
+    utils::ONE_YEAR_IN_DAYS,
+};
+
+pub struct OutputSubDataset {
+    min_initial_states: MinInitialStates,
+
+    // Inserted
+    pub count: BiMap<f32>,
+    pub volume: BiMap<f32>,
+
+    // Computed
+    pub annualized_volume: BiMap<f32>,
+    pub velocity: BiMap<f32>,
+    // add outputs_per_second
+}
+
+impl OutputSubDataset {
+    pub fn import(parent_path: &str) -> color_eyre::Result<Self> {
+        let f = |s: &str| format!("{parent_path}/{s}");
+
+        let mut s = Self {
+            min_initial_states: MinInitialStates::default(),
+
+            count: BiMap::new_bin(1, &f("output_count")),
+            volume: BiMap::new_bin(1, &f("output_volume")),
+            annualized_volume: BiMap::new_bin(1, &f("annualized_output_volume")),
+            velocity: BiMap::new_bin(1, &f("output_velocity")),
+        };
+
+        s.min_initial_states
+            .consume(MinInitialStates::compute_from_dataset(&s));
+
+        Ok(s)
+    }
+
+    pub fn insert(
+        &mut self,
+        &InsertData {
+            height,
+            date,
+            is_date_last_block,
+            date_blocks_range,
+            ..
+        }: &InsertData,
+        state: &OutputState,
+    ) {
+        let count = self.count.height.insert(height, state.count);
+
+        self.volume.height.insert(height, state.volume);
+
+        if is_date_last_block {
+            self.count.date.insert(date, count);
+
+            self.volume.date_insert_sum_range(date, date_blocks_range);
+        }
+    }
+
+    pub fn compute(
+        &mut self,
+        &ComputeData { heights, dates }: &ComputeData,
+        cohort_supply: &mut BiMap<f32>,
+    ) {
+        self.annualized_volume.multi_insert_last_x_sum(
+            heights,
+            dates,
+            &mut self.volume,
+            ONE_YEAR_IN_DAYS,
+        );
+
+        self.velocity.multi_insert_divide(
+            heights,
+            dates,
+            &mut self.annualized_volume,
+            cohort_supply,
+        );
+    }
+}
+
+impl AnyDataset for OutputSubDataset {
+    fn get_min_initial_states(&self) -> &MinInitialStates {
+        &self.min_initial_states
+    }
+}

_src/parser/datasets/subs/price_paid.rs

@@ -0,0 +1,266 @@
+use allocative::Allocative;
+use struct_iterable::Iterable;
+
+use crate::{
+    parser::{
+        datasets::{AnyDataset, InsertData, MinInitialStates},
+        states::PricePaidState,
+    },
+    structs::{BiMap, Config, Date, Height, MapKind, MapPath},
+};
+
+#[derive(Allocative, Iterable)]
+pub struct PricePaidSubDataset {
+    min_initial_states: MinInitialStates,
+
+    pp_median: BiMap<f32>,
+    pp_95p: BiMap<f32>,
+    pp_90p: BiMap<f32>,
+    pp_85p: BiMap<f32>,
+    pp_80p: BiMap<f32>,
+    pp_75p: BiMap<f32>,
+    pp_70p: BiMap<f32>,
+    pp_65p: BiMap<f32>,
+    pp_60p: BiMap<f32>,
+    pp_55p: BiMap<f32>,
+    pp_45p: BiMap<f32>,
+    pp_40p: BiMap<f32>,
+    pp_35p: BiMap<f32>,
+    pp_30p: BiMap<f32>,
+    pp_25p: BiMap<f32>,
+    pp_20p: BiMap<f32>,
+    pp_15p: BiMap<f32>,
+    pp_10p: BiMap<f32>,
+    pp_05p: BiMap<f32>,
+}
+
+impl PricePaidSubDataset {
+    pub fn import(
+        path: &MapPath,
+        name: &Option<String>,
+        config: &Config,
+    ) -> color_eyre::Result<Self> {
+        let f = |s: &str| {
+            if let Some(name) = name {
+                path.join(&format!("{name}/{s}"))
+            } else {
+                path.join(s)
+            }
+        };
+
+        let mut s = Self {
+            min_initial_states: MinInitialStates::default(),
+
+            // ---
+            // Inserted
+            // ---
+            pp_median: BiMap::new_bin(1, MapKind::Inserted, &f("median_price_paid")),
+            pp_95p: BiMap::new_bin(1, MapKind::Inserted, &f("95p_price_paid")),
+            pp_90p: BiMap::new_bin(1, MapKind::Inserted, &f("90p_price_paid")),
+            pp_85p: BiMap::new_bin(1, MapKind::Inserted, &f("85p_price_paid")),
+            pp_80p: BiMap::new_bin(1, MapKind::Inserted, &f("80p_price_paid")),
+            pp_75p: BiMap::new_bin(1, MapKind::Inserted, &f("75p_price_paid")),
+            pp_70p: BiMap::new_bin(1, MapKind::Inserted, &f("70p_price_paid")),
+            pp_65p: BiMap::new_bin(1, MapKind::Inserted, &f("65p_price_paid")),
+            pp_60p: BiMap::new_bin(1, MapKind::Inserted, &f("60p_price_paid")),
+            pp_55p: BiMap::new_bin(1, MapKind::Inserted, &f("55p_price_paid")),
+            pp_45p: BiMap::new_bin(1, MapKind::Inserted, &f("45p_price_paid")),
+            pp_40p: BiMap::new_bin(1, MapKind::Inserted, &f("40p_price_paid")),
+            pp_35p: BiMap::new_bin(1, MapKind::Inserted, &f("35p_price_paid")),
+            pp_30p: BiMap::new_bin(1, MapKind::Inserted, &f("30p_price_paid")),
+            pp_25p: BiMap::new_bin(1, MapKind::Inserted, &f("25p_price_paid")),
+            pp_20p: BiMap::new_bin(1, MapKind::Inserted, &f("20p_price_paid")),
+            pp_15p: BiMap::new_bin(1, MapKind::Inserted, &f("15p_price_paid")),
+            pp_10p: BiMap::new_bin(1, MapKind::Inserted, &f("10p_price_paid")),
+            pp_05p: BiMap::new_bin(1, MapKind::Inserted, &f("05p_price_paid")),
+        };
+
+        s.min_initial_states
+            .consume(MinInitialStates::compute_from_dataset(&s, config));
+
+        Ok(s)
+    }
+
+    pub fn insert(
+        &mut self,
+        &InsertData {
+            height,
+            is_date_last_block,
+            date,
+            ..
+        }: &InsertData,
+        state: &PricePaidState,
+    ) {
+        let pp_05p = state.pp_05p();
+        let pp_10p = state.pp_10p();
+        let pp_15p = state.pp_15p();
+        let pp_20p = state.pp_20p();
+        let pp_25p = state.pp_25p();
+        let pp_30p = state.pp_30p();
+        let pp_35p = state.pp_35p();
+        let pp_40p = state.pp_40p();
+        let pp_45p = state.pp_45p();
+        let pp_median = state.pp_median();
+        let pp_55p = state.pp_55p();
+        let pp_60p = state.pp_60p();
+        let pp_65p = state.pp_65p();
+        let pp_70p = state.pp_70p();
+        let pp_75p = state.pp_75p();
+        let pp_80p = state.pp_80p();
+        let pp_85p = state.pp_85p();
+        let pp_90p = state.pp_90p();
+        let pp_95p = state.pp_95p();
+
+        // Check if iter was empty
+        if pp_05p.is_none() {
+            self.insert_height_default(height);
+
+            if is_date_last_block {
+                self.insert_date_default(date);
+            }
+
+            return;
+        }
+
+        let pp_05p = self
+            .pp_05p
+            .height
+            .insert(height, pp_05p.unwrap().to_dollar() as f32);
+        let pp_10p = self
+            .pp_10p
+            .height
+            .insert(height, pp_10p.unwrap().to_dollar() as f32);
+        let pp_15p = self
+            .pp_15p
+            .height
+            .insert(height, pp_15p.unwrap().to_dollar() as f32);
+        let pp_20p = self
+            .pp_20p
+            .height
+            .insert(height, pp_20p.unwrap().to_dollar() as f32);
+        let pp_25p = self
+            .pp_25p
+            .height
+            .insert(height, pp_25p.unwrap().to_dollar() as f32);
+        let pp_30p = self
+            .pp_30p
+            .height
+            .insert(height, pp_30p.unwrap().to_dollar() as f32);
+        let pp_35p = self
+            .pp_35p
+            .height
+            .insert(height, pp_35p.unwrap().to_dollar() as f32);
+        let pp_40p = self
+            .pp_40p
+            .height
+            .insert(height, pp_40p.unwrap().to_dollar() as f32);
+        let pp_45p = self
+            .pp_45p
+            .height
+            .insert(height, pp_45p.unwrap().to_dollar() as f32);
+        let pp_median = self
+            .pp_median
+            .height
+            .insert(height, pp_median.unwrap().to_dollar() as f32);
+        let pp_55p = self
+            .pp_55p
+            .height
+            .insert(height, pp_55p.unwrap().to_dollar() as f32);
+        let pp_60p = self
+            .pp_60p
+            .height
+            .insert(height, pp_60p.unwrap().to_dollar() as f32);
+        let pp_65p = self
+            .pp_65p
+            .height
+            .insert(height, pp_65p.unwrap().to_dollar() as f32);
+        let pp_70p = self
+            .pp_70p
+            .height
+            .insert(height, pp_70p.unwrap().to_dollar() as f32);
+        let pp_75p = self
+            .pp_75p
+            .height
+            .insert(height, pp_75p.unwrap().to_dollar() as f32);
+        let pp_80p = self
+            .pp_80p
+            .height
+            .insert(height, pp_80p.unwrap().to_dollar() as f32);
+        let pp_85p = self
+            .pp_85p
+            .height
+            .insert(height, pp_85p.unwrap().to_dollar() as f32);
+        let pp_90p = self
+            .pp_90p
+            .height
+            .insert(height, pp_90p.unwrap().to_dollar() as f32);
+        let pp_95p = self
+            .pp_95p
+            .height
+            .insert(height, pp_95p.unwrap().to_dollar() as f32);
+
+        if is_date_last_block {
+            self.pp_05p.date.insert(date, pp_05p);
+            self.pp_10p.date.insert(date, pp_10p);
+            self.pp_15p.date.insert(date, pp_15p);
+            self.pp_20p.date.insert(date, pp_20p);
+            self.pp_25p.date.insert(date, pp_25p);
+            self.pp_30p.date.insert(date, pp_30p);
+            self.pp_35p.date.insert(date, pp_35p);
+            self.pp_40p.date.insert(date, pp_40p);
+            self.pp_45p.date.insert(date, pp_45p);
+            self.pp_median.date.insert(date, pp_median);
+            self.pp_55p.date.insert(date, pp_55p);
+            self.pp_60p.date.insert(date, pp_60p);
+            self.pp_65p.date.insert(date, pp_65p);
+            self.pp_70p.date.insert(date, pp_70p);
+            self.pp_75p.date.insert(date, pp_75p);
+            self.pp_80p.date.insert(date, pp_80p);
+            self.pp_85p.date.insert(date, pp_85p);
+            self.pp_90p.date.insert(date, pp_90p);
+            self.pp_95p.date.insert(date, pp_95p);
+        }
+    }
+
+    fn insert_height_default(&mut self, height: Height) {
+        self.inserted_as_mut_vec().into_iter().for_each(|bi| {
+            bi.height.insert_default(height);
+        })
+    }
+
+    fn insert_date_default(&mut self, date: Date) {
+        self.inserted_as_mut_vec().into_iter().for_each(|bi| {
+            bi.date.insert_default(date);
+        })
+    }
+
+    pub fn inserted_as_mut_vec(&mut self) -> Vec<&mut BiMap<f32>> {
+        vec![
+            &mut self.pp_95p,
+            &mut self.pp_90p,
+            &mut self.pp_85p,
+            &mut self.pp_80p,
+            &mut self.pp_75p,
+            &mut self.pp_70p,
+            &mut self.pp_65p,
+            &mut self.pp_60p,
+            &mut self.pp_55p,
+            &mut self.pp_median,
+            &mut self.pp_45p,
+            &mut self.pp_40p,
+            &mut self.pp_35p,
+            &mut self.pp_30p,
+            &mut self.pp_25p,
+            &mut self.pp_20p,
+            &mut self.pp_15p,
+            &mut self.pp_10p,
+            &mut self.pp_05p,
+        ]
+    }
+}
+
+impl AnyDataset for PricePaidSubDataset {
+    fn get_min_initial_states(&self) -> &MinInitialStates {
+        &self.min_initial_states
+    }
+}

_src/parser/datasets/subs/ratio.rs

@@ -0,0 +1,171 @@
+use allocative::Allocative;
+use struct_iterable::Iterable;
+
+use crate::{
+    parser::datasets::{AnyDataset, ComputeData, MinInitialStates},
+    structs::{BiMap, Config, MapKind, MapPath},
+    utils::{ONE_MONTH_IN_DAYS, ONE_WEEK_IN_DAYS, ONE_YEAR_IN_DAYS},
+};
+
+#[derive(Allocative, Iterable)]
+pub struct RatioDataset {
+    min_initial_states: MinInitialStates,
+
+    ratio: BiMap<f32>,
+    ratio_1w_sma: BiMap<f32>,
+    ratio_1m_sma: BiMap<f32>,
+    ratio_1y_sma: BiMap<f32>,
+    ratio_1y_sma_momentum_oscillator: BiMap<f32>,
+    ratio_99p: BiMap<f32>,
+    ratio_99_5p: BiMap<f32>,
+    ratio_99_9p: BiMap<f32>,
+    ratio_1p: BiMap<f32>,
+    ratio_0_5p: BiMap<f32>,
+    ratio_0_1p: BiMap<f32>,
+    price_99p: BiMap<f32>,
+    price_99_5p: BiMap<f32>,
+    price_99_9p: BiMap<f32>,
+    price_1p: BiMap<f32>,
+    price_0_5p: BiMap<f32>,
+    price_0_1p: BiMap<f32>,
+}
+
+impl RatioDataset {
+    pub fn import(path: &MapPath, name: &str, config: &Config) -> color_eyre::Result<Self> {
+        let f_ratio = |s: &str| path.join(&format!("market_price_to_{name}_{s}"));
+        let f_price = |s: &str| path.join(&format!("{name}_{s}"));
+
+        let mut s = Self {
+            min_initial_states: MinInitialStates::default(),
+
+            // ---
+            // Computed
+            // ---
+            ratio: BiMap::new_bin(1, MapKind::Computed, &f_ratio("ratio")),
+            ratio_1w_sma: BiMap::new_bin(2, MapKind::Computed, &f_ratio("ratio_1w_sma")),
+            ratio_1m_sma: BiMap::new_bin(2, MapKind::Computed, &f_ratio("ratio_1m_sma")),
+            ratio_1y_sma: BiMap::new_bin(2, MapKind::Computed, &f_ratio("ratio_1y_sma")),
+            ratio_1y_sma_momentum_oscillator: BiMap::new_bin(
+                2,
+                MapKind::Computed,
+                &f_ratio("ratio_1y_sma_momentum_oscillator"),
+            ),
+            ratio_99p: BiMap::new_bin(3, MapKind::Computed, &f_ratio("ratio_99p")),
+            ratio_99_5p: BiMap::new_bin(3, MapKind::Computed, &f_ratio("ratio_99_5p")),
+            ratio_99_9p: BiMap::new_bin(3, MapKind::Computed, &f_ratio("ratio_99_9p")),
+            ratio_1p: BiMap::new_bin(3, MapKind::Computed, &f_ratio("ratio_1p")),
+            ratio_0_5p: BiMap::new_bin(3, MapKind::Computed, &f_ratio("ratio_0_5p")),
+            ratio_0_1p: BiMap::new_bin(3, MapKind::Computed, &f_ratio("ratio_0_1p")),
+            price_99p: BiMap::new_bin(4, MapKind::Computed, &f_price("99p")),
+            price_99_5p: BiMap::new_bin(4, MapKind::Computed, &f_price("99_5p")),
+            price_99_9p: BiMap::new_bin(4, MapKind::Computed, &f_price("99_9p")),
+            price_1p: BiMap::new_bin(4, MapKind::Computed, &f_price("1p")),
+            price_0_5p: BiMap::new_bin(4, MapKind::Computed, &f_price("0_5p")),
+            price_0_1p: BiMap::new_bin(4, MapKind::Computed, &f_price("0_1p")),
+        };
+
+        s.min_initial_states
+            .consume(MinInitialStates::compute_from_dataset(&s, config));
+
+        Ok(s)
+    }
+
+    pub fn compute(
+        &mut self,
+        &ComputeData { heights, dates, .. }: &ComputeData,
+        market_price: &mut BiMap<f32>,
+        other_price: &mut BiMap<f32>,
+    ) {
+        self.ratio.height.multi_insert_divide(
+            heights,
+            &mut market_price.height,
+            &mut other_price.height,
+        );
+
+        self.ratio
+            .date
+            .multi_insert_divide(dates, &mut market_price.date, &mut other_price.date);
+
+        self.ratio_1w_sma.multi_insert_simple_average(
+            heights,
+            dates,
+            &mut self.ratio,
+            ONE_WEEK_IN_DAYS,
+        );
+
+        self.ratio_1m_sma.multi_insert_simple_average(
+            heights,
+            dates,
+            &mut self.ratio,
+            ONE_MONTH_IN_DAYS,
+        );
+
+        self.ratio_1m_sma.multi_insert_simple_average(
+            heights,
+            dates,
+            &mut self.ratio,
+            ONE_MONTH_IN_DAYS,
+        );
+
+        self.ratio_1y_sma.multi_insert_simple_average(
+            heights,
+            dates,
+            &mut self.ratio,
+            ONE_YEAR_IN_DAYS,
+        );
+
+        self.ratio_1y_sma_momentum_oscillator
+            .height
+            .multi_insert_complex_transform(
+                heights,
+                &mut self.ratio.height,
+                |(ratio, height, ..)| {
+                    (ratio / self.ratio_1y_sma.height.get_or_import(height).unwrap()) - 1.0
+                },
+            );
+
+        self.ratio_1y_sma_momentum_oscillator
+            .date
+            .multi_insert_complex_transform(dates, &mut self.ratio.date, |(ratio, date, _, _)| {
+                (ratio / self.ratio_1y_sma.date.get_or_import(date).unwrap()) - 1.0
+            });
+
+        self.ratio.multi_insert_percentile(
+            heights,
+            dates,
+            vec![
+                (&mut self.ratio_99p, 0.99),
+                (&mut self.ratio_99_5p, 0.995),
+                (&mut self.ratio_99_9p, 0.999),
+                (&mut self.ratio_1p, 0.1),
+                (&mut self.ratio_0_5p, 0.005),
+                (&mut self.ratio_0_1p, 0.001),
+            ],
+            None,
+        );
+
+        self.price_99p
+            .multi_insert_multiply(heights, dates, other_price, &mut self.ratio_99p);
+
+        self.price_99_5p
+            .multi_insert_multiply(heights, dates, other_price, &mut self.ratio_99_5p);
+
+        self.price_99_9p
+            .multi_insert_multiply(heights, dates, other_price, &mut self.ratio_99_9p);
+
+        self.price_1p
+            .multi_insert_multiply(heights, dates, other_price, &mut self.ratio_1p);
+
+        self.price_0_5p
+            .multi_insert_multiply(heights, dates, other_price, &mut self.ratio_0_5p);
+
+        self.price_0_1p
+            .multi_insert_multiply(heights, dates, other_price, &mut self.ratio_0_1p);
+    }
+}
+
+impl AnyDataset for RatioDataset {
+    fn get_min_initial_states(&self) -> &MinInitialStates {
+        &self.min_initial_states
+    }
+}

_src/parser/datasets/subs/realized.rs

@@ -0,0 +1,387 @@
+use allocative::Allocative;
+use struct_iterable::Iterable;
+
+use crate::{
+    parser::{
+        datasets::{AnyDataset, ComputeData, InsertData, MinInitialStates},
+        states::RealizedState,
+    },
+    structs::{BiMap, Config, DateMap, HeightMap, MapKind, MapPath, Price},
+    utils::ONE_MONTH_IN_DAYS,
+};
+
+#[derive(Allocative, Iterable)]
+pub struct RealizedSubDataset {
+    min_initial_states: MinInitialStates,
+
+    realized_profit: HeightMap<f32>,
+    realized_loss: HeightMap<f32>,
+    value_created: HeightMap<f32>,
+    adjusted_value_created: HeightMap<f32>,
+    value_destroyed: HeightMap<f32>,
+    adjusted_value_destroyed: HeightMap<f32>,
+    realized_profit_1d_sum: DateMap<f32>,
+    realized_loss_1d_sum: DateMap<f32>,
+    value_created_1d_sum: DateMap<f32>,
+    adjusted_value_created_1d_sum: DateMap<f32>,
+    value_destroyed_1d_sum: DateMap<f32>,
+    adjusted_value_destroyed_1d_sum: DateMap<f32>,
+    spent_output_profit_ratio: BiMap<f32>,
+    adjusted_spent_output_profit_ratio: BiMap<f32>,
+    negative_realized_loss: HeightMap<f32>,
+    negative_realized_loss_1d_sum: DateMap<f32>,
+    net_realized_profit_and_loss: HeightMap<f32>,
+    net_realized_profit_and_loss_1d_sum: DateMap<f32>,
+    net_realized_profit_and_loss_1d_sum_to_market_cap_ratio: DateMap<f32>,
+    cumulative_realized_profit: BiMap<f32>,
+    cumulative_realized_loss: BiMap<f32>,
+    cumulative_net_realized_profit_and_loss: BiMap<f32>,
+    cumulative_net_realized_profit_and_loss_1m_net_change: BiMap<f32>,
+    realized_value: HeightMap<f32>,
+    realized_value_1d_sum: DateMap<f32>,
+    sell_side_risk_ratio: DateMap<f32>,
+    realized_profit_to_loss_ratio: HeightMap<f32>,
+    realized_profit_to_loss_1d_sum_ratio: DateMap<f32>,
+}
+
+impl RealizedSubDataset {
+    pub fn import(
+        path: &MapPath,
+        name: &Option<String>,
+        config: &Config,
+    ) -> color_eyre::Result<Self> {
+        let f = |s: &str| {
+            if let Some(name) = name {
+                path.join(&format!("{name}/{s}"))
+            } else {
+                path.join(s)
+            }
+        };
+        let mut s = Self {
+            min_initial_states: MinInitialStates::default(),
+
+            // ---
+            // Inserted
+            // ---
+            realized_profit: HeightMap::new_bin(1, MapKind::Inserted, &f("realized_profit")),
+            realized_loss: HeightMap::new_bin(1, MapKind::Inserted, &f("realized_loss")),
+            value_created: HeightMap::new_bin(1, MapKind::Inserted, &f("value_created")),
+            adjusted_value_created: HeightMap::new_bin(
+                1,
+                MapKind::Inserted,
+                &f("adjusted_value_created"),
+            ),
+            value_destroyed: HeightMap::new_bin(1, MapKind::Inserted, &f("value_destroyed")),
+            adjusted_value_destroyed: HeightMap::new_bin(
+                1,
+                MapKind::Inserted,
+                &f("adjusted_value_destroyed"),
+            ),
+            realized_profit_1d_sum: DateMap::new_bin(
+                1,
+                MapKind::Inserted,
+                &f("realized_profit_1d_sum"),
+            ),
+            realized_loss_1d_sum: DateMap::new_bin(
+                1,
+                MapKind::Inserted,
+                &f("realized_loss_1d_sum"),
+            ),
+            value_created_1d_sum: DateMap::new_bin(
+                1,
+                MapKind::Inserted,
+                &f("value_created_1d_sum"),
+            ),
+            adjusted_value_created_1d_sum: DateMap::new_bin(
+                1,
+                MapKind::Inserted,
+                &f("adjusted_value_created_1d_sum"),
+            ),
+            value_destroyed_1d_sum: DateMap::new_bin(
+                1,
+                MapKind::Inserted,
+                &f("value_destroyed_1d_sum"),
+            ),
+            adjusted_value_destroyed_1d_sum: DateMap::new_bin(
+                1,
+                MapKind::Inserted,
+                &f("adjusted_value_destroyed_1d_sum"),
+            ),
+            spent_output_profit_ratio: BiMap::new_bin(
+                2,
+                MapKind::Inserted,
+                &f("spent_output_profit_ratio"),
+            ),
+            adjusted_spent_output_profit_ratio: BiMap::new_bin(
+                2,
+                MapKind::Inserted,
+                &f("adjusted_spent_output_profit_ratio"),
+            ),
+
+            // ---
+            // Computed
+            // ---
+            negative_realized_loss: HeightMap::new_bin(
+                2,
+                MapKind::Computed,
+                &f("negative_realized_loss"),
+            ),
+            negative_realized_loss_1d_sum: DateMap::new_bin(
+                2,
+                MapKind::Computed,
+                &f("negative_realized_loss_1d_sum"),
+            ),
+            net_realized_profit_and_loss: HeightMap::new_bin(
+                1,
+                MapKind::Computed,
+                &f("net_realized_profit_and_loss"),
+            ),
+            net_realized_profit_and_loss_1d_sum: DateMap::new_bin(
+                1,
+                MapKind::Computed,
+                &f("net_realized_profit_and_loss_1d_sum"),
+            ),
+            net_realized_profit_and_loss_1d_sum_to_market_cap_ratio: DateMap::new_bin(
+                2,
+                MapKind::Computed,
+                &f("net_realized_profit_and_loss_to_market_cap_ratio"),
+            ),
+            cumulative_realized_profit: BiMap::new_bin(
+                1,
+                MapKind::Computed,
+                &f("cumulative_realized_profit"),
+            ),
+            cumulative_realized_loss: BiMap::new_bin(
+                1,
+                MapKind::Computed,
+                &f("cumulative_realized_loss"),
+            ),
+            cumulative_net_realized_profit_and_loss: BiMap::new_bin(
+                1,
+                MapKind::Computed,
+                &f("cumulative_net_realized_profit_and_loss"),
+            ),
+            cumulative_net_realized_profit_and_loss_1m_net_change: BiMap::new_bin(
+                1,
+                MapKind::Computed,
+                &f("cumulative_net_realized_profit_and_loss_1m_net_change"),
+            ),
+            realized_value: HeightMap::new_bin(1, MapKind::Computed, &f("realized_value")),
+            realized_value_1d_sum: DateMap::new_bin(
+                1,
+                MapKind::Computed,
+                &f("realized_value_1d_sum"),
+            ),
+            sell_side_risk_ratio: DateMap::new_bin(
+                1,
+                MapKind::Computed,
+                &f("sell_side_risk_ratio"),
+            ),
+            realized_profit_to_loss_ratio: HeightMap::new_bin(
+                1,
+                MapKind::Computed,
+                &f("realized_profit_to_loss_ratio"),
+            ),
+            realized_profit_to_loss_1d_sum_ratio: DateMap::new_bin(
+                1,
+                MapKind::Computed,
+                &f("realized_profit_to_loss_1d_sum_ratio"),
+            ),
+        };
+
+        s.min_initial_states
+            .consume(MinInitialStates::compute_from_dataset(&s, config));
+
+        Ok(s)
+    }
+
+    pub fn insert(
+        &mut self,
+        &InsertData {
+            height,
+            date,
+            is_date_last_block,
+            date_blocks_range,
+            ..
+        }: &InsertData,
+        height_state: &RealizedState,
+    ) {
+        self.realized_profit
+            .insert(height, height_state.realized_profit().to_dollar() as f32);
+
+        self.realized_loss
+            .insert(height, height_state.realized_loss().to_dollar() as f32);
+
+        self.value_created
+            .insert(height, height_state.value_created().to_dollar() as f32);
+
+        self.adjusted_value_created.insert(
+            height,
+            height_state.adjusted_value_created().to_dollar() as f32,
+        );
+
+        self.value_destroyed
+            .insert(height, height_state.value_destroyed().to_dollar() as f32);
+
+        self.adjusted_value_destroyed.insert(
+            height,
+            height_state.adjusted_value_destroyed().to_dollar() as f32,
+        );
+
+        self.spent_output_profit_ratio.height.insert(height, {
+            if height_state.value_destroyed() > Price::ZERO {
+                (height_state.value_created().to_cent() as f64
+                    / height_state.value_destroyed().to_cent() as f64) as f32
+            } else {
+                1.0
+            }
+        });
+
+        self.adjusted_spent_output_profit_ratio
+            .height
+            .insert(height, {
+                if height_state.adjusted_value_destroyed() > Price::ZERO {
+                    (height_state.adjusted_value_created().to_cent() as f64
+                        / height_state.adjusted_value_destroyed().to_cent() as f64)
+                        as f32
+                } else {
+                    1.0
+                }
+            });
+
+        if is_date_last_block {
+            self.realized_profit_1d_sum
+                .insert(date, self.realized_profit.sum_range(date_blocks_range));
+
+            self.realized_loss_1d_sum
+                .insert(date, self.realized_loss.sum_range(date_blocks_range));
+
+            let value_created_1d_sum = self
+                .value_created_1d_sum
+                .insert(date, self.value_created.sum_range(date_blocks_range));
+
+            let adjusted_value_created_1d_sum = self.adjusted_value_created_1d_sum.insert(
+                date,
+                self.adjusted_value_created.sum_range(date_blocks_range),
+            );
+
+            let value_destroyed_1d_sum = self
+                .value_destroyed_1d_sum
+                .insert(date, self.value_destroyed.sum_range(date_blocks_range));
+
+            let adjusted_value_destroyed_1d_sum = self.adjusted_value_destroyed_1d_sum.insert(
+                date,
+                self.adjusted_value_destroyed.sum_range(date_blocks_range),
+            );
+
+            self.spent_output_profit_ratio
+                .date
+                .insert(date, value_created_1d_sum / value_destroyed_1d_sum);
+
+            self.adjusted_spent_output_profit_ratio.date.insert(
+                date,
+                adjusted_value_created_1d_sum / adjusted_value_destroyed_1d_sum,
+            );
+        }
+    }
+
+    pub fn compute(
+        &mut self,
+        &ComputeData { heights, dates, .. }: &ComputeData,
+        market_cap: &mut BiMap<f32>,
+    ) {
+        self.negative_realized_loss.multi_insert_simple_transform(
+            heights,
+            &mut self.realized_loss,
+            |v, _| v * -1.0,
+        );
+
+        self.negative_realized_loss_1d_sum
+            .multi_insert_simple_transform(dates, &mut self.realized_loss_1d_sum, |v, _| v * -1.0);
+
+        self.net_realized_profit_and_loss.multi_insert_subtract(
+            heights,
+            &mut self.realized_profit,
+            &mut self.realized_loss,
+        );
+
+        self.net_realized_profit_and_loss_1d_sum
+            .multi_insert_subtract(
+                dates,
+                &mut self.realized_profit_1d_sum,
+                &mut self.realized_loss_1d_sum,
+            );
+
+        self.net_realized_profit_and_loss_1d_sum_to_market_cap_ratio
+            .multi_insert_percentage(
+                dates,
+                &mut self.net_realized_profit_and_loss_1d_sum,
+                &mut market_cap.date,
+            );
+
+        self.cumulative_realized_profit
+            .height
+            .multi_insert_cumulative(heights, &mut self.realized_profit);
+        self.cumulative_realized_profit
+            .date
+            .multi_insert_cumulative(dates, &mut self.realized_profit_1d_sum);
+
+        self.cumulative_realized_loss
+            .height
+            .multi_insert_cumulative(heights, &mut self.realized_loss);
+        self.cumulative_realized_loss
+            .date
+            .multi_insert_cumulative(dates, &mut self.realized_loss_1d_sum);
+
+        self.cumulative_net_realized_profit_and_loss
+            .height
+            .multi_insert_cumulative(heights, &mut self.net_realized_profit_and_loss);
+        self.cumulative_net_realized_profit_and_loss
+            .date
+            .multi_insert_cumulative(dates, &mut self.net_realized_profit_and_loss_1d_sum);
+
+        self.cumulative_net_realized_profit_and_loss_1m_net_change
+            .multi_insert_net_change(
+                heights,
+                dates,
+                &mut self.cumulative_net_realized_profit_and_loss,
+                ONE_MONTH_IN_DAYS,
+            );
+
+        self.realized_value.multi_insert_add(
+            heights,
+            &mut self.realized_profit,
+            &mut self.realized_loss,
+        );
+
+        self.realized_value_1d_sum.multi_insert_add(
+            dates,
+            &mut self.realized_profit_1d_sum,
+            &mut self.realized_loss_1d_sum,
+        );
+
+        self.sell_side_risk_ratio.multi_insert_percentage(
+            dates,
+            &mut self.realized_value_1d_sum,
+            &mut market_cap.date,
+        );
+
+        self.realized_profit_to_loss_ratio.multi_insert_divide(
+            heights,
+            &mut self.realized_profit,
+            &mut self.realized_loss,
+        );
+        self.realized_profit_to_loss_1d_sum_ratio
+            .multi_insert_divide(
+                dates,
+                &mut self.realized_profit_1d_sum,
+                &mut self.realized_loss_1d_sum,
+            );
+    }
+}
+
+impl AnyDataset for RealizedSubDataset {
+    fn get_min_initial_states(&self) -> &MinInitialStates {
+        &self.min_initial_states
+    }
+}

_src/parser/datasets/subs/recap.rs

@@ -0,0 +1,277 @@
+use std::{iter::Sum, ops::Add};
+
+use allocative::Allocative;
+
+use crate::{
+    structs::{
+        Date, DateMapChunkId, GenericMap, MapChunkId, MapKey, MapKind, MapPath, MapSerialized,
+        MapValue, SerializedDateMap,
+    },
+    utils::{get_percentile, LossyFrom},
+};
+
+pub type DateRecapDataset<T> = RecapDataset<Date, T, DateMapChunkId, SerializedDateMap<T>>;
+
+#[derive(Allocative)]
+pub struct RecapDataset<Key, Value, ChunkId, Serialized> {
+    average: Option<GenericMap<Key, Value, ChunkId, Serialized>>,
+    sum: Option<GenericMap<Key, Value, ChunkId, Serialized>>,
+    max: Option<GenericMap<Key, Value, ChunkId, Serialized>>,
+    _90p: Option<GenericMap<Key, Value, ChunkId, Serialized>>,
+    _75p: Option<GenericMap<Key, Value, ChunkId, Serialized>>,
+    median: Option<GenericMap<Key, Value, ChunkId, Serialized>>,
+    _25p: Option<GenericMap<Key, Value, ChunkId, Serialized>>,
+    _10p: Option<GenericMap<Key, Value, ChunkId, Serialized>>,
+    min: Option<GenericMap<Key, Value, ChunkId, Serialized>>,
+}
+
+#[derive(Default)]
+pub struct RecapOptions {
+    average: bool,
+    sum: bool,
+    max: bool,
+    _90p: bool,
+    _75p: bool,
+    median: bool,
+    _25p: bool,
+    _10p: bool,
+    min: bool,
+}
+
+impl RecapOptions {
+    pub fn add_min(mut self) -> Self {
+        self.min = true;
+        self
+    }
+
+    pub fn add_max(mut self) -> Self {
+        self.max = true;
+        self
+    }
+
+    pub fn add_median(mut self) -> Self {
+        self.median = true;
+        self
+    }
+
+    pub fn add_average(mut self) -> Self {
+        self.average = true;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn add_sum(mut self) -> Self {
+        self.sum = true;
+        self
+    }
+
+    pub fn add_90p(mut self) -> Self {
+        self._90p = true;
+        self
+    }
+
+    pub fn add_75p(mut self) -> Self {
+        self._75p = true;
+        self
+    }
+
+    pub fn add_25p(mut self) -> Self {
+        self._25p = true;
+        self
+    }
+
+    pub fn add_10p(mut self) -> Self {
+        self._10p = true;
+        self
+    }
+}
+
+impl<Key, Value, ChunkId, Serialized> RecapDataset<Key, Value, ChunkId, Serialized>
+where
+    Value: MapValue,
+    ChunkId: MapChunkId,
+    Key: MapKey<ChunkId>,
+    Serialized: MapSerialized<Key, Value, ChunkId>,
+{
+    pub fn import(path: &MapPath, options: RecapOptions) -> color_eyre::Result<Self> {
+        let f = |s: &str| path.join(s);
+
+        let s = Self {
+            // ---
+            // Computed
+            // ---
+            min: options
+                .min
+                .then(|| GenericMap::new_bin(1, MapKind::Computed, &f("min"))),
+            max: options
+                .max
+                .then(|| GenericMap::new_bin(1, MapKind::Computed, &f("max"))),
+            median: options
+                .median
+                .then(|| GenericMap::new_bin(1, MapKind::Computed, &f("median"))),
+            average: options
+                .average
+                .then(|| GenericMap::new_bin(1, MapKind::Computed, &f("average"))),
+            sum: options
+                .sum
+                .then(|| GenericMap::new_bin(1, MapKind::Computed, &f("sum"))),
+            _90p: options
+                ._90p
+                .then(|| GenericMap::new_bin(1, MapKind::Computed, &f("90p"))),
+            _75p: options
+                ._75p
+                .then(|| GenericMap::new_bin(1, MapKind::Computed, &f("75p"))),
+            _25p: options
+                ._25p
+                .then(|| GenericMap::new_bin(1, MapKind::Computed, &f("25p"))),
+            _10p: options
+                ._10p
+                .then(|| GenericMap::new_bin(1, MapKind::Computed, &f("10p"))),
+        };
+
+        Ok(s)
+    }
+
+    pub fn compute<'a, Value2>(&mut self, key: Key, values: &'a mut [Value2])
+    where
+        Value: LossyFrom<f32> + LossyFrom<Value2>,
+        Value2: Sum<&'a Value2> + Ord + Add<Output = Value2> + Clone + Copy + LossyFrom<f32>,
+        f32: LossyFrom<Value> + LossyFrom<Value2>,
+    {
+        if self.max.is_some()
+            || self._90p.is_some()
+            || self._75p.is_some()
+            || self.median.is_some()
+            || self._25p.is_some()
+            || self._10p.is_some()
+            || self.min.is_some()
+        {
+            values.sort_unstable();
+
+            if let Some(max) = self.max.as_mut() {
+                max.insert_computed(key, Value::lossy_from(*values.last().unwrap()));
+            }
+
+            if let Some(_90p) = self._90p.as_mut() {
+                _90p.insert_computed(key, Value::lossy_from(get_percentile(values, 0.90)));
+            }
+
+            if let Some(_75p) = self._75p.as_mut() {
+                _75p.insert_computed(key, Value::lossy_from(get_percentile(values, 0.75)));
+            }
+
+            if let Some(median) = self.median.as_mut() {
+                median.insert_computed(key, Value::lossy_from(get_percentile(values, 0.50)));
+            }
+
+            if let Some(_25p) = self._25p.as_mut() {
+                _25p.insert_computed(key, Value::lossy_from(get_percentile(values, 0.25)));
+            }
+
+            if let Some(_10p) = self._10p.as_mut() {
+                _10p.insert_computed(key, Value::lossy_from(get_percentile(values, 0.10)));
+            }
+
+            if let Some(min) = self.min.as_mut() {
+                min.insert_computed(key, Value::lossy_from(*values.first().unwrap()));
+            }
+        }
+
+        if self.sum.is_some() || self.average.is_some() {
+            let sum = Value::lossy_from(values.iter().sum::<Value2>());
+
+            if let Some(sum_map) = self.sum.as_mut() {
+                sum_map.insert_computed(key, sum);
+            }
+
+            if let Some(average) = self.average.as_mut() {
+                let len = values.len() as f32;
+                average.insert_computed(key, Value::lossy_from(f32::lossy_from(sum) / len));
+            }
+        }
+    }
+
+    pub fn as_vec(&self) -> Vec<&GenericMap<Key, Value, ChunkId, Serialized>> {
+        let mut v = vec![];
+
+        if let Some(min) = self.min.as_ref() {
+            v.push(min);
+        }
+
+        if let Some(max) = self.max.as_ref() {
+            v.push(max);
+        }
+
+        if let Some(median) = self.median.as_ref() {
+            v.push(median);
+        }
+
+        if let Some(average) = self.average.as_ref() {
+            v.push(average);
+        }
+
+        if let Some(sum) = self.sum.as_ref() {
+            v.push(sum);
+        }
+
+        if let Some(_90p) = self._90p.as_ref() {
+            v.push(_90p);
+        }
+
+        if let Some(_75p) = self._75p.as_ref() {
+            v.push(_75p);
+        }
+
+        if let Some(_25p) = self._25p.as_ref() {
+            v.push(_25p);
+        }
+
+        if let Some(_10p) = self._10p.as_ref() {
+            v.push(_10p);
+        }
+
+        v
+    }
+
+    pub fn as_mut_vec(&mut self) -> Vec<&mut GenericMap<Key, Value, ChunkId, Serialized>> {
+        let mut v = vec![];
+
+        if let Some(min) = self.min.as_mut() {
+            v.push(min);
+        }
+
+        if let Some(max) = self.max.as_mut() {
+            v.push(max);
+        }
+
+        if let Some(median) = self.median.as_mut() {
+            v.push(median);
+        }
+
+        if let Some(average) = self.average.as_mut() {
+            v.push(average);
+        }
+
+        if let Some(sum) = self.sum.as_mut() {
+            v.push(sum);
+        }
+
+        if let Some(_90p) = self._90p.as_mut() {
+            v.push(_90p);
+        }
+
+        if let Some(_75p) = self._75p.as_mut() {
+            v.push(_75p);
+        }
+
+        if let Some(_25p) = self._25p.as_mut() {
+            v.push(_25p);
+        }
+
+        if let Some(_10p) = self._10p.as_mut() {
+            v.push(_10p);
+        }
+
+        v
+    }
+}

_src/parser/datasets/subs/supply.rs

@@ -0,0 +1,109 @@
+use allocative::Allocative;
+use struct_iterable::Iterable;
+
+use crate::{
+    parser::{
+        datasets::{AnyDataset, ComputeData, InsertData, MinInitialStates},
+        states::SupplyState,
+    },
+    structs::{BiMap, Config, MapKind, MapPath},
+};
+
+#[derive(Allocative, Iterable)]
+pub struct SupplySubDataset {
+    min_initial_states: MinInitialStates,
+
+    pub supply: BiMap<f64>,
+    pub supply_to_circulating_supply_ratio: BiMap<f64>,
+    pub halved_supply: BiMap<f64>,
+    pub halved_supply_to_circulating_supply_ratio: BiMap<f64>,
+}
+
+impl SupplySubDataset {
+    pub fn import(
+        path: &MapPath,
+        name: &Option<String>,
+        config: &Config,
+    ) -> color_eyre::Result<Self> {
+        let f = |s: &str| {
+            if let Some(name) = name {
+                path.join(&format!("{name}/{s}"))
+            } else {
+                path.join(s)
+            }
+        };
+
+        let mut s = Self {
+            min_initial_states: MinInitialStates::default(),
+
+            // ---
+            // Inserted
+            // ---
+            supply: BiMap::new_bin(1, MapKind::Inserted, &f("supply")),
+
+            // ---
+            // Computed,
+            // ---
+            supply_to_circulating_supply_ratio: BiMap::new_bin(
+                1,
+                MapKind::Computed,
+                &f("supply_to_circulating_supply_ratio"),
+            ),
+            halved_supply: BiMap::new_bin(1, MapKind::Computed, &f("halved_supply")),
+            halved_supply_to_circulating_supply_ratio: BiMap::new_bin(
+                1,
+                MapKind::Computed,
+                &f("halved_supply_to_circulating_supply_ratio"),
+            ),
+        };
+
+        s.min_initial_states
+            .consume(MinInitialStates::compute_from_dataset(&s, config));
+
+        Ok(s)
+    }
+
+    pub fn insert(
+        &mut self,
+        &InsertData {
+            height,
+            date,
+            is_date_last_block,
+            ..
+        }: &InsertData,
+        state: &SupplyState,
+    ) {
+        let total_supply = self.supply.height.insert(height, state.supply().to_btc());
+
+        if is_date_last_block {
+            self.supply.date.insert(date, total_supply);
+        }
+    }
+
+    #[allow(unused_variables)]
+    pub fn compute(
+        &mut self,
+        &ComputeData { heights, dates, .. }: &ComputeData,
+        circulating_supply: &mut BiMap<f64>,
+    ) {
+        self.supply_to_circulating_supply_ratio
+            .multi_insert_percentage(heights, dates, &mut self.supply, circulating_supply);
+
+        self.halved_supply
+            .multi_insert_simple_transform(heights, dates, &mut self.supply, &|v| v / 2.0);
+
+        self.halved_supply_to_circulating_supply_ratio
+            .multi_insert_simple_transform(
+                heights,
+                dates,
+                &mut self.supply_to_circulating_supply_ratio,
+                &|v| v / 2.0,
+            );
+    }
+}
+
+impl AnyDataset for SupplySubDataset {
+    fn get_min_initial_states(&self) -> &MinInitialStates {
+        &self.min_initial_states
+    }
+}

_src/parser/datasets/subs/unrealized.rs

@@ -0,0 +1,199 @@
+use allocative::Allocative;
+use struct_iterable::Iterable;
+
+use crate::{
+    parser::{
+        datasets::{AnyDataset, ComputeData, InsertData, MinInitialStates},
+        states::UnrealizedState,
+    },
+    structs::{BiMap, Config, MapKind, MapPath},
+};
+
+#[derive(Allocative, Iterable)]
+pub struct UnrealizedSubDataset {
+    min_initial_states: MinInitialStates,
+
+    supply_in_profit: BiMap<f64>,
+    unrealized_profit: BiMap<f32>,
+    unrealized_loss: BiMap<f32>,
+    supply_in_loss: BiMap<f64>,
+    negative_unrealized_loss: BiMap<f32>,
+    net_unrealized_profit_and_loss: BiMap<f32>,
+    net_unrealized_profit_and_loss_to_market_cap_ratio: BiMap<f32>,
+    supply_in_profit_to_own_supply_ratio: BiMap<f64>,
+    supply_in_profit_to_circulating_supply_ratio: BiMap<f64>,
+    supply_in_loss_to_own_supply_ratio: BiMap<f64>,
+    supply_in_loss_to_circulating_supply_ratio: BiMap<f64>,
+}
+
+impl UnrealizedSubDataset {
+    pub fn import(
+        path: &MapPath,
+        name: &Option<String>,
+        config: &Config,
+    ) -> color_eyre::Result<Self> {
+        let f = |s: &str| {
+            if let Some(name) = name {
+                path.join(&format!("{name}/{s}"))
+            } else {
+                path.join(s)
+            }
+        };
+
+        let mut s = Self {
+            min_initial_states: MinInitialStates::default(),
+
+            // ---
+            // Inserted
+            // ---
+            supply_in_profit: BiMap::new_bin(1, MapKind::Inserted, &f("supply_in_profit")),
+            unrealized_profit: BiMap::new_bin(1, MapKind::Inserted, &f("unrealized_profit")),
+            unrealized_loss: BiMap::new_bin(1, MapKind::Inserted, &f("unrealized_loss")),
+
+            // ---
+            // Inserted
+            // ---
+            supply_in_loss: BiMap::new_bin(1, MapKind::Computed, &f("supply_in_loss")),
+            negative_unrealized_loss: BiMap::new_bin(
+                1,
+                MapKind::Computed,
+                &f("negative_unrealized_loss"),
+            ),
+            net_unrealized_profit_and_loss: BiMap::new_bin(
+                1,
+                MapKind::Computed,
+                &f("net_unrealized_profit_and_loss"),
+            ),
+            net_unrealized_profit_and_loss_to_market_cap_ratio: BiMap::new_bin(
+                2,
+                MapKind::Computed,
+                &f("net_unrealized_profit_and_loss_to_market_cap_ratio"),
+            ),
+            supply_in_profit_to_own_supply_ratio: BiMap::new_bin(
+                1,
+                MapKind::Computed,
+                &f("supply_in_profit_to_own_supply_ratio"),
+            ),
+            supply_in_profit_to_circulating_supply_ratio: BiMap::new_bin(
+                1,
+                MapKind::Computed,
+                &f("supply_in_profit_to_circulating_supply_ratio"),
+            ),
+            supply_in_loss_to_own_supply_ratio: BiMap::new_bin(
+                1,
+                MapKind::Computed,
+                &f("supply_in_loss_to_own_supply_ratio"),
+            ),
+            supply_in_loss_to_circulating_supply_ratio: BiMap::new_bin(
+                1,
+                MapKind::Computed,
+                &f("supply_in_loss_to_circulating_supply_ratio"),
+            ),
+        };
+
+        s.min_initial_states
+            .consume(MinInitialStates::compute_from_dataset(&s, config));
+
+        Ok(s)
+    }
+
+    pub fn insert(
+        &mut self,
+        &InsertData {
+            height,
+            date,
+            is_date_last_block,
+            ..
+        }: &InsertData,
+        block_state: &UnrealizedState,
+        date_state: &Option<UnrealizedState>,
+    ) {
+        self.supply_in_profit
+            .height
+            .insert(height, block_state.supply_in_profit().to_btc());
+
+        self.unrealized_profit
+            .height
+            .insert(height, block_state.unrealized_profit().to_dollar() as f32);
+
+        self.unrealized_loss
+            .height
+            .insert(height, block_state.unrealized_loss().to_dollar() as f32);
+
+        if is_date_last_block {
+            let date_state = date_state.as_ref().unwrap();
+
+            self.supply_in_profit
+                .date
+                .insert(date, date_state.supply_in_profit().to_btc());
+
+            self.unrealized_profit
+                .date
+                .insert(date, date_state.unrealized_profit().to_dollar() as f32);
+
+            self.unrealized_loss
+                .date
+                .insert(date, date_state.unrealized_loss().to_dollar() as f32);
+        }
+    }
+
+    pub fn compute(
+        &mut self,
+        &ComputeData { heights, dates, .. }: &ComputeData,
+        own_supply: &mut BiMap<f64>,
+        circulating_supply: &mut BiMap<f64>,
+        market_cap: &mut BiMap<f32>,
+    ) {
+        self.supply_in_loss.multi_insert_subtract(
+            heights,
+            dates,
+            own_supply,
+            &mut self.supply_in_profit,
+        );
+
+        self.negative_unrealized_loss.multi_insert_simple_transform(
+            heights,
+            dates,
+            &mut self.unrealized_loss,
+            &|v| v * -1.0,
+        );
+
+        self.net_unrealized_profit_and_loss.multi_insert_subtract(
+            heights,
+            dates,
+            &mut self.unrealized_profit,
+            &mut self.unrealized_loss,
+        );
+
+        self.net_unrealized_profit_and_loss_to_market_cap_ratio
+            .multi_insert_percentage(
+                heights,
+                dates,
+                &mut self.net_unrealized_profit_and_loss,
+                market_cap,
+            );
+
+        self.supply_in_profit_to_own_supply_ratio
+            .multi_insert_percentage(heights, dates, &mut self.supply_in_profit, own_supply);
+
+        self.supply_in_profit_to_circulating_supply_ratio
+            .multi_insert_percentage(
+                heights,
+                dates,
+                &mut self.supply_in_profit,
+                circulating_supply,
+            );
+
+        self.supply_in_loss_to_own_supply_ratio
+            .multi_insert_percentage(heights, dates, &mut self.supply_in_loss, own_supply);
+
+        self.supply_in_loss_to_circulating_supply_ratio
+            .multi_insert_percentage(heights, dates, &mut self.supply_in_loss, circulating_supply);
+    }
+}
+
+impl AnyDataset for UnrealizedSubDataset {
+    fn get_min_initial_states(&self) -> &MinInitialStates {
+        &self.min_initial_states
+    }
+}

_src/parser/datasets/subs/utxo.rs

@@ -0,0 +1,70 @@
+use allocative::Allocative;
+use struct_iterable::Iterable;
+
+use crate::{
+    parser::{
+        datasets::{AnyDataset, InsertData, MinInitialStates},
+        states::UTXOState,
+    },
+    structs::{BiMap, Config, MapKind, MapPath},
+};
+
+#[derive(Allocative, Iterable)]
+pub struct UTXOSubDataset {
+    min_initial_states: MinInitialStates,
+
+    count: BiMap<f64>,
+}
+
+impl UTXOSubDataset {
+    pub fn import(
+        path: &MapPath,
+        name: &Option<String>,
+        config: &Config,
+    ) -> color_eyre::Result<Self> {
+        let f = |s: &str| {
+            if let Some(name) = name {
+                path.join(&format!("{name}/{s}"))
+            } else {
+                path.join(s)
+            }
+        };
+
+        let mut s = Self {
+            min_initial_states: MinInitialStates::default(),
+
+            // ---
+            // Inserted
+            // ---
+            count: BiMap::new_bin(1, MapKind::Inserted, &f("utxo_count")),
+        };
+
+        s.min_initial_states
+            .consume(MinInitialStates::compute_from_dataset(&s, config));
+
+        Ok(s)
+    }
+
+    pub fn insert(
+        &mut self,
+        &InsertData {
+            height,
+            is_date_last_block,
+            date,
+            ..
+        }: &InsertData,
+        state: &UTXOState,
+    ) {
+        let count = self.count.height.insert(height, state.count());
+
+        if is_date_last_block {
+            self.count.date.insert(date, count);
+        }
+    }
+}
+
+impl AnyDataset for UTXOSubDataset {
+    fn get_min_initial_states(&self) -> &MinInitialStates {
+        &self.min_initial_states
+    }
+}