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

computer: simplify compute_all functions

Browse Source
This commit is contained in:
nym21
2025-09-09 19:22:56 +02:00
parent 18fb2e7d4d
commit dfa077a1c9
24 changed files with 1079 additions and 2629 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/brk_computer/src/chain.rs
+126 -292
View File
@@ -933,12 +933,8 @@ impl Vecs {
price: Option<&price::Vecs>, price: Option<&price::Vecs>,
exit: &Exit, exit: &Exit,
) -> Result<()> { ) -> Result<()> {
self.timeindexes_to_timestamp.compute_all( self.timeindexes_to_timestamp
indexer, .compute_all(starting_indexes, exit, |vec| {
indexes,
starting_indexes,
exit,
|vec, _, indexes, starting_indexes, exit| {
vec.compute_transform( vec.compute_transform(
starting_indexes.dateindex, starting_indexes.dateindex,
&indexes.dateindex_to_date, &indexes.dateindex_to_date,
@@ -946,15 +942,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_block_count.compute_all( self.indexes_to_block_count
indexer, .compute_all(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, indexer, _, starting_indexes, exit| {
v.compute_range( v.compute_range(
starting_indexes.height, starting_indexes.height,
&indexer.vecs.height_to_weight, &indexer.vecs.height_to_weight,
@@ -962,15 +953,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_1w_block_count.compute_all( self.indexes_to_1w_block_count
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sum( v.compute_sum(
starting_indexes.dateindex, starting_indexes.dateindex,
self.indexes_to_block_count.dateindex.unwrap_sum(), self.indexes_to_block_count.dateindex.unwrap_sum(),
@@ -978,15 +964,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_1m_block_count.compute_all( self.indexes_to_1m_block_count
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sum( v.compute_sum(
starting_indexes.dateindex, starting_indexes.dateindex,
self.indexes_to_block_count.dateindex.unwrap_sum(), self.indexes_to_block_count.dateindex.unwrap_sum(),
@@ -994,15 +975,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_1y_block_count.compute_all( self.indexes_to_1y_block_count
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sum( v.compute_sum(
starting_indexes.dateindex, starting_indexes.dateindex,
self.indexes_to_block_count.dateindex.unwrap_sum(), self.indexes_to_block_count.dateindex.unwrap_sum(),
@@ -1010,8 +986,7 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
let mut height_to_timestamp_iter = indexer.vecs.height_to_timestamp.iter(); let mut height_to_timestamp_iter = indexer.vecs.height_to_timestamp.iter();
self.height_to_interval.compute_transform( self.height_to_interval.compute_transform(
@@ -1086,12 +1061,8 @@ impl Vecs {
)?; )?;
let mut height_to_difficultyepoch_iter = indexes.height_to_difficultyepoch.into_iter(); let mut height_to_difficultyepoch_iter = indexes.height_to_difficultyepoch.into_iter();
self.indexes_to_difficultyepoch.compute_all( self.indexes_to_difficultyepoch
indexer, .compute_all(starting_indexes, exit, |vec| {
indexes,
starting_indexes,
exit,
|vec, _, indexes, starting_indexes, exit| {
let mut height_count_iter = indexes.dateindex_to_height_count.into_iter(); let mut height_count_iter = indexes.dateindex_to_height_count.into_iter();
vec.compute_transform( vec.compute_transform(
starting_indexes.dateindex, starting_indexes.dateindex,
@@ -1107,16 +1078,11 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
let mut height_to_halvingepoch_iter = indexes.height_to_halvingepoch.into_iter(); let mut height_to_halvingepoch_iter = indexes.height_to_halvingepoch.into_iter();
self.indexes_to_halvingepoch.compute_all( self.indexes_to_halvingepoch
indexer, .compute_all(starting_indexes, exit, |vec| {
indexes,
starting_indexes,
exit,
|vec, _, indexes, starting_indexes, exit| {
let mut height_count_iter = indexes.dateindex_to_height_count.into_iter(); let mut height_count_iter = indexes.dateindex_to_height_count.into_iter();
vec.compute_transform( vec.compute_transform(
starting_indexes.dateindex, starting_indexes.dateindex,
@@ -1132,8 +1098,7 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_difficulty.compute_rest( self.indexes_to_difficulty.compute_rest(
indexes, indexes,
@@ -1142,12 +1107,8 @@ impl Vecs {
Some(&indexer.vecs.height_to_difficulty), Some(&indexer.vecs.height_to_difficulty),
)?; )?;
self.indexes_to_tx_count.compute_all( self.indexes_to_tx_count
indexer, .compute_all(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, indexer, _, starting_indexes, exit| {
v.compute_count_from_indexes( v.compute_count_from_indexes(
starting_indexes.height, starting_indexes.height,
&indexer.vecs.height_to_first_txindex, &indexer.vecs.height_to_first_txindex,
@@ -1155,8 +1116,7 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_input_count.compute_rest( self.indexes_to_input_count.compute_rest(
indexer, indexer,
@@ -1177,25 +1137,19 @@ impl Vecs {
let compute_indexes_to_tx_vany = let compute_indexes_to_tx_vany =
|indexes_to_tx_vany: &mut ComputedVecsFromHeight<StoredU64>, txversion| { |indexes_to_tx_vany: &mut ComputedVecsFromHeight<StoredU64>, txversion| {
let mut txindex_to_txversion_iter = indexer.vecs.txindex_to_txversion.iter(); let mut txindex_to_txversion_iter = indexer.vecs.txindex_to_txversion.iter();
indexes_to_tx_vany.compute_all( indexes_to_tx_vany.compute_all(indexes, starting_indexes, exit, |vec| {
indexer, vec.compute_filtered_count_from_indexes(
indexes, starting_indexes.height,
starting_indexes, &indexer.vecs.height_to_first_txindex,
exit, &indexer.vecs.txindex_to_txid,
|vec, indexer, _, starting_indexes, exit| { |txindex| {
vec.compute_filtered_count_from_indexes( let v = txindex_to_txversion_iter.unwrap_get_inner(txindex);
starting_indexes.height, v == txversion
&indexer.vecs.height_to_first_txindex, },
&indexer.vecs.txindex_to_txid, exit,
|txindex| { )?;
let v = txindex_to_txversion_iter.unwrap_get_inner(txindex); Ok(())
v == txversion })
},
exit,
)?;
Ok(())
},
)
}; };
compute_indexes_to_tx_vany(&mut self.indexes_to_tx_v1, TxVersion::ONE)?; compute_indexes_to_tx_vany(&mut self.indexes_to_tx_v1, TxVersion::ONE)?;
compute_indexes_to_tx_vany(&mut self.indexes_to_tx_v2, TxVersion::TWO)?; compute_indexes_to_tx_vany(&mut self.indexes_to_tx_v2, TxVersion::TWO)?;
@@ -1206,7 +1160,7 @@ impl Vecs {
// indexes, // indexes,
// starting_indexes, // starting_indexes,
// exit, // exit,
// |vec, indexer, _, starting_indexes, exit| { // |vec| {
// vec.compute_sum_from_indexes( // vec.compute_sum_from_indexes(
// starting_indexes.txindex, // starting_indexes.txindex,
// &indexer.vecs.txindex_to_first_outputindex, // &indexer.vecs.txindex_to_first_outputindex,
@@ -1222,7 +1176,7 @@ impl Vecs {
// indexes, // indexes,
// starting_indexes, // starting_indexes,
// exit, // exit,
// |vec, indexer, _, starting_indexes, exit| { // |vec| {
// vec.compute_sum_from_indexes( // vec.compute_sum_from_indexes(
// starting_indexes.txindex, // starting_indexes.txindex,
// &indexer.vecs.txindex_to_first_inputindex, // &indexer.vecs.txindex_to_first_inputindex,
@@ -1292,13 +1246,8 @@ impl Vecs {
Some(&self.txindex_to_vsize), Some(&self.txindex_to_vsize),
)?; )?;
self.indexes_to_coinbase.compute_all( self.indexes_to_coinbase
indexer, .compute_all(indexes, price, starting_indexes, exit, |vec| {
indexes,
price,
starting_indexes,
exit,
|vec, indexer, _, starting_indexes, exit| {
let mut txindex_to_first_outputindex_iter = let mut txindex_to_first_outputindex_iter =
indexer.vecs.txindex_to_first_outputindex.iter(); indexer.vecs.txindex_to_first_outputindex.iter();
let mut txindex_to_output_count_iter = indexes.txindex_to_output_count.iter(); let mut txindex_to_output_count_iter = indexes.txindex_to_output_count.iter();
@@ -1322,16 +1271,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_subsidy.compute_all( self.indexes_to_subsidy
indexer, .compute_all(indexes, price, starting_indexes, exit, |vec| {
indexes,
price,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
let mut indexes_to_fee_sum_iter = let mut indexes_to_fee_sum_iter =
self.indexes_to_fee.sats.height.unwrap_sum().iter(); self.indexes_to_fee.sats.height.unwrap_sum().iter();
vec.compute_transform( vec.compute_transform(
@@ -1344,16 +1287,14 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_unclaimed_rewards.compute_all( self.indexes_to_unclaimed_rewards.compute_all(
indexer,
indexes, indexes,
price, price,
starting_indexes, starting_indexes,
exit, exit,
|vec, _, _, starting_indexes, exit| { |vec| {
vec.compute_transform( vec.compute_transform(
starting_indexes.height, starting_indexes.height,
self.indexes_to_subsidy.sats.height.as_ref().unwrap(), self.indexes_to_subsidy.sats.height.as_ref().unwrap(),
@@ -1369,12 +1310,8 @@ impl Vecs {
}, },
)?; )?;
self.indexes_to_p2a_count.compute_all( self.indexes_to_p2a_count
indexer, .compute_all(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, indexer, _, starting_indexes, exit| {
v.compute_count_from_indexes( v.compute_count_from_indexes(
starting_indexes.height, starting_indexes.height,
&indexer.vecs.height_to_first_p2aaddressindex, &indexer.vecs.height_to_first_p2aaddressindex,
@@ -1382,15 +1319,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_p2ms_count.compute_all( self.indexes_to_p2ms_count
indexer, .compute_all(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, indexer, _, starting_indexes, exit| {
v.compute_count_from_indexes( v.compute_count_from_indexes(
starting_indexes.height, starting_indexes.height,
&indexer.vecs.height_to_first_p2msoutputindex, &indexer.vecs.height_to_first_p2msoutputindex,
@@ -1398,15 +1330,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_p2pk33_count.compute_all( self.indexes_to_p2pk33_count
indexer, .compute_all(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, indexer, _, starting_indexes, exit| {
v.compute_count_from_indexes( v.compute_count_from_indexes(
starting_indexes.height, starting_indexes.height,
&indexer.vecs.height_to_first_p2pk33addressindex, &indexer.vecs.height_to_first_p2pk33addressindex,
@@ -1414,15 +1341,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_p2pk65_count.compute_all( self.indexes_to_p2pk65_count
indexer, .compute_all(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, indexer, _, starting_indexes, exit| {
v.compute_count_from_indexes( v.compute_count_from_indexes(
starting_indexes.height, starting_indexes.height,
&indexer.vecs.height_to_first_p2pk65addressindex, &indexer.vecs.height_to_first_p2pk65addressindex,
@@ -1430,15 +1352,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_p2pkh_count.compute_all( self.indexes_to_p2pkh_count
indexer, .compute_all(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, indexer, _, starting_indexes, exit| {
v.compute_count_from_indexes( v.compute_count_from_indexes(
starting_indexes.height, starting_indexes.height,
&indexer.vecs.height_to_first_p2pkhaddressindex, &indexer.vecs.height_to_first_p2pkhaddressindex,
@@ -1446,15 +1363,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_p2sh_count.compute_all( self.indexes_to_p2sh_count
indexer, .compute_all(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, indexer, _, starting_indexes, exit| {
v.compute_count_from_indexes( v.compute_count_from_indexes(
starting_indexes.height, starting_indexes.height,
&indexer.vecs.height_to_first_p2shaddressindex, &indexer.vecs.height_to_first_p2shaddressindex,
@@ -1462,15 +1374,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_p2tr_count.compute_all( self.indexes_to_p2tr_count
indexer, .compute_all(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, indexer, _, starting_indexes, exit| {
v.compute_count_from_indexes( v.compute_count_from_indexes(
starting_indexes.height, starting_indexes.height,
&indexer.vecs.height_to_first_p2traddressindex, &indexer.vecs.height_to_first_p2traddressindex,
@@ -1478,15 +1385,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_p2wpkh_count.compute_all( self.indexes_to_p2wpkh_count
indexer, .compute_all(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, indexer, _, starting_indexes, exit| {
v.compute_count_from_indexes( v.compute_count_from_indexes(
starting_indexes.height, starting_indexes.height,
&indexer.vecs.height_to_first_p2wpkhaddressindex, &indexer.vecs.height_to_first_p2wpkhaddressindex,
@@ -1494,15 +1396,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_p2wsh_count.compute_all( self.indexes_to_p2wsh_count
indexer, .compute_all(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, indexer, _, starting_indexes, exit| {
v.compute_count_from_indexes( v.compute_count_from_indexes(
starting_indexes.height, starting_indexes.height,
&indexer.vecs.height_to_first_p2wshaddressindex, &indexer.vecs.height_to_first_p2wshaddressindex,
@@ -1510,15 +1407,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_opreturn_count.compute_all( self.indexes_to_opreturn_count
indexer, .compute_all(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, indexer, _, starting_indexes, exit| {
v.compute_count_from_indexes( v.compute_count_from_indexes(
starting_indexes.height, starting_indexes.height,
&indexer.vecs.height_to_first_opreturnindex, &indexer.vecs.height_to_first_opreturnindex,
@@ -1526,15 +1418,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_unknownoutput_count.compute_all( self.indexes_to_unknownoutput_count
indexer, .compute_all(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, indexer, _, starting_indexes, exit| {
v.compute_count_from_indexes( v.compute_count_from_indexes(
starting_indexes.height, starting_indexes.height,
&indexer.vecs.height_to_first_unknownoutputindex, &indexer.vecs.height_to_first_unknownoutputindex,
@@ -1542,15 +1429,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_emptyoutput_count.compute_all( self.indexes_to_emptyoutput_count
indexer, .compute_all(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, indexer, _, starting_indexes, exit| {
v.compute_count_from_indexes( v.compute_count_from_indexes(
starting_indexes.height, starting_indexes.height,
&indexer.vecs.height_to_first_emptyoutputindex, &indexer.vecs.height_to_first_emptyoutputindex,
@@ -1558,15 +1440,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_exact_utxo_count.compute_all( self.indexes_to_exact_utxo_count
indexer, .compute_all(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
let mut input_count_iter = self let mut input_count_iter = self
.indexes_to_input_count .indexes_to_input_count
.height .height
@@ -1611,8 +1488,7 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.dateindex_to_fee_dominance.compute_transform2( self.dateindex_to_fee_dominance.compute_transform2(
starting_indexes.dateindex, starting_indexes.dateindex,
@@ -1639,12 +1515,8 @@ impl Vecs {
exit, exit,
)?; )?;
self.indexes_to_difficulty_as_hash.compute_all( self.indexes_to_difficulty_as_hash
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
let multiplier = 2.0_f64.powi(32) / 600.0; let multiplier = 2.0_f64.powi(32) / 600.0;
v.compute_transform( v.compute_transform(
starting_indexes.dateindex, starting_indexes.dateindex,
@@ -1653,17 +1525,12 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
let now = Timestamp::now(); let now = Timestamp::now();
let today = Date::from(now); let today = Date::from(now);
self.indexes_to_hash_rate.compute_all( self.indexes_to_hash_rate
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_transform3( v.compute_transform3(
starting_indexes.dateindex, starting_indexes.dateindex,
self.indexes_to_block_count.dateindex.unwrap_sum(), self.indexes_to_block_count.dateindex.unwrap_sum(),
@@ -1690,15 +1557,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_hash_rate_1w_sma.compute_all( self.indexes_to_hash_rate_1w_sma
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma( v.compute_sma(
starting_indexes.dateindex, starting_indexes.dateindex,
self.indexes_to_hash_rate.dateindex.as_ref().unwrap(), self.indexes_to_hash_rate.dateindex.as_ref().unwrap(),
@@ -1706,15 +1568,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_hash_rate_1m_sma.compute_all( self.indexes_to_hash_rate_1m_sma
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma( v.compute_sma(
starting_indexes.dateindex, starting_indexes.dateindex,
self.indexes_to_hash_rate.dateindex.as_ref().unwrap(), self.indexes_to_hash_rate.dateindex.as_ref().unwrap(),
@@ -1722,15 +1579,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_hash_rate_2m_sma.compute_all( self.indexes_to_hash_rate_2m_sma
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma( v.compute_sma(
starting_indexes.dateindex, starting_indexes.dateindex,
self.indexes_to_hash_rate.dateindex.as_ref().unwrap(), self.indexes_to_hash_rate.dateindex.as_ref().unwrap(),
@@ -1738,15 +1590,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_hash_rate_1y_sma.compute_all( self.indexes_to_hash_rate_1y_sma
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma( v.compute_sma(
starting_indexes.dateindex, starting_indexes.dateindex,
self.indexes_to_hash_rate.dateindex.as_ref().unwrap(), self.indexes_to_hash_rate.dateindex.as_ref().unwrap(),
@@ -1754,8 +1601,7 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
if self.indexes_to_subsidy_usd_1y_sma.is_some() { if self.indexes_to_subsidy_usd_1y_sma.is_some() {
let date_to_coinbase_usd_sum = self let date_to_coinbase_usd_sum = self
@@ -1769,45 +1615,33 @@ impl Vecs {
self.indexes_to_subsidy_usd_1y_sma self.indexes_to_subsidy_usd_1y_sma
.as_mut() .as_mut()
.unwrap() .unwrap()
.compute_all( .compute_all(starting_indexes, exit, |v| {
indexer, v.compute_sma(
indexes, starting_indexes.dateindex,
starting_indexes, date_to_coinbase_usd_sum,
exit, 365,
|v, _, _, starting_indexes, exit| { exit,
v.compute_sma( )?;
starting_indexes.dateindex, Ok(())
date_to_coinbase_usd_sum, })?;
365,
exit,
)?;
Ok(())
},
)?;
self.indexes_to_puell_multiple self.indexes_to_puell_multiple
.as_mut() .as_mut()
.unwrap() .unwrap()
.compute_all( .compute_all(starting_indexes, exit, |v| {
indexer, v.compute_divide(
indexes, starting_indexes.dateindex,
starting_indexes, date_to_coinbase_usd_sum,
exit, self.indexes_to_subsidy_usd_1y_sma
|v, _, _, starting_indexes, exit| { .as_ref()
v.compute_divide( .unwrap()
starting_indexes.dateindex, .dateindex
date_to_coinbase_usd_sum, .as_ref()
self.indexes_to_subsidy_usd_1y_sma .unwrap(),
.as_ref() exit,
.unwrap() )?;
.dateindex Ok(())
.as_ref() })?;
.unwrap(),
exit,
)?;
Ok(())
},
)?;
} }
Ok(()) Ok(())
crates/brk_computer/src/cointime.rs
+44 -130
View File
@@ -1,7 +1,6 @@
use std::path::Path; use std::path::Path;
use brk_error::Result; use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{Bitcoin, CheckedSub, Dollars, StoredF64, Version}; use brk_structs::{Bitcoin, CheckedSub, Dollars, StoredF64, Version};
use vecdb::{AnyCollectableVec, Database, Exit, PAGE_SIZE, VecIterator}; use vecdb::{AnyCollectableVec, Database, Exit, PAGE_SIZE, VecIterator};
@@ -262,7 +261,6 @@ impl Vecs {
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
pub fn compute( pub fn compute(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs, indexes: &indexes::Vecs,
starting_indexes: &Indexes, starting_indexes: &Indexes,
price: Option<&price::Vecs>, price: Option<&price::Vecs>,
@@ -270,15 +268,7 @@ impl Vecs {
stateful: &stateful::Vecs, stateful: &stateful::Vecs,
exit: &Exit, exit: &Exit,
) -> Result<()> { ) -> Result<()> {
self.compute_( self.compute_(indexes, starting_indexes, price, chain, stateful, exit)?;
indexer,
indexes,
starting_indexes,
price,
chain,
stateful,
exit,
)?;
self.db.flush_then_punch()?; self.db.flush_then_punch()?;
Ok(()) Ok(())
} }
@@ -286,7 +276,6 @@ impl Vecs {
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
fn compute_( fn compute_(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs, indexes: &indexes::Vecs,
starting_indexes: &Indexes, starting_indexes: &Indexes,
price: Option<&price::Vecs>, price: Option<&price::Vecs>,
@@ -296,12 +285,8 @@ impl Vecs {
) -> Result<()> { ) -> Result<()> {
let circulating_supply = &stateful.utxo_cohorts.all.1.height_to_supply; let circulating_supply = &stateful.utxo_cohorts.all.1.height_to_supply;
self.indexes_to_coinblocks_created.compute_all( self.indexes_to_coinblocks_created
indexer, .compute_all(indexes, starting_indexes, exit, |vec| {
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
vec.compute_transform( vec.compute_transform(
starting_indexes.height, starting_indexes.height,
circulating_supply, circulating_supply,
@@ -309,18 +294,13 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
let indexes_to_coinblocks_destroyed = let indexes_to_coinblocks_destroyed =
&stateful.utxo_cohorts.all.1.indexes_to_coinblocks_destroyed; &stateful.utxo_cohorts.all.1.indexes_to_coinblocks_destroyed;
self.indexes_to_coinblocks_stored.compute_all( self.indexes_to_coinblocks_stored
indexer, .compute_all(indexes, starting_indexes, exit, |vec| {
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
let mut coinblocks_destroyed_iter = indexes_to_coinblocks_destroyed let mut coinblocks_destroyed_iter = indexes_to_coinblocks_destroyed
.height .height
.as_ref() .as_ref()
@@ -336,15 +316,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_liveliness.compute_all( self.indexes_to_liveliness
indexer, .compute_all(indexes, starting_indexes, exit, |vec| {
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
vec.compute_divide( vec.compute_divide(
starting_indexes.height, starting_indexes.height,
indexes_to_coinblocks_destroyed indexes_to_coinblocks_destroyed
@@ -356,16 +331,11 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
let liveliness = &self.indexes_to_liveliness; let liveliness = &self.indexes_to_liveliness;
self.indexes_to_vaultedness.compute_all( self.indexes_to_vaultedness
indexer, .compute_all(indexes, starting_indexes, exit, |vec| {
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
vec.compute_transform( vec.compute_transform(
starting_indexes.height, starting_indexes.height,
liveliness.height.as_ref().unwrap(), liveliness.height.as_ref().unwrap(),
@@ -373,16 +343,14 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
let vaultedness = &self.indexes_to_vaultedness; let vaultedness = &self.indexes_to_vaultedness;
self.indexes_to_activity_to_vaultedness_ratio.compute_all( self.indexes_to_activity_to_vaultedness_ratio.compute_all(
indexer,
indexes, indexes,
starting_indexes, starting_indexes,
exit, exit,
|vec, _, _, starting_indexes, exit| { |vec| {
vec.compute_divide( vec.compute_divide(
starting_indexes.height, starting_indexes.height,
liveliness.height.as_ref().unwrap(), liveliness.height.as_ref().unwrap(),
@@ -394,12 +362,11 @@ impl Vecs {
)?; )?;
self.indexes_to_vaulted_supply.compute_all( self.indexes_to_vaulted_supply.compute_all(
indexer,
indexes, indexes,
price, price,
starting_indexes, starting_indexes,
exit, exit,
|vec, _, _, starting_indexes, exit| { |vec| {
vec.compute_multiply( vec.compute_multiply(
starting_indexes.height, starting_indexes.height,
circulating_supply, circulating_supply,
@@ -411,12 +378,11 @@ impl Vecs {
)?; )?;
self.indexes_to_active_supply.compute_all( self.indexes_to_active_supply.compute_all(
indexer,
indexes, indexes,
price, price,
starting_indexes, starting_indexes,
exit, exit,
|vec, _, _, starting_indexes, exit| { |vec| {
vec.compute_multiply( vec.compute_multiply(
starting_indexes.height, starting_indexes.height,
circulating_supply, circulating_supply,
@@ -447,12 +413,8 @@ impl Vecs {
.as_ref() .as_ref()
.unwrap(); .unwrap();
self.indexes_to_thermo_cap.compute_all( self.indexes_to_thermo_cap
indexer, .compute_all(indexes, starting_indexes, exit, |vec| {
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
vec.compute_transform( vec.compute_transform(
starting_indexes.height, starting_indexes.height,
chain chain
@@ -466,15 +428,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_investor_cap.compute_all( self.indexes_to_investor_cap
indexer, .compute_all(indexes, starting_indexes, exit, |vec| {
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
vec.compute_subtract( vec.compute_subtract(
starting_indexes.height, starting_indexes.height,
realized_cap, realized_cap,
@@ -482,15 +439,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_vaulted_cap.compute_all( self.indexes_to_vaulted_cap
indexer, .compute_all(indexes, starting_indexes, exit, |vec| {
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
vec.compute_divide( vec.compute_divide(
starting_indexes.height, starting_indexes.height,
realized_cap, realized_cap,
@@ -498,15 +450,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_active_cap.compute_all( self.indexes_to_active_cap
indexer, .compute_all(indexes, starting_indexes, exit, |vec| {
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
vec.compute_multiply( vec.compute_multiply(
starting_indexes.height, starting_indexes.height,
realized_cap, realized_cap,
@@ -514,15 +461,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_vaulted_price.compute_all( self.indexes_to_vaulted_price
indexer, .compute_all(indexes, starting_indexes, exit, |vec| {
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
vec.compute_divide( vec.compute_divide(
starting_indexes.height, starting_indexes.height,
realized_price, realized_price,
@@ -530,24 +472,17 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_vaulted_price_ratio.compute_rest( self.indexes_to_vaulted_price_ratio.compute_rest(
indexer,
indexes,
price, price,
starting_indexes, starting_indexes,
exit, exit,
Some(self.indexes_to_vaulted_price.dateindex.unwrap_last()), Some(self.indexes_to_vaulted_price.dateindex.unwrap_last()),
)?; )?;
self.indexes_to_active_price.compute_all( self.indexes_to_active_price
indexer, .compute_all(indexes, starting_indexes, exit, |vec| {
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
vec.compute_multiply( vec.compute_multiply(
starting_indexes.height, starting_indexes.height,
realized_price, realized_price,
@@ -555,12 +490,9 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_active_price_ratio.compute_rest( self.indexes_to_active_price_ratio.compute_rest(
indexer,
indexes,
price, price,
starting_indexes, starting_indexes,
exit, exit,
@@ -568,11 +500,10 @@ impl Vecs {
)?; )?;
self.indexes_to_true_market_mean.compute_all( self.indexes_to_true_market_mean.compute_all(
indexer,
indexes, indexes,
starting_indexes, starting_indexes,
exit, exit,
|vec, _, _, starting_indexes, exit| { |vec| {
vec.compute_divide( vec.compute_divide(
starting_indexes.height, starting_indexes.height,
self.indexes_to_investor_cap.height.as_ref().unwrap(), self.indexes_to_investor_cap.height.as_ref().unwrap(),
@@ -588,8 +519,6 @@ impl Vecs {
)?; )?;
self.indexes_to_true_market_mean_ratio.compute_rest( self.indexes_to_true_market_mean_ratio.compute_rest(
indexer,
indexes,
price, price,
starting_indexes, starting_indexes,
exit, exit,
@@ -597,11 +526,10 @@ impl Vecs {
)?; )?;
self.indexes_to_cointime_value_destroyed.compute_all( self.indexes_to_cointime_value_destroyed.compute_all(
indexer,
indexes, indexes,
starting_indexes, starting_indexes,
exit, exit,
|vec, _, _, starting_indexes, exit| { |vec| {
// TODO: Another example when the callback should be applied to each index, instead of to base then merging from more granular to less // TODO: Another example when the callback should be applied to each index, instead of to base then merging from more granular to less
// The price taken won't be correct for time based indexes // The price taken won't be correct for time based indexes
vec.compute_multiply( vec.compute_multiply(
@@ -615,11 +543,10 @@ impl Vecs {
)?; )?;
self.indexes_to_cointime_value_created.compute_all( self.indexes_to_cointime_value_created.compute_all(
indexer,
indexes, indexes,
starting_indexes, starting_indexes,
exit, exit,
|vec, _, _, starting_indexes, exit| { |vec| {
vec.compute_multiply( vec.compute_multiply(
starting_indexes.height, starting_indexes.height,
&price.chainindexes_to_price_close.height, &price.chainindexes_to_price_close.height,
@@ -631,11 +558,10 @@ impl Vecs {
)?; )?;
self.indexes_to_cointime_value_stored.compute_all( self.indexes_to_cointime_value_stored.compute_all(
indexer,
indexes, indexes,
starting_indexes, starting_indexes,
exit, exit,
|vec, _, _, starting_indexes, exit| { |vec| {
vec.compute_multiply( vec.compute_multiply(
starting_indexes.height, starting_indexes.height,
&price.chainindexes_to_price_close.height, &price.chainindexes_to_price_close.height,
@@ -646,12 +572,8 @@ impl Vecs {
}, },
)?; )?;
self.indexes_to_cointime_price.compute_all( self.indexes_to_cointime_price
indexer, .compute_all(indexes, starting_indexes, exit, |vec| {
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
vec.compute_divide( vec.compute_divide(
starting_indexes.height, starting_indexes.height,
self.indexes_to_cointime_value_destroyed self.indexes_to_cointime_value_destroyed
@@ -663,15 +585,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_cointime_cap.compute_all( self.indexes_to_cointime_cap
indexer, .compute_all(indexes, starting_indexes, exit, |vec| {
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
vec.compute_multiply( vec.compute_multiply(
starting_indexes.height, starting_indexes.height,
self.indexes_to_cointime_price.height.as_ref().unwrap(), self.indexes_to_cointime_price.height.as_ref().unwrap(),
@@ -679,12 +596,9 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_cointime_price_ratio.compute_rest( self.indexes_to_cointime_price_ratio.compute_rest(
indexer,
indexes,
price, price,
starting_indexes, starting_indexes,
exit, exit,
crates/brk_computer/src/constants.rs
+31 -52
View File
@@ -1,7 +1,6 @@
use std::path::Path; use std::path::Path;
use brk_error::Result; use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{StoredF32, StoredI16, StoredU16, Version}; use brk_structs::{StoredF32, StoredI16, StoredU16, Version};
use vecdb::{AnyCollectableVec, AnyVec, Database, Exit}; use vecdb::{AnyCollectableVec, AnyVec, Database, Exit};
@@ -168,19 +167,17 @@ impl Vecs {
pub fn compute( pub fn compute(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs, indexes: &indexes::Vecs,
starting_indexes: &Indexes, starting_indexes: &Indexes,
exit: &Exit, exit: &Exit,
) -> Result<()> { ) -> Result<()> {
self.compute_(indexer, indexes, starting_indexes, exit)?; self.compute_(indexes, starting_indexes, exit)?;
self.db.flush_then_punch()?; self.db.flush_then_punch()?;
Ok(()) Ok(())
} }
fn compute_( fn compute_(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs, indexes: &indexes::Vecs,
starting_indexes: &Indexes, starting_indexes: &Indexes,
exit: &Exit, exit: &Exit,
@@ -197,22 +194,16 @@ impl Vecs {
] ]
.into_iter() .into_iter()
.try_for_each(|(vec, value)| { .try_for_each(|(vec, value)| {
vec.compute_all( vec.compute_all(indexes, starting_indexes, exit, |vec| {
indexer, vec.compute_to(
indexes, starting_indexes.height,
starting_indexes, indexes.height_to_date.len(),
exit, indexes.height_to_date.version(),
|vec, _, indexes, starting_indexes, exit| { |i| (i, StoredU16::new(value)),
vec.compute_to( exit,
starting_indexes.height, )?;
indexes.height_to_date.len(), Ok(())
indexes.height_to_date.version(), })
|i| (i, StoredU16::new(value)),
exit,
)?;
Ok(())
},
)
})?; })?;
[ [
@@ -223,22 +214,16 @@ impl Vecs {
] ]
.into_iter() .into_iter()
.try_for_each(|(vec, value)| { .try_for_each(|(vec, value)| {
vec.compute_all( vec.compute_all(indexes, starting_indexes, exit, |vec| {
indexer, vec.compute_to(
indexes, starting_indexes.height,
starting_indexes, indexes.height_to_date.len(),
exit, indexes.height_to_date.version(),
|vec, _, indexes, starting_indexes, exit| { |i| (i, StoredI16::new(value)),
vec.compute_to( exit,
starting_indexes.height, )?;
indexes.height_to_date.len(), Ok(())
indexes.height_to_date.version(), })
|i| (i, StoredI16::new(value)),
exit,
)?;
Ok(())
},
)
})?; })?;
[ [
@@ -247,22 +232,16 @@ impl Vecs {
] ]
.into_iter() .into_iter()
.try_for_each(|(vec, value)| { .try_for_each(|(vec, value)| {
vec.compute_all( vec.compute_all(indexes, starting_indexes, exit, |vec| {
indexer, vec.compute_to(
indexes, starting_indexes.height,
starting_indexes, indexes.height_to_date.len(),
exit, indexes.height_to_date.version(),
|vec, _, indexes, starting_indexes, exit| { |i| (i, StoredF32::from(value)),
vec.compute_to( exit,
starting_indexes.height, )?;
indexes.height_to_date.len(), Ok(())
indexes.height_to_date.version(), })
|i| (i, StoredF32::from(value)),
exit,
)?;
Ok(())
},
)
})?; })?;
Ok(()) Ok(())
crates/brk_computer/src/grouped/builder_computed.rs
-473
View File
@@ -1,473 +0,0 @@
use brk_error::Result;
use brk_structs::Version;
use vecdb::{
AnyBoxedIterableVec, AnyCloneableIterableVec, AnyCollectableVec, AnyIterableVec, Computation,
ComputedVec, ComputedVecFrom2, Database, Exit, Format, FromCoarserIndex, StoredIndex,
};
use crate::grouped::{EagerVecBuilder, VecBuilderOptions};
use super::ComputedType;
#[allow(clippy::type_complexity)]
#[derive(Clone)]
pub struct ComputedVecBuilder<I, T, S1I, S2T>
where
I: StoredIndex,
T: ComputedType,
S2T: ComputedType,
{
pub first: Option<Box<ComputedVecFrom2<I, T, S1I, T, I, S2T>>>,
pub average: Option<Box<ComputedVecFrom2<I, T, S1I, T, I, S2T>>>,
pub sum: Option<Box<ComputedVecFrom2<I, T, S1I, T, I, S2T>>>,
pub max: Option<Box<ComputedVecFrom2<I, T, S1I, T, I, S2T>>>,
pub min: Option<Box<ComputedVecFrom2<I, T, S1I, T, I, S2T>>>,
pub last: Option<Box<ComputedVecFrom2<I, T, S1I, T, I, S2T>>>,
pub cumulative: Option<Box<ComputedVecFrom2<I, T, S1I, T, I, S2T>>>,
}
const VERSION: Version = Version::ZERO;
impl<I, T, S1I, S2T> ComputedVecBuilder<I, T, S1I, S2T>
where
I: StoredIndex,
T: ComputedType + 'static,
S1I: StoredIndex + 'static + FromCoarserIndex<I>,
S2T: ComputedType,
{
#[allow(clippy::too_many_arguments)]
pub fn forced_import(
db: &Database,
name: &str,
version: Version,
format: Format,
computation: Computation,
source: Option<AnyBoxedIterableVec<S1I, T>>,
source_extra: &EagerVecBuilder<S1I, T>,
len_source: AnyBoxedIterableVec<I, S2T>,
options: ComputedVecBuilderOptions,
) -> Result<Self> {
let only_one_active = options.is_only_one_active();
let suffix = |s: &str| format!("{name}_{s}");
let maybe_suffix = |s: &str| {
if only_one_active {
name.to_string()
} else {
suffix(s)
}
};
Ok(Self {
first: options.first.then(|| {
Box::new(
ComputedVec::forced_import_or_init_from_2(
computation,
db,
&maybe_suffix("first"),
version + VERSION + Version::ZERO,
format,
source_extra
.first
.as_ref()
.map_or_else(|| source.as_ref().unwrap().clone(), |v| v.clone()),
len_source.clone(),
|i: I, source, len_source| {
if i.unwrap_to_usize() >= len_source.len() {
return None;
}
source
.next_at(S1I::min_from(i))
.map(|(_, cow)| cow.into_owned())
},
)
.unwrap(),
)
}),
last: options.last.then(|| {
Box::new(
ComputedVec::forced_import_or_init_from_2(
computation,
db,
name,
version + VERSION + Version::ZERO,
format,
source_extra.last.as_ref().map_or_else(
|| {
source
.as_ref()
.unwrap_or_else(|| {
dbg!(db, name, I::to_string());
panic!()
})
.clone()
},
|v| v.clone(),
),
len_source.clone(),
|i: I, source, len_source| {
if i.unwrap_to_usize() >= len_source.len() {
return None;
}
source
.next_at(S1I::max_from(i, source.len()))
.map(|(_, cow)| cow.into_owned())
},
)
.unwrap(),
)
}),
min: options.min.then(|| {
Box::new(
ComputedVec::forced_import_or_init_from_2(
computation,
db,
&maybe_suffix("min"),
version + VERSION + Version::ZERO,
format,
source_extra
.min
.as_ref()
.map_or_else(|| source.as_ref().unwrap().clone(), |v| v.clone()),
len_source.clone(),
|i: I, source, len_source| {
if i.unwrap_to_usize() >= len_source.len() {
return None;
}
S1I::inclusive_range_from(i, source.len())
.flat_map(|i| source.next_at(i).map(|(_, cow)| cow.into_owned()))
.min()
},
)
.unwrap(),
)
}),
max: options.max.then(|| {
Box::new(
ComputedVec::forced_import_or_init_from_2(
computation,
db,
&maybe_suffix("max"),
version + VERSION + Version::ZERO,
format,
source_extra
.max
.as_ref()
.map_or_else(|| source.as_ref().unwrap().clone(), |v| v.clone()),
len_source.clone(),
|i: I, source, len_source| {
if i.unwrap_to_usize() >= len_source.len() {
return None;
}
S1I::inclusive_range_from(i, source.len())
.flat_map(|i| source.next_at(i).map(|(_, cow)| cow.into_owned()))
.max()
},
)
.unwrap(),
)
}),
average: options.average.then(|| {
Box::new(
ComputedVec::forced_import_or_init_from_2(
computation,
db,
&maybe_suffix("average"),
version + VERSION + Version::ZERO,
format,
source_extra
.average
.as_ref()
.map_or_else(|| source.as_ref().unwrap().clone(), |v| v.clone()),
len_source.clone(),
|i: I, source, len_source| {
if i.unwrap_to_usize() >= len_source.len() {
return None;
}
let vec = S1I::inclusive_range_from(i, source.len())
.flat_map(|i| source.next_at(i).map(|(_, cow)| cow.into_owned()))
.collect::<Vec<_>>();
if vec.is_empty() {
return None;
}
let mut sum = T::from(0);
let len = vec.len();
vec.into_iter().for_each(|v| sum += v);
Some(sum / len)
},
)
.unwrap(),
)
}),
sum: options.sum.then(|| {
Box::new(
ComputedVec::forced_import_or_init_from_2(
computation,
db,
&(if !options.last && !options.average && !options.min && !options.max {
name.to_string()
} else {
maybe_suffix("sum")
}),
version + VERSION + Version::ZERO,
format,
source_extra
.sum
.as_ref()
.map_or_else(|| source.as_ref().unwrap().clone(), |v| v.clone()),
len_source.clone(),
|i: I, source, len_source| {
if i.unwrap_to_usize() >= len_source.len() {
return None;
}
let vec = S1I::inclusive_range_from(i, source.len())
.flat_map(|i| source.next_at(i).map(|(_, cow)| cow.into_owned()))
.collect::<Vec<_>>();
if vec.is_empty() {
return None;
}
let mut sum = T::from(0);
vec.into_iter().for_each(|v| sum += v);
Some(sum)
},
)
.unwrap(),
)
}),
cumulative: options.cumulative.then(|| {
Box::new(
ComputedVec::forced_import_or_init_from_2(
computation,
db,
&suffix("cumulative"),
version + VERSION + Version::ZERO,
format,
source_extra.cumulative.as_ref().unwrap().boxed_clone(),
len_source.clone(),
|i: I, source, len_source| {
if i.unwrap_to_usize() >= len_source.len() {
return None;
}
source
.next_at(S1I::max_from(i, source.len()))
.map(|(_, cow)| cow.into_owned())
},
)
.unwrap(),
)
}),
})
}
pub fn compute_if_necessary<T2>(
&mut self,
max_from: I,
len_source: &impl AnyIterableVec<I, T2>,
exit: &Exit,
) -> Result<()> {
if let Some(first) = self.first.as_mut() {
first.compute_if_necessary(max_from, len_source, exit)?;
}
if let Some(last) = self.last.as_mut() {
last.compute_if_necessary(max_from, len_source, exit)?;
}
if let Some(min) = self.min.as_mut() {
min.compute_if_necessary(max_from, len_source, exit)?;
}
if let Some(max) = self.max.as_mut() {
max.compute_if_necessary(max_from, len_source, exit)?;
}
if let Some(average) = self.average.as_mut() {
average.compute_if_necessary(max_from, len_source, exit)?;
}
if let Some(sum) = self.sum.as_mut() {
sum.compute_if_necessary(max_from, len_source, exit)?;
}
if let Some(cumulative) = self.cumulative.as_mut() {
cumulative.compute_if_necessary(max_from, len_source, exit)?;
}
Ok(())
}
pub fn starting_index(&self, max_from: I) -> I {
max_from.min(I::from(
self.vecs().into_iter().map(|v| v.len()).min().unwrap(),
))
}
pub fn unwrap_first(&self) -> &ComputedVecFrom2<I, T, S1I, T, I, S2T> {
self.first.as_ref().unwrap()
}
#[allow(unused)]
pub fn unwrap_average(&self) -> &ComputedVecFrom2<I, T, S1I, T, I, S2T> {
self.average.as_ref().unwrap()
}
pub fn unwrap_sum(&self) -> &ComputedVecFrom2<I, T, S1I, T, I, S2T> {
self.sum.as_ref().unwrap()
}
pub fn unwrap_max(&self) -> &ComputedVecFrom2<I, T, S1I, T, I, S2T> {
self.max.as_ref().unwrap()
}
pub fn unwrap_min(&self) -> &ComputedVecFrom2<I, T, S1I, T, I, S2T> {
self.min.as_ref().unwrap()
}
pub fn unwrap_last(&self) -> &ComputedVecFrom2<I, T, S1I, T, I, S2T> {
self.last.as_ref().unwrap()
}
#[allow(unused)]
pub fn unwrap_cumulative(&self) -> &ComputedVecFrom2<I, T, S1I, T, I, S2T> {
self.cumulative.as_ref().unwrap()
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
let mut v: Vec<&dyn AnyCollectableVec> = vec![];
if let Some(first) = self.first.as_ref() {
v.push(first.as_ref());
}
if let Some(last) = self.last.as_ref() {
v.push(last.as_ref());
}
if let Some(min) = self.min.as_ref() {
v.push(min.as_ref());
}
if let Some(max) = self.max.as_ref() {
v.push(max.as_ref());
}
if let Some(average) = self.average.as_ref() {
v.push(average.as_ref());
}
if let Some(sum) = self.sum.as_ref() {
v.push(sum.as_ref());
}
if let Some(cumulative) = self.cumulative.as_ref() {
v.push(cumulative.as_ref());
}
v
}
}
#[derive(Default, Clone, Copy)]
pub struct ComputedVecBuilderOptions {
average: bool,
sum: bool,
max: bool,
min: bool,
first: bool,
last: bool,
cumulative: bool,
}
impl From<VecBuilderOptions> for ComputedVecBuilderOptions {
fn from(value: VecBuilderOptions) -> Self {
Self {
average: value.average(),
sum: value.sum(),
max: value.max(),
min: value.min(),
first: value.first(),
last: value.last(),
cumulative: value.cumulative(),
}
}
}
impl ComputedVecBuilderOptions {
pub fn add_first(mut self) -> Self {
self.first = true;
self
}
pub fn add_last(mut self) -> Self {
self.last = true;
self
}
pub fn add_min(mut self) -> Self {
self.min = true;
self
}
pub fn add_max(mut self) -> Self {
self.max = true;
self
}
pub fn add_average(mut self) -> Self {
self.average = true;
self
}
pub fn add_sum(mut self) -> Self {
self.sum = true;
self
}
pub fn add_cumulative(mut self) -> Self {
self.cumulative = true;
self
}
#[allow(unused)]
pub fn rm_min(mut self) -> Self {
self.min = false;
self
}
#[allow(unused)]
pub fn rm_max(mut self) -> Self {
self.max = false;
self
}
#[allow(unused)]
pub fn rm_average(mut self) -> Self {
self.average = false;
self
}
#[allow(unused)]
pub fn rm_sum(mut self) -> Self {
self.sum = false;
self
}
#[allow(unused)]
pub fn rm_cumulative(mut self) -> Self {
self.cumulative = false;
self
}
pub fn add_minmax(mut self) -> Self {
self.min = true;
self.max = true;
self
}
pub fn is_only_one_active(&self) -> bool {
[
self.average,
self.sum,
self.max,
self.min,
self.first,
self.last,
self.cumulative,
]
.iter()
.filter(|b| **b)
.count()
== 1
}
pub fn copy_self_extra(&self) -> Self {
Self {
cumulative: self.cumulative,
..Self::default()
}
}
}
crates/brk_computer/src/grouped/from_dateindex.rs
+2 -17
View File
@@ -1,7 +1,6 @@
use allocative::Allocative; use allocative::Allocative;
use brk_error::Result; use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{ use brk_structs::{
DateIndex, DecadeIndex, MonthIndex, QuarterIndex, SemesterIndex, Version, WeekIndex, YearIndex, DateIndex, DecadeIndex, MonthIndex, QuarterIndex, SemesterIndex, Version, WeekIndex, YearIndex,
}; };
@@ -112,28 +111,14 @@ where
pub fn compute_all<F>( pub fn compute_all<F>(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
starting_indexes: &Indexes, starting_indexes: &Indexes,
exit: &Exit, exit: &Exit,
mut compute: F, mut compute: F,
) -> Result<()> ) -> Result<()>
where where
F: FnMut( F: FnMut(&mut EagerVec<DateIndex, T>) -> Result<()>,
&mut EagerVec<DateIndex, T>,
&Indexer,
&indexes::Vecs,
&Indexes,
&Exit,
) -> Result<()>,
{ {
compute( compute(self.dateindex.as_mut().unwrap())?;
self.dateindex.as_mut().unwrap(),
indexer,
indexes,
starting_indexes,
exit,
)?;
let dateindex: Option<&EagerVec<DateIndex, T>> = None; let dateindex: Option<&EagerVec<DateIndex, T>> = None;
self.compute_rest(starting_indexes, exit, dateindex) self.compute_rest(starting_indexes, exit, dateindex)
crates/brk_computer/src/grouped/from_height.rs
+2 -10
View File
@@ -1,7 +1,6 @@
use allocative::Allocative; use allocative::Allocative;
use brk_error::Result; use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{ use brk_structs::{
DateIndex, DecadeIndex, DifficultyEpoch, Height, MonthIndex, QuarterIndex, SemesterIndex, DateIndex, DecadeIndex, DifficultyEpoch, Height, MonthIndex, QuarterIndex, SemesterIndex,
Version, WeekIndex, YearIndex, Version, WeekIndex, YearIndex,
@@ -134,22 +133,15 @@ where
pub fn compute_all<F>( pub fn compute_all<F>(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs, indexes: &indexes::Vecs,
starting_indexes: &Indexes, starting_indexes: &Indexes,
exit: &Exit, exit: &Exit,
mut compute: F, mut compute: F,
) -> Result<()> ) -> Result<()>
where where
F: FnMut(&mut EagerVec<Height, T>, &Indexer, &indexes::Vecs, &Indexes, &Exit) -> Result<()>, F: FnMut(&mut EagerVec<Height, T>) -> Result<()>,
{ {
compute( compute(self.height.as_mut().unwrap())?;
self.height.as_mut().unwrap(),
indexer,
indexes,
starting_indexes,
exit,
)?;
let height: Option<&EagerVec<Height, T>> = None; let height: Option<&EagerVec<Height, T>> = None;
self.compute_rest(indexes, starting_indexes, exit, height) self.compute_rest(indexes, starting_indexes, exit, height)
crates/brk_computer/src/grouped/from_height_strict.rs
+2 -4
View File
@@ -1,6 +1,5 @@
use brk_error::Result; use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{DifficultyEpoch, Height, Version}; use brk_structs::{DifficultyEpoch, Height, Version};
use vecdb::{AnyCollectableVec, Database, EagerVec, Exit}; use vecdb::{AnyCollectableVec, Database, EagerVec, Exit};
@@ -59,16 +58,15 @@ where
pub fn compute<F>( pub fn compute<F>(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs, indexes: &indexes::Vecs,
starting_indexes: &Indexes, starting_indexes: &Indexes,
exit: &Exit, exit: &Exit,
mut compute: F, mut compute: F,
) -> Result<()> ) -> Result<()>
where where
F: FnMut(&mut EagerVec<Height, T>, &Indexer, &indexes::Vecs, &Indexes, &Exit) -> Result<()>, F: FnMut(&mut EagerVec<Height, T>) -> Result<()>,
{ {
compute(&mut self.height, indexer, indexes, starting_indexes, exit)?; compute(&mut self.height)?;
self.height_extra self.height_extra
.extend(starting_indexes.height, &self.height, exit)?; .extend(starting_indexes.height, &self.height, exit)?;
crates/brk_computer/src/grouped/ratio_from_dateindex.rs
+50 -100
View File
@@ -1,5 +1,4 @@
use brk_error::Result; use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{Date, DateIndex, Dollars, StoredF32, Version}; use brk_structs::{Date, DateIndex, Dollars, StoredF32, Version};
use vecdb::{ use vecdb::{
AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, CollectableVec, Database, EagerVec, AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, CollectableVec, Database, EagerVec,
@@ -284,45 +283,25 @@ impl ComputedRatioVecsFromDateIndex {
pub fn compute_all<F>( pub fn compute_all<F>(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
price: &price::Vecs, price: &price::Vecs,
starting_indexes: &Indexes, starting_indexes: &Indexes,
exit: &Exit, exit: &Exit,
compute: F, compute: F,
) -> Result<()> ) -> Result<()>
where where
F: FnMut( F: FnMut(&mut EagerVec<DateIndex, Dollars>) -> Result<()>,
&mut EagerVec<DateIndex, Dollars>,
&Indexer,
&indexes::Vecs,
&Indexes,
&Exit,
) -> Result<()>,
{ {
self.price.as_mut().unwrap().compute_all( self.price
indexer, .as_mut()
indexes, .unwrap()
starting_indexes, .compute_all(starting_indexes, exit, compute)?;
exit,
compute,
)?;
let date_to_price_opt: Option<&EagerVec<DateIndex, Dollars>> = None; let date_to_price_opt: Option<&EagerVec<DateIndex, Dollars>> = None;
self.compute_rest( self.compute_rest(price, starting_indexes, exit, date_to_price_opt)
indexer,
indexes,
price,
starting_indexes,
exit,
date_to_price_opt,
)
} }
pub fn compute_rest( pub fn compute_rest(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
price: &price::Vecs, price: &price::Vecs,
starting_indexes: &Indexes, starting_indexes: &Indexes,
exit: &Exit, exit: &Exit,
@@ -334,28 +313,22 @@ impl ComputedRatioVecsFromDateIndex {
std::mem::transmute(&self.price.as_ref().unwrap().dateindex) std::mem::transmute(&self.price.as_ref().unwrap().dateindex)
}); });
self.ratio.compute_all( self.ratio.compute_all(starting_indexes, exit, |v| {
indexer, v.compute_transform2(
indexes, starting_indexes.dateindex,
starting_indexes, closes,
exit, price,
|v, _, _, starting_indexes, exit| { |(i, close, price, ..)| {
v.compute_transform2( if price == Dollars::ZERO {
starting_indexes.dateindex, (i, StoredF32::from(1.0))
closes, } else {
price, (i, StoredF32::from(*close / price))
|(i, close, price, ..)| { }
if price == Dollars::ZERO { },
(i, StoredF32::from(1.0)) exit,
} else { )?;
(i, StoredF32::from(*close / price)) Ok(())
} })?;
},
exit,
)?;
Ok(())
},
)?;
if self.ratio_1w_sma.is_none() { if self.ratio_1w_sma.is_none() {
return Ok(()); return Ok(());
@@ -363,12 +336,10 @@ impl ComputedRatioVecsFromDateIndex {
let min_ratio_date = DateIndex::try_from(Date::MIN_RATIO).unwrap(); let min_ratio_date = DateIndex::try_from(Date::MIN_RATIO).unwrap();
self.ratio_1w_sma.as_mut().unwrap().compute_all( self.ratio_1w_sma
indexer, .as_mut()
indexes, .unwrap()
starting_indexes, .compute_all(starting_indexes, exit, |v| {
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma_( v.compute_sma_(
starting_indexes.dateindex, starting_indexes.dateindex,
self.ratio.dateindex.as_ref().unwrap(), self.ratio.dateindex.as_ref().unwrap(),
@@ -377,15 +348,12 @@ impl ComputedRatioVecsFromDateIndex {
Some(min_ratio_date), Some(min_ratio_date),
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.ratio_1m_sma.as_mut().unwrap().compute_all( self.ratio_1m_sma
indexer, .as_mut()
indexes, .unwrap()
starting_indexes, .compute_all(starting_indexes, exit, |v| {
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma_( v.compute_sma_(
starting_indexes.dateindex, starting_indexes.dateindex,
self.ratio.dateindex.as_ref().unwrap(), self.ratio.dateindex.as_ref().unwrap(),
@@ -394,8 +362,7 @@ impl ComputedRatioVecsFromDateIndex {
Some(min_ratio_date), Some(min_ratio_date),
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
let ratio_version = self.ratio.dateindex.as_ref().unwrap().version(); let ratio_version = self.ratio.dateindex.as_ref().unwrap().version();
self.mut_ratio_vecs() self.mut_ratio_vecs()
@@ -562,12 +529,10 @@ impl ComputedRatioVecsFromDateIndex {
std::mem::transmute(&self.price.as_ref().unwrap().dateindex) std::mem::transmute(&self.price.as_ref().unwrap().dateindex)
}); });
self.ratio_pct99_in_usd.as_mut().unwrap().compute_all( self.ratio_pct99_in_usd
indexer, .as_mut()
indexes, .unwrap()
starting_indexes, .compute_all(starting_indexes, exit, |vec| {
exit,
|vec, _, _, starting_indexes, exit| {
let mut iter = self let mut iter = self
.ratio_pct99 .ratio_pct99
.as_ref() .as_ref()
@@ -586,31 +551,24 @@ impl ComputedRatioVecsFromDateIndex {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
let compute_in_usd = let compute_in_usd =
|in_usd: Option<&mut ComputedVecsFromDateIndex<Dollars>>, |in_usd: Option<&mut ComputedVecsFromDateIndex<Dollars>>,
source: Option<&ComputedVecsFromDateIndex<StoredF32>>| { source: Option<&ComputedVecsFromDateIndex<StoredF32>>| {
in_usd.unwrap().compute_all( in_usd.unwrap().compute_all(starting_indexes, exit, |vec| {
indexer, let mut iter = source.unwrap().dateindex.as_ref().unwrap().into_iter();
indexes, vec.compute_transform(
starting_indexes, starting_indexes.dateindex,
exit, date_to_price,
|vec, _, _, starting_indexes, exit| { |(i, price, ..)| {
let mut iter = source.unwrap().dateindex.as_ref().unwrap().into_iter(); let multiplier = iter.unwrap_get_inner(i);
vec.compute_transform( (i, price * multiplier)
starting_indexes.dateindex, },
date_to_price, exit,
|(i, price, ..)| { )?;
let multiplier = iter.unwrap_get_inner(i); Ok(())
(i, price * multiplier) })
},
exit,
)?;
Ok(())
},
)
}; };
compute_in_usd(self.ratio_pct1_in_usd.as_mut(), self.ratio_pct1.as_ref())?; compute_in_usd(self.ratio_pct1_in_usd.as_mut(), self.ratio_pct1.as_ref())?;
@@ -621,32 +579,24 @@ impl ComputedRatioVecsFromDateIndex {
compute_in_usd(self.ratio_pct99_in_usd.as_mut(), self.ratio_pct99.as_ref())?; compute_in_usd(self.ratio_pct99_in_usd.as_mut(), self.ratio_pct99.as_ref())?;
self.ratio_sd.as_mut().unwrap().compute_all( self.ratio_sd.as_mut().unwrap().compute_all(
indexer,
indexes,
starting_indexes, starting_indexes,
exit, exit,
self.ratio.dateindex.as_ref().unwrap(), self.ratio.dateindex.as_ref().unwrap(),
Some(date_to_price), Some(date_to_price),
)?; )?;
self.ratio_4y_sd.as_mut().unwrap().compute_all( self.ratio_4y_sd.as_mut().unwrap().compute_all(
indexer,
indexes,
starting_indexes, starting_indexes,
exit, exit,
self.ratio.dateindex.as_ref().unwrap(), self.ratio.dateindex.as_ref().unwrap(),
Some(date_to_price), Some(date_to_price),
)?; )?;
self.ratio_2y_sd.as_mut().unwrap().compute_all( self.ratio_2y_sd.as_mut().unwrap().compute_all(
indexer,
indexes,
starting_indexes, starting_indexes,
exit, exit,
self.ratio.dateindex.as_ref().unwrap(), self.ratio.dateindex.as_ref().unwrap(),
Some(date_to_price), Some(date_to_price),
)?; )?;
self.ratio_1y_sd.as_mut().unwrap().compute_all( self.ratio_1y_sd.as_mut().unwrap().compute_all(
indexer,
indexes,
starting_indexes, starting_indexes,
exit, exit,
self.ratio.dateindex.as_ref().unwrap(), self.ratio.dateindex.as_ref().unwrap(),
crates/brk_computer/src/grouped/sd_from_dateindex.rs
+28 -56
View File
@@ -1,5 +1,4 @@
use brk_error::Result; use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{CheckedSub, Date, DateIndex, Dollars, StoredF32, Version}; use brk_structs::{CheckedSub, Date, DateIndex, Dollars, StoredF32, Version};
use vecdb::{ use vecdb::{
AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, BoxedVecIterator, CollectableVec, AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, BoxedVecIterator, CollectableVec,
@@ -419,8 +418,6 @@ impl ComputedStandardDeviationVecsFromDateIndex {
pub fn compute_all( pub fn compute_all(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
starting_indexes: &Indexes, starting_indexes: &Indexes,
exit: &Exit, exit: &Exit,
source: &impl CollectableVec<DateIndex, StoredF32>, source: &impl CollectableVec<DateIndex, StoredF32>,
@@ -428,12 +425,10 @@ impl ComputedStandardDeviationVecsFromDateIndex {
) -> Result<()> { ) -> Result<()> {
let min_date = DateIndex::try_from(Date::MIN_RATIO).unwrap(); let min_date = DateIndex::try_from(Date::MIN_RATIO).unwrap();
self.sma.as_mut().unwrap().compute_all( self.sma
indexer, .as_mut()
indexes, .unwrap()
starting_indexes, .compute_all(starting_indexes, exit, |v| {
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma_( v.compute_sma_(
starting_indexes.dateindex, starting_indexes.dateindex,
source, source,
@@ -442,26 +437,15 @@ impl ComputedStandardDeviationVecsFromDateIndex {
Some(min_date), Some(min_date),
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
let sma_opt: Option<&EagerVec<DateIndex, StoredF32>> = None; let sma_opt: Option<&EagerVec<DateIndex, StoredF32>> = None;
self.compute_rest( self.compute_rest(starting_indexes, exit, sma_opt, source, price_opt)
indexer,
indexes,
starting_indexes,
exit,
sma_opt,
source,
price_opt,
)
} }
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
pub fn compute_rest( pub fn compute_rest(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
starting_indexes: &Indexes, starting_indexes: &Indexes,
exit: &Exit, exit: &Exit,
sma_opt: Option<&impl AnyIterableVec<DateIndex, StoredF32>>, sma_opt: Option<&impl AnyIterableVec<DateIndex, StoredF32>>,
@@ -630,22 +614,16 @@ impl ComputedStandardDeviationVecsFromDateIndex {
})?; })?;
if let Some(zscore) = self.zscore.as_mut() { if let Some(zscore) = self.zscore.as_mut() {
zscore.compute_all( zscore.compute_all(starting_indexes, exit, |vec| {
indexer, vec.compute_zscore(
indexes, starting_indexes.dateindex,
starting_indexes, source,
exit, sma,
|vec, _, _, starting_indexes, exit| { self.sd.dateindex.as_ref().unwrap(),
vec.compute_zscore( exit,
starting_indexes.dateindex, )?;
source, Ok(())
sma, })?;
self.sd.dateindex.as_ref().unwrap(),
exit,
)?;
Ok(())
},
)?;
} }
let Some(price) = price_opt else { let Some(price) = price_opt else {
@@ -655,24 +633,18 @@ impl ComputedStandardDeviationVecsFromDateIndex {
let compute_in_usd = let compute_in_usd =
|in_usd: &mut ComputedVecsFromDateIndex<Dollars>, |in_usd: &mut ComputedVecsFromDateIndex<Dollars>,
mut iter: BoxedVecIterator<DateIndex, StoredF32>| { mut iter: BoxedVecIterator<DateIndex, StoredF32>| {
in_usd.compute_all( in_usd.compute_all(starting_indexes, exit, |vec| {
indexer, vec.compute_transform(
indexes, starting_indexes.dateindex,
starting_indexes, price,
exit, |(i, price, ..)| {
|vec, _, _, starting_indexes, exit| { let multiplier = iter.unwrap_get_inner(i);
vec.compute_transform( (i, price * multiplier)
starting_indexes.dateindex, },
price, exit,
|(i, price, ..)| { )?;
let multiplier = iter.unwrap_get_inner(i); Ok(())
(i, price * multiplier) })
},
exit,
)?;
Ok(())
},
)
}; };
if self._0sd_in_usd.is_none() { if self._0sd_in_usd.is_none() {
crates/brk_computer/src/grouped/value_from_dateindex.rs
+21 -56
View File
@@ -1,5 +1,4 @@
use brk_error::Result; use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{Bitcoin, DateIndex, Dollars, Sats, Version}; use brk_structs::{Bitcoin, DateIndex, Dollars, Sats, Version};
use vecdb::{AnyCollectableVec, CollectableVec, Database, EagerVec, Exit, StoredVec}; use vecdb::{AnyCollectableVec, CollectableVec, Database, EagerVec, Exit, StoredVec};
@@ -65,40 +64,24 @@ impl ComputedValueVecsFromDateIndex {
pub fn compute_all<F>( pub fn compute_all<F>(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
price: Option<&price::Vecs>, price: Option<&price::Vecs>,
starting_indexes: &Indexes, starting_indexes: &Indexes,
exit: &Exit, exit: &Exit,
mut compute: F, mut compute: F,
) -> Result<()> ) -> Result<()>
where where
F: FnMut( F: FnMut(&mut EagerVec<DateIndex, Sats>) -> Result<()>,
&mut EagerVec<DateIndex, Sats>,
&Indexer,
&indexes::Vecs,
&Indexes,
&Exit,
) -> Result<()>,
{ {
compute( compute(self.sats.dateindex.as_mut().unwrap())?;
self.sats.dateindex.as_mut().unwrap(),
indexer,
indexes,
starting_indexes,
exit,
)?;
let dateindex: Option<&StoredVec<DateIndex, Sats>> = None; let dateindex: Option<&StoredVec<DateIndex, Sats>> = None;
self.compute_rest(indexer, indexes, price, starting_indexes, exit, dateindex)?; self.compute_rest(price, starting_indexes, exit, dateindex)?;
Ok(()) Ok(())
} }
pub fn compute_rest( pub fn compute_rest(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
price: Option<&price::Vecs>, price: Option<&price::Vecs>,
starting_indexes: &Indexes, starting_indexes: &Indexes,
exit: &Exit, exit: &Exit,
@@ -108,33 +91,21 @@ impl ComputedValueVecsFromDateIndex {
self.sats self.sats
.compute_rest(starting_indexes, exit, Some(dateindex))?; .compute_rest(starting_indexes, exit, Some(dateindex))?;
self.bitcoin.compute_all( self.bitcoin.compute_all(starting_indexes, exit, |v| {
indexer, v.compute_from_sats(starting_indexes.dateindex, dateindex, exit)
indexes, })?;
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_from_sats(starting_indexes.dateindex, dateindex, exit)
},
)?;
} else { } else {
let dateindex: Option<&StoredVec<DateIndex, Sats>> = None; let dateindex: Option<&StoredVec<DateIndex, Sats>> = None;
self.sats.compute_rest(starting_indexes, exit, dateindex)?; self.sats.compute_rest(starting_indexes, exit, dateindex)?;
self.bitcoin.compute_all( self.bitcoin.compute_all(starting_indexes, exit, |v| {
indexer, v.compute_from_sats(
indexes, starting_indexes.dateindex,
starting_indexes, self.sats.dateindex.as_ref().unwrap(),
exit, exit,
|v, _, _, starting_indexes, exit| { )
v.compute_from_sats( })?;
starting_indexes.dateindex,
self.sats.dateindex.as_ref().unwrap(),
exit,
)
},
)?;
} }
let dateindex_to_bitcoin = self.bitcoin.dateindex.as_ref().unwrap(); let dateindex_to_bitcoin = self.bitcoin.dateindex.as_ref().unwrap();
@@ -147,20 +118,14 @@ impl ComputedValueVecsFromDateIndex {
.unwrap(); .unwrap();
if let Some(dollars) = self.dollars.as_mut() { if let Some(dollars) = self.dollars.as_mut() {
dollars.compute_all( dollars.compute_all(starting_indexes, exit, |v| {
indexer, v.compute_from_bitcoin(
indexes, starting_indexes.dateindex,
starting_indexes, dateindex_to_bitcoin,
exit, dateindex_to_price_close,
|v, _, _, starting_indexes, exit| { exit,
v.compute_from_bitcoin( )
starting_indexes.dateindex, })?;
dateindex_to_bitcoin,
dateindex_to_price_close,
exit,
)
},
)?;
} }
Ok(()) Ok(())
crates/brk_computer/src/grouped/value_from_height.rs
+17 -48
View File
@@ -1,6 +1,5 @@
use allocative::Allocative; use allocative::Allocative;
use brk_error::Result; use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{Bitcoin, Dollars, Height, Sats, Version}; use brk_structs::{Bitcoin, Dollars, Height, Sats, Version};
use vecdb::{AnyCollectableVec, CollectableVec, Database, EagerVec, Exit, StoredVec}; use vecdb::{AnyCollectableVec, CollectableVec, Database, EagerVec, Exit, StoredVec};
@@ -66,7 +65,6 @@ impl ComputedValueVecsFromHeight {
pub fn compute_all<F>( pub fn compute_all<F>(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs, indexes: &indexes::Vecs,
price: Option<&price::Vecs>, price: Option<&price::Vecs>,
starting_indexes: &Indexes, starting_indexes: &Indexes,
@@ -74,31 +72,18 @@ impl ComputedValueVecsFromHeight {
mut compute: F, mut compute: F,
) -> Result<()> ) -> Result<()>
where where
F: FnMut( F: FnMut(&mut EagerVec<Height, Sats>) -> Result<()>,
&mut EagerVec<Height, Sats>,
&Indexer,
&indexes::Vecs,
&Indexes,
&Exit,
) -> Result<()>,
{ {
compute( compute(self.sats.height.as_mut().unwrap())?;
self.sats.height.as_mut().unwrap(),
indexer,
indexes,
starting_indexes,
exit,
)?;
let height: Option<&StoredVec<Height, Sats>> = None; let height: Option<&StoredVec<Height, Sats>> = None;
self.compute_rest(indexer, indexes, price, starting_indexes, exit, height)?; self.compute_rest(indexes, price, starting_indexes, exit, height)?;
Ok(()) Ok(())
} }
pub fn compute_rest( pub fn compute_rest(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs, indexes: &indexes::Vecs,
price: Option<&price::Vecs>, price: Option<&price::Vecs>,
starting_indexes: &Indexes, starting_indexes: &Indexes,
@@ -109,54 +94,38 @@ impl ComputedValueVecsFromHeight {
self.sats self.sats
.compute_rest(indexes, starting_indexes, exit, Some(height))?; .compute_rest(indexes, starting_indexes, exit, Some(height))?;
self.bitcoin.compute_all( self.bitcoin
indexer, .compute_all(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_from_sats(starting_indexes.height, height, exit) v.compute_from_sats(starting_indexes.height, height, exit)
}, })?;
)?;
} else { } else {
let height: Option<&StoredVec<Height, Sats>> = None; let height: Option<&StoredVec<Height, Sats>> = None;
self.sats self.sats
.compute_rest(indexes, starting_indexes, exit, height)?; .compute_rest(indexes, starting_indexes, exit, height)?;
self.bitcoin.compute_all( self.bitcoin
indexer, .compute_all(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_from_sats( v.compute_from_sats(
starting_indexes.height, starting_indexes.height,
self.sats.height.as_ref().unwrap(), self.sats.height.as_ref().unwrap(),
exit, exit,
) )
}, })?;
)?;
} }
let height_to_bitcoin = self.bitcoin.height.as_ref().unwrap(); let height_to_bitcoin = self.bitcoin.height.as_ref().unwrap();
let height_to_price_close = &price.as_ref().unwrap().chainindexes_to_price_close.height; let height_to_price_close = &price.as_ref().unwrap().chainindexes_to_price_close.height;
if let Some(dollars) = self.dollars.as_mut() { if let Some(dollars) = self.dollars.as_mut() {
dollars.compute_all( dollars.compute_all(indexes, starting_indexes, exit, |v| {
indexer, v.compute_from_bitcoin(
indexes, starting_indexes.height,
starting_indexes, height_to_bitcoin,
exit, height_to_price_close,
|v, _, _, starting_indexes, exit| { exit,
v.compute_from_bitcoin( )
starting_indexes.height, })?;
height_to_bitcoin,
height_to_price_close,
exit,
)
},
)?;
} }
Ok(()) Ok(())
crates/brk_computer/src/grouped/value_height.rs
+3 -18
View File
@@ -1,12 +1,11 @@
use brk_error::Result; use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{Bitcoin, Dollars, Height, Sats, Version}; use brk_structs::{Bitcoin, Dollars, Height, Sats, Version};
use vecdb::{AnyCollectableVec, CollectableVec, Database, EagerVec, Exit, Format, StoredVec}; use vecdb::{AnyCollectableVec, CollectableVec, Database, EagerVec, Exit, Format, StoredVec};
use crate::{ use crate::{
Indexes, Indexes,
grouped::Source, grouped::Source,
indexes, price, price,
traits::{ComputeFromBitcoin, ComputeFromSats}, traits::{ComputeFromBitcoin, ComputeFromSats},
}; };
@@ -53,29 +52,15 @@ impl ComputedHeightValueVecs {
pub fn compute_all<F>( pub fn compute_all<F>(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
price: Option<&price::Vecs>, price: Option<&price::Vecs>,
starting_indexes: &Indexes, starting_indexes: &Indexes,
exit: &Exit, exit: &Exit,
mut compute: F, mut compute: F,
) -> Result<()> ) -> Result<()>
where where
F: FnMut( F: FnMut(&mut EagerVec<Height, Sats>) -> Result<()>,
&mut EagerVec<Height, Sats>,
&Indexer,
&indexes::Vecs,
&Indexes,
&Exit,
) -> Result<()>,
{ {
compute( compute(self.sats.as_mut().unwrap())?;
self.sats.as_mut().unwrap(),
indexer,
indexes,
starting_indexes,
exit,
)?;
let height: Option<&StoredVec<Height, Sats>> = None; let height: Option<&StoredVec<Height, Sats>> = None;
self.compute_rest(price, starting_indexes, exit, height)?; self.compute_rest(price, starting_indexes, exit, height)?;
crates/brk_computer/src/lib.rs
+2 -5
View File
@@ -116,7 +116,7 @@ impl Computer {
info!("Computing constants..."); info!("Computing constants...");
self.constants self.constants
.compute(indexer, &self.indexes, &starting_indexes, exit)?; .compute(&self.indexes, &starting_indexes, exit)?;
if let Some(fetched) = self.fetched.as_mut() { if let Some(fetched) = self.fetched.as_mut() {
info!("Computing fetched..."); info!("Computing fetched...");
@@ -124,7 +124,6 @@ impl Computer {
info!("Computing prices..."); info!("Computing prices...");
self.price.as_mut().unwrap().compute( self.price.as_mut().unwrap().compute(
indexer,
&self.indexes, &self.indexes,
&starting_indexes, &starting_indexes,
fetched, fetched,
@@ -147,8 +146,7 @@ impl Computer {
if let Some(price) = self.price.as_ref() { if let Some(price) = self.price.as_ref() {
info!("Computing market..."); info!("Computing market...");
self.market self.market.compute(price, &starting_indexes, exit)?;
.compute(indexer, &self.indexes, price, &starting_indexes, exit)?;
} }
chain.join().unwrap()?; chain.join().unwrap()?;
@@ -178,7 +176,6 @@ impl Computer {
info!("Computing cointime..."); info!("Computing cointime...");
self.cointime.compute( self.cointime.compute(
indexer,
&self.indexes, &self.indexes,
&starting_indexes, &starting_indexes,
self.price.as_ref(), self.price.as_ref(),
crates/brk_computer/src/market.rs
+166 -346
View File
@@ -1,7 +1,6 @@
use std::{path::Path, thread}; use std::{path::Path, thread};
use brk_error::Result; use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{Date, DateIndex, Dollars, Height, Sats, StoredF32, StoredU16, Version}; use brk_structs::{Date, DateIndex, Dollars, Height, Sats, StoredF32, StoredU16, Version};
use vecdb::{AnyCollectableVec, Database, EagerVec, Exit, PAGE_SIZE, StoredIndex, VecIterator}; use vecdb::{AnyCollectableVec, Database, EagerVec, Exit, PAGE_SIZE, StoredIndex, VecIterator};
@@ -1528,21 +1527,17 @@ impl Vecs {
pub fn compute( pub fn compute(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
price: &price::Vecs, price: &price::Vecs,
starting_indexes: &Indexes, starting_indexes: &Indexes,
exit: &Exit, exit: &Exit,
) -> Result<()> { ) -> Result<()> {
self.compute_(indexer, indexes, price, starting_indexes, exit)?; self.compute_(price, starting_indexes, exit)?;
self.db.flush_then_punch()?; self.db.flush_then_punch()?;
Ok(()) Ok(())
} }
fn compute_( fn compute_(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
price: &price::Vecs, price: &price::Vecs,
starting_indexes: &Indexes, starting_indexes: &Indexes,
exit: &Exit, exit: &Exit,
@@ -1559,27 +1554,18 @@ impl Vecs {
exit, exit,
)?; )?;
self.indexes_to_price_ath.compute_all( self.indexes_to_price_ath
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_all_time_high( v.compute_all_time_high(
starting_indexes.dateindex, starting_indexes.dateindex,
price.timeindexes_to_price_high.dateindex.as_ref().unwrap(), price.timeindexes_to_price_high.dateindex.as_ref().unwrap(),
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_price_drawdown.compute_all( self.indexes_to_price_drawdown
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_drawdown( v.compute_drawdown(
starting_indexes.dateindex, starting_indexes.dateindex,
price.timeindexes_to_price_close.dateindex.as_ref().unwrap(), price.timeindexes_to_price_close.dateindex.as_ref().unwrap(),
@@ -1587,15 +1573,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_days_since_price_ath.compute_all( self.indexes_to_days_since_price_ath
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
let mut high_iter = price let mut high_iter = price
.timeindexes_to_price_high .timeindexes_to_price_high
.dateindex .dateindex
@@ -1626,15 +1607,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_max_days_between_price_aths.compute_all( self.indexes_to_max_days_between_price_aths
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
let mut prev = None; let mut prev = None;
v.compute_transform( v.compute_transform(
starting_indexes.dateindex, starting_indexes.dateindex,
@@ -1658,15 +1634,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_max_years_between_price_aths.compute_all( self.indexes_to_max_years_between_price_aths
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_transform( v.compute_transform(
starting_indexes.dateindex, starting_indexes.dateindex,
self.indexes_to_max_days_between_price_aths self.indexes_to_max_days_between_price_aths
@@ -1677,8 +1648,7 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
[ [
(1, &mut self.price_1d_ago, &mut self._1d_price_returns, None), (1, &mut self.price_1d_ago, &mut self._1d_price_returns, None),
@@ -1752,54 +1722,36 @@ impl Vecs {
] ]
.into_iter() .into_iter()
.try_for_each(|(days, ago, returns, cagr)| -> Result<()> { .try_for_each(|(days, ago, returns, cagr)| -> Result<()> {
ago.compute_all( ago.compute_all(starting_indexes, exit, |v| {
indexer, v.compute_previous_value(
indexes, starting_indexes.dateindex,
starting_indexes, price.timeindexes_to_price_close.dateindex.as_ref().unwrap(),
exit, days,
|v, _, _, starting_indexes, exit| { exit,
v.compute_previous_value( )?;
starting_indexes.dateindex, Ok(())
price.timeindexes_to_price_close.dateindex.as_ref().unwrap(), })?;
days,
exit,
)?;
Ok(())
},
)?;
returns.compute_all( returns.compute_all(starting_indexes, exit, |v| {
indexer, v.compute_percentage_change(
indexes, starting_indexes.dateindex,
starting_indexes, price.timeindexes_to_price_close.dateindex.as_ref().unwrap(),
exit, days,
|v, _, _, starting_indexes, exit| { exit,
v.compute_percentage_change( )?;
starting_indexes.dateindex, Ok(())
price.timeindexes_to_price_close.dateindex.as_ref().unwrap(), })?;
days,
exit,
)?;
Ok(())
},
)?;
if let Some(cagr) = cagr { if let Some(cagr) = cagr {
cagr.compute_all( cagr.compute_all(starting_indexes, exit, |v| {
indexer, v.compute_cagr(
indexes, starting_indexes.dateindex,
starting_indexes, returns.dateindex.as_ref().unwrap(),
exit, days,
|v, _, _, starting_indexes, exit| { exit,
v.compute_cagr( )?;
starting_indexes.dateindex, Ok(())
returns.dateindex.as_ref().unwrap(), })?;
days,
exit,
)?;
Ok(())
},
)?;
} }
Ok(()) Ok(())
@@ -1894,70 +1846,46 @@ impl Vecs {
.into_iter() .into_iter()
.try_for_each( .try_for_each(
|(days, dca_stack, dca_avg_price, dca_returns, dca_cagr)| -> Result<()> { |(days, dca_stack, dca_avg_price, dca_returns, dca_cagr)| -> Result<()> {
dca_stack.compute_all( dca_stack.compute_all(starting_indexes, exit, |v| {
indexer, v.compute_dca_stack_via_len(
indexes, starting_indexes.dateindex,
starting_indexes, price.timeindexes_to_price_close.dateindex.as_ref().unwrap(),
exit, days,
|v, _, _, starting_indexes, exit| { exit,
v.compute_dca_stack_via_len( )?;
starting_indexes.dateindex, Ok(())
price.timeindexes_to_price_close.dateindex.as_ref().unwrap(), })?;
days,
exit,
)?;
Ok(())
},
)?;
dca_avg_price.compute_all( dca_avg_price.compute_all(starting_indexes, exit, |v| {
indexer, v.compute_dca_avg_price_via_len(
indexes, starting_indexes.dateindex,
starting_indexes, dca_stack.dateindex.as_ref().unwrap(),
exit, days,
|v, _, _, starting_indexes, exit| { exit,
v.compute_dca_avg_price_via_len( )?;
starting_indexes.dateindex, Ok(())
dca_stack.dateindex.as_ref().unwrap(), })?;
days,
exit,
)?;
Ok(())
},
)?;
dca_returns.compute_all( dca_returns.compute_all(starting_indexes, exit, |v| {
indexer, v.compute_percentage_difference(
indexes, starting_indexes.dateindex,
starting_indexes, price.timeindexes_to_price_close.dateindex.as_ref().unwrap(),
exit, dca_avg_price.dateindex.as_ref().unwrap(),
|v, _, _, starting_indexes, exit| { exit,
v.compute_percentage_difference( )?;
starting_indexes.dateindex, Ok(())
price.timeindexes_to_price_close.dateindex.as_ref().unwrap(), })?;
dca_avg_price.dateindex.as_ref().unwrap(),
exit,
)?;
Ok(())
},
)?;
if let Some(dca_cagr) = dca_cagr { if let Some(dca_cagr) = dca_cagr {
dca_cagr.compute_all( dca_cagr.compute_all(starting_indexes, exit, |v| {
indexer, v.compute_cagr(
indexes, starting_indexes.dateindex,
starting_indexes, dca_returns.dateindex.as_ref().unwrap(),
exit, days,
|v, _, _, starting_indexes, exit| { exit,
v.compute_cagr( )?;
starting_indexes.dateindex, Ok(())
dca_returns.dateindex.as_ref().unwrap(), })?;
days,
exit,
)?;
Ok(())
},
)?;
} }
Ok(()) Ok(())
@@ -2036,53 +1964,35 @@ impl Vecs {
.try_for_each(|(year, avg_price, returns, stack)| -> Result<()> { .try_for_each(|(year, avg_price, returns, stack)| -> Result<()> {
let dateindex = DateIndex::try_from(Date::new(year, 1, 1)).unwrap(); let dateindex = DateIndex::try_from(Date::new(year, 1, 1)).unwrap();
stack.compute_all( stack.compute_all(starting_indexes, exit, |v| {
indexer, v.compute_dca_stack_via_from(
indexes, starting_indexes.dateindex,
starting_indexes, price.timeindexes_to_price_close.dateindex.as_ref().unwrap(),
exit, dateindex,
|v, _, _, starting_indexes, exit| { exit,
v.compute_dca_stack_via_from( )?;
starting_indexes.dateindex, Ok(())
price.timeindexes_to_price_close.dateindex.as_ref().unwrap(), })?;
dateindex,
exit,
)?;
Ok(())
},
)?;
avg_price.compute_all( avg_price.compute_all(starting_indexes, exit, |v| {
indexer, v.compute_dca_avg_price_via_from(
indexes, starting_indexes.dateindex,
starting_indexes, stack.dateindex.as_ref().unwrap(),
exit, dateindex,
|v, _, _, starting_indexes, exit| { exit,
v.compute_dca_avg_price_via_from( )?;
starting_indexes.dateindex, Ok(())
stack.dateindex.as_ref().unwrap(), })?;
dateindex,
exit,
)?;
Ok(())
},
)?;
returns.compute_all( returns.compute_all(starting_indexes, exit, |v| {
indexer, v.compute_percentage_difference(
indexes, starting_indexes.dateindex,
starting_indexes, price.timeindexes_to_price_close.dateindex.as_ref().unwrap(),
exit, avg_price.dateindex.as_ref().unwrap(),
|v, _, _, starting_indexes, exit| { exit,
v.compute_percentage_difference( )?;
starting_indexes.dateindex, Ok(())
price.timeindexes_to_price_close.dateindex.as_ref().unwrap(), })?;
avg_price.dateindex.as_ref().unwrap(),
exit,
)?;
Ok(())
},
)?;
Ok(()) Ok(())
})?; })?;
@@ -2163,50 +2073,32 @@ impl Vecs {
.into_iter() .into_iter()
.for_each(|(sma, ema, days)| { .for_each(|(sma, ema, days)| {
s.spawn(move || -> Result<()> { s.spawn(move || -> Result<()> {
sma.compute_all( sma.compute_all(price, starting_indexes, exit, |v| {
indexer, v.compute_sma(
indexes, starting_indexes.dateindex,
price, price.timeindexes_to_price_close.dateindex.as_ref().unwrap(),
starting_indexes, days,
exit, exit,
|v, _, _, starting_indexes, exit| { )?;
v.compute_sma( Ok(())
starting_indexes.dateindex, })?;
price.timeindexes_to_price_close.dateindex.as_ref().unwrap(),
days,
exit,
)?;
Ok(())
},
)?;
ema.compute_all( ema.compute_all(price, starting_indexes, exit, |v| {
indexer, v.compute_ema(
indexes, starting_indexes.dateindex,
price, price.timeindexes_to_price_close.dateindex.as_ref().unwrap(),
starting_indexes, days,
exit, exit,
|v, _, _, starting_indexes, exit| { )?;
v.compute_ema( Ok(())
starting_indexes.dateindex, })
price.timeindexes_to_price_close.dateindex.as_ref().unwrap(),
days,
exit,
)?;
Ok(())
},
)
}); });
}); });
Ok(()) Ok(())
})?; })?;
self.indexes_to_price_200d_sma_x0_8.compute_all( self.indexes_to_price_200d_sma_x0_8
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_transform( v.compute_transform(
starting_indexes.dateindex, starting_indexes.dateindex,
self.indexes_to_price_200d_sma self.indexes_to_price_200d_sma
@@ -2220,15 +2112,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_price_200d_sma_x2_4.compute_all( self.indexes_to_price_200d_sma_x2_4
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_transform( v.compute_transform(
starting_indexes.dateindex, starting_indexes.dateindex,
self.indexes_to_price_200d_sma self.indexes_to_price_200d_sma
@@ -2242,40 +2129,29 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_1d_returns_1w_sd.compute_all( self.indexes_to_1d_returns_1w_sd.compute_all(
indexer,
indexes,
starting_indexes, starting_indexes,
exit, exit,
self._1d_price_returns.dateindex.as_ref().unwrap(), self._1d_price_returns.dateindex.as_ref().unwrap(),
None as Option<&EagerVec<DateIndex, Dollars>>, None as Option<&EagerVec<DateIndex, Dollars>>,
)?; )?;
self.indexes_to_1d_returns_1m_sd.compute_all( self.indexes_to_1d_returns_1m_sd.compute_all(
indexer,
indexes,
starting_indexes, starting_indexes,
exit, exit,
self._1d_price_returns.dateindex.as_ref().unwrap(), self._1d_price_returns.dateindex.as_ref().unwrap(),
None as Option<&EagerVec<DateIndex, Dollars>>, None as Option<&EagerVec<DateIndex, Dollars>>,
)?; )?;
self.indexes_to_1d_returns_1y_sd.compute_all( self.indexes_to_1d_returns_1y_sd.compute_all(
indexer,
indexes,
starting_indexes, starting_indexes,
exit, exit,
self._1d_price_returns.dateindex.as_ref().unwrap(), self._1d_price_returns.dateindex.as_ref().unwrap(),
None as Option<&EagerVec<DateIndex, Dollars>>, None as Option<&EagerVec<DateIndex, Dollars>>,
)?; )?;
self.indexes_to_price_1w_volatility.compute_all( self.indexes_to_price_1w_volatility
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_transform( v.compute_transform(
starting_indexes.dateindex, starting_indexes.dateindex,
self.indexes_to_1d_returns_1w_sd self.indexes_to_1d_returns_1w_sd
@@ -2287,14 +2163,9 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?; self.indexes_to_price_1m_volatility
self.indexes_to_price_1m_volatility.compute_all( .compute_all(starting_indexes, exit, |v| {
indexer,
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_transform( v.compute_transform(
starting_indexes.dateindex, starting_indexes.dateindex,
self.indexes_to_1d_returns_1m_sd self.indexes_to_1d_returns_1m_sd
@@ -2306,14 +2177,9 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?; self.indexes_to_price_1y_volatility
self.indexes_to_price_1y_volatility.compute_all( .compute_all(starting_indexes, exit, |v| {
indexer,
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_transform( v.compute_transform(
starting_indexes.dateindex, starting_indexes.dateindex,
self.indexes_to_1d_returns_1y_sd self.indexes_to_1d_returns_1y_sd
@@ -2325,8 +2191,7 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.dateindex_to_price_true_range.compute_transform3( self.dateindex_to_price_true_range.compute_transform3(
starting_indexes.dateindex, starting_indexes.dateindex,
@@ -2349,12 +2214,8 @@ impl Vecs {
exit, exit,
)?; )?;
self.indexes_to_price_1w_max.compute_all( self.indexes_to_price_1w_max
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_max( v.compute_max(
starting_indexes.dateindex, starting_indexes.dateindex,
price.timeindexes_to_price_high.dateindex.as_ref().unwrap(), price.timeindexes_to_price_high.dateindex.as_ref().unwrap(),
@@ -2362,15 +2223,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_price_1w_min.compute_all( self.indexes_to_price_1w_min
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_min( v.compute_min(
starting_indexes.dateindex, starting_indexes.dateindex,
price.timeindexes_to_price_low.dateindex.as_ref().unwrap(), price.timeindexes_to_price_low.dateindex.as_ref().unwrap(),
@@ -2378,15 +2234,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_price_2w_max.compute_all( self.indexes_to_price_2w_max
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_max( v.compute_max(
starting_indexes.dateindex, starting_indexes.dateindex,
price.timeindexes_to_price_high.dateindex.as_ref().unwrap(), price.timeindexes_to_price_high.dateindex.as_ref().unwrap(),
@@ -2394,15 +2245,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_price_2w_min.compute_all( self.indexes_to_price_2w_min
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_min( v.compute_min(
starting_indexes.dateindex, starting_indexes.dateindex,
price.timeindexes_to_price_low.dateindex.as_ref().unwrap(), price.timeindexes_to_price_low.dateindex.as_ref().unwrap(),
@@ -2410,15 +2256,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_price_1m_max.compute_all( self.indexes_to_price_1m_max
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_max( v.compute_max(
starting_indexes.dateindex, starting_indexes.dateindex,
price.timeindexes_to_price_high.dateindex.as_ref().unwrap(), price.timeindexes_to_price_high.dateindex.as_ref().unwrap(),
@@ -2426,15 +2267,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_price_1m_min.compute_all( self.indexes_to_price_1m_min
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_min( v.compute_min(
starting_indexes.dateindex, starting_indexes.dateindex,
price.timeindexes_to_price_low.dateindex.as_ref().unwrap(), price.timeindexes_to_price_low.dateindex.as_ref().unwrap(),
@@ -2442,15 +2278,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_price_1y_max.compute_all( self.indexes_to_price_1y_max
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_max( v.compute_max(
starting_indexes.dateindex, starting_indexes.dateindex,
price.timeindexes_to_price_high.dateindex.as_ref().unwrap(), price.timeindexes_to_price_high.dateindex.as_ref().unwrap(),
@@ -2458,15 +2289,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_price_1y_min.compute_all( self.indexes_to_price_1y_min
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_min( v.compute_min(
starting_indexes.dateindex, starting_indexes.dateindex,
price.timeindexes_to_price_low.dateindex.as_ref().unwrap(), price.timeindexes_to_price_low.dateindex.as_ref().unwrap(),
@@ -2474,15 +2300,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_price_2w_choppiness_index.compute_all( self.indexes_to_price_2w_choppiness_index
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
let n = 14; let n = 14;
let log10n = (n as f32).log10(); let log10n = (n as f32).log10();
v.compute_transform3( v.compute_transform3(
@@ -2501,8 +2322,7 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
Ok(()) Ok(())
} }
crates/brk_computer/src/pools/mod.rs
-1
View File
@@ -106,7 +106,6 @@ impl Vecs {
self.vecs.par_iter_mut().try_for_each(|(_, vecs)| { self.vecs.par_iter_mut().try_for_each(|(_, vecs)| {
vecs.compute( vecs.compute(
indexer,
indexes, indexes,
starting_indexes, starting_indexes,
&self.height_to_pool, &self.height_to_pool,
crates/brk_computer/src/pools/vecs.rs
+39 -109
View File
@@ -1,6 +1,5 @@
use allocative::Allocative; use allocative::Allocative;
use brk_error::Result; use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{Height, Sats, StoredF32, StoredU16, StoredU32}; use brk_structs::{Height, Sats, StoredF32, StoredU16, StoredU32};
use vecdb::{AnyCollectableVec, AnyIterableVec, Database, Exit, StoredIndex, VecIterator, Version}; use vecdb::{AnyCollectableVec, AnyIterableVec, Database, Exit, StoredIndex, VecIterator, Version};
@@ -163,7 +162,6 @@ impl Vecs {
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
pub fn compute( pub fn compute(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs, indexes: &indexes::Vecs,
starting_indexes: &Indexes, starting_indexes: &Indexes,
height_to_pool: &impl AnyIterableVec<Height, PoolId>, height_to_pool: &impl AnyIterableVec<Height, PoolId>,
@@ -171,12 +169,8 @@ impl Vecs {
price: Option<&price::Vecs>, price: Option<&price::Vecs>,
exit: &Exit, exit: &Exit,
) -> Result<()> { ) -> Result<()> {
self.indexes_to_blocks_mined.compute_all( self.indexes_to_blocks_mined
indexer, .compute_all(indexes, starting_indexes, exit, |vec| {
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
vec.compute_transform( vec.compute_transform(
starting_indexes.height, starting_indexes.height,
height_to_pool, height_to_pool,
@@ -193,15 +187,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_1w_blocks_mined.compute_all( self.indexes_to_1w_blocks_mined
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sum( v.compute_sum(
starting_indexes.dateindex, starting_indexes.dateindex,
self.indexes_to_blocks_mined.dateindex.unwrap_sum(), self.indexes_to_blocks_mined.dateindex.unwrap_sum(),
@@ -209,15 +198,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_1m_blocks_mined.compute_all( self.indexes_to_1m_blocks_mined
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sum( v.compute_sum(
starting_indexes.dateindex, starting_indexes.dateindex,
self.indexes_to_blocks_mined.dateindex.unwrap_sum(), self.indexes_to_blocks_mined.dateindex.unwrap_sum(),
@@ -225,15 +209,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_1y_blocks_mined.compute_all( self.indexes_to_1y_blocks_mined
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sum( v.compute_sum(
starting_indexes.dateindex, starting_indexes.dateindex,
self.indexes_to_blocks_mined.dateindex.unwrap_sum(), self.indexes_to_blocks_mined.dateindex.unwrap_sum(),
@@ -241,18 +220,12 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
let height_to_blocks_mined = self.indexes_to_blocks_mined.height.as_ref().unwrap(); let height_to_blocks_mined = self.indexes_to_blocks_mined.height.as_ref().unwrap();
self.indexes_to_subsidy.compute_all( self.indexes_to_subsidy
indexer, .compute_all(indexes, price, starting_indexes, exit, |vec| {
indexes,
price,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
vec.compute_transform2( vec.compute_transform2(
starting_indexes.height, starting_indexes.height,
height_to_blocks_mined, height_to_blocks_mined,
@@ -270,16 +243,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_fee.compute_all( self.indexes_to_fee
indexer, .compute_all(indexes, price, starting_indexes, exit, |vec| {
indexes,
price,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
vec.compute_transform2( vec.compute_transform2(
starting_indexes.height, starting_indexes.height,
height_to_blocks_mined, height_to_blocks_mined,
@@ -297,16 +264,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_coinbase.compute_all( self.indexes_to_coinbase
indexer, .compute_all(indexes, price, starting_indexes, exit, |vec| {
indexes,
price,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
vec.compute_transform2( vec.compute_transform2(
starting_indexes.height, starting_indexes.height,
height_to_blocks_mined, height_to_blocks_mined,
@@ -324,15 +285,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_dominance.compute_all( self.indexes_to_dominance
indexer, .compute_all(starting_indexes, exit, |vec| {
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
vec.compute_percentage( vec.compute_percentage(
starting_indexes.dateindex, starting_indexes.dateindex,
self.indexes_to_blocks_mined.dateindex.unwrap_cumulative(), self.indexes_to_blocks_mined.dateindex.unwrap_cumulative(),
@@ -340,15 +296,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_1d_dominance.compute_all( self.indexes_to_1d_dominance
indexer, .compute_all(starting_indexes, exit, |vec| {
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
vec.compute_percentage( vec.compute_percentage(
starting_indexes.dateindex, starting_indexes.dateindex,
self.indexes_to_blocks_mined.dateindex.unwrap_sum(), self.indexes_to_blocks_mined.dateindex.unwrap_sum(),
@@ -356,15 +307,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_1w_dominance.compute_all( self.indexes_to_1w_dominance
indexer, .compute_all(starting_indexes, exit, |vec| {
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
vec.compute_percentage( vec.compute_percentage(
starting_indexes.dateindex, starting_indexes.dateindex,
self.indexes_to_1w_blocks_mined.dateindex.as_ref().unwrap(), self.indexes_to_1w_blocks_mined.dateindex.as_ref().unwrap(),
@@ -372,15 +318,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_1m_dominance.compute_all( self.indexes_to_1m_dominance
indexer, .compute_all(starting_indexes, exit, |vec| {
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
vec.compute_percentage( vec.compute_percentage(
starting_indexes.dateindex, starting_indexes.dateindex,
self.indexes_to_1m_blocks_mined.dateindex.as_ref().unwrap(), self.indexes_to_1m_blocks_mined.dateindex.as_ref().unwrap(),
@@ -388,15 +329,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_1y_dominance.compute_all( self.indexes_to_1y_dominance
indexer, .compute_all(starting_indexes, exit, |vec| {
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
vec.compute_percentage( vec.compute_percentage(
starting_indexes.dateindex, starting_indexes.dateindex,
self.indexes_to_1y_blocks_mined.dateindex.as_ref().unwrap(), self.indexes_to_1y_blocks_mined.dateindex.as_ref().unwrap(),
@@ -404,15 +340,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_days_since_block.compute_all( self.indexes_to_days_since_block
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
let mut prev = None; let mut prev = None;
v.compute_transform2( v.compute_transform2(
starting_indexes.dateindex, starting_indexes.dateindex,
@@ -438,8 +369,7 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
Ok(()) Ok(())
} }
crates/brk_computer/src/price.rs
+49 -132
View File
@@ -1,7 +1,6 @@
use std::path::Path; use std::path::Path;
use brk_error::Result; use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{ use brk_structs::{
Cents, Close, DateIndex, DecadeIndex, DifficultyEpoch, Dollars, Height, High, Low, MonthIndex, Cents, Close, DateIndex, DecadeIndex, DifficultyEpoch, Dollars, Height, High, Low, MonthIndex,
OHLCDollars, OHLCSats, Open, QuarterIndex, Sats, SemesterIndex, Version, WeekIndex, YearIndex, OHLCDollars, OHLCSats, Open, QuarterIndex, Sats, SemesterIndex, Version, WeekIndex, YearIndex,
@@ -338,20 +337,18 @@ impl Vecs {
pub fn compute( pub fn compute(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs, indexes: &indexes::Vecs,
starting_indexes: &Indexes, starting_indexes: &Indexes,
fetched: &fetched::Vecs, fetched: &fetched::Vecs,
exit: &Exit, exit: &Exit,
) -> Result<()> { ) -> Result<()> {
self.compute_(indexer, indexes, starting_indexes, fetched, exit)?; self.compute_(indexes, starting_indexes, fetched, exit)?;
self.db.flush_then_punch()?; self.db.flush_then_punch()?;
Ok(()) Ok(())
} }
fn compute_( fn compute_(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs, indexes: &indexes::Vecs,
starting_indexes: &Indexes, starting_indexes: &Indexes,
fetched: &fetched::Vecs, fetched: &fetched::Vecs,
@@ -445,12 +442,8 @@ impl Vecs {
})?; })?;
self.dateindex_to_price_ohlc.safe_flush(exit)?; self.dateindex_to_price_ohlc.safe_flush(exit)?;
self.timeindexes_to_price_close.compute_all( self.timeindexes_to_price_close
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_transform( v.compute_transform(
starting_indexes.dateindex, starting_indexes.dateindex,
&self.dateindex_to_price_ohlc, &self.dateindex_to_price_ohlc,
@@ -458,15 +451,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.timeindexes_to_price_high.compute_all( self.timeindexes_to_price_high
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_transform( v.compute_transform(
starting_indexes.dateindex, starting_indexes.dateindex,
&self.dateindex_to_price_ohlc, &self.dateindex_to_price_ohlc,
@@ -474,15 +462,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.timeindexes_to_price_low.compute_all( self.timeindexes_to_price_low
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_transform( v.compute_transform(
starting_indexes.dateindex, starting_indexes.dateindex,
&self.dateindex_to_price_ohlc, &self.dateindex_to_price_ohlc,
@@ -490,15 +473,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.timeindexes_to_price_open.compute_all( self.timeindexes_to_price_open
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_transform( v.compute_transform(
starting_indexes.dateindex, starting_indexes.dateindex,
&self.dateindex_to_price_ohlc, &self.dateindex_to_price_ohlc,
@@ -506,15 +484,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.chainindexes_to_price_close.compute( self.chainindexes_to_price_close
indexer, .compute(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_transform( v.compute_transform(
starting_indexes.height, starting_indexes.height,
&self.height_to_price_ohlc, &self.height_to_price_ohlc,
@@ -522,15 +495,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.chainindexes_to_price_high.compute( self.chainindexes_to_price_high
indexer, .compute(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_transform( v.compute_transform(
starting_indexes.height, starting_indexes.height,
&self.height_to_price_ohlc, &self.height_to_price_ohlc,
@@ -538,15 +506,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.chainindexes_to_price_low.compute( self.chainindexes_to_price_low
indexer, .compute(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_transform( v.compute_transform(
starting_indexes.height, starting_indexes.height,
&self.height_to_price_ohlc, &self.height_to_price_ohlc,
@@ -554,15 +517,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.chainindexes_to_price_open.compute( self.chainindexes_to_price_open
indexer, .compute(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_transform( v.compute_transform(
starting_indexes.height, starting_indexes.height,
&self.height_to_price_ohlc, &self.height_to_price_ohlc,
@@ -570,8 +528,7 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
let mut weekindex_first_iter = self let mut weekindex_first_iter = self
.timeindexes_to_price_open .timeindexes_to_price_open
@@ -843,12 +800,8 @@ impl Vecs {
})?; })?;
self.decadeindex_to_price_ohlc.safe_flush(exit)?; self.decadeindex_to_price_ohlc.safe_flush(exit)?;
self.chainindexes_to_price_open_in_sats.compute( self.chainindexes_to_price_open_in_sats
indexer, .compute(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_transform( v.compute_transform(
starting_indexes.height, starting_indexes.height,
&self.chainindexes_to_price_open.height, &self.chainindexes_to_price_open.height,
@@ -856,15 +809,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.chainindexes_to_price_high_in_sats.compute( self.chainindexes_to_price_high_in_sats
indexer, .compute(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_transform( v.compute_transform(
starting_indexes.height, starting_indexes.height,
&self.chainindexes_to_price_low.height, &self.chainindexes_to_price_low.height,
@@ -872,15 +820,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.chainindexes_to_price_low_in_sats.compute( self.chainindexes_to_price_low_in_sats
indexer, .compute(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_transform( v.compute_transform(
starting_indexes.height, starting_indexes.height,
&self.chainindexes_to_price_high.height, &self.chainindexes_to_price_high.height,
@@ -888,15 +831,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.chainindexes_to_price_close_in_sats.compute( self.chainindexes_to_price_close_in_sats
indexer, .compute(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_transform( v.compute_transform(
starting_indexes.height, starting_indexes.height,
&self.chainindexes_to_price_close.height, &self.chainindexes_to_price_close.height,
@@ -904,15 +842,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.timeindexes_to_price_open_in_sats.compute_all( self.timeindexes_to_price_open_in_sats
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_transform( v.compute_transform(
starting_indexes.dateindex, starting_indexes.dateindex,
self.timeindexes_to_price_open.dateindex.as_ref().unwrap(), self.timeindexes_to_price_open.dateindex.as_ref().unwrap(),
@@ -920,15 +853,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.timeindexes_to_price_high_in_sats.compute_all( self.timeindexes_to_price_high_in_sats
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_transform( v.compute_transform(
starting_indexes.dateindex, starting_indexes.dateindex,
self.timeindexes_to_price_low.dateindex.as_ref().unwrap(), self.timeindexes_to_price_low.dateindex.as_ref().unwrap(),
@@ -936,15 +864,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.timeindexes_to_price_low_in_sats.compute_all( self.timeindexes_to_price_low_in_sats
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_transform( v.compute_transform(
starting_indexes.dateindex, starting_indexes.dateindex,
self.timeindexes_to_price_high.dateindex.as_ref().unwrap(), self.timeindexes_to_price_high.dateindex.as_ref().unwrap(),
@@ -952,15 +875,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.timeindexes_to_price_close_in_sats.compute_all( self.timeindexes_to_price_close_in_sats
indexer, .compute_all(starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_transform( v.compute_transform(
starting_indexes.dateindex, starting_indexes.dateindex,
self.timeindexes_to_price_close.dateindex.as_ref().unwrap(), self.timeindexes_to_price_close.dateindex.as_ref().unwrap(),
@@ -968,8 +886,7 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
let mut height_first_iter = self.chainindexes_to_price_open_in_sats.height.iter(); let mut height_first_iter = self.chainindexes_to_price_open_in_sats.height.iter();
let mut height_max_iter = self.chainindexes_to_price_high_in_sats.height.iter(); let mut height_max_iter = self.chainindexes_to_price_high_in_sats.height.iter();
crates/brk_computer/src/stateful/address_cohort.rs
+1 -5
View File
@@ -1,7 +1,6 @@
use std::{ops::Deref, path::Path}; use std::{ops::Deref, path::Path};
use brk_error::Result; use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{Bitcoin, DateIndex, Dollars, Height, StoredU64, Version}; use brk_structs::{Bitcoin, DateIndex, Dollars, Height, StoredU64, Version};
use vecdb::{ use vecdb::{
AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit, Format, AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit, Format,
@@ -171,7 +170,6 @@ impl DynCohortVecs for Vecs {
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
fn compute_rest_part1( fn compute_rest_part1(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs, indexes: &indexes::Vecs,
price: Option<&price::Vecs>, price: Option<&price::Vecs>,
starting_indexes: &Indexes, starting_indexes: &Indexes,
@@ -185,7 +183,7 @@ impl DynCohortVecs for Vecs {
)?; )?;
self.inner self.inner
.compute_rest_part1(indexer, indexes, price, starting_indexes, exit) .compute_rest_part1(indexes, price, starting_indexes, exit)
} }
fn vecs(&self) -> Vec<&dyn AnyCollectableVec> { fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
@@ -224,7 +222,6 @@ impl CohortVecs for Vecs {
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
fn compute_rest_part2( fn compute_rest_part2(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs, indexes: &indexes::Vecs,
price: Option<&price::Vecs>, price: Option<&price::Vecs>,
starting_indexes: &Indexes, starting_indexes: &Indexes,
@@ -237,7 +234,6 @@ impl CohortVecs for Vecs {
exit: &Exit, exit: &Exit,
) -> Result<()> { ) -> Result<()> {
self.inner.compute_rest_part2( self.inner.compute_rest_part2(
indexer,
indexes, indexes,
price, price,
starting_indexes, starting_indexes,
crates/brk_computer/src/stateful/address_cohorts.rs
+3 -7
View File
@@ -1,7 +1,6 @@
use std::path::Path; use std::path::Path;
use brk_error::Result; use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{ use brk_structs::{
AddressGroups, Bitcoin, ByAmountRange, ByGreatEqualAmount, ByLowerThanAmount, DateIndex, AddressGroups, Bitcoin, ByAmountRange, ByGreatEqualAmount, ByLowerThanAmount, DateIndex,
Dollars, GroupFilter, Height, Version, Dollars, GroupFilter, Height, Version,
@@ -502,21 +501,19 @@ impl Vecs {
pub fn compute_rest_part1( pub fn compute_rest_part1(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs, indexes: &indexes::Vecs,
price: Option<&price::Vecs>, price: Option<&price::Vecs>,
starting_indexes: &Indexes, starting_indexes: &Indexes,
exit: &Exit, exit: &Exit,
) -> Result<()> { ) -> Result<()> {
self.as_mut_vecs().into_iter().try_for_each(|(_, v)| { self.as_mut_vecs()
v.compute_rest_part1(indexer, indexes, price, starting_indexes, exit) .into_iter()
}) .try_for_each(|(_, v)| v.compute_rest_part1(indexes, price, starting_indexes, exit))
} }
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
pub fn compute_rest_part2( pub fn compute_rest_part2(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs, indexes: &indexes::Vecs,
price: Option<&price::Vecs>, price: Option<&price::Vecs>,
starting_indexes: &Indexes, starting_indexes: &Indexes,
@@ -531,7 +528,6 @@ impl Vecs {
self.0.as_boxed_mut_vecs().into_iter().try_for_each(|v| { self.0.as_boxed_mut_vecs().into_iter().try_for_each(|v| {
v.into_iter().try_for_each(|(_, v)| { v.into_iter().try_for_each(|(_, v)| {
v.compute_rest_part2( v.compute_rest_part2(
indexer,
indexes, indexes,
price, price,
starting_indexes, starting_indexes,
crates/brk_computer/src/stateful/common.rs
+463 -707
View File
File diff suppressed because it is too large Load Diff
crates/brk_computer/src/stateful/mod.rs
+26 -46
View File
@@ -1309,12 +1309,8 @@ impl Vecs {
info!("Computing rest part 1..."); info!("Computing rest part 1...");
self.indexes_to_addr_count.compute_all( self.indexes_to_addr_count
indexer, .compute_all(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sum_of_others( v.compute_sum_of_others(
starting_indexes.height, starting_indexes.height,
&self &self
@@ -1326,15 +1322,10 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_empty_addr_count.compute_all( self.indexes_to_empty_addr_count
indexer, .compute_all(indexes, starting_indexes, exit, |v| {
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sum_of_others( v.compute_sum_of_others(
starting_indexes.height, starting_indexes.height,
&self &self
@@ -1346,11 +1337,9 @@ impl Vecs {
exit, exit,
)?; )?;
Ok(()) Ok(())
}, })?;
)?;
self.indexes_to_unspendable_supply.compute_rest( self.indexes_to_unspendable_supply.compute_rest(
indexer,
indexes, indexes,
price, price,
starting_indexes, starting_indexes,
@@ -1358,7 +1347,6 @@ impl Vecs {
Some(&self.height_to_unspendable_supply), Some(&self.height_to_unspendable_supply),
)?; )?;
self.indexes_to_opreturn_supply.compute_rest( self.indexes_to_opreturn_supply.compute_rest(
indexer,
indexes, indexes,
price, price,
starting_indexes, starting_indexes,
@@ -1381,36 +1369,30 @@ impl Vecs {
)?; )?;
self.utxo_cohorts self.utxo_cohorts
.compute_rest_part1(indexer, indexes, price, starting_indexes, exit)?; .compute_rest_part1(indexes, price, starting_indexes, exit)?;
self.address_cohorts self.address_cohorts
.compute_rest_part1(indexer, indexes, price, starting_indexes, exit)?; .compute_rest_part1(indexes, price, starting_indexes, exit)?;
if let Some(indexes_to_market_cap) = self.indexes_to_market_cap.as_mut() { if let Some(indexes_to_market_cap) = self.indexes_to_market_cap.as_mut() {
indexes_to_market_cap.compute_all( indexes_to_market_cap.compute_all(starting_indexes, exit, |v| {
indexer, v.compute_transform(
indexes, starting_indexes.dateindex,
starting_indexes, self.utxo_cohorts
exit, .all
|v, _, _, starting_indexes, exit| { .1
v.compute_transform( .indexes_to_supply
starting_indexes.dateindex, .dollars
self.utxo_cohorts .as_ref()
.all .unwrap()
.1 .dateindex
.indexes_to_supply .as_ref()
.dollars .unwrap(),
.as_ref() |(i, v, ..)| (i, v),
.unwrap() exit,
.dateindex )?;
.as_ref() Ok(())
.unwrap(), })?;
|(i, v, ..)| (i, v),
exit,
)?;
Ok(())
},
)?;
} }
info!("Computing rest part 2..."); info!("Computing rest part 2...");
@@ -1450,7 +1432,6 @@ impl Vecs {
let dateindex_to_realized_cap_ref = dateindex_to_realized_cap.as_ref(); let dateindex_to_realized_cap_ref = dateindex_to_realized_cap.as_ref();
self.utxo_cohorts.compute_rest_part2( self.utxo_cohorts.compute_rest_part2(
indexer,
indexes, indexes,
price, price,
starting_indexes, starting_indexes,
@@ -1464,7 +1445,6 @@ impl Vecs {
)?; )?;
self.address_cohorts.compute_rest_part2( self.address_cohorts.compute_rest_part2(
indexer,
indexes, indexes,
price, price,
starting_indexes, starting_indexes,
crates/brk_computer/src/stateful/trait.rs
-3
View File
@@ -1,5 +1,4 @@
use brk_error::Result; use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{Bitcoin, DateIndex, Dollars, Height, Version}; use brk_structs::{Bitcoin, DateIndex, Dollars, Height, Version};
use vecdb::{AnyCollectableVec, AnyIterableVec, Exit}; use vecdb::{AnyCollectableVec, AnyIterableVec, Exit};
@@ -29,7 +28,6 @@ pub trait DynCohortVecs: Send + Sync {
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
fn compute_rest_part1( fn compute_rest_part1(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs, indexes: &indexes::Vecs,
price: Option<&price::Vecs>, price: Option<&price::Vecs>,
starting_indexes: &Indexes, starting_indexes: &Indexes,
@@ -50,7 +48,6 @@ pub trait CohortVecs: DynCohortVecs {
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
fn compute_rest_part2( fn compute_rest_part2(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs, indexes: &indexes::Vecs,
price: Option<&price::Vecs>, price: Option<&price::Vecs>,
starting_indexes: &Indexes, starting_indexes: &Indexes,
crates/brk_computer/src/stateful/utxo_cohort.rs
+1 -5
View File
@@ -1,7 +1,6 @@
use std::{ops::Deref, path::Path}; use std::{ops::Deref, path::Path};
use brk_error::Result; use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{Bitcoin, DateIndex, Dollars, Height, Version}; use brk_structs::{Bitcoin, DateIndex, Dollars, Height, Version};
use vecdb::{AnyCollectableVec, AnyIterableVec, Database, Exit, Format}; use vecdb::{AnyCollectableVec, AnyIterableVec, Database, Exit, Format};
@@ -122,14 +121,13 @@ impl DynCohortVecs for Vecs {
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
fn compute_rest_part1( fn compute_rest_part1(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs, indexes: &indexes::Vecs,
price: Option<&price::Vecs>, price: Option<&price::Vecs>,
starting_indexes: &Indexes, starting_indexes: &Indexes,
exit: &Exit, exit: &Exit,
) -> Result<()> { ) -> Result<()> {
self.inner self.inner
.compute_rest_part1(indexer, indexes, price, starting_indexes, exit) .compute_rest_part1(indexes, price, starting_indexes, exit)
} }
fn vecs(&self) -> Vec<&dyn AnyCollectableVec> { fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
@@ -154,7 +152,6 @@ impl CohortVecs for Vecs {
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
fn compute_rest_part2( fn compute_rest_part2(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs, indexes: &indexes::Vecs,
price: Option<&price::Vecs>, price: Option<&price::Vecs>,
starting_indexes: &Indexes, starting_indexes: &Indexes,
@@ -167,7 +164,6 @@ impl CohortVecs for Vecs {
exit: &Exit, exit: &Exit,
) -> Result<()> { ) -> Result<()> {
self.inner.compute_rest_part2( self.inner.compute_rest_part2(
indexer,
indexes, indexes,
price, price,
starting_indexes, starting_indexes,
crates/brk_computer/src/stateful/utxo_cohorts.rs
+3 -7
View File
@@ -1,7 +1,6 @@
use std::{collections::BTreeMap, ops::ControlFlow, path::Path}; use std::{collections::BTreeMap, ops::ControlFlow, path::Path};
use brk_error::Result; use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{ use brk_structs::{
Bitcoin, ByAgeRange, ByAmountRange, ByEpoch, ByGreatEqualAmount, ByLowerThanAmount, ByMaxAge, Bitcoin, ByAgeRange, ByAmountRange, ByEpoch, ByGreatEqualAmount, ByLowerThanAmount, ByMaxAge,
ByMinAge, BySpendableType, ByTerm, CheckedSub, DateIndex, Dollars, GroupFilter, HalvingEpoch, ByMinAge, BySpendableType, ByTerm, CheckedSub, DateIndex, Dollars, GroupFilter, HalvingEpoch,
@@ -1736,21 +1735,19 @@ impl Vecs {
pub fn compute_rest_part1( pub fn compute_rest_part1(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs, indexes: &indexes::Vecs,
price: Option<&price::Vecs>, price: Option<&price::Vecs>,
starting_indexes: &Indexes, starting_indexes: &Indexes,
exit: &Exit, exit: &Exit,
) -> Result<()> { ) -> Result<()> {
self.as_mut_vecs().into_iter().try_for_each(|(_, v)| { self.as_mut_vecs()
v.compute_rest_part1(indexer, indexes, price, starting_indexes, exit) .into_iter()
}) .try_for_each(|(_, v)| v.compute_rest_part1(indexes, price, starting_indexes, exit))
} }
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
pub fn compute_rest_part2( pub fn compute_rest_part2(
&mut self, &mut self,
indexer: &Indexer,
indexes: &indexes::Vecs, indexes: &indexes::Vecs,
price: Option<&price::Vecs>, price: Option<&price::Vecs>,
starting_indexes: &Indexes, starting_indexes: &Indexes,
@@ -1765,7 +1762,6 @@ impl Vecs {
self.0.as_boxed_mut_vecs().into_iter().try_for_each(|v| { self.0.as_boxed_mut_vecs().into_iter().try_for_each(|v| {
v.into_iter().try_for_each(|(_, v)| { v.into_iter().try_for_each(|(_, v)| {
v.compute_rest_part2( v.compute_rest_part2(
indexer,
indexes, indexes,
price, price,
starting_indexes, starting_indexes,