Mirror/brk
1
0
Fork 0
mirror of https://github.com/bitcoinresearchkit/brk.git synced 2026-07-28 19:28:11 -07:00
Code Issues Packages Projects Releases Wiki Activity

global: ivecs

Browse Source
This commit is contained in:
nym21
2025-10-05 16:05:17 +02:00
parent 5fde0101bf
commit b622285999
59 changed files with 1106 additions and 2240 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/brk_computer/src/blks.rs
+6 -18
View File
@@ -4,14 +4,15 @@ use brk_error::Result;
use brk_indexer::Indexer;
use brk_parser::Parser;
use brk_structs::{BlkPosition, Height, TxIndex, Version};
use brk_vecs::IVecs;
use vecdb::{
AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, CompressedVec, Database, Exit,
GenericStoredVec, PAGE_SIZE, VecIterator,
AnyIterableVec, AnyStoredVec, AnyVec, CompressedVec, Database, Exit, GenericStoredVec,
PAGE_SIZE, VecIterator,
};
use super::{Indexes, indexes};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Vecs {
db: Database,
@@ -41,11 +42,8 @@ impl Vecs {
db,
};
this.db.retain_regions(
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
this.db
.retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
Ok(this)
}
@@ -128,14 +126,4 @@ impl Vecs {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
Box::new(
[
&self.height_to_position as &dyn AnyCollectableVec,
&self.txindex_to_position,
]
.into_iter(),
)
}
}
crates/brk_computer/src/chain.rs
+6 -144
View File
@@ -9,9 +9,10 @@ use brk_structs::{
SemesterIndex, StoredBool, StoredF32, StoredF64, StoredU32, StoredU64, Timestamp, TxIndex,
TxVersion, Version, WeekIndex, Weight, YearIndex,
};
use brk_vecs::IVecs;
use vecdb::{
AnyCloneableIterableVec, AnyCollectableVec, AnyIterableVec, Database, EagerVec, Exit,
LazyVecFrom1, LazyVecFrom2, LazyVecFrom3, PAGE_SIZE, StoredIndex, VecIterator,
AnyCloneableIterableVec, AnyIterableVec, Database, EagerVec, Exit, LazyVecFrom1, LazyVecFrom2,
LazyVecFrom3, PAGE_SIZE, StoredIndex, VecIterator,
};
use crate::grouped::{
@@ -32,7 +33,7 @@ const TARGET_BLOCKS_PER_YEAR: u64 = 2 * TARGET_BLOCKS_PER_SEMESTER;
const TARGET_BLOCKS_PER_DECADE: u64 = 10 * TARGET_BLOCKS_PER_YEAR;
const ONE_TERA_HASH: f64 = 1_000_000_000_000.0;
#[derive(Clone, Allocative)]
#[derive(Clone, IVecs, Allocative)]
pub struct Vecs {
db: Database,
@@ -1151,11 +1152,8 @@ impl Vecs {
db,
};
this.db.retain_regions(
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
this.db
.retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
Ok(this)
}
@@ -2289,140 +2287,4 @@ impl Vecs {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(
[
&self.height_to_interval as &dyn AnyCollectableVec,
&self.height_to_vbytes,
&self.difficultyepoch_to_timestamp,
&self.halvingepoch_to_timestamp,
&self.inputindex_to_value,
&self.txindex_to_fee,
&self.txindex_to_fee_rate,
&self.txindex_to_input_value,
&self.txindex_to_is_coinbase,
&self.txindex_to_output_value,
&self.txindex_to_vsize,
&self.txindex_to_weight,
&self.dateindex_to_fee_dominance,
&self.dateindex_to_subsidy_dominance,
&self.dateindex_to_block_count_target,
&self.weekindex_to_block_count_target,
&self.monthindex_to_block_count_target,
&self.quarterindex_to_block_count_target,
&self.semesterindex_to_block_count_target,
&self.yearindex_to_block_count_target,
&self.decadeindex_to_block_count_target,
&self.height_to_24h_block_count,
&self.height_to_24h_coinbase_sum,
&self.height_to_24h_coinbase_usd_sum,
]
.into_iter(),
);
iter = Box::new(iter.chain(self.indexes_to_hash_rate.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_rate_1w_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_rate_1m_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_rate_2m_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_rate_1y_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.timeindexes_to_timestamp.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_block_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1w_block_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1m_block_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1y_block_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_block_interval.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_block_size.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_block_vbytes.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_block_weight.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_inflation_rate.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_difficulty.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_difficulty_adjustment.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_difficultyepoch.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_halvingepoch.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_difficulty_as_hash.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.indexes_to_blocks_before_next_difficulty_adjustment
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_days_before_next_difficulty_adjustment
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_blocks_before_next_halving
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_days_before_next_halving
.iter_any_collectable(),
),
);
iter = Box::new(iter.chain(self.indexes_to_sent.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_price_ths.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_price_phs.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_value_ths.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_value_phs.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_price_ths_min.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_price_phs_min.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_value_ths_min.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_value_phs_min.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_price_rebound.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_value_rebound.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_coinbase.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_fee.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_fee_rate.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_tx_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_tx_v1.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_tx_v2.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_tx_v3.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_tx_vsize.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_tx_weight.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_emptyoutput_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_input_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_opreturn_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_output_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_p2a_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_p2ms_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_p2pk33_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_p2pk65_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_p2pkh_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_p2sh_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_p2tr_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_p2wpkh_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_p2wsh_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_unknownoutput_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_subsidy.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_exact_utxo_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_unclaimed_rewards.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_annualized_volume.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_annualized_volume_btc.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_annualized_volume_usd.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_tx_btc_velocity.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_tx_usd_velocity.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_tx_per_sec.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_outputs_per_sec.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_inputs_per_sec.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.indexes_to_subsidy_usd_1y_sma
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_puell_multiple
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter
}
}
crates/brk_computer/src/cointime.rs
+5 -75
View File
@@ -2,7 +2,8 @@ use std::path::Path;
use brk_error::Result;
use brk_structs::{Bitcoin, CheckedSub, Dollars, StoredF32, StoredF64, Version};
use vecdb::{AnyCollectableVec, Database, Exit, PAGE_SIZE, VecIterator};
use brk_vecs::IVecs;
use vecdb::{Database, Exit, PAGE_SIZE, VecIterator};
use crate::grouped::ComputedVecsFromDateIndex;
@@ -15,7 +16,7 @@ use super::{
indexes, price, stateful,
};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Vecs {
db: Database,
@@ -277,11 +278,8 @@ impl Vecs {
db,
};
this.db.retain_regions(
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
this.db
.retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
Ok(this)
}
@@ -678,72 +676,4 @@ impl Vecs {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(std::iter::empty());
iter = Box::new(
iter.chain(
self.indexes_to_cointime_adj_inflation_rate
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_cointime_adj_tx_btc_velocity
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_cointime_adj_tx_usd_velocity
.iter_any_collectable(),
),
);
iter = Box::new(iter.chain(self.indexes_to_coinblocks_created.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_coinblocks_stored.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_liveliness.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_vaultedness.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.indexes_to_activity_to_vaultedness_ratio
.iter_any_collectable(),
),
);
iter = Box::new(iter.chain(self.indexes_to_vaulted_supply.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_active_supply.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_thermo_cap.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_investor_cap.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_vaulted_cap.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_active_cap.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_vaulted_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_vaulted_price_ratio.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_active_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_active_price_ratio.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_true_market_mean.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.indexes_to_true_market_mean_ratio
.iter_any_collectable(),
),
);
iter = Box::new(iter.chain(self.indexes_to_cointime_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_cointime_cap.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_cointime_price_ratio.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.indexes_to_cointime_value_destroyed
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_cointime_value_created
.iter_any_collectable(),
),
);
iter = Box::new(iter.chain(self.indexes_to_cointime_value_stored.iter_any_collectable()));
iter
}
}
crates/brk_computer/src/constants.rs
+5 -29
View File
@@ -2,7 +2,8 @@ use std::path::Path;
use brk_error::Result;
use brk_structs::{StoredF32, StoredI16, StoredU16, Version};
use vecdb::{AnyCollectableVec, AnyVec, Database, Exit};
use brk_vecs::IVecs;
use vecdb::{AnyVec, Database, Exit};
use crate::grouped::Source;
@@ -12,7 +13,7 @@ use super::{
indexes,
};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Vecs {
db: Database,
@@ -159,11 +160,8 @@ impl Vecs {
db,
};
this.db.retain_regions(
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
this.db
.retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
Ok(this)
}
@@ -249,26 +247,4 @@ impl Vecs {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(std::iter::empty());
iter = Box::new(iter.chain(self.constant_0.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_1.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_2.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_3.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_4.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_38_2.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_50.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_61_8.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_100.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_600.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_minus_1.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_minus_2.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_minus_3.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_minus_4.iter_any_collectable()));
iter
}
}
crates/brk_computer/src/fetched.rs
+6 -16
View File
@@ -4,14 +4,15 @@ use brk_error::Result;
use brk_fetcher::Fetcher;
use brk_indexer::Indexer;
use brk_structs::{DateIndex, Height, OHLCCents, Version};
use brk_vecs::IVecs;
use vecdb::{
AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, Database, Exit, GenericStoredVec,
RawVec, StoredIndex, VecIterator,
AnyIterableVec, AnyStoredVec, AnyVec, Database, Exit, GenericStoredVec, RawVec, StoredIndex,
VecIterator,
};
use super::{Indexes, indexes};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Vecs {
db: Database,
fetcher: Fetcher,
@@ -41,11 +42,8 @@ impl Vecs {
db,
};
this.db.retain_regions(
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
this.db
.retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
Ok(this)
}
@@ -138,12 +136,4 @@ impl Vecs {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
[
&self.dateindex_to_price_ohlc_in_cents as &dyn AnyCollectableVec,
&self.height_to_price_ohlc_in_cents,
]
.into_iter()
}
}
crates/brk_computer/src/grouped/builder_eager.rs
+6 -99
View File
@@ -1,6 +1,7 @@
use allocative::Allocative;
use brk_error::{Error, Result};
use brk_structs::{CheckedSub, StoredU64, Version};
use brk_vecs::IVecs;
use vecdb::{
AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit, Format,
GenericStoredVec, StoredIndex, StoredRaw,
@@ -10,8 +11,8 @@ use crate::utils::get_percentile;
use super::ComputedType;
#[derive(Clone, Debug, Allocative)]
pub struct EagerVecBuilder<I, T>
#[derive(Clone, Debug, IVecs, Allocative)]
pub struct EagerVecsBuilder<I, T>
where
I: StoredIndex,
T: ComputedType,
@@ -32,7 +33,7 @@ where
const VERSION: Version = Version::ZERO;
impl<I, T> EagerVecBuilder<I, T>
impl<I, T> EagerVecsBuilder<I, T>
where
I: StoredIndex,
T: ComputedType,
@@ -394,7 +395,7 @@ where
pub fn from_aligned<I2>(
&mut self,
max_from: I,
source: &EagerVecBuilder<I2, T>,
source: &EagerVecsBuilder<I2, T>,
first_indexes: &impl AnyIterableVec<I, I2>,
count_indexes: &impl AnyIterableVec<I, StoredU64>,
exit: &Exit,
@@ -540,9 +541,7 @@ where
}
pub fn starting_index(&self, max_from: I) -> I {
max_from.min(I::from(
self.iter_any_collectable().map(|v| v.len()).min().unwrap(),
))
max_from.min(I::from(self.iter().map(|v| v.len()).min().unwrap()))
}
pub fn unwrap_first(&self) -> &EagerVec<I, T> {
@@ -589,98 +588,6 @@ where
self.cumulative.as_ref().unwrap()
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(std::iter::empty());
iter = Box::new(
iter.chain(
self.first
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.last
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.min
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.max
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.median
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.average
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.sum
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.cumulative
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.pct90
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.pct75
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.pct25
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.pct10
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter
}
pub fn safe_flush(&mut self, exit: &Exit) -> Result<()> {
if let Some(first) = self.first.as_mut() {
first.safe_flush(exit)?;
crates/brk_computer/src/grouped/builder_lazy.rs
+8 -65
View File
@@ -1,20 +1,22 @@
use allocative::Allocative;
use brk_structs::Version;
use brk_vecs::IVecs;
use vecdb::{
AnyBoxedIterableVec, AnyCloneableIterableVec, AnyCollectableVec, FromCoarserIndex,
LazyVecFrom2, StoredIndex,
};
use crate::grouped::{EagerVecBuilder, VecBuilderOptions};
use crate::grouped::{EagerVecsBuilder, VecBuilderOptions};
use super::ComputedType;
#[allow(clippy::type_complexity)]
#[derive(Clone, Allocative)]
pub struct LazyVecBuilder<I, T, S1I, S2T>
#[derive(Clone, IVecs, Allocative)]
pub struct LazyVecsBuilder<I, T, S1I, S2T>
where
I: StoredIndex,
T: ComputedType,
S1I: StoredIndex,
S2T: ComputedType,
{
pub first: Option<Box<LazyVecFrom2<I, T, S1I, T, I, S2T>>>,
@@ -28,7 +30,7 @@ where
const VERSION: Version = Version::ZERO;
impl<I, T, S1I, S2T> LazyVecBuilder<I, T, S1I, S2T>
impl<I, T, S1I, S2T> LazyVecsBuilder<I, T, S1I, S2T>
where
I: StoredIndex,
T: ComputedType + 'static,
@@ -40,7 +42,7 @@ where
name: &str,
version: Version,
source: Option<AnyBoxedIterableVec<S1I, T>>,
source_extra: &EagerVecBuilder<S1I, T>,
source_extra: &EagerVecsBuilder<S1I, T>,
len_source: AnyBoxedIterableVec<I, S2T>,
options: LazyVecBuilderOptions,
) -> Self {
@@ -216,9 +218,7 @@ where
}
pub fn starting_index(&self, max_from: I) -> I {
max_from.min(I::from(
self.iter_any_collectable().map(|v| v.len()).min().unwrap(),
))
max_from.min(I::from(self.iter().map(|v| v.len()).min().unwrap()))
}
pub fn unwrap_first(&self) -> &LazyVecFrom2<I, T, S1I, T, I, S2T> {
@@ -244,63 +244,6 @@ where
pub fn unwrap_cumulative(&self) -> &LazyVecFrom2<I, T, S1I, T, I, S2T> {
self.cumulative.as_ref().unwrap()
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(std::iter::empty());
iter = Box::new(
iter.chain(
self.first
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.last
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.min
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.max
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.average
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.sum
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.cumulative
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter
}
}
#[derive(Default, Clone, Copy)]
crates/brk_computer/src/grouped/from_dateindex.rs
+19 -37
View File
@@ -4,25 +4,26 @@ use brk_error::Result;
use brk_structs::{
DateIndex, DecadeIndex, MonthIndex, QuarterIndex, SemesterIndex, Version, WeekIndex, YearIndex,
};
use vecdb::{AnyCloneableIterableVec, AnyCollectableVec, AnyIterableVec, Database, EagerVec, Exit};
use brk_vecs::IVecs;
use vecdb::{AnyCloneableIterableVec, AnyIterableVec, Database, EagerVec, Exit};
use crate::{Indexes, grouped::LazyVecBuilder, indexes};
use crate::{Indexes, grouped::LazyVecsBuilder, indexes};
use super::{ComputedType, EagerVecBuilder, Source, VecBuilderOptions};
use super::{ComputedType, EagerVecsBuilder, Source, VecBuilderOptions};
#[derive(Clone, Allocative)]
#[derive(Clone, IVecs, Allocative)]
pub struct ComputedVecsFromDateIndex<T>
where
T: ComputedType + PartialOrd,
{
pub dateindex: Option<EagerVec<DateIndex, T>>,
pub dateindex_extra: EagerVecBuilder<DateIndex, T>,
pub weekindex: LazyVecBuilder<WeekIndex, T, DateIndex, WeekIndex>,
pub monthindex: LazyVecBuilder<MonthIndex, T, DateIndex, MonthIndex>,
pub quarterindex: LazyVecBuilder<QuarterIndex, T, DateIndex, QuarterIndex>,
pub semesterindex: LazyVecBuilder<SemesterIndex, T, DateIndex, SemesterIndex>,
pub yearindex: LazyVecBuilder<YearIndex, T, DateIndex, YearIndex>,
pub decadeindex: LazyVecBuilder<DecadeIndex, T, DateIndex, DecadeIndex>,
pub dateindex_extra: EagerVecsBuilder<DateIndex, T>,
pub weekindex: LazyVecsBuilder<WeekIndex, T, DateIndex, WeekIndex>,
pub monthindex: LazyVecsBuilder<MonthIndex, T, DateIndex, MonthIndex>,
pub quarterindex: LazyVecsBuilder<QuarterIndex, T, DateIndex, QuarterIndex>,
pub semesterindex: LazyVecsBuilder<SemesterIndex, T, DateIndex, SemesterIndex>,
pub yearindex: LazyVecsBuilder<YearIndex, T, DateIndex, YearIndex>,
pub decadeindex: LazyVecsBuilder<DecadeIndex, T, DateIndex, DecadeIndex>,
}
const VERSION: Version = Version::ZERO;
@@ -44,7 +45,7 @@ where
EagerVec::forced_import_compressed(db, name, version + VERSION + Version::ZERO).unwrap()
});
let dateindex_extra = EagerVecBuilder::forced_import_compressed(
let dateindex_extra = EagerVecsBuilder::forced_import_compressed(
db,
name,
version + VERSION + Version::ZERO,
@@ -56,7 +57,7 @@ where
let dateindex_source = source.vec().or(dateindex.as_ref().map(|v| v.boxed_clone()));
Ok(Self {
weekindex: LazyVecBuilder::forced_import(
weekindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
dateindex_source.clone(),
@@ -64,7 +65,7 @@ where
indexes.weekindex_to_weekindex.boxed_clone(),
options.into(),
),
monthindex: LazyVecBuilder::forced_import(
monthindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
dateindex_source.clone(),
@@ -72,7 +73,7 @@ where
indexes.monthindex_to_monthindex.boxed_clone(),
options.into(),
),
quarterindex: LazyVecBuilder::forced_import(
quarterindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
dateindex_source.clone(),
@@ -80,7 +81,7 @@ where
indexes.quarterindex_to_quarterindex.boxed_clone(),
options.into(),
),
semesterindex: LazyVecBuilder::forced_import(
semesterindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
dateindex_source.clone(),
@@ -88,7 +89,7 @@ where
indexes.semesterindex_to_semesterindex.boxed_clone(),
options.into(),
),
yearindex: LazyVecBuilder::forced_import(
yearindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
dateindex_source.clone(),
@@ -96,7 +97,7 @@ where
indexes.yearindex_to_yearindex.boxed_clone(),
options.into(),
),
decadeindex: LazyVecBuilder::forced_import(
decadeindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
dateindex_source.clone(),
@@ -142,23 +143,4 @@ where
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(
self.dateindex
.as_ref()
.map(|x| x as &dyn AnyCollectableVec)
.into_iter(),
);
iter = Box::new(iter.chain(self.dateindex_extra.iter_any_collectable()));
iter = Box::new(iter.chain(self.weekindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.monthindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.quarterindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.semesterindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.yearindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.decadeindex.iter_any_collectable()));
iter
}
}
crates/brk_computer/src/grouped/from_height.rs
+23 -43
View File
@@ -5,32 +5,33 @@ use brk_structs::{
DateIndex, DecadeIndex, DifficultyEpoch, Height, MonthIndex, QuarterIndex, SemesterIndex,
Version, WeekIndex, YearIndex,
};
use vecdb::{AnyCloneableIterableVec, AnyCollectableVec, AnyIterableVec, Database, EagerVec, Exit};
use brk_vecs::IVecs;
use vecdb::{AnyCloneableIterableVec, AnyIterableVec, Database, EagerVec, Exit};
use crate::{
Indexes,
grouped::{LazyVecBuilder, Source},
grouped::{LazyVecsBuilder, Source},
indexes,
};
use super::{ComputedType, EagerVecBuilder, VecBuilderOptions};
use super::{ComputedType, EagerVecsBuilder, VecBuilderOptions};
#[derive(Clone, Allocative)]
#[derive(Clone, IVecs, Allocative)]
pub struct ComputedVecsFromHeight<T>
where
T: ComputedType + PartialOrd,
{
pub height: Option<EagerVec<Height, T>>,
pub height_extra: EagerVecBuilder<Height, T>,
pub dateindex: EagerVecBuilder<DateIndex, T>,
pub weekindex: LazyVecBuilder<WeekIndex, T, DateIndex, WeekIndex>,
pub difficultyepoch: EagerVecBuilder<DifficultyEpoch, T>,
pub monthindex: LazyVecBuilder<MonthIndex, T, DateIndex, MonthIndex>,
pub quarterindex: LazyVecBuilder<QuarterIndex, T, DateIndex, QuarterIndex>,
pub semesterindex: LazyVecBuilder<SemesterIndex, T, DateIndex, SemesterIndex>,
pub yearindex: LazyVecBuilder<YearIndex, T, DateIndex, YearIndex>,
pub height_extra: EagerVecsBuilder<Height, T>,
pub dateindex: EagerVecsBuilder<DateIndex, T>,
pub weekindex: LazyVecsBuilder<WeekIndex, T, DateIndex, WeekIndex>,
pub difficultyepoch: EagerVecsBuilder<DifficultyEpoch, T>,
pub monthindex: LazyVecsBuilder<MonthIndex, T, DateIndex, MonthIndex>,
pub quarterindex: LazyVecsBuilder<QuarterIndex, T, DateIndex, QuarterIndex>,
pub semesterindex: LazyVecsBuilder<SemesterIndex, T, DateIndex, SemesterIndex>,
pub yearindex: LazyVecsBuilder<YearIndex, T, DateIndex, YearIndex>,
// TODO: pub halvingepoch: StorableVecGeneator<Halvingepoch, T>,
pub decadeindex: LazyVecBuilder<DecadeIndex, T, DateIndex, DecadeIndex>,
pub decadeindex: LazyVecsBuilder<DecadeIndex, T, DateIndex, DecadeIndex>,
}
const VERSION: Version = Version::ZERO;
@@ -53,14 +54,14 @@ where
EagerVec::forced_import_compressed(db, name, version + VERSION + Version::ZERO).unwrap()
});
let height_extra = EagerVecBuilder::forced_import_compressed(
let height_extra = EagerVecsBuilder::forced_import_compressed(
db,
name,
version + VERSION + Version::ZERO,
options.copy_self_extra(),
)?;
let dateindex = EagerVecBuilder::forced_import_compressed(
let dateindex = EagerVecsBuilder::forced_import_compressed(
db,
name,
version + VERSION + Version::ZERO,
@@ -70,7 +71,7 @@ where
let options = options.remove_percentiles();
Ok(Self {
weekindex: LazyVecBuilder::forced_import(
weekindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -78,7 +79,7 @@ where
indexes.weekindex_to_weekindex.boxed_clone(),
options.into(),
),
monthindex: LazyVecBuilder::forced_import(
monthindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -86,7 +87,7 @@ where
indexes.monthindex_to_monthindex.boxed_clone(),
options.into(),
),
quarterindex: LazyVecBuilder::forced_import(
quarterindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -94,7 +95,7 @@ where
indexes.quarterindex_to_quarterindex.boxed_clone(),
options.into(),
),
semesterindex: LazyVecBuilder::forced_import(
semesterindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -102,7 +103,7 @@ where
indexes.semesterindex_to_semesterindex.boxed_clone(),
options.into(),
),
yearindex: LazyVecBuilder::forced_import(
yearindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -110,7 +111,7 @@ where
indexes.yearindex_to_yearindex.boxed_clone(),
options.into(),
),
decadeindex: LazyVecBuilder::forced_import(
decadeindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -122,7 +123,7 @@ where
height,
height_extra,
dateindex,
difficultyepoch: EagerVecBuilder::forced_import_compressed(
difficultyepoch: EagerVecsBuilder::forced_import_compressed(
db,
name,
version + VERSION + Version::ZERO,
@@ -198,25 +199,4 @@ where
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(
self.height
.as_ref()
.map(|x| x as &dyn AnyCollectableVec)
.into_iter(),
);
iter = Box::new(iter.chain(self.height_extra.iter_any_collectable()));
iter = Box::new(iter.chain(self.dateindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.weekindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.difficultyepoch.iter_any_collectable()));
iter = Box::new(iter.chain(self.monthindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.quarterindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.semesterindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.yearindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.decadeindex.iter_any_collectable()));
iter
}
}
crates/brk_computer/src/grouped/from_height_strict.rs
+8 -14
View File
@@ -1,20 +1,21 @@
use brk_error::Result;
use brk_structs::{DifficultyEpoch, Height, Version};
use vecdb::{AnyCollectableVec, Database, EagerVec, Exit};
use brk_vecs::IVecs;
use vecdb::{Database, EagerVec, Exit};
use crate::{Indexes, indexes};
use super::{ComputedType, EagerVecBuilder, VecBuilderOptions};
use super::{ComputedType, EagerVecsBuilder, VecBuilderOptions};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct ComputedVecsFromHeightStrict<T>
where
T: ComputedType + PartialOrd,
{
pub height: EagerVec<Height, T>,
pub height_extra: EagerVecBuilder<Height, T>,
pub difficultyepoch: EagerVecBuilder<DifficultyEpoch, T>,
pub height_extra: EagerVecsBuilder<Height, T>,
pub difficultyepoch: EagerVecsBuilder<DifficultyEpoch, T>,
// TODO: pub halvingepoch: StorableVecGeneator<Halvingepoch, T>,
}
@@ -34,7 +35,7 @@ where
let height =
EagerVec::forced_import_compressed(db, name, version + VERSION + Version::ZERO)?;
let height_extra = EagerVecBuilder::forced_import_compressed(
let height_extra = EagerVecsBuilder::forced_import_compressed(
db,
name,
version + VERSION + Version::ZERO,
@@ -46,7 +47,7 @@ where
Ok(Self {
height,
height_extra,
difficultyepoch: EagerVecBuilder::forced_import_compressed(
difficultyepoch: EagerVecsBuilder::forced_import_compressed(
db,
name,
version + VERSION + Version::ZERO,
@@ -81,11 +82,4 @@ where
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
[&self.height as &dyn AnyCollectableVec]
.into_iter()
.chain(self.height_extra.iter_any_collectable())
.chain(self.difficultyepoch.iter_any_collectable())
}
}
crates/brk_computer/src/grouped/from_txindex.rs
+24 -44
View File
@@ -5,35 +5,36 @@ use brk_structs::{
Bitcoin, DateIndex, DecadeIndex, DifficultyEpoch, Dollars, Height, MonthIndex, QuarterIndex,
Sats, SemesterIndex, TxIndex, Version, WeekIndex, YearIndex,
};
use brk_vecs::IVecs;
use vecdb::{
AnyCloneableIterableVec, AnyCollectableVec, AnyVec, CollectableVec, Database, EagerVec, Exit,
GenericStoredVec, StoredIndex, VecIterator,
AnyCloneableIterableVec, AnyVec, CollectableVec, Database, EagerVec, Exit, GenericStoredVec,
StoredIndex, VecIterator,
};
use crate::{
Indexes,
grouped::{LazyVecBuilder, Source},
grouped::{LazyVecsBuilder, Source},
indexes, price,
};
use super::{ComputedType, EagerVecBuilder, VecBuilderOptions};
use super::{ComputedType, EagerVecsBuilder, VecBuilderOptions};
#[derive(Clone, Allocative)]
#[derive(Clone, IVecs, Allocative)]
pub struct ComputedVecsFromTxindex<T>
where
T: ComputedType + PartialOrd,
{
pub txindex: Option<Box<EagerVec<TxIndex, T>>>,
pub height: EagerVecBuilder<Height, T>,
pub dateindex: EagerVecBuilder<DateIndex, T>,
pub weekindex: LazyVecBuilder<WeekIndex, T, DateIndex, WeekIndex>,
pub difficultyepoch: EagerVecBuilder<DifficultyEpoch, T>,
pub monthindex: LazyVecBuilder<MonthIndex, T, DateIndex, MonthIndex>,
pub quarterindex: LazyVecBuilder<QuarterIndex, T, DateIndex, QuarterIndex>,
pub semesterindex: LazyVecBuilder<SemesterIndex, T, DateIndex, SemesterIndex>,
pub yearindex: LazyVecBuilder<YearIndex, T, DateIndex, YearIndex>,
pub height: EagerVecsBuilder<Height, T>,
pub dateindex: EagerVecsBuilder<DateIndex, T>,
pub weekindex: LazyVecsBuilder<WeekIndex, T, DateIndex, WeekIndex>,
pub difficultyepoch: EagerVecsBuilder<DifficultyEpoch, T>,
pub monthindex: LazyVecsBuilder<MonthIndex, T, DateIndex, MonthIndex>,
pub quarterindex: LazyVecsBuilder<QuarterIndex, T, DateIndex, QuarterIndex>,
pub semesterindex: LazyVecsBuilder<SemesterIndex, T, DateIndex, SemesterIndex>,
pub yearindex: LazyVecsBuilder<YearIndex, T, DateIndex, YearIndex>,
// TODO: pub halvingepoch: StorableVecGeneator<Halvingepoch, T>,
pub decadeindex: LazyVecBuilder<DecadeIndex, T, DateIndex, DecadeIndex>,
pub decadeindex: LazyVecsBuilder<DecadeIndex, T, DateIndex, DecadeIndex>,
}
const VERSION: Version = Version::ZERO;
@@ -59,7 +60,7 @@ where
)
});
let height = EagerVecBuilder::forced_import_compressed(
let height = EagerVecsBuilder::forced_import_compressed(
db,
name,
version + VERSION + Version::ZERO,
@@ -68,7 +69,7 @@ where
let options = options.remove_percentiles();
let dateindex = EagerVecBuilder::forced_import_compressed(
let dateindex = EagerVecsBuilder::forced_import_compressed(
db,
name,
version + VERSION + Version::ZERO,
@@ -76,7 +77,7 @@ where
)?;
Ok(Self {
weekindex: LazyVecBuilder::forced_import(
weekindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -84,7 +85,7 @@ where
indexes.weekindex_to_weekindex.boxed_clone(),
options.into(),
),
monthindex: LazyVecBuilder::forced_import(
monthindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -92,7 +93,7 @@ where
indexes.monthindex_to_monthindex.boxed_clone(),
options.into(),
),
quarterindex: LazyVecBuilder::forced_import(
quarterindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -100,7 +101,7 @@ where
indexes.quarterindex_to_quarterindex.boxed_clone(),
options.into(),
),
semesterindex: LazyVecBuilder::forced_import(
semesterindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -108,7 +109,7 @@ where
indexes.semesterindex_to_semesterindex.boxed_clone(),
options.into(),
),
yearindex: LazyVecBuilder::forced_import(
yearindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -116,7 +117,7 @@ where
indexes.yearindex_to_yearindex.boxed_clone(),
options.into(),
),
decadeindex: LazyVecBuilder::forced_import(
decadeindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -128,7 +129,7 @@ where
txindex,
height,
dateindex,
difficultyepoch: EagerVecBuilder::forced_import_compressed(
difficultyepoch: EagerVecsBuilder::forced_import_compressed(
db,
name,
version + VERSION + Version::ZERO,
@@ -225,27 +226,6 @@ where
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(
self.txindex
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec)
.into_iter(),
);
iter = Box::new(iter.chain(self.height.iter_any_collectable()));
iter = Box::new(iter.chain(self.dateindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.weekindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.difficultyepoch.iter_any_collectable()));
iter = Box::new(iter.chain(self.monthindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.quarterindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.semesterindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.yearindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.decadeindex.iter_any_collectable()));
iter
}
}
impl ComputedVecsFromTxindex<Bitcoin> {
crates/brk_computer/src/grouped/ratio_from_dateindex.rs
+4 -132
View File
@@ -1,8 +1,9 @@
use brk_error::Result;
use brk_structs::{Date, DateIndex, Dollars, StoredF32, Version};
use brk_vecs::IVecs;
use vecdb::{
AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, CollectableVec, Database, EagerVec,
Exit, GenericStoredVec, StoredIndex, VecIterator,
AnyIterableVec, AnyStoredVec, AnyVec, CollectableVec, Database, EagerVec, Exit,
GenericStoredVec, StoredIndex, VecIterator,
};
use crate::{
@@ -16,7 +17,7 @@ use crate::{
use super::{ComputedVecsFromDateIndex, VecBuilderOptions};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct ComputedRatioVecsFromDateIndex {
pub price: Option<ComputedVecsFromDateIndex<Dollars>>,
@@ -631,133 +632,4 @@ impl ComputedRatioVecsFromDateIndex {
.flatten()
.collect::<Vec<_>>()
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(self.price.iter().flat_map(|v| v.iter_any_collectable()));
iter = Box::new(iter.chain(self.ratio.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.ratio_1w_sma
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_1m_sma
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(iter.chain(self.ratio_sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(
iter.chain(
self.ratio_1y_sd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_2y_sd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_4y_sd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct1
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct2
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct5
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct95
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct98
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct99
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct1_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct2_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct5_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct95_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct98_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct99_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter
}
}
crates/brk_computer/src/grouped/sd_from_dateindex.rs
+4 -74
View File
@@ -1,15 +1,16 @@
use brk_error::Result;
use brk_structs::{CheckedSub, Date, DateIndex, Dollars, StoredF32, Version};
use brk_vecs::IVecs;
use vecdb::{
AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, BoxedVecIterator, CollectableVec,
Database, EagerVec, Exit, GenericStoredVec, StoredIndex,
AnyIterableVec, AnyStoredVec, AnyVec, BoxedVecIterator, CollectableVec, Database, EagerVec,
Exit, GenericStoredVec, StoredIndex,
};
use crate::{Indexes, grouped::source::Source, indexes};
use super::{ComputedVecsFromDateIndex, VecBuilderOptions};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct ComputedStandardDeviationVecsFromDateIndex {
days: usize,
@@ -804,75 +805,4 @@ impl ComputedStandardDeviationVecsFromDateIndex {
self.mut_stateful_computed()
.map(|c| c.dateindex.as_mut().unwrap())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(self.sma.iter().flat_map(|v| v.iter_any_collectable()));
iter = Box::new(iter.chain(self.sd.iter_any_collectable()));
iter = Box::new(iter.chain(self.p0_5sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.p1sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.p1_5sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.p2sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.p2_5sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.p3sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.m0_5sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.m1sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.m1_5sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.m2sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.m2_5sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.m3sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self._0sd_usd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(
iter.chain(
self.p0_5sd_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(iter.chain(self.p1sd_usd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(
iter.chain(
self.p1_5sd_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(iter.chain(self.p2sd_usd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(
iter.chain(
self.p2_5sd_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(iter.chain(self.p3sd_usd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(
iter.chain(
self.m0_5sd_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(iter.chain(self.m1sd_usd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(
iter.chain(
self.m1_5sd_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(iter.chain(self.m2sd_usd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(
iter.chain(
self.m2_5sd_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(iter.chain(self.m3sd_usd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.zscore.iter().flat_map(|v| v.iter_any_collectable())));
iter
}
}
crates/brk_computer/src/grouped/value_from_dateindex.rs
+3 -9
View File
@@ -1,6 +1,7 @@
use brk_error::Result;
use brk_structs::{Bitcoin, DateIndex, Dollars, Sats, Version};
use vecdb::{AnyCollectableVec, CollectableVec, Database, EagerVec, Exit, StoredVec};
use brk_vecs::IVecs;
use vecdb::{CollectableVec, Database, EagerVec, Exit, StoredVec};
use crate::{
Indexes,
@@ -11,7 +12,7 @@ use crate::{
use super::{Source, VecBuilderOptions};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct ComputedValueVecsFromDateIndex {
pub sats: ComputedVecsFromDateIndex<Sats>,
pub bitcoin: ComputedVecsFromDateIndex<Bitcoin>,
@@ -130,11 +131,4 @@ impl ComputedValueVecsFromDateIndex {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
std::iter::empty()
.chain(self.sats.iter_any_collectable())
.chain(self.bitcoin.iter_any_collectable())
.chain(self.dollars.iter().flat_map(|v| v.iter_any_collectable()))
}
}
crates/brk_computer/src/grouped/value_from_height.rs
+3 -9
View File
@@ -1,7 +1,8 @@
use allocative::Allocative;
use brk_error::Result;
use brk_structs::{Bitcoin, Dollars, Height, Sats, Version};
use vecdb::{AnyCollectableVec, CollectableVec, Database, EagerVec, Exit, StoredVec};
use brk_vecs::IVecs;
use vecdb::{CollectableVec, Database, EagerVec, Exit, StoredVec};
use crate::{
Indexes,
@@ -12,7 +13,7 @@ use crate::{
use super::{ComputedVecsFromHeight, VecBuilderOptions};
#[derive(Clone, Allocative)]
#[derive(Clone, IVecs, Allocative)]
pub struct ComputedValueVecsFromHeight {
pub sats: ComputedVecsFromHeight<Sats>,
pub bitcoin: ComputedVecsFromHeight<Bitcoin>,
@@ -130,11 +131,4 @@ impl ComputedValueVecsFromHeight {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
std::iter::empty()
.chain(self.sats.iter_any_collectable())
.chain(self.bitcoin.iter_any_collectable())
.chain(self.dollars.iter().flat_map(|v| v.iter_any_collectable()))
}
}
crates/brk_computer/src/grouped/value_from_txindex.rs
+4 -16
View File
@@ -2,16 +2,17 @@ use allocative::Allocative;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{Bitcoin, Close, Dollars, Height, Sats, TxIndex, Version};
use brk_vecs::IVecs;
use vecdb::{
AnyCloneableIterableVec, AnyCollectableVec, CollectableVec, Database, Exit, LazyVecFrom1,
LazyVecFrom3, StoredIndex, StoredVec,
AnyCloneableIterableVec, CollectableVec, Database, Exit, LazyVecFrom1, LazyVecFrom3,
StoredIndex, StoredVec,
};
use crate::{Indexes, grouped::Source, indexes, price};
use super::{ComputedVecsFromTxindex, VecBuilderOptions};
#[derive(Clone, Allocative)]
#[derive(Clone, IVecs, Allocative)]
pub struct ComputedValueVecsFromTxindex {
pub sats: ComputedVecsFromTxindex<Sats>,
pub bitcoin_txindex: LazyVecFrom1<TxIndex, Bitcoin, TxIndex, Sats>,
@@ -201,17 +202,4 @@ impl ComputedValueVecsFromTxindex {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
[&self.bitcoin_txindex as &dyn AnyCollectableVec]
.into_iter()
.chain(self.sats.iter_any_collectable())
.chain(self.bitcoin.iter_any_collectable())
.chain(
self.dollars_txindex
.iter()
.map(|v| v as &dyn AnyCollectableVec),
)
.chain(self.dollars.iter().flat_map(|v| v.iter_any_collectable()))
}
}
crates/brk_computer/src/grouped/value_height.rs
+3 -9
View File
@@ -1,6 +1,7 @@
use brk_error::Result;
use brk_structs::{Bitcoin, Dollars, Height, Sats, Version};
use vecdb::{AnyCollectableVec, CollectableVec, Database, EagerVec, Exit, Format, StoredVec};
use brk_vecs::IVecs;
use vecdb::{CollectableVec, Database, EagerVec, Exit, Format, StoredVec};
use crate::{
Indexes,
@@ -9,7 +10,7 @@ use crate::{
traits::{ComputeFromBitcoin, ComputeFromSats},
};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct ComputedHeightValueVecs {
pub sats: Option<EagerVec<Height, Sats>>,
pub bitcoin: EagerVec<Height, Bitcoin>,
@@ -100,11 +101,4 @@ impl ComputedHeightValueVecs {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
[&self.bitcoin as &dyn AnyCollectableVec]
.into_iter()
.chain(self.sats.iter().map(|v| v as &dyn AnyCollectableVec))
.chain(self.dollars.iter().map(|v| v as &dyn AnyCollectableVec))
}
}
crates/brk_computer/src/indexes.rs
+4 -72
View File
@@ -10,6 +10,7 @@ use brk_structs::{
P2WPKHBytes, P2WSHAddressIndex, P2WSHBytes, QuarterIndex, Sats, SemesterIndex, StoredU64,
Timestamp, TxIndex, Txid, UnknownOutputIndex, Version, WeekIndex, YearIndex,
};
use brk_vecs::IVecs;
use vecdb::{
AnyCloneableIterableVec, AnyCollectableVec, Database, EagerVec, Exit, LazyVecFrom1,
LazyVecFrom2, PAGE_SIZE, StoredIndex, VecIterator,
@@ -17,7 +18,7 @@ use vecdb::{
const VERSION: Version = Version::ZERO;
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Vecs {
db: Database,
@@ -474,11 +475,8 @@ impl Vecs {
db,
};
this.db.retain_regions(
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
this.db
.retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
Ok(this)
}
@@ -932,72 +930,6 @@ impl Vecs {
halvingepoch: starting_halvingepoch,
})
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
[
&self.dateindex_to_date as &dyn AnyCollectableVec,
&self.dateindex_to_dateindex,
&self.dateindex_to_first_height,
&self.dateindex_to_height_count,
&self.dateindex_to_monthindex,
&self.dateindex_to_weekindex,
&self.decadeindex_to_decadeindex,
&self.decadeindex_to_first_yearindex,
&self.decadeindex_to_yearindex_count,
&self.difficultyepoch_to_difficultyepoch,
&self.difficultyepoch_to_first_height,
&self.difficultyepoch_to_height_count,
&self.emptyoutputindex_to_emptyoutputindex,
&self.halvingepoch_to_first_height,
&self.halvingepoch_to_halvingepoch,
&self.height_to_date,
&self.height_to_date_fixed,
&self.height_to_dateindex,
&self.height_to_difficultyepoch,
&self.height_to_halvingepoch,
&self.height_to_height,
&self.height_to_timestamp_fixed,
&self.height_to_txindex_count,
&self.inputindex_to_inputindex,
&self.monthindex_to_dateindex_count,
&self.monthindex_to_first_dateindex,
&self.monthindex_to_monthindex,
&self.monthindex_to_quarterindex,
&self.monthindex_to_semesterindex,
&self.monthindex_to_yearindex,
&self.opreturnindex_to_opreturnindex,
&self.outputindex_to_outputindex,
&self.p2aaddressindex_to_p2aaddressindex,
&self.p2msoutputindex_to_p2msoutputindex,
&self.p2pk33addressindex_to_p2pk33addressindex,
&self.p2pk65addressindex_to_p2pk65addressindex,
&self.p2pkhaddressindex_to_p2pkhaddressindex,
&self.p2shaddressindex_to_p2shaddressindex,
&self.p2traddressindex_to_p2traddressindex,
&self.p2wpkhaddressindex_to_p2wpkhaddressindex,
&self.p2wshaddressindex_to_p2wshaddressindex,
&self.quarterindex_to_first_monthindex,
&self.quarterindex_to_monthindex_count,
&self.quarterindex_to_quarterindex,
&self.semesterindex_to_first_monthindex,
&self.semesterindex_to_monthindex_count,
&self.semesterindex_to_semesterindex,
&self.txindex_to_height,
&self.txindex_to_txindex,
&self.txindex_to_input_count,
&self.txindex_to_output_count,
&self.unknownoutputindex_to_unknownoutputindex,
&self.weekindex_to_dateindex_count,
&self.weekindex_to_first_dateindex,
&self.weekindex_to_weekindex,
&self.yearindex_to_decadeindex,
&self.yearindex_to_first_monthindex,
&self.yearindex_to_monthindex_count,
&self.yearindex_to_yearindex,
&self.outputindex_to_txindex,
]
.into_iter()
}
}
pub struct Indexes {
crates/brk_computer/src/lib.rs
+3 -19
View File
@@ -7,8 +7,9 @@ use brk_fetcher::Fetcher;
use brk_indexer::Indexer;
use brk_parser::Parser;
use brk_structs::Version;
use brk_vecs::IVecs;
use log::info;
use vecdb::{AnyCollectableVec, Exit, Format};
use vecdb::{Exit, Format};
mod blks;
mod chain;
@@ -31,7 +32,7 @@ pub use pools::*;
pub use states::PriceToAmount;
use states::*;
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Computer {
pub chain: chain::Vecs,
pub cointime: cointime::Vecs,
@@ -206,23 +207,6 @@ impl Computer {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(self.fetched.iter().flat_map(|v| v.iter_any_collectable()));
iter = Box::new(iter.chain(self.chain.iter_any_collectable()));
iter = Box::new(iter.chain(self.cointime.iter_any_collectable()));
iter = Box::new(iter.chain(self.constants.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes.iter_any_collectable()));
iter = Box::new(iter.chain(self.market.iter_any_collectable()));
iter = Box::new(iter.chain(self.pools.iter_any_collectable()));
iter = Box::new(iter.chain(self.blks.iter_any_collectable()));
iter = Box::new(iter.chain(self.price.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.stateful.iter_any_collectable()));
iter
}
pub fn static_clone(&self) -> &'static Self {
Box::leak(Box::new(self.clone()))
}
crates/brk_computer/src/market.rs
+5 -206
View File
@@ -2,7 +2,8 @@ use std::{path::Path, thread};
use brk_error::Result;
use brk_structs::{Date, DateIndex, Dollars, Height, Sats, StoredF32, StoredU16, Version};
use vecdb::{AnyCollectableVec, Database, EagerVec, Exit, PAGE_SIZE, StoredIndex, VecIterator};
use brk_vecs::IVecs;
use vecdb::{Database, EagerVec, Exit, PAGE_SIZE, StoredIndex, VecIterator};
use crate::{
grouped::{ComputedStandardDeviationVecsFromDateIndex, Source, StandardDeviationVecsOptions},
@@ -16,7 +17,7 @@ use super::{
indexes,
};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Vecs {
db: Database,
@@ -1515,11 +1516,8 @@ impl Vecs {
db,
};
this.db.retain_regions(
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
this.db
.retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
Ok(this)
}
@@ -2325,203 +2323,4 @@ impl Vecs {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(
[
&self.height_to_price_ath as &dyn AnyCollectableVec,
&self.height_to_price_drawdown,
&self.dateindex_to_price_true_range,
&self.dateindex_to_price_true_range_2w_sum,
]
.into_iter(),
);
iter = Box::new(iter.chain(self.indexes_to_price_ath.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_drawdown.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_days_since_price_ath.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.indexes_to_max_days_between_price_aths
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_max_years_between_price_aths
.iter_any_collectable(),
),
);
iter = Box::new(iter.chain(self.indexes_to_price_1w_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_8d_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_13d_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_21d_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1m_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_34d_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_55d_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_89d_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_144d_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_200d_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1y_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_2y_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_200w_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_4y_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_200d_sma_x0_8.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_200d_sma_x2_4.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1w_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_8d_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_13d_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_21d_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1m_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_34d_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_55d_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_89d_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_144d_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_200d_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1y_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_2y_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_200w_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_4y_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_1d_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_1w_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_1m_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_3m_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_6m_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_1y_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_2y_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_3y_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_4y_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_5y_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_6y_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_8y_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_10y_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self._1d_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._1w_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._1m_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._3m_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._6m_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._1y_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._2y_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._3y_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._4y_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._5y_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._6y_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._8y_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._10y_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._2y_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._3y_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._4y_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._5y_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._6y_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._8y_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._10y_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._1w_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._1m_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._3m_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._6m_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._1y_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._2y_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._3y_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._4y_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._5y_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._6y_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._8y_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._10y_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2025_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2024_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2023_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2022_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2021_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2020_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2019_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2018_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2017_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2016_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2015_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._2y_dca_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._3y_dca_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._4y_dca_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._5y_dca_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._6y_dca_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._8y_dca_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._10y_dca_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._1w_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._1m_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._3m_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._6m_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._1y_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._2y_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._3y_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._4y_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._5y_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._6y_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._8y_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._10y_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2025_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2024_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2023_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2022_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2021_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2020_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2019_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2018_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2017_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2016_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2015_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._1w_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self._1m_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self._3m_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self._6m_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self._1y_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self._2y_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self._3y_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self._4y_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self._5y_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self._6y_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self._8y_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self._10y_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2025_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2024_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2023_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2022_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2021_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2020_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2019_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2018_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2017_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2016_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2015_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1d_returns_1w_sd.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1d_returns_1m_sd.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1d_returns_1y_sd.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1w_volatility.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1m_volatility.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1y_volatility.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.indexes_to_price_2w_choppiness_index
.iter_any_collectable(),
),
);
iter = Box::new(iter.chain(self.indexes_to_price_1w_min.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1w_max.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_2w_min.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_2w_max.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1m_min.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1m_max.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1y_min.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1y_max.iter_any_collectable()));
iter
}
}
crates/brk_computer/src/pools/mod.rs
+6 -18
View File
@@ -5,10 +5,11 @@ use brk_error::Result;
use brk_indexer::Indexer;
use brk_store::AnyStore;
use brk_structs::{AddressBytes, Height, OutputIndex, OutputType, PoolId, Pools, pools};
use brk_vecs::IVecs;
use rayon::prelude::*;
use vecdb::{
AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, Database, Exit, GenericStoredVec,
PAGE_SIZE, RawVec, StoredIndex, VecIterator, Version,
AnyIterableVec, AnyStoredVec, AnyVec, Database, Exit, GenericStoredVec, PAGE_SIZE, RawVec,
StoredIndex, VecIterator, Version,
};
mod vecs;
@@ -19,7 +20,7 @@ use crate::{
price,
};
#[derive(Clone, Allocative)]
#[derive(Clone, IVecs, Allocative)]
pub struct Vecs {
db: Database,
pools: &'static Pools,
@@ -61,11 +62,8 @@ impl Vecs {
db,
};
this.db.retain_regions(
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
this.db
.retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
Ok(this)
}
@@ -214,14 +212,4 @@ impl Vecs {
self.height_to_pool.safe_flush(exit)?;
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
[&self.height_to_pool as &dyn AnyCollectableVec]
.into_iter()
.chain(
self.vecs
.iter()
.flat_map(|(_, vecs)| vecs.iter_any_collectable()),
)
}
}
crates/brk_computer/src/pools/vecs.rs
+3 -23
View File
@@ -1,7 +1,8 @@
use allocative::Allocative;
use brk_error::Result;
use brk_structs::{Height, PoolId, Pools, Sats, StoredF32, StoredU16, StoredU32};
use vecdb::{AnyCollectableVec, AnyIterableVec, Database, Exit, StoredIndex, VecIterator, Version};
use brk_vecs::IVecs;
use vecdb::{AnyIterableVec, Database, Exit, StoredIndex, VecIterator, Version};
use crate::{
chain,
@@ -13,7 +14,7 @@ use crate::{
price,
};
#[derive(Clone, Allocative)]
#[derive(Clone, IVecs, Allocative)]
pub struct Vecs {
id: PoolId,
@@ -373,25 +374,4 @@ impl Vecs {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(std::iter::empty());
iter = Box::new(iter.chain(self.indexes_to_blocks_mined.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1w_blocks_mined.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1m_blocks_mined.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1y_blocks_mined.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_subsidy.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_fee.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_coinbase.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_dominance.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1d_dominance.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1w_dominance.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1m_dominance.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1y_dominance.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_days_since_block.iter_any_collectable()));
iter
}
}
crates/brk_computer/src/price.rs
+6 -96
View File
@@ -5,9 +5,10 @@ use brk_structs::{
Cents, Close, DateIndex, DecadeIndex, DifficultyEpoch, Dollars, Height, High, Low, MonthIndex,
OHLCDollars, OHLCSats, Open, QuarterIndex, Sats, SemesterIndex, Version, WeekIndex, YearIndex,
};
use brk_vecs::IVecs;
use vecdb::{
AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit,
GenericStoredVec, PAGE_SIZE, RawVec,
AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit, GenericStoredVec, PAGE_SIZE,
RawVec,
};
use crate::{fetched, grouped::Source};
@@ -18,7 +19,7 @@ use super::{
indexes,
};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Vecs {
db: Database,
@@ -325,11 +326,8 @@ impl Vecs {
db,
};
this.db.retain_regions(
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
this.db
.retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
Ok(this)
}
@@ -1226,92 +1224,4 @@ impl Vecs {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(
[
&self.dateindex_to_price_close_in_cents as &dyn AnyCollectableVec,
&self.dateindex_to_price_high_in_cents,
&self.dateindex_to_price_low_in_cents,
&self.dateindex_to_price_ohlc,
&self.dateindex_to_price_open_in_cents,
&self.height_to_price_close_in_cents,
&self.height_to_price_high_in_cents,
&self.height_to_price_low_in_cents,
&self.height_to_price_ohlc,
&self.height_to_price_open_in_cents,
&self.weekindex_to_price_ohlc,
&self.difficultyepoch_to_price_ohlc,
&self.monthindex_to_price_ohlc,
&self.quarterindex_to_price_ohlc,
&self.semesterindex_to_price_ohlc,
&self.yearindex_to_price_ohlc,
&self.decadeindex_to_price_ohlc,
&self.height_to_price_ohlc_in_sats,
&self.dateindex_to_price_ohlc_in_sats,
&self.weekindex_to_price_ohlc_in_sats,
&self.difficultyepoch_to_price_ohlc_in_sats,
&self.monthindex_to_price_ohlc_in_sats,
&self.quarterindex_to_price_ohlc_in_sats,
&self.semesterindex_to_price_ohlc_in_sats,
&self.yearindex_to_price_ohlc_in_sats,
&self.decadeindex_to_price_ohlc_in_sats,
]
.into_iter(),
);
iter = Box::new(iter.chain(self.timeindexes_to_price_close.iter_any_collectable()));
iter = Box::new(iter.chain(self.timeindexes_to_price_high.iter_any_collectable()));
iter = Box::new(iter.chain(self.timeindexes_to_price_low.iter_any_collectable()));
iter = Box::new(iter.chain(self.timeindexes_to_price_open.iter_any_collectable()));
iter = Box::new(iter.chain(self.chainindexes_to_price_close.iter_any_collectable()));
iter = Box::new(iter.chain(self.chainindexes_to_price_high.iter_any_collectable()));
iter = Box::new(iter.chain(self.chainindexes_to_price_low.iter_any_collectable()));
iter = Box::new(iter.chain(self.chainindexes_to_price_open.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.timeindexes_to_price_close_in_sats
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.timeindexes_to_price_high_in_sats
.iter_any_collectable(),
),
);
iter = Box::new(iter.chain(self.timeindexes_to_price_low_in_sats.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.timeindexes_to_price_open_in_sats
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.chainindexes_to_price_close_in_sats
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.chainindexes_to_price_high_in_sats
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.chainindexes_to_price_low_in_sats
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.chainindexes_to_price_open_in_sats
.iter_any_collectable(),
),
);
iter
}
}
crates/brk_computer/src/stateful/address_cohort.rs
+5 -10
View File
@@ -2,9 +2,10 @@ use std::path::Path;
use brk_error::Result;
use brk_structs::{Bitcoin, DateIndex, Dollars, Height, StoredU64, Version};
use brk_vecs::IVecs;
use vecdb::{
AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit, Format,
GenericStoredVec, VecIterator,
AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit, Format, GenericStoredVec,
VecIterator,
};
use crate::{
@@ -20,10 +21,11 @@ use crate::{
const VERSION: Version = Version::ZERO;
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Vecs {
starting_height: Option<Height>,
#[vecs(skip)]
pub state: Option<AddressCohortState>,
pub inner: common::Vecs,
@@ -84,13 +86,6 @@ impl Vecs {
)?,
})
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
self.inner
.iter_any_collectable()
.chain([&self.height_to_addr_count as &dyn AnyCollectableVec])
.chain(self.indexes_to_addr_count.iter_any_collectable())
}
}
impl DynCohortVecs for Vecs {
crates/brk_computer/src/stateful/address_cohorts.rs
+2 -1
View File
@@ -5,6 +5,7 @@ use brk_structs::{
AddressGroups, Bitcoin, ByAmountRange, ByGreatEqualAmount, ByLowerThanAmount, DateIndex,
Dollars, GroupFilter, Height, Version,
};
use brk_vecs::IVecs;
use derive_deref::{Deref, DerefMut};
use vecdb::{AnyIterableVec, Database, Exit, Format};
@@ -18,7 +19,7 @@ use crate::{
const VERSION: Version = Version::new(0);
#[derive(Clone, Deref, DerefMut)]
#[derive(Clone, Deref, DerefMut, IVecs)]
pub struct Vecs(AddressGroups<(GroupFilter, address_cohort::Vecs)>);
impl Vecs {
crates/brk_computer/src/stateful/addresstype/height_to_addresscount.rs
+2 -1
View File
@@ -1,11 +1,12 @@
use brk_error::Result;
use brk_structs::{ByAddressType, Height, StoredU64};
use brk_vecs::IVecs;
use derive_deref::{Deref, DerefMut};
use vecdb::{EagerVec, Exit, GenericStoredVec};
use super::AddressTypeToAddressCount;
#[derive(Debug, Clone, Deref, DerefMut)]
#[derive(Debug, Clone, Deref, DerefMut, IVecs)]
pub struct AddressTypeToHeightToAddressCount(ByAddressType<EagerVec<Height, StoredU64>>);
impl From<ByAddressType<EagerVec<Height, StoredU64>>> for AddressTypeToHeightToAddressCount {
crates/brk_computer/src/stateful/addresstype/indexes_to_addresscount.rs
+3 -8
View File
@@ -1,13 +1,14 @@
use brk_error::Result;
use brk_structs::{ByAddressType, StoredU64};
use brk_vecs::IVecs;
use derive_deref::{Deref, DerefMut};
use vecdb::{AnyCollectableVec, Exit};
use vecdb::Exit;
use crate::{Indexes, grouped::ComputedVecsFromHeight, indexes};
use super::AddressTypeToHeightToAddressCount;
#[derive(Clone, Deref, DerefMut)]
#[derive(Clone, Deref, DerefMut, IVecs)]
pub struct AddressTypeToIndexesToAddressCount(ByAddressType<ComputedVecsFromHeight<StoredU64>>);
impl From<ByAddressType<ComputedVecsFromHeight<StoredU64>>> for AddressTypeToIndexesToAddressCount {
@@ -74,10 +75,4 @@ impl AddressTypeToIndexesToAddressCount {
)?;
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
self.0
.iter_typed()
.flat_map(|(_, v)| v.iter_any_collectable())
}
}
crates/brk_computer/src/stateful/common.rs
+4 -697
View File
@@ -2,9 +2,10 @@ use brk_error::{Error, Result};
use brk_structs::{
Bitcoin, DateIndex, Dollars, Height, Sats, StoredF32, StoredF64, StoredU64, Version,
};
use brk_vecs::IVecs;
use vecdb::{
AnyCloneableIterableVec, AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, Database,
EagerVec, Exit, Format, GenericStoredVec, VecIterator,
AnyCloneableIterableVec, AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit,
Format, GenericStoredVec, VecIterator,
};
use crate::{
@@ -17,7 +18,7 @@ use crate::{
states::CohortState,
};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Vecs {
// Cumulative
pub height_to_realized_cap: Option<EagerVec<Height, Dollars>>,
@@ -3240,698 +3241,4 @@ impl Vecs {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(
[
&self.height_to_satblocks_destroyed as &dyn AnyCollectableVec,
&self.height_to_satdays_destroyed,
&self.height_to_supply,
&self.height_to_utxo_count,
]
.into_iter(),
);
iter = Box::new(
iter.chain(
self.dateindex_to_adjusted_sopr
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.dateindex_to_adjusted_sopr_30d_ema
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.dateindex_to_adjusted_sopr_7d_ema
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.dateindex_to_sell_side_risk_ratio
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.dateindex_to_sell_side_risk_ratio_30d_ema
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.dateindex_to_sell_side_risk_ratio_7d_ema
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.dateindex_to_sopr
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.dateindex_to_sopr_30d_ema
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.dateindex_to_sopr_7d_ema
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.dateindex_to_supply_in_loss
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.dateindex_to_supply_in_profit
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.dateindex_to_unrealized_loss
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.dateindex_to_unrealized_profit
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_adjusted_value_created
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_adjusted_value_destroyed
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_max_price_paid
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_min_price_paid
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_neg_unrealized_loss
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_neg_unrealized_loss_rel_to_market_cap
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_neg_unrealized_loss_rel_to_own_market_cap
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_neg_unrealized_loss_rel_to_own_total_unrealized_pnl
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_net_unrealized_pnl
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_net_unrealized_pnl_rel_to_market_cap
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_net_unrealized_pnl_rel_to_own_market_cap
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_net_unrealized_pnl_rel_to_own_total_unrealized_pnl
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_realized_cap
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_realized_loss
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_realized_profit
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(iter.chain(self.height_to_supply_half_value.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.height_to_supply_in_loss
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_supply_in_loss_rel_to_circulating_supply
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_supply_in_loss_rel_to_own_supply
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_supply_in_loss_value
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.height_to_supply_in_profit
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_supply_in_profit_rel_to_circulating_supply
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_supply_in_profit_rel_to_own_supply
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_supply_in_profit_value
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(iter.chain(self.height_to_supply_value.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.height_to_total_realized_pnl
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_total_unrealized_pnl
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_unrealized_loss
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_unrealized_loss_rel_to_market_cap
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_unrealized_loss_rel_to_own_market_cap
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_unrealized_loss_rel_to_own_total_unrealized_pnl
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_unrealized_profit
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_unrealized_profit_rel_to_market_cap
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_unrealized_profit_rel_to_own_market_cap
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_unrealized_profit_rel_to_own_total_unrealized_pnl
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_value_created
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_value_destroyed
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_adjusted_value_created
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_adjusted_value_destroyed
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(iter.chain(self.indexes_to_coinblocks_destroyed.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_coindays_destroyed.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.indexes_to_max_price_paid
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_min_price_paid
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_neg_realized_loss
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_neg_unrealized_loss
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_neg_unrealized_loss_rel_to_market_cap
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_neg_unrealized_loss_rel_to_own_market_cap
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_neg_unrealized_loss_rel_to_own_total_unrealized_pnl
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_net_realized_pnl
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_net_realized_pnl_cumulative_30d_delta
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_net_realized_pnl_cumulative_30d_delta_rel_to_market_cap
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_net_realized_pnl_cumulative_30d_delta_rel_to_realized_cap
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_net_realized_pnl_rel_to_realized_cap
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_net_unrealized_pnl
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_net_unrealized_pnl_rel_to_market_cap
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_net_unrealized_pnl_rel_to_own_market_cap
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_net_unrealized_pnl_rel_to_own_total_unrealized_pnl
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_realized_cap
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_realized_cap_30d_delta
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_realized_cap_rel_to_own_market_cap
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_realized_loss
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_realized_loss_rel_to_realized_cap
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_realized_price
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_realized_price_extra
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_realized_profit
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_realized_profit_rel_to_realized_cap
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_realized_value
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(iter.chain(self.indexes_to_supply.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_supply_half.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.indexes_to_supply_in_loss
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_supply_in_loss_rel_to_circulating_supply
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_supply_in_loss_rel_to_own_supply
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_supply_in_profit
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_supply_in_profit_rel_to_circulating_supply
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_supply_in_profit_rel_to_own_supply
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_supply_rel_to_circulating_supply
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_total_realized_pnl
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_total_unrealized_pnl
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_unrealized_loss
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_unrealized_loss_rel_to_market_cap
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_unrealized_loss_rel_to_own_market_cap
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_unrealized_loss_rel_to_own_total_unrealized_pnl
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_unrealized_profit
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_unrealized_profit_rel_to_market_cap
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_unrealized_profit_rel_to_own_market_cap
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_unrealized_profit_rel_to_own_total_unrealized_pnl
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(iter.chain(self.indexes_to_utxo_count.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.indexes_to_value_created
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_value_destroyed
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.dateindex_to_realized_profit_to_loss_ratio
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter
}
}
crates/brk_computer/src/stateful/mod.rs
+7 -93
View File
@@ -15,12 +15,13 @@ use brk_structs::{
P2PK65AddressIndex, P2PKHAddressIndex, P2SHAddressIndex, P2TRAddressIndex, P2WPKHAddressIndex,
P2WSHAddressIndex, Sats, StoredU64, Timestamp, TypeIndex, Version,
};
use brk_vecs::IVecs;
use log::info;
use rayon::prelude::*;
use vecdb::{
AnyCloneableIterableVec, AnyCollectableVec, AnyStoredVec, AnyVec, CollectableVec, Database,
EagerVec, Exit, Format, GenericStoredVec, ImportOptions, LazyVecFrom1, PAGE_SIZE, RawVec,
Reader, Stamp, StoredIndex, VecIterator,
AnyCloneableIterableVec, AnyStoredVec, AnyVec, CollectableVec, Database, EagerVec, Exit,
Format, GenericStoredVec, ImportOptions, LazyVecFrom1, PAGE_SIZE, RawVec, Reader, Stamp,
StoredIndex, VecIterator,
};
use crate::{
@@ -49,7 +50,7 @@ use withaddressdatasource::*;
const VERSION: Version = Version::new(21);
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Vecs {
db: Database,
@@ -492,11 +493,8 @@ impl Vecs {
db,
};
this.db.retain_regions(
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
this.db
.retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
Ok(this)
}
@@ -1836,90 +1834,6 @@ impl Vecs {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(
[
&self.height_to_unspendable_supply as &dyn AnyCollectableVec,
&self.height_to_opreturn_supply,
&self.chain_state,
&self.p2pk33addressindex_to_anyaddressindex,
&self.p2pk65addressindex_to_anyaddressindex,
&self.p2pkhaddressindex_to_anyaddressindex,
&self.p2shaddressindex_to_anyaddressindex,
&self.p2traddressindex_to_anyaddressindex,
&self.p2wpkhaddressindex_to_anyaddressindex,
&self.p2wshaddressindex_to_anyaddressindex,
&self.p2aaddressindex_to_anyaddressindex,
&self.loadedaddressindex_to_loadedaddressdata,
&self.emptyaddressindex_to_emptyaddressdata,
&self.loadedaddressindex_to_loadedaddressindex,
&self.emptyaddressindex_to_emptyaddressindex,
]
.into_iter(),
);
iter = Box::new(
iter.chain(
self.utxo_cohorts
.iter_right()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.address_cohorts
.iter_right()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(iter.chain(self.indexes_to_unspendable_supply.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_opreturn_supply.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_addr_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_empty_addr_count.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.addresstype_to_indexes_to_addr_count
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_market_cap
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.addresstype_to_indexes_to_empty_addr_count
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.addresstype_to_height_to_addr_count
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.addresstype_to_height_to_empty_addr_count
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_market_cap
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter
}
}
impl AddressTypeToVec<(TypeIndex, Sats)> {
crates/brk_computer/src/stateful/utxo_cohort.rs
+3 -1
View File
@@ -2,6 +2,7 @@ use std::{ops::Deref, path::Path};
use brk_error::Result;
use brk_structs::{Bitcoin, DateIndex, Dollars, Height, Version};
use brk_vecs::IVecs;
use vecdb::{AnyIterableVec, Database, Exit, Format};
use crate::{
@@ -12,10 +13,11 @@ use crate::{
},
};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Vecs {
state_starting_height: Option<Height>,
#[vecs(skip)]
pub state: Option<UTXOCohortState>,
inner: common::Vecs,
crates/brk_computer/src/stateful/utxo_cohorts.rs
+2 -1
View File
@@ -6,6 +6,7 @@ use brk_structs::{
ByMinAge, BySpendableType, ByTerm, CheckedSub, DateIndex, Dollars, GroupFilter, HalvingEpoch,
Height, Timestamp, UTXOGroups, Version,
};
use brk_vecs::IVecs;
use derive_deref::{Deref, DerefMut};
use vecdb::{AnyIterableVec, Database, Exit, Format, StoredIndex};
@@ -19,7 +20,7 @@ use super::{r#trait::CohortVecs, utxo_cohort};
const VERSION: Version = Version::new(0);
#[derive(Clone, Deref, DerefMut)]
#[derive(Clone, Deref, DerefMut, IVecs)]
pub struct Vecs(UTXOGroups<(GroupFilter, utxo_cohort::Vecs)>);
impl Vecs {