diff --git a/crates/brk_computer/src/chain.rs b/crates/brk_computer/src/chain.rs index 9797f81b0..38eabed54 100644 --- a/crates/brk_computer/src/chain.rs +++ b/crates/brk_computer/src/chain.rs @@ -933,12 +933,8 @@ impl Vecs { price: Option<&price::Vecs>, exit: &Exit, ) -> Result<()> { - self.timeindexes_to_timestamp.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, indexes, starting_indexes, exit| { + self.timeindexes_to_timestamp + .compute_all(starting_indexes, exit, |vec| { vec.compute_transform( starting_indexes.dateindex, &indexes.dateindex_to_date, @@ -946,15 +942,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_block_count.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, indexer, _, starting_indexes, exit| { + self.indexes_to_block_count + .compute_all(indexes, starting_indexes, exit, |v| { v.compute_range( starting_indexes.height, &indexer.vecs.height_to_weight, @@ -962,15 +953,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_1w_block_count.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_1w_block_count + .compute_all(starting_indexes, exit, |v| { v.compute_sum( starting_indexes.dateindex, self.indexes_to_block_count.dateindex.unwrap_sum(), @@ -978,15 +964,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_1m_block_count.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_1m_block_count + .compute_all(starting_indexes, exit, |v| { v.compute_sum( starting_indexes.dateindex, self.indexes_to_block_count.dateindex.unwrap_sum(), @@ -994,15 +975,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_1y_block_count.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_1y_block_count + .compute_all(starting_indexes, exit, |v| { v.compute_sum( starting_indexes.dateindex, self.indexes_to_block_count.dateindex.unwrap_sum(), @@ -1010,8 +986,7 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; let mut height_to_timestamp_iter = indexer.vecs.height_to_timestamp.iter(); self.height_to_interval.compute_transform( @@ -1086,12 +1061,8 @@ impl Vecs { )?; let mut height_to_difficultyepoch_iter = indexes.height_to_difficultyepoch.into_iter(); - self.indexes_to_difficultyepoch.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, indexes, starting_indexes, exit| { + self.indexes_to_difficultyepoch + .compute_all(starting_indexes, exit, |vec| { let mut height_count_iter = indexes.dateindex_to_height_count.into_iter(); vec.compute_transform( starting_indexes.dateindex, @@ -1107,16 +1078,11 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; let mut height_to_halvingepoch_iter = indexes.height_to_halvingepoch.into_iter(); - self.indexes_to_halvingepoch.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, indexes, starting_indexes, exit| { + self.indexes_to_halvingepoch + .compute_all(starting_indexes, exit, |vec| { let mut height_count_iter = indexes.dateindex_to_height_count.into_iter(); vec.compute_transform( starting_indexes.dateindex, @@ -1132,8 +1098,7 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; self.indexes_to_difficulty.compute_rest( indexes, @@ -1142,12 +1107,8 @@ impl Vecs { Some(&indexer.vecs.height_to_difficulty), )?; - self.indexes_to_tx_count.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, indexer, _, starting_indexes, exit| { + self.indexes_to_tx_count + .compute_all(indexes, starting_indexes, exit, |v| { v.compute_count_from_indexes( starting_indexes.height, &indexer.vecs.height_to_first_txindex, @@ -1155,8 +1116,7 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; self.indexes_to_input_count.compute_rest( indexer, @@ -1177,25 +1137,19 @@ impl Vecs { let compute_indexes_to_tx_vany = |indexes_to_tx_vany: &mut ComputedVecsFromHeight, txversion| { let mut txindex_to_txversion_iter = indexer.vecs.txindex_to_txversion.iter(); - indexes_to_tx_vany.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, indexer, _, starting_indexes, exit| { - vec.compute_filtered_count_from_indexes( - starting_indexes.height, - &indexer.vecs.height_to_first_txindex, - &indexer.vecs.txindex_to_txid, - |txindex| { - let v = txindex_to_txversion_iter.unwrap_get_inner(txindex); - v == txversion - }, - exit, - )?; - Ok(()) - }, - ) + indexes_to_tx_vany.compute_all(indexes, starting_indexes, exit, |vec| { + vec.compute_filtered_count_from_indexes( + starting_indexes.height, + &indexer.vecs.height_to_first_txindex, + &indexer.vecs.txindex_to_txid, + |txindex| { + let v = txindex_to_txversion_iter.unwrap_get_inner(txindex); + 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_v2, TxVersion::TWO)?; @@ -1206,7 +1160,7 @@ impl Vecs { // indexes, // starting_indexes, // exit, - // |vec, indexer, _, starting_indexes, exit| { + // |vec| { // vec.compute_sum_from_indexes( // starting_indexes.txindex, // &indexer.vecs.txindex_to_first_outputindex, @@ -1222,7 +1176,7 @@ impl Vecs { // indexes, // starting_indexes, // exit, - // |vec, indexer, _, starting_indexes, exit| { + // |vec| { // vec.compute_sum_from_indexes( // starting_indexes.txindex, // &indexer.vecs.txindex_to_first_inputindex, @@ -1292,13 +1246,8 @@ impl Vecs { Some(&self.txindex_to_vsize), )?; - self.indexes_to_coinbase.compute_all( - indexer, - indexes, - price, - starting_indexes, - exit, - |vec, indexer, _, starting_indexes, exit| { + self.indexes_to_coinbase + .compute_all(indexes, price, starting_indexes, exit, |vec| { let mut 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(); @@ -1322,16 +1271,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_subsidy.compute_all( - indexer, - indexes, - price, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { + self.indexes_to_subsidy + .compute_all(indexes, price, starting_indexes, exit, |vec| { let mut indexes_to_fee_sum_iter = self.indexes_to_fee.sats.height.unwrap_sum().iter(); vec.compute_transform( @@ -1344,16 +1287,14 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; self.indexes_to_unclaimed_rewards.compute_all( - indexer, indexes, price, starting_indexes, exit, - |vec, _, _, starting_indexes, exit| { + |vec| { vec.compute_transform( starting_indexes.height, self.indexes_to_subsidy.sats.height.as_ref().unwrap(), @@ -1369,12 +1310,8 @@ impl Vecs { }, )?; - self.indexes_to_p2a_count.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, indexer, _, starting_indexes, exit| { + self.indexes_to_p2a_count + .compute_all(indexes, starting_indexes, exit, |v| { v.compute_count_from_indexes( starting_indexes.height, &indexer.vecs.height_to_first_p2aaddressindex, @@ -1382,15 +1319,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_p2ms_count.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, indexer, _, starting_indexes, exit| { + self.indexes_to_p2ms_count + .compute_all(indexes, starting_indexes, exit, |v| { v.compute_count_from_indexes( starting_indexes.height, &indexer.vecs.height_to_first_p2msoutputindex, @@ -1398,15 +1330,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_p2pk33_count.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, indexer, _, starting_indexes, exit| { + self.indexes_to_p2pk33_count + .compute_all(indexes, starting_indexes, exit, |v| { v.compute_count_from_indexes( starting_indexes.height, &indexer.vecs.height_to_first_p2pk33addressindex, @@ -1414,15 +1341,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_p2pk65_count.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, indexer, _, starting_indexes, exit| { + self.indexes_to_p2pk65_count + .compute_all(indexes, starting_indexes, exit, |v| { v.compute_count_from_indexes( starting_indexes.height, &indexer.vecs.height_to_first_p2pk65addressindex, @@ -1430,15 +1352,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_p2pkh_count.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, indexer, _, starting_indexes, exit| { + self.indexes_to_p2pkh_count + .compute_all(indexes, starting_indexes, exit, |v| { v.compute_count_from_indexes( starting_indexes.height, &indexer.vecs.height_to_first_p2pkhaddressindex, @@ -1446,15 +1363,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_p2sh_count.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, indexer, _, starting_indexes, exit| { + self.indexes_to_p2sh_count + .compute_all(indexes, starting_indexes, exit, |v| { v.compute_count_from_indexes( starting_indexes.height, &indexer.vecs.height_to_first_p2shaddressindex, @@ -1462,15 +1374,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_p2tr_count.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, indexer, _, starting_indexes, exit| { + self.indexes_to_p2tr_count + .compute_all(indexes, starting_indexes, exit, |v| { v.compute_count_from_indexes( starting_indexes.height, &indexer.vecs.height_to_first_p2traddressindex, @@ -1478,15 +1385,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_p2wpkh_count.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, indexer, _, starting_indexes, exit| { + self.indexes_to_p2wpkh_count + .compute_all(indexes, starting_indexes, exit, |v| { v.compute_count_from_indexes( starting_indexes.height, &indexer.vecs.height_to_first_p2wpkhaddressindex, @@ -1494,15 +1396,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_p2wsh_count.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, indexer, _, starting_indexes, exit| { + self.indexes_to_p2wsh_count + .compute_all(indexes, starting_indexes, exit, |v| { v.compute_count_from_indexes( starting_indexes.height, &indexer.vecs.height_to_first_p2wshaddressindex, @@ -1510,15 +1407,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_opreturn_count.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, indexer, _, starting_indexes, exit| { + self.indexes_to_opreturn_count + .compute_all(indexes, starting_indexes, exit, |v| { v.compute_count_from_indexes( starting_indexes.height, &indexer.vecs.height_to_first_opreturnindex, @@ -1526,15 +1418,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_unknownoutput_count.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, indexer, _, starting_indexes, exit| { + self.indexes_to_unknownoutput_count + .compute_all(indexes, starting_indexes, exit, |v| { v.compute_count_from_indexes( starting_indexes.height, &indexer.vecs.height_to_first_unknownoutputindex, @@ -1542,15 +1429,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_emptyoutput_count.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, indexer, _, starting_indexes, exit| { + self.indexes_to_emptyoutput_count + .compute_all(indexes, starting_indexes, exit, |v| { v.compute_count_from_indexes( starting_indexes.height, &indexer.vecs.height_to_first_emptyoutputindex, @@ -1558,15 +1440,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_exact_utxo_count.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_exact_utxo_count + .compute_all(indexes, starting_indexes, exit, |v| { let mut input_count_iter = self .indexes_to_input_count .height @@ -1611,8 +1488,7 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; self.dateindex_to_fee_dominance.compute_transform2( starting_indexes.dateindex, @@ -1639,12 +1515,8 @@ impl Vecs { exit, )?; - self.indexes_to_difficulty_as_hash.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_difficulty_as_hash + .compute_all(starting_indexes, exit, |v| { let multiplier = 2.0_f64.powi(32) / 600.0; v.compute_transform( starting_indexes.dateindex, @@ -1653,17 +1525,12 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; let now = Timestamp::now(); let today = Date::from(now); - self.indexes_to_hash_rate.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_hash_rate + .compute_all(starting_indexes, exit, |v| { v.compute_transform3( starting_indexes.dateindex, self.indexes_to_block_count.dateindex.unwrap_sum(), @@ -1690,15 +1557,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_hash_rate_1w_sma.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_hash_rate_1w_sma + .compute_all(starting_indexes, exit, |v| { v.compute_sma( starting_indexes.dateindex, self.indexes_to_hash_rate.dateindex.as_ref().unwrap(), @@ -1706,15 +1568,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_hash_rate_1m_sma.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_hash_rate_1m_sma + .compute_all(starting_indexes, exit, |v| { v.compute_sma( starting_indexes.dateindex, self.indexes_to_hash_rate.dateindex.as_ref().unwrap(), @@ -1722,15 +1579,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_hash_rate_2m_sma.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_hash_rate_2m_sma + .compute_all(starting_indexes, exit, |v| { v.compute_sma( starting_indexes.dateindex, self.indexes_to_hash_rate.dateindex.as_ref().unwrap(), @@ -1738,15 +1590,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_hash_rate_1y_sma.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_hash_rate_1y_sma + .compute_all(starting_indexes, exit, |v| { v.compute_sma( starting_indexes.dateindex, self.indexes_to_hash_rate.dateindex.as_ref().unwrap(), @@ -1754,8 +1601,7 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; if self.indexes_to_subsidy_usd_1y_sma.is_some() { let date_to_coinbase_usd_sum = self @@ -1769,45 +1615,33 @@ impl Vecs { self.indexes_to_subsidy_usd_1y_sma .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_sma( - starting_indexes.dateindex, - date_to_coinbase_usd_sum, - 365, - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |v| { + v.compute_sma( + starting_indexes.dateindex, + date_to_coinbase_usd_sum, + 365, + exit, + )?; + Ok(()) + })?; self.indexes_to_puell_multiple .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_divide( - starting_indexes.dateindex, - date_to_coinbase_usd_sum, - self.indexes_to_subsidy_usd_1y_sma - .as_ref() - .unwrap() - .dateindex - .as_ref() - .unwrap(), - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |v| { + v.compute_divide( + starting_indexes.dateindex, + date_to_coinbase_usd_sum, + self.indexes_to_subsidy_usd_1y_sma + .as_ref() + .unwrap() + .dateindex + .as_ref() + .unwrap(), + exit, + )?; + Ok(()) + })?; } Ok(()) diff --git a/crates/brk_computer/src/cointime.rs b/crates/brk_computer/src/cointime.rs index 1dbfa6c41..33457aa2c 100644 --- a/crates/brk_computer/src/cointime.rs +++ b/crates/brk_computer/src/cointime.rs @@ -1,7 +1,6 @@ use std::path::Path; use brk_error::Result; -use brk_indexer::Indexer; use brk_structs::{Bitcoin, CheckedSub, Dollars, StoredF64, Version}; use vecdb::{AnyCollectableVec, Database, Exit, PAGE_SIZE, VecIterator}; @@ -262,7 +261,6 @@ impl Vecs { #[allow(clippy::too_many_arguments)] pub fn compute( &mut self, - indexer: &Indexer, indexes: &indexes::Vecs, starting_indexes: &Indexes, price: Option<&price::Vecs>, @@ -270,15 +268,7 @@ impl Vecs { stateful: &stateful::Vecs, exit: &Exit, ) -> Result<()> { - self.compute_( - indexer, - indexes, - starting_indexes, - price, - chain, - stateful, - exit, - )?; + self.compute_(indexes, starting_indexes, price, chain, stateful, exit)?; self.db.flush_then_punch()?; Ok(()) } @@ -286,7 +276,6 @@ impl Vecs { #[allow(clippy::too_many_arguments)] fn compute_( &mut self, - indexer: &Indexer, indexes: &indexes::Vecs, starting_indexes: &Indexes, price: Option<&price::Vecs>, @@ -296,12 +285,8 @@ impl Vecs { ) -> Result<()> { let circulating_supply = &stateful.utxo_cohorts.all.1.height_to_supply; - self.indexes_to_coinblocks_created.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { + self.indexes_to_coinblocks_created + .compute_all(indexes, starting_indexes, exit, |vec| { vec.compute_transform( starting_indexes.height, circulating_supply, @@ -309,18 +294,13 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; let indexes_to_coinblocks_destroyed = &stateful.utxo_cohorts.all.1.indexes_to_coinblocks_destroyed; - self.indexes_to_coinblocks_stored.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { + self.indexes_to_coinblocks_stored + .compute_all(indexes, starting_indexes, exit, |vec| { let mut coinblocks_destroyed_iter = indexes_to_coinblocks_destroyed .height .as_ref() @@ -336,15 +316,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_liveliness.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { + self.indexes_to_liveliness + .compute_all(indexes, starting_indexes, exit, |vec| { vec.compute_divide( starting_indexes.height, indexes_to_coinblocks_destroyed @@ -356,16 +331,11 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; let liveliness = &self.indexes_to_liveliness; - self.indexes_to_vaultedness.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { + self.indexes_to_vaultedness + .compute_all(indexes, starting_indexes, exit, |vec| { vec.compute_transform( starting_indexes.height, liveliness.height.as_ref().unwrap(), @@ -373,16 +343,14 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; let vaultedness = &self.indexes_to_vaultedness; self.indexes_to_activity_to_vaultedness_ratio.compute_all( - indexer, indexes, starting_indexes, exit, - |vec, _, _, starting_indexes, exit| { + |vec| { vec.compute_divide( starting_indexes.height, liveliness.height.as_ref().unwrap(), @@ -394,12 +362,11 @@ impl Vecs { )?; self.indexes_to_vaulted_supply.compute_all( - indexer, indexes, price, starting_indexes, exit, - |vec, _, _, starting_indexes, exit| { + |vec| { vec.compute_multiply( starting_indexes.height, circulating_supply, @@ -411,12 +378,11 @@ impl Vecs { )?; self.indexes_to_active_supply.compute_all( - indexer, indexes, price, starting_indexes, exit, - |vec, _, _, starting_indexes, exit| { + |vec| { vec.compute_multiply( starting_indexes.height, circulating_supply, @@ -447,12 +413,8 @@ impl Vecs { .as_ref() .unwrap(); - self.indexes_to_thermo_cap.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { + self.indexes_to_thermo_cap + .compute_all(indexes, starting_indexes, exit, |vec| { vec.compute_transform( starting_indexes.height, chain @@ -466,15 +428,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_investor_cap.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { + self.indexes_to_investor_cap + .compute_all(indexes, starting_indexes, exit, |vec| { vec.compute_subtract( starting_indexes.height, realized_cap, @@ -482,15 +439,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_vaulted_cap.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { + self.indexes_to_vaulted_cap + .compute_all(indexes, starting_indexes, exit, |vec| { vec.compute_divide( starting_indexes.height, realized_cap, @@ -498,15 +450,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_active_cap.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { + self.indexes_to_active_cap + .compute_all(indexes, starting_indexes, exit, |vec| { vec.compute_multiply( starting_indexes.height, realized_cap, @@ -514,15 +461,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_vaulted_price.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { + self.indexes_to_vaulted_price + .compute_all(indexes, starting_indexes, exit, |vec| { vec.compute_divide( starting_indexes.height, realized_price, @@ -530,24 +472,17 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; self.indexes_to_vaulted_price_ratio.compute_rest( - indexer, - indexes, price, starting_indexes, exit, Some(self.indexes_to_vaulted_price.dateindex.unwrap_last()), )?; - self.indexes_to_active_price.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { + self.indexes_to_active_price + .compute_all(indexes, starting_indexes, exit, |vec| { vec.compute_multiply( starting_indexes.height, realized_price, @@ -555,12 +490,9 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; self.indexes_to_active_price_ratio.compute_rest( - indexer, - indexes, price, starting_indexes, exit, @@ -568,11 +500,10 @@ impl Vecs { )?; self.indexes_to_true_market_mean.compute_all( - indexer, indexes, starting_indexes, exit, - |vec, _, _, starting_indexes, exit| { + |vec| { vec.compute_divide( starting_indexes.height, self.indexes_to_investor_cap.height.as_ref().unwrap(), @@ -588,8 +519,6 @@ impl Vecs { )?; self.indexes_to_true_market_mean_ratio.compute_rest( - indexer, - indexes, price, starting_indexes, exit, @@ -597,11 +526,10 @@ impl Vecs { )?; self.indexes_to_cointime_value_destroyed.compute_all( - indexer, indexes, starting_indexes, 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 // The price taken won't be correct for time based indexes vec.compute_multiply( @@ -615,11 +543,10 @@ impl Vecs { )?; self.indexes_to_cointime_value_created.compute_all( - indexer, indexes, starting_indexes, exit, - |vec, _, _, starting_indexes, exit| { + |vec| { vec.compute_multiply( starting_indexes.height, &price.chainindexes_to_price_close.height, @@ -631,11 +558,10 @@ impl Vecs { )?; self.indexes_to_cointime_value_stored.compute_all( - indexer, indexes, starting_indexes, exit, - |vec, _, _, starting_indexes, exit| { + |vec| { vec.compute_multiply( starting_indexes.height, &price.chainindexes_to_price_close.height, @@ -646,12 +572,8 @@ impl Vecs { }, )?; - self.indexes_to_cointime_price.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { + self.indexes_to_cointime_price + .compute_all(indexes, starting_indexes, exit, |vec| { vec.compute_divide( starting_indexes.height, self.indexes_to_cointime_value_destroyed @@ -663,15 +585,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_cointime_cap.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { + self.indexes_to_cointime_cap + .compute_all(indexes, starting_indexes, exit, |vec| { vec.compute_multiply( starting_indexes.height, self.indexes_to_cointime_price.height.as_ref().unwrap(), @@ -679,12 +596,9 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; self.indexes_to_cointime_price_ratio.compute_rest( - indexer, - indexes, price, starting_indexes, exit, diff --git a/crates/brk_computer/src/constants.rs b/crates/brk_computer/src/constants.rs index 08feb0b2a..def3bbc22 100644 --- a/crates/brk_computer/src/constants.rs +++ b/crates/brk_computer/src/constants.rs @@ -1,7 +1,6 @@ use std::path::Path; use brk_error::Result; -use brk_indexer::Indexer; use brk_structs::{StoredF32, StoredI16, StoredU16, Version}; use vecdb::{AnyCollectableVec, AnyVec, Database, Exit}; @@ -168,19 +167,17 @@ impl Vecs { pub fn compute( &mut self, - indexer: &Indexer, indexes: &indexes::Vecs, starting_indexes: &Indexes, exit: &Exit, ) -> Result<()> { - self.compute_(indexer, indexes, starting_indexes, exit)?; + self.compute_(indexes, starting_indexes, exit)?; self.db.flush_then_punch()?; Ok(()) } fn compute_( &mut self, - indexer: &Indexer, indexes: &indexes::Vecs, starting_indexes: &Indexes, exit: &Exit, @@ -197,22 +194,16 @@ impl Vecs { ] .into_iter() .try_for_each(|(vec, value)| { - vec.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, indexes, starting_indexes, exit| { - vec.compute_to( - starting_indexes.height, - indexes.height_to_date.len(), - indexes.height_to_date.version(), - |i| (i, StoredU16::new(value)), - exit, - )?; - Ok(()) - }, - ) + vec.compute_all(indexes, starting_indexes, exit, |vec| { + vec.compute_to( + starting_indexes.height, + indexes.height_to_date.len(), + indexes.height_to_date.version(), + |i| (i, StoredU16::new(value)), + exit, + )?; + Ok(()) + }) })?; [ @@ -223,22 +214,16 @@ impl Vecs { ] .into_iter() .try_for_each(|(vec, value)| { - vec.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, indexes, starting_indexes, exit| { - vec.compute_to( - starting_indexes.height, - indexes.height_to_date.len(), - indexes.height_to_date.version(), - |i| (i, StoredI16::new(value)), - exit, - )?; - Ok(()) - }, - ) + vec.compute_all(indexes, starting_indexes, exit, |vec| { + vec.compute_to( + starting_indexes.height, + indexes.height_to_date.len(), + indexes.height_to_date.version(), + |i| (i, StoredI16::new(value)), + exit, + )?; + Ok(()) + }) })?; [ @@ -247,22 +232,16 @@ impl Vecs { ] .into_iter() .try_for_each(|(vec, value)| { - vec.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, indexes, starting_indexes, exit| { - vec.compute_to( - starting_indexes.height, - indexes.height_to_date.len(), - indexes.height_to_date.version(), - |i| (i, StoredF32::from(value)), - exit, - )?; - Ok(()) - }, - ) + vec.compute_all(indexes, starting_indexes, exit, |vec| { + vec.compute_to( + starting_indexes.height, + indexes.height_to_date.len(), + indexes.height_to_date.version(), + |i| (i, StoredF32::from(value)), + exit, + )?; + Ok(()) + }) })?; Ok(()) diff --git a/crates/brk_computer/src/grouped/builder_computed.rs b/crates/brk_computer/src/grouped/builder_computed.rs deleted file mode 100644 index 068fd405f..000000000 --- a/crates/brk_computer/src/grouped/builder_computed.rs +++ /dev/null @@ -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 -where - I: StoredIndex, - T: ComputedType, - S2T: ComputedType, -{ - pub first: Option>>, - pub average: Option>>, - pub sum: Option>>, - pub max: Option>>, - pub min: Option>>, - pub last: Option>>, - pub cumulative: Option>>, -} - -const VERSION: Version = Version::ZERO; - -impl ComputedVecBuilder -where - I: StoredIndex, - T: ComputedType + 'static, - S1I: StoredIndex + 'static + FromCoarserIndex, - S2T: ComputedType, -{ - #[allow(clippy::too_many_arguments)] - pub fn forced_import( - db: &Database, - name: &str, - version: Version, - format: Format, - computation: Computation, - source: Option>, - source_extra: &EagerVecBuilder, - len_source: AnyBoxedIterableVec, - options: ComputedVecBuilderOptions, - ) -> Result { - 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::>(); - 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::>(); - 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( - &mut self, - max_from: I, - len_source: &impl AnyIterableVec, - 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 { - self.first.as_ref().unwrap() - } - #[allow(unused)] - pub fn unwrap_average(&self) -> &ComputedVecFrom2 { - self.average.as_ref().unwrap() - } - pub fn unwrap_sum(&self) -> &ComputedVecFrom2 { - self.sum.as_ref().unwrap() - } - pub fn unwrap_max(&self) -> &ComputedVecFrom2 { - self.max.as_ref().unwrap() - } - pub fn unwrap_min(&self) -> &ComputedVecFrom2 { - self.min.as_ref().unwrap() - } - pub fn unwrap_last(&self) -> &ComputedVecFrom2 { - self.last.as_ref().unwrap() - } - #[allow(unused)] - pub fn unwrap_cumulative(&self) -> &ComputedVecFrom2 { - 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 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() - } - } -} diff --git a/crates/brk_computer/src/grouped/from_dateindex.rs b/crates/brk_computer/src/grouped/from_dateindex.rs index 8c07ae78d..e552c7ebf 100644 --- a/crates/brk_computer/src/grouped/from_dateindex.rs +++ b/crates/brk_computer/src/grouped/from_dateindex.rs @@ -1,7 +1,6 @@ use allocative::Allocative; use brk_error::Result; -use brk_indexer::Indexer; use brk_structs::{ DateIndex, DecadeIndex, MonthIndex, QuarterIndex, SemesterIndex, Version, WeekIndex, YearIndex, }; @@ -112,28 +111,14 @@ where pub fn compute_all( &mut self, - indexer: &Indexer, - indexes: &indexes::Vecs, starting_indexes: &Indexes, exit: &Exit, mut compute: F, ) -> Result<()> where - F: FnMut( - &mut EagerVec, - &Indexer, - &indexes::Vecs, - &Indexes, - &Exit, - ) -> Result<()>, + F: FnMut(&mut EagerVec) -> Result<()>, { - compute( - self.dateindex.as_mut().unwrap(), - indexer, - indexes, - starting_indexes, - exit, - )?; + compute(self.dateindex.as_mut().unwrap())?; let dateindex: Option<&EagerVec> = None; self.compute_rest(starting_indexes, exit, dateindex) diff --git a/crates/brk_computer/src/grouped/from_height.rs b/crates/brk_computer/src/grouped/from_height.rs index fb66658f2..959dba904 100644 --- a/crates/brk_computer/src/grouped/from_height.rs +++ b/crates/brk_computer/src/grouped/from_height.rs @@ -1,7 +1,6 @@ use allocative::Allocative; use brk_error::Result; -use brk_indexer::Indexer; use brk_structs::{ DateIndex, DecadeIndex, DifficultyEpoch, Height, MonthIndex, QuarterIndex, SemesterIndex, Version, WeekIndex, YearIndex, @@ -134,22 +133,15 @@ where pub fn compute_all( &mut self, - indexer: &Indexer, indexes: &indexes::Vecs, starting_indexes: &Indexes, exit: &Exit, mut compute: F, ) -> Result<()> where - F: FnMut(&mut EagerVec, &Indexer, &indexes::Vecs, &Indexes, &Exit) -> Result<()>, + F: FnMut(&mut EagerVec) -> Result<()>, { - compute( - self.height.as_mut().unwrap(), - indexer, - indexes, - starting_indexes, - exit, - )?; + compute(self.height.as_mut().unwrap())?; let height: Option<&EagerVec> = None; self.compute_rest(indexes, starting_indexes, exit, height) diff --git a/crates/brk_computer/src/grouped/from_height_strict.rs b/crates/brk_computer/src/grouped/from_height_strict.rs index c3c156c14..2866334d9 100644 --- a/crates/brk_computer/src/grouped/from_height_strict.rs +++ b/crates/brk_computer/src/grouped/from_height_strict.rs @@ -1,6 +1,5 @@ use brk_error::Result; -use brk_indexer::Indexer; use brk_structs::{DifficultyEpoch, Height, Version}; use vecdb::{AnyCollectableVec, Database, EagerVec, Exit}; @@ -59,16 +58,15 @@ where pub fn compute( &mut self, - indexer: &Indexer, indexes: &indexes::Vecs, starting_indexes: &Indexes, exit: &Exit, mut compute: F, ) -> Result<()> where - F: FnMut(&mut EagerVec, &Indexer, &indexes::Vecs, &Indexes, &Exit) -> Result<()>, + F: FnMut(&mut EagerVec) -> Result<()>, { - compute(&mut self.height, indexer, indexes, starting_indexes, exit)?; + compute(&mut self.height)?; self.height_extra .extend(starting_indexes.height, &self.height, exit)?; diff --git a/crates/brk_computer/src/grouped/ratio_from_dateindex.rs b/crates/brk_computer/src/grouped/ratio_from_dateindex.rs index 5c83b91e2..1c1a96ce8 100644 --- a/crates/brk_computer/src/grouped/ratio_from_dateindex.rs +++ b/crates/brk_computer/src/grouped/ratio_from_dateindex.rs @@ -1,5 +1,4 @@ use brk_error::Result; -use brk_indexer::Indexer; use brk_structs::{Date, DateIndex, Dollars, StoredF32, Version}; use vecdb::{ AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, CollectableVec, Database, EagerVec, @@ -284,45 +283,25 @@ impl ComputedRatioVecsFromDateIndex { pub fn compute_all( &mut self, - indexer: &Indexer, - indexes: &indexes::Vecs, price: &price::Vecs, starting_indexes: &Indexes, exit: &Exit, compute: F, ) -> Result<()> where - F: FnMut( - &mut EagerVec, - &Indexer, - &indexes::Vecs, - &Indexes, - &Exit, - ) -> Result<()>, + F: FnMut(&mut EagerVec) -> Result<()>, { - self.price.as_mut().unwrap().compute_all( - indexer, - indexes, - starting_indexes, - exit, - compute, - )?; + self.price + .as_mut() + .unwrap() + .compute_all(starting_indexes, exit, compute)?; let date_to_price_opt: Option<&EagerVec> = None; - self.compute_rest( - indexer, - indexes, - price, - starting_indexes, - exit, - date_to_price_opt, - ) + self.compute_rest(price, starting_indexes, exit, date_to_price_opt) } pub fn compute_rest( &mut self, - indexer: &Indexer, - indexes: &indexes::Vecs, price: &price::Vecs, starting_indexes: &Indexes, exit: &Exit, @@ -334,28 +313,22 @@ impl ComputedRatioVecsFromDateIndex { std::mem::transmute(&self.price.as_ref().unwrap().dateindex) }); - self.ratio.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_transform2( - starting_indexes.dateindex, - closes, - price, - |(i, close, price, ..)| { - if price == Dollars::ZERO { - (i, StoredF32::from(1.0)) - } else { - (i, StoredF32::from(*close / price)) - } - }, - exit, - )?; - Ok(()) - }, - )?; + self.ratio.compute_all(starting_indexes, exit, |v| { + v.compute_transform2( + starting_indexes.dateindex, + closes, + price, + |(i, close, price, ..)| { + if price == Dollars::ZERO { + (i, StoredF32::from(1.0)) + } else { + (i, StoredF32::from(*close / price)) + } + }, + exit, + )?; + Ok(()) + })?; if self.ratio_1w_sma.is_none() { return Ok(()); @@ -363,12 +336,10 @@ impl ComputedRatioVecsFromDateIndex { let min_ratio_date = DateIndex::try_from(Date::MIN_RATIO).unwrap(); - self.ratio_1w_sma.as_mut().unwrap().compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.ratio_1w_sma + .as_mut() + .unwrap() + .compute_all(starting_indexes, exit, |v| { v.compute_sma_( starting_indexes.dateindex, self.ratio.dateindex.as_ref().unwrap(), @@ -377,15 +348,12 @@ impl ComputedRatioVecsFromDateIndex { Some(min_ratio_date), )?; Ok(()) - }, - )?; + })?; - self.ratio_1m_sma.as_mut().unwrap().compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.ratio_1m_sma + .as_mut() + .unwrap() + .compute_all(starting_indexes, exit, |v| { v.compute_sma_( starting_indexes.dateindex, self.ratio.dateindex.as_ref().unwrap(), @@ -394,8 +362,7 @@ impl ComputedRatioVecsFromDateIndex { Some(min_ratio_date), )?; Ok(()) - }, - )?; + })?; let ratio_version = self.ratio.dateindex.as_ref().unwrap().version(); self.mut_ratio_vecs() @@ -562,12 +529,10 @@ impl ComputedRatioVecsFromDateIndex { std::mem::transmute(&self.price.as_ref().unwrap().dateindex) }); - self.ratio_pct99_in_usd.as_mut().unwrap().compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { + self.ratio_pct99_in_usd + .as_mut() + .unwrap() + .compute_all(starting_indexes, exit, |vec| { let mut iter = self .ratio_pct99 .as_ref() @@ -586,31 +551,24 @@ impl ComputedRatioVecsFromDateIndex { exit, )?; Ok(()) - }, - )?; + })?; let compute_in_usd = |in_usd: Option<&mut ComputedVecsFromDateIndex>, source: Option<&ComputedVecsFromDateIndex>| { - in_usd.unwrap().compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - let mut iter = source.unwrap().dateindex.as_ref().unwrap().into_iter(); - vec.compute_transform( - starting_indexes.dateindex, - date_to_price, - |(i, price, ..)| { - let multiplier = iter.unwrap_get_inner(i); - (i, price * multiplier) - }, - exit, - )?; - Ok(()) - }, - ) + in_usd.unwrap().compute_all(starting_indexes, exit, |vec| { + let mut iter = source.unwrap().dateindex.as_ref().unwrap().into_iter(); + vec.compute_transform( + starting_indexes.dateindex, + date_to_price, + |(i, price, ..)| { + let multiplier = iter.unwrap_get_inner(i); + (i, price * multiplier) + }, + exit, + )?; + Ok(()) + }) }; 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())?; self.ratio_sd.as_mut().unwrap().compute_all( - indexer, - indexes, starting_indexes, exit, self.ratio.dateindex.as_ref().unwrap(), Some(date_to_price), )?; self.ratio_4y_sd.as_mut().unwrap().compute_all( - indexer, - indexes, starting_indexes, exit, self.ratio.dateindex.as_ref().unwrap(), Some(date_to_price), )?; self.ratio_2y_sd.as_mut().unwrap().compute_all( - indexer, - indexes, starting_indexes, exit, self.ratio.dateindex.as_ref().unwrap(), Some(date_to_price), )?; self.ratio_1y_sd.as_mut().unwrap().compute_all( - indexer, - indexes, starting_indexes, exit, self.ratio.dateindex.as_ref().unwrap(), diff --git a/crates/brk_computer/src/grouped/sd_from_dateindex.rs b/crates/brk_computer/src/grouped/sd_from_dateindex.rs index 68d56d613..ab6cf6126 100644 --- a/crates/brk_computer/src/grouped/sd_from_dateindex.rs +++ b/crates/brk_computer/src/grouped/sd_from_dateindex.rs @@ -1,5 +1,4 @@ use brk_error::Result; -use brk_indexer::Indexer; use brk_structs::{CheckedSub, Date, DateIndex, Dollars, StoredF32, Version}; use vecdb::{ AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, BoxedVecIterator, CollectableVec, @@ -419,8 +418,6 @@ impl ComputedStandardDeviationVecsFromDateIndex { pub fn compute_all( &mut self, - indexer: &Indexer, - indexes: &indexes::Vecs, starting_indexes: &Indexes, exit: &Exit, source: &impl CollectableVec, @@ -428,12 +425,10 @@ impl ComputedStandardDeviationVecsFromDateIndex { ) -> Result<()> { let min_date = DateIndex::try_from(Date::MIN_RATIO).unwrap(); - self.sma.as_mut().unwrap().compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.sma + .as_mut() + .unwrap() + .compute_all(starting_indexes, exit, |v| { v.compute_sma_( starting_indexes.dateindex, source, @@ -442,26 +437,15 @@ impl ComputedStandardDeviationVecsFromDateIndex { Some(min_date), )?; Ok(()) - }, - )?; + })?; let sma_opt: Option<&EagerVec> = None; - self.compute_rest( - indexer, - indexes, - starting_indexes, - exit, - sma_opt, - source, - price_opt, - ) + self.compute_rest(starting_indexes, exit, sma_opt, source, price_opt) } #[allow(clippy::too_many_arguments)] pub fn compute_rest( &mut self, - indexer: &Indexer, - indexes: &indexes::Vecs, starting_indexes: &Indexes, exit: &Exit, sma_opt: Option<&impl AnyIterableVec>, @@ -630,22 +614,16 @@ impl ComputedStandardDeviationVecsFromDateIndex { })?; if let Some(zscore) = self.zscore.as_mut() { - zscore.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_zscore( - starting_indexes.dateindex, - source, - sma, - self.sd.dateindex.as_ref().unwrap(), - exit, - )?; - Ok(()) - }, - )?; + zscore.compute_all(starting_indexes, exit, |vec| { + vec.compute_zscore( + starting_indexes.dateindex, + source, + sma, + self.sd.dateindex.as_ref().unwrap(), + exit, + )?; + Ok(()) + })?; } let Some(price) = price_opt else { @@ -655,24 +633,18 @@ impl ComputedStandardDeviationVecsFromDateIndex { let compute_in_usd = |in_usd: &mut ComputedVecsFromDateIndex, mut iter: BoxedVecIterator| { - in_usd.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_transform( - starting_indexes.dateindex, - price, - |(i, price, ..)| { - let multiplier = iter.unwrap_get_inner(i); - (i, price * multiplier) - }, - exit, - )?; - Ok(()) - }, - ) + in_usd.compute_all(starting_indexes, exit, |vec| { + vec.compute_transform( + starting_indexes.dateindex, + price, + |(i, price, ..)| { + let multiplier = iter.unwrap_get_inner(i); + (i, price * multiplier) + }, + exit, + )?; + Ok(()) + }) }; if self._0sd_in_usd.is_none() { diff --git a/crates/brk_computer/src/grouped/value_from_dateindex.rs b/crates/brk_computer/src/grouped/value_from_dateindex.rs index 31f342243..58b57e27f 100644 --- a/crates/brk_computer/src/grouped/value_from_dateindex.rs +++ b/crates/brk_computer/src/grouped/value_from_dateindex.rs @@ -1,5 +1,4 @@ use brk_error::Result; -use brk_indexer::Indexer; use brk_structs::{Bitcoin, DateIndex, Dollars, Sats, Version}; use vecdb::{AnyCollectableVec, CollectableVec, Database, EagerVec, Exit, StoredVec}; @@ -65,40 +64,24 @@ impl ComputedValueVecsFromDateIndex { pub fn compute_all( &mut self, - indexer: &Indexer, - indexes: &indexes::Vecs, price: Option<&price::Vecs>, starting_indexes: &Indexes, exit: &Exit, mut compute: F, ) -> Result<()> where - F: FnMut( - &mut EagerVec, - &Indexer, - &indexes::Vecs, - &Indexes, - &Exit, - ) -> Result<()>, + F: FnMut(&mut EagerVec) -> Result<()>, { - compute( - self.sats.dateindex.as_mut().unwrap(), - indexer, - indexes, - starting_indexes, - exit, - )?; + compute(self.sats.dateindex.as_mut().unwrap())?; let dateindex: Option<&StoredVec> = None; - self.compute_rest(indexer, indexes, price, starting_indexes, exit, dateindex)?; + self.compute_rest(price, starting_indexes, exit, dateindex)?; Ok(()) } pub fn compute_rest( &mut self, - indexer: &Indexer, - indexes: &indexes::Vecs, price: Option<&price::Vecs>, starting_indexes: &Indexes, exit: &Exit, @@ -108,33 +91,21 @@ impl ComputedValueVecsFromDateIndex { self.sats .compute_rest(starting_indexes, exit, Some(dateindex))?; - self.bitcoin.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_from_sats(starting_indexes.dateindex, dateindex, exit) - }, - )?; + self.bitcoin.compute_all(starting_indexes, exit, |v| { + v.compute_from_sats(starting_indexes.dateindex, dateindex, exit) + })?; } else { let dateindex: Option<&StoredVec> = None; self.sats.compute_rest(starting_indexes, exit, dateindex)?; - self.bitcoin.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_from_sats( - starting_indexes.dateindex, - self.sats.dateindex.as_ref().unwrap(), - exit, - ) - }, - )?; + self.bitcoin.compute_all(starting_indexes, exit, |v| { + v.compute_from_sats( + starting_indexes.dateindex, + self.sats.dateindex.as_ref().unwrap(), + exit, + ) + })?; } let dateindex_to_bitcoin = self.bitcoin.dateindex.as_ref().unwrap(); @@ -147,20 +118,14 @@ impl ComputedValueVecsFromDateIndex { .unwrap(); if let Some(dollars) = self.dollars.as_mut() { - dollars.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_from_bitcoin( - starting_indexes.dateindex, - dateindex_to_bitcoin, - dateindex_to_price_close, - exit, - ) - }, - )?; + dollars.compute_all(starting_indexes, exit, |v| { + v.compute_from_bitcoin( + starting_indexes.dateindex, + dateindex_to_bitcoin, + dateindex_to_price_close, + exit, + ) + })?; } Ok(()) diff --git a/crates/brk_computer/src/grouped/value_from_height.rs b/crates/brk_computer/src/grouped/value_from_height.rs index 6ba42a744..0c72ec8d2 100644 --- a/crates/brk_computer/src/grouped/value_from_height.rs +++ b/crates/brk_computer/src/grouped/value_from_height.rs @@ -1,6 +1,5 @@ use allocative::Allocative; use brk_error::Result; -use brk_indexer::Indexer; use brk_structs::{Bitcoin, Dollars, Height, Sats, Version}; use vecdb::{AnyCollectableVec, CollectableVec, Database, EagerVec, Exit, StoredVec}; @@ -66,7 +65,6 @@ impl ComputedValueVecsFromHeight { pub fn compute_all( &mut self, - indexer: &Indexer, indexes: &indexes::Vecs, price: Option<&price::Vecs>, starting_indexes: &Indexes, @@ -74,31 +72,18 @@ impl ComputedValueVecsFromHeight { mut compute: F, ) -> Result<()> where - F: FnMut( - &mut EagerVec, - &Indexer, - &indexes::Vecs, - &Indexes, - &Exit, - ) -> Result<()>, + F: FnMut(&mut EagerVec) -> Result<()>, { - compute( - self.sats.height.as_mut().unwrap(), - indexer, - indexes, - starting_indexes, - exit, - )?; + compute(self.sats.height.as_mut().unwrap())?; let height: Option<&StoredVec> = None; - self.compute_rest(indexer, indexes, price, starting_indexes, exit, height)?; + self.compute_rest(indexes, price, starting_indexes, exit, height)?; Ok(()) } pub fn compute_rest( &mut self, - indexer: &Indexer, indexes: &indexes::Vecs, price: Option<&price::Vecs>, starting_indexes: &Indexes, @@ -109,54 +94,38 @@ impl ComputedValueVecsFromHeight { self.sats .compute_rest(indexes, starting_indexes, exit, Some(height))?; - self.bitcoin.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.bitcoin + .compute_all(indexes, starting_indexes, exit, |v| { v.compute_from_sats(starting_indexes.height, height, exit) - }, - )?; + })?; } else { let height: Option<&StoredVec> = None; self.sats .compute_rest(indexes, starting_indexes, exit, height)?; - self.bitcoin.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.bitcoin + .compute_all(indexes, starting_indexes, exit, |v| { v.compute_from_sats( starting_indexes.height, self.sats.height.as_ref().unwrap(), exit, ) - }, - )?; + })?; } let height_to_bitcoin = self.bitcoin.height.as_ref().unwrap(); let height_to_price_close = &price.as_ref().unwrap().chainindexes_to_price_close.height; if let Some(dollars) = self.dollars.as_mut() { - dollars.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_from_bitcoin( - starting_indexes.height, - height_to_bitcoin, - height_to_price_close, - exit, - ) - }, - )?; + dollars.compute_all(indexes, starting_indexes, exit, |v| { + v.compute_from_bitcoin( + starting_indexes.height, + height_to_bitcoin, + height_to_price_close, + exit, + ) + })?; } Ok(()) diff --git a/crates/brk_computer/src/grouped/value_height.rs b/crates/brk_computer/src/grouped/value_height.rs index 3fab71737..9917fc207 100644 --- a/crates/brk_computer/src/grouped/value_height.rs +++ b/crates/brk_computer/src/grouped/value_height.rs @@ -1,12 +1,11 @@ use brk_error::Result; -use brk_indexer::Indexer; use brk_structs::{Bitcoin, Dollars, Height, Sats, Version}; use vecdb::{AnyCollectableVec, CollectableVec, Database, EagerVec, Exit, Format, StoredVec}; use crate::{ Indexes, grouped::Source, - indexes, price, + price, traits::{ComputeFromBitcoin, ComputeFromSats}, }; @@ -53,29 +52,15 @@ impl ComputedHeightValueVecs { pub fn compute_all( &mut self, - indexer: &Indexer, - indexes: &indexes::Vecs, price: Option<&price::Vecs>, starting_indexes: &Indexes, exit: &Exit, mut compute: F, ) -> Result<()> where - F: FnMut( - &mut EagerVec, - &Indexer, - &indexes::Vecs, - &Indexes, - &Exit, - ) -> Result<()>, + F: FnMut(&mut EagerVec) -> Result<()>, { - compute( - self.sats.as_mut().unwrap(), - indexer, - indexes, - starting_indexes, - exit, - )?; + compute(self.sats.as_mut().unwrap())?; let height: Option<&StoredVec> = None; self.compute_rest(price, starting_indexes, exit, height)?; diff --git a/crates/brk_computer/src/lib.rs b/crates/brk_computer/src/lib.rs index 51518afff..d37064ffc 100644 --- a/crates/brk_computer/src/lib.rs +++ b/crates/brk_computer/src/lib.rs @@ -116,7 +116,7 @@ impl Computer { info!("Computing constants..."); self.constants - .compute(indexer, &self.indexes, &starting_indexes, exit)?; + .compute(&self.indexes, &starting_indexes, exit)?; if let Some(fetched) = self.fetched.as_mut() { info!("Computing fetched..."); @@ -124,7 +124,6 @@ impl Computer { info!("Computing prices..."); self.price.as_mut().unwrap().compute( - indexer, &self.indexes, &starting_indexes, fetched, @@ -147,8 +146,7 @@ impl Computer { if let Some(price) = self.price.as_ref() { info!("Computing market..."); - self.market - .compute(indexer, &self.indexes, price, &starting_indexes, exit)?; + self.market.compute(price, &starting_indexes, exit)?; } chain.join().unwrap()?; @@ -178,7 +176,6 @@ impl Computer { info!("Computing cointime..."); self.cointime.compute( - indexer, &self.indexes, &starting_indexes, self.price.as_ref(), diff --git a/crates/brk_computer/src/market.rs b/crates/brk_computer/src/market.rs index 94af307e7..5eb5e2cfc 100644 --- a/crates/brk_computer/src/market.rs +++ b/crates/brk_computer/src/market.rs @@ -1,7 +1,6 @@ use std::{path::Path, thread}; use brk_error::Result; -use brk_indexer::Indexer; use brk_structs::{Date, DateIndex, Dollars, Height, Sats, StoredF32, StoredU16, Version}; use vecdb::{AnyCollectableVec, Database, EagerVec, Exit, PAGE_SIZE, StoredIndex, VecIterator}; @@ -1528,21 +1527,17 @@ impl Vecs { pub fn compute( &mut self, - indexer: &Indexer, - indexes: &indexes::Vecs, price: &price::Vecs, starting_indexes: &Indexes, exit: &Exit, ) -> Result<()> { - self.compute_(indexer, indexes, price, starting_indexes, exit)?; + self.compute_(price, starting_indexes, exit)?; self.db.flush_then_punch()?; Ok(()) } fn compute_( &mut self, - indexer: &Indexer, - indexes: &indexes::Vecs, price: &price::Vecs, starting_indexes: &Indexes, exit: &Exit, @@ -1559,27 +1554,18 @@ impl Vecs { exit, )?; - self.indexes_to_price_ath.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_price_ath + .compute_all(starting_indexes, exit, |v| { v.compute_all_time_high( starting_indexes.dateindex, price.timeindexes_to_price_high.dateindex.as_ref().unwrap(), exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_price_drawdown.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_price_drawdown + .compute_all(starting_indexes, exit, |v| { v.compute_drawdown( starting_indexes.dateindex, price.timeindexes_to_price_close.dateindex.as_ref().unwrap(), @@ -1587,15 +1573,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_days_since_price_ath.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_days_since_price_ath + .compute_all(starting_indexes, exit, |v| { let mut high_iter = price .timeindexes_to_price_high .dateindex @@ -1626,15 +1607,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_max_days_between_price_aths.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_max_days_between_price_aths + .compute_all(starting_indexes, exit, |v| { let mut prev = None; v.compute_transform( starting_indexes.dateindex, @@ -1658,15 +1634,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_max_years_between_price_aths.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_max_years_between_price_aths + .compute_all(starting_indexes, exit, |v| { v.compute_transform( starting_indexes.dateindex, self.indexes_to_max_days_between_price_aths @@ -1677,8 +1648,7 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; [ (1, &mut self.price_1d_ago, &mut self._1d_price_returns, None), @@ -1752,54 +1722,36 @@ impl Vecs { ] .into_iter() .try_for_each(|(days, ago, returns, cagr)| -> Result<()> { - ago.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_previous_value( - starting_indexes.dateindex, - price.timeindexes_to_price_close.dateindex.as_ref().unwrap(), - days, - exit, - )?; - Ok(()) - }, - )?; + ago.compute_all(starting_indexes, exit, |v| { + v.compute_previous_value( + starting_indexes.dateindex, + price.timeindexes_to_price_close.dateindex.as_ref().unwrap(), + days, + exit, + )?; + Ok(()) + })?; - returns.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_percentage_change( - starting_indexes.dateindex, - price.timeindexes_to_price_close.dateindex.as_ref().unwrap(), - days, - exit, - )?; - Ok(()) - }, - )?; + returns.compute_all(starting_indexes, exit, |v| { + v.compute_percentage_change( + starting_indexes.dateindex, + price.timeindexes_to_price_close.dateindex.as_ref().unwrap(), + days, + exit, + )?; + Ok(()) + })?; if let Some(cagr) = cagr { - cagr.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_cagr( - starting_indexes.dateindex, - returns.dateindex.as_ref().unwrap(), - days, - exit, - )?; - Ok(()) - }, - )?; + cagr.compute_all(starting_indexes, exit, |v| { + v.compute_cagr( + starting_indexes.dateindex, + returns.dateindex.as_ref().unwrap(), + days, + exit, + )?; + Ok(()) + })?; } Ok(()) @@ -1894,70 +1846,46 @@ impl Vecs { .into_iter() .try_for_each( |(days, dca_stack, dca_avg_price, dca_returns, dca_cagr)| -> Result<()> { - dca_stack.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_dca_stack_via_len( - starting_indexes.dateindex, - price.timeindexes_to_price_close.dateindex.as_ref().unwrap(), - days, - exit, - )?; - Ok(()) - }, - )?; + dca_stack.compute_all(starting_indexes, exit, |v| { + v.compute_dca_stack_via_len( + starting_indexes.dateindex, + price.timeindexes_to_price_close.dateindex.as_ref().unwrap(), + days, + exit, + )?; + Ok(()) + })?; - dca_avg_price.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_dca_avg_price_via_len( - starting_indexes.dateindex, - dca_stack.dateindex.as_ref().unwrap(), - days, - exit, - )?; - Ok(()) - }, - )?; + dca_avg_price.compute_all(starting_indexes, exit, |v| { + v.compute_dca_avg_price_via_len( + starting_indexes.dateindex, + dca_stack.dateindex.as_ref().unwrap(), + days, + exit, + )?; + Ok(()) + })?; - dca_returns.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_percentage_difference( - starting_indexes.dateindex, - price.timeindexes_to_price_close.dateindex.as_ref().unwrap(), - dca_avg_price.dateindex.as_ref().unwrap(), - exit, - )?; - Ok(()) - }, - )?; + dca_returns.compute_all(starting_indexes, exit, |v| { + v.compute_percentage_difference( + starting_indexes.dateindex, + 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 { - dca_cagr.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_cagr( - starting_indexes.dateindex, - dca_returns.dateindex.as_ref().unwrap(), - days, - exit, - )?; - Ok(()) - }, - )?; + dca_cagr.compute_all(starting_indexes, exit, |v| { + v.compute_cagr( + starting_indexes.dateindex, + dca_returns.dateindex.as_ref().unwrap(), + days, + exit, + )?; + Ok(()) + })?; } Ok(()) @@ -2036,53 +1964,35 @@ impl Vecs { .try_for_each(|(year, avg_price, returns, stack)| -> Result<()> { let dateindex = DateIndex::try_from(Date::new(year, 1, 1)).unwrap(); - stack.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_dca_stack_via_from( - starting_indexes.dateindex, - price.timeindexes_to_price_close.dateindex.as_ref().unwrap(), - dateindex, - exit, - )?; - Ok(()) - }, - )?; + stack.compute_all(starting_indexes, exit, |v| { + v.compute_dca_stack_via_from( + starting_indexes.dateindex, + price.timeindexes_to_price_close.dateindex.as_ref().unwrap(), + dateindex, + exit, + )?; + Ok(()) + })?; - avg_price.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_dca_avg_price_via_from( - starting_indexes.dateindex, - stack.dateindex.as_ref().unwrap(), - dateindex, - exit, - )?; - Ok(()) - }, - )?; + avg_price.compute_all(starting_indexes, exit, |v| { + v.compute_dca_avg_price_via_from( + starting_indexes.dateindex, + stack.dateindex.as_ref().unwrap(), + dateindex, + exit, + )?; + Ok(()) + })?; - returns.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_percentage_difference( - starting_indexes.dateindex, - price.timeindexes_to_price_close.dateindex.as_ref().unwrap(), - avg_price.dateindex.as_ref().unwrap(), - exit, - )?; - Ok(()) - }, - )?; + returns.compute_all(starting_indexes, exit, |v| { + v.compute_percentage_difference( + starting_indexes.dateindex, + price.timeindexes_to_price_close.dateindex.as_ref().unwrap(), + avg_price.dateindex.as_ref().unwrap(), + exit, + )?; + Ok(()) + })?; Ok(()) })?; @@ -2163,50 +2073,32 @@ impl Vecs { .into_iter() .for_each(|(sma, ema, days)| { s.spawn(move || -> Result<()> { - sma.compute_all( - indexer, - indexes, - price, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_sma( - starting_indexes.dateindex, - price.timeindexes_to_price_close.dateindex.as_ref().unwrap(), - days, - exit, - )?; - Ok(()) - }, - )?; + sma.compute_all(price, starting_indexes, exit, |v| { + v.compute_sma( + starting_indexes.dateindex, + price.timeindexes_to_price_close.dateindex.as_ref().unwrap(), + days, + exit, + )?; + Ok(()) + })?; - ema.compute_all( - indexer, - indexes, - price, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_ema( - starting_indexes.dateindex, - price.timeindexes_to_price_close.dateindex.as_ref().unwrap(), - days, - exit, - )?; - Ok(()) - }, - ) + ema.compute_all(price, starting_indexes, exit, |v| { + v.compute_ema( + starting_indexes.dateindex, + price.timeindexes_to_price_close.dateindex.as_ref().unwrap(), + days, + exit, + )?; + Ok(()) + }) }); }); Ok(()) })?; - self.indexes_to_price_200d_sma_x0_8.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_price_200d_sma_x0_8 + .compute_all(starting_indexes, exit, |v| { v.compute_transform( starting_indexes.dateindex, self.indexes_to_price_200d_sma @@ -2220,15 +2112,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_price_200d_sma_x2_4.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_price_200d_sma_x2_4 + .compute_all(starting_indexes, exit, |v| { v.compute_transform( starting_indexes.dateindex, self.indexes_to_price_200d_sma @@ -2242,40 +2129,29 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; self.indexes_to_1d_returns_1w_sd.compute_all( - indexer, - indexes, starting_indexes, exit, self._1d_price_returns.dateindex.as_ref().unwrap(), None as Option<&EagerVec>, )?; self.indexes_to_1d_returns_1m_sd.compute_all( - indexer, - indexes, starting_indexes, exit, self._1d_price_returns.dateindex.as_ref().unwrap(), None as Option<&EagerVec>, )?; self.indexes_to_1d_returns_1y_sd.compute_all( - indexer, - indexes, starting_indexes, exit, self._1d_price_returns.dateindex.as_ref().unwrap(), None as Option<&EagerVec>, )?; - self.indexes_to_price_1w_volatility.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_price_1w_volatility + .compute_all(starting_indexes, exit, |v| { v.compute_transform( starting_indexes.dateindex, self.indexes_to_1d_returns_1w_sd @@ -2287,14 +2163,9 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; - self.indexes_to_price_1m_volatility.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + })?; + self.indexes_to_price_1m_volatility + .compute_all(starting_indexes, exit, |v| { v.compute_transform( starting_indexes.dateindex, self.indexes_to_1d_returns_1m_sd @@ -2306,14 +2177,9 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; - self.indexes_to_price_1y_volatility.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + })?; + self.indexes_to_price_1y_volatility + .compute_all(starting_indexes, exit, |v| { v.compute_transform( starting_indexes.dateindex, self.indexes_to_1d_returns_1y_sd @@ -2325,8 +2191,7 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; self.dateindex_to_price_true_range.compute_transform3( starting_indexes.dateindex, @@ -2349,12 +2214,8 @@ impl Vecs { exit, )?; - self.indexes_to_price_1w_max.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_price_1w_max + .compute_all(starting_indexes, exit, |v| { v.compute_max( starting_indexes.dateindex, price.timeindexes_to_price_high.dateindex.as_ref().unwrap(), @@ -2362,15 +2223,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_price_1w_min.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_price_1w_min + .compute_all(starting_indexes, exit, |v| { v.compute_min( starting_indexes.dateindex, price.timeindexes_to_price_low.dateindex.as_ref().unwrap(), @@ -2378,15 +2234,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_price_2w_max.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_price_2w_max + .compute_all(starting_indexes, exit, |v| { v.compute_max( starting_indexes.dateindex, price.timeindexes_to_price_high.dateindex.as_ref().unwrap(), @@ -2394,15 +2245,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_price_2w_min.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_price_2w_min + .compute_all(starting_indexes, exit, |v| { v.compute_min( starting_indexes.dateindex, price.timeindexes_to_price_low.dateindex.as_ref().unwrap(), @@ -2410,15 +2256,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_price_1m_max.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_price_1m_max + .compute_all(starting_indexes, exit, |v| { v.compute_max( starting_indexes.dateindex, price.timeindexes_to_price_high.dateindex.as_ref().unwrap(), @@ -2426,15 +2267,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_price_1m_min.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_price_1m_min + .compute_all(starting_indexes, exit, |v| { v.compute_min( starting_indexes.dateindex, price.timeindexes_to_price_low.dateindex.as_ref().unwrap(), @@ -2442,15 +2278,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_price_1y_max.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_price_1y_max + .compute_all(starting_indexes, exit, |v| { v.compute_max( starting_indexes.dateindex, price.timeindexes_to_price_high.dateindex.as_ref().unwrap(), @@ -2458,15 +2289,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_price_1y_min.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_price_1y_min + .compute_all(starting_indexes, exit, |v| { v.compute_min( starting_indexes.dateindex, price.timeindexes_to_price_low.dateindex.as_ref().unwrap(), @@ -2474,15 +2300,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_price_2w_choppiness_index.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_price_2w_choppiness_index + .compute_all(starting_indexes, exit, |v| { let n = 14; let log10n = (n as f32).log10(); v.compute_transform3( @@ -2501,8 +2322,7 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; Ok(()) } diff --git a/crates/brk_computer/src/pools/mod.rs b/crates/brk_computer/src/pools/mod.rs index 33cbd029d..90c37b52e 100644 --- a/crates/brk_computer/src/pools/mod.rs +++ b/crates/brk_computer/src/pools/mod.rs @@ -106,7 +106,6 @@ impl Vecs { self.vecs.par_iter_mut().try_for_each(|(_, vecs)| { vecs.compute( - indexer, indexes, starting_indexes, &self.height_to_pool, diff --git a/crates/brk_computer/src/pools/vecs.rs b/crates/brk_computer/src/pools/vecs.rs index fd003eb29..90fcdf38b 100644 --- a/crates/brk_computer/src/pools/vecs.rs +++ b/crates/brk_computer/src/pools/vecs.rs @@ -1,6 +1,5 @@ use allocative::Allocative; use brk_error::Result; -use brk_indexer::Indexer; use brk_structs::{Height, Sats, StoredF32, StoredU16, StoredU32}; use vecdb::{AnyCollectableVec, AnyIterableVec, Database, Exit, StoredIndex, VecIterator, Version}; @@ -163,7 +162,6 @@ impl Vecs { #[allow(clippy::too_many_arguments)] pub fn compute( &mut self, - indexer: &Indexer, indexes: &indexes::Vecs, starting_indexes: &Indexes, height_to_pool: &impl AnyIterableVec, @@ -171,12 +169,8 @@ impl Vecs { price: Option<&price::Vecs>, exit: &Exit, ) -> Result<()> { - self.indexes_to_blocks_mined.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { + self.indexes_to_blocks_mined + .compute_all(indexes, starting_indexes, exit, |vec| { vec.compute_transform( starting_indexes.height, height_to_pool, @@ -193,15 +187,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_1w_blocks_mined.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_1w_blocks_mined + .compute_all(starting_indexes, exit, |v| { v.compute_sum( starting_indexes.dateindex, self.indexes_to_blocks_mined.dateindex.unwrap_sum(), @@ -209,15 +198,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_1m_blocks_mined.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_1m_blocks_mined + .compute_all(starting_indexes, exit, |v| { v.compute_sum( starting_indexes.dateindex, self.indexes_to_blocks_mined.dateindex.unwrap_sum(), @@ -225,15 +209,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_1y_blocks_mined.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_1y_blocks_mined + .compute_all(starting_indexes, exit, |v| { v.compute_sum( starting_indexes.dateindex, self.indexes_to_blocks_mined.dateindex.unwrap_sum(), @@ -241,18 +220,12 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; let height_to_blocks_mined = self.indexes_to_blocks_mined.height.as_ref().unwrap(); - self.indexes_to_subsidy.compute_all( - indexer, - indexes, - price, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { + self.indexes_to_subsidy + .compute_all(indexes, price, starting_indexes, exit, |vec| { vec.compute_transform2( starting_indexes.height, height_to_blocks_mined, @@ -270,16 +243,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_fee.compute_all( - indexer, - indexes, - price, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { + self.indexes_to_fee + .compute_all(indexes, price, starting_indexes, exit, |vec| { vec.compute_transform2( starting_indexes.height, height_to_blocks_mined, @@ -297,16 +264,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_coinbase.compute_all( - indexer, - indexes, - price, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { + self.indexes_to_coinbase + .compute_all(indexes, price, starting_indexes, exit, |vec| { vec.compute_transform2( starting_indexes.height, height_to_blocks_mined, @@ -324,15 +285,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_dominance.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { + self.indexes_to_dominance + .compute_all(starting_indexes, exit, |vec| { vec.compute_percentage( starting_indexes.dateindex, self.indexes_to_blocks_mined.dateindex.unwrap_cumulative(), @@ -340,15 +296,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_1d_dominance.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { + self.indexes_to_1d_dominance + .compute_all(starting_indexes, exit, |vec| { vec.compute_percentage( starting_indexes.dateindex, self.indexes_to_blocks_mined.dateindex.unwrap_sum(), @@ -356,15 +307,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_1w_dominance.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { + self.indexes_to_1w_dominance + .compute_all(starting_indexes, exit, |vec| { vec.compute_percentage( starting_indexes.dateindex, self.indexes_to_1w_blocks_mined.dateindex.as_ref().unwrap(), @@ -372,15 +318,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_1m_dominance.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { + self.indexes_to_1m_dominance + .compute_all(starting_indexes, exit, |vec| { vec.compute_percentage( starting_indexes.dateindex, self.indexes_to_1m_blocks_mined.dateindex.as_ref().unwrap(), @@ -388,15 +329,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_1y_dominance.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { + self.indexes_to_1y_dominance + .compute_all(starting_indexes, exit, |vec| { vec.compute_percentage( starting_indexes.dateindex, self.indexes_to_1y_blocks_mined.dateindex.as_ref().unwrap(), @@ -404,15 +340,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_days_since_block.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_days_since_block + .compute_all(starting_indexes, exit, |v| { let mut prev = None; v.compute_transform2( starting_indexes.dateindex, @@ -438,8 +369,7 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; Ok(()) } diff --git a/crates/brk_computer/src/price.rs b/crates/brk_computer/src/price.rs index 54eef63b8..3cdc8af18 100644 --- a/crates/brk_computer/src/price.rs +++ b/crates/brk_computer/src/price.rs @@ -1,7 +1,6 @@ use std::path::Path; use brk_error::Result; -use brk_indexer::Indexer; use brk_structs::{ Cents, Close, DateIndex, DecadeIndex, DifficultyEpoch, Dollars, Height, High, Low, MonthIndex, OHLCDollars, OHLCSats, Open, QuarterIndex, Sats, SemesterIndex, Version, WeekIndex, YearIndex, @@ -338,20 +337,18 @@ impl Vecs { pub fn compute( &mut self, - indexer: &Indexer, indexes: &indexes::Vecs, starting_indexes: &Indexes, fetched: &fetched::Vecs, exit: &Exit, ) -> Result<()> { - self.compute_(indexer, indexes, starting_indexes, fetched, exit)?; + self.compute_(indexes, starting_indexes, fetched, exit)?; self.db.flush_then_punch()?; Ok(()) } fn compute_( &mut self, - indexer: &Indexer, indexes: &indexes::Vecs, starting_indexes: &Indexes, fetched: &fetched::Vecs, @@ -445,12 +442,8 @@ impl Vecs { })?; self.dateindex_to_price_ohlc.safe_flush(exit)?; - self.timeindexes_to_price_close.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.timeindexes_to_price_close + .compute_all(starting_indexes, exit, |v| { v.compute_transform( starting_indexes.dateindex, &self.dateindex_to_price_ohlc, @@ -458,15 +451,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.timeindexes_to_price_high.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.timeindexes_to_price_high + .compute_all(starting_indexes, exit, |v| { v.compute_transform( starting_indexes.dateindex, &self.dateindex_to_price_ohlc, @@ -474,15 +462,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.timeindexes_to_price_low.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.timeindexes_to_price_low + .compute_all(starting_indexes, exit, |v| { v.compute_transform( starting_indexes.dateindex, &self.dateindex_to_price_ohlc, @@ -490,15 +473,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.timeindexes_to_price_open.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.timeindexes_to_price_open + .compute_all(starting_indexes, exit, |v| { v.compute_transform( starting_indexes.dateindex, &self.dateindex_to_price_ohlc, @@ -506,15 +484,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.chainindexes_to_price_close.compute( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.chainindexes_to_price_close + .compute(indexes, starting_indexes, exit, |v| { v.compute_transform( starting_indexes.height, &self.height_to_price_ohlc, @@ -522,15 +495,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.chainindexes_to_price_high.compute( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.chainindexes_to_price_high + .compute(indexes, starting_indexes, exit, |v| { v.compute_transform( starting_indexes.height, &self.height_to_price_ohlc, @@ -538,15 +506,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.chainindexes_to_price_low.compute( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.chainindexes_to_price_low + .compute(indexes, starting_indexes, exit, |v| { v.compute_transform( starting_indexes.height, &self.height_to_price_ohlc, @@ -554,15 +517,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.chainindexes_to_price_open.compute( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.chainindexes_to_price_open + .compute(indexes, starting_indexes, exit, |v| { v.compute_transform( starting_indexes.height, &self.height_to_price_ohlc, @@ -570,8 +528,7 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; let mut weekindex_first_iter = self .timeindexes_to_price_open @@ -843,12 +800,8 @@ impl Vecs { })?; self.decadeindex_to_price_ohlc.safe_flush(exit)?; - self.chainindexes_to_price_open_in_sats.compute( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.chainindexes_to_price_open_in_sats + .compute(indexes, starting_indexes, exit, |v| { v.compute_transform( starting_indexes.height, &self.chainindexes_to_price_open.height, @@ -856,15 +809,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.chainindexes_to_price_high_in_sats.compute( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.chainindexes_to_price_high_in_sats + .compute(indexes, starting_indexes, exit, |v| { v.compute_transform( starting_indexes.height, &self.chainindexes_to_price_low.height, @@ -872,15 +820,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.chainindexes_to_price_low_in_sats.compute( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.chainindexes_to_price_low_in_sats + .compute(indexes, starting_indexes, exit, |v| { v.compute_transform( starting_indexes.height, &self.chainindexes_to_price_high.height, @@ -888,15 +831,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.chainindexes_to_price_close_in_sats.compute( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.chainindexes_to_price_close_in_sats + .compute(indexes, starting_indexes, exit, |v| { v.compute_transform( starting_indexes.height, &self.chainindexes_to_price_close.height, @@ -904,15 +842,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.timeindexes_to_price_open_in_sats.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.timeindexes_to_price_open_in_sats + .compute_all(starting_indexes, exit, |v| { v.compute_transform( starting_indexes.dateindex, self.timeindexes_to_price_open.dateindex.as_ref().unwrap(), @@ -920,15 +853,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.timeindexes_to_price_high_in_sats.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.timeindexes_to_price_high_in_sats + .compute_all(starting_indexes, exit, |v| { v.compute_transform( starting_indexes.dateindex, self.timeindexes_to_price_low.dateindex.as_ref().unwrap(), @@ -936,15 +864,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.timeindexes_to_price_low_in_sats.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.timeindexes_to_price_low_in_sats + .compute_all(starting_indexes, exit, |v| { v.compute_transform( starting_indexes.dateindex, self.timeindexes_to_price_high.dateindex.as_ref().unwrap(), @@ -952,15 +875,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.timeindexes_to_price_close_in_sats.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.timeindexes_to_price_close_in_sats + .compute_all(starting_indexes, exit, |v| { v.compute_transform( starting_indexes.dateindex, self.timeindexes_to_price_close.dateindex.as_ref().unwrap(), @@ -968,8 +886,7 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; 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(); diff --git a/crates/brk_computer/src/stateful/address_cohort.rs b/crates/brk_computer/src/stateful/address_cohort.rs index d5b75dcf9..cf8d3fda0 100644 --- a/crates/brk_computer/src/stateful/address_cohort.rs +++ b/crates/brk_computer/src/stateful/address_cohort.rs @@ -1,7 +1,6 @@ use std::{ops::Deref, path::Path}; use brk_error::Result; -use brk_indexer::Indexer; use brk_structs::{Bitcoin, DateIndex, Dollars, Height, StoredU64, Version}; use vecdb::{ AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit, Format, @@ -171,7 +170,6 @@ impl DynCohortVecs for Vecs { #[allow(clippy::too_many_arguments)] fn compute_rest_part1( &mut self, - indexer: &Indexer, indexes: &indexes::Vecs, price: Option<&price::Vecs>, starting_indexes: &Indexes, @@ -185,7 +183,7 @@ impl DynCohortVecs for Vecs { )?; 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> { @@ -224,7 +222,6 @@ impl CohortVecs for Vecs { #[allow(clippy::too_many_arguments)] fn compute_rest_part2( &mut self, - indexer: &Indexer, indexes: &indexes::Vecs, price: Option<&price::Vecs>, starting_indexes: &Indexes, @@ -237,7 +234,6 @@ impl CohortVecs for Vecs { exit: &Exit, ) -> Result<()> { self.inner.compute_rest_part2( - indexer, indexes, price, starting_indexes, diff --git a/crates/brk_computer/src/stateful/address_cohorts.rs b/crates/brk_computer/src/stateful/address_cohorts.rs index cc81e511d..94ba6f610 100644 --- a/crates/brk_computer/src/stateful/address_cohorts.rs +++ b/crates/brk_computer/src/stateful/address_cohorts.rs @@ -1,7 +1,6 @@ use std::path::Path; use brk_error::Result; -use brk_indexer::Indexer; use brk_structs::{ AddressGroups, Bitcoin, ByAmountRange, ByGreatEqualAmount, ByLowerThanAmount, DateIndex, Dollars, GroupFilter, Height, Version, @@ -502,21 +501,19 @@ impl Vecs { pub fn compute_rest_part1( &mut self, - indexer: &Indexer, indexes: &indexes::Vecs, price: Option<&price::Vecs>, starting_indexes: &Indexes, exit: &Exit, ) -> Result<()> { - self.as_mut_vecs().into_iter().try_for_each(|(_, v)| { - v.compute_rest_part1(indexer, indexes, price, starting_indexes, exit) - }) + self.as_mut_vecs() + .into_iter() + .try_for_each(|(_, v)| v.compute_rest_part1(indexes, price, starting_indexes, exit)) } #[allow(clippy::too_many_arguments)] pub fn compute_rest_part2( &mut self, - indexer: &Indexer, indexes: &indexes::Vecs, price: Option<&price::Vecs>, starting_indexes: &Indexes, @@ -531,7 +528,6 @@ impl Vecs { self.0.as_boxed_mut_vecs().into_iter().try_for_each(|v| { v.into_iter().try_for_each(|(_, v)| { v.compute_rest_part2( - indexer, indexes, price, starting_indexes, diff --git a/crates/brk_computer/src/stateful/common.rs b/crates/brk_computer/src/stateful/common.rs index 5b4b45fea..aa57dbdf4 100644 --- a/crates/brk_computer/src/stateful/common.rs +++ b/crates/brk_computer/src/stateful/common.rs @@ -1,5 +1,4 @@ use brk_error::{Error, Result}; -use brk_indexer::Indexer; use brk_structs::{ Bitcoin, DateIndex, Dollars, Height, Sats, StoredF32, StoredF64, StoredU64, Version, }; @@ -2255,7 +2254,6 @@ impl Vecs { #[allow(clippy::too_many_arguments)] pub fn compute_rest_part1( &mut self, - indexer: &Indexer, indexes: &indexes::Vecs, price: Option<&price::Vecs>, starting_indexes: &Indexes, @@ -2268,13 +2266,8 @@ impl Vecs { Some(&self.height_to_supply), )?; - self.indexes_to_supply.compute_all( - indexer, - indexes, - price, - starting_indexes, - exit, - |v, _, indexes, starting_indexes, exit| { + self.indexes_to_supply + .compute_all(price, starting_indexes, exit, |v| { let mut dateindex_to_height_count_iter = indexes.dateindex_to_height_count.into_iter(); let mut height_to_supply_iter = self.height_to_supply.into_iter(); @@ -2292,8 +2285,7 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; self.indexes_to_utxo_count.compute_rest( indexes, @@ -2302,13 +2294,8 @@ impl Vecs { Some(&self.height_to_utxo_count), )?; - self.height_to_supply_half_value.compute_all( - indexer, - indexes, - price, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.height_to_supply_half_value + .compute_all(price, starting_indexes, exit, |v| { v.compute_transform( starting_indexes.height, &self.height_to_supply, @@ -2316,16 +2303,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_supply_half.compute_all( - indexer, - indexes, - price, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_supply_half + .compute_all(price, starting_indexes, exit, |v| { v.compute_transform( starting_indexes.dateindex, self.indexes_to_supply.sats.dateindex.as_ref().unwrap(), @@ -2333,15 +2314,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_coinblocks_destroyed.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_coinblocks_destroyed + .compute_all(indexes, starting_indexes, exit, |v| { v.compute_transform( starting_indexes.height, &self.height_to_satblocks_destroyed, @@ -2349,15 +2325,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_coindays_destroyed.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_coindays_destroyed + .compute_all(indexes, starting_indexes, exit, |v| { v.compute_transform( starting_indexes.height, &self.height_to_satdays_destroyed, @@ -2365,8 +2336,7 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; Ok(()) } @@ -2374,7 +2344,6 @@ impl Vecs { #[allow(clippy::too_many_arguments)] pub fn compute_rest_part2( &mut self, - indexer: &Indexer, indexes: &indexes::Vecs, price: Option<&price::Vecs>, starting_indexes: &Indexes, @@ -2387,21 +2356,15 @@ impl Vecs { exit: &Exit, ) -> Result<()> { if let Some(v) = self.indexes_to_supply_rel_to_circulating_supply.as_mut() { - v.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_percentage( - starting_indexes.height, - &self.height_to_supply_value.bitcoin, - height_to_supply, - exit, - )?; - Ok(()) - }, - )?; + v.compute_all(indexes, starting_indexes, exit, |v| { + v.compute_percentage( + starting_indexes.height, + &self.height_to_supply_value.bitcoin, + height_to_supply, + exit, + )?; + Ok(()) + })?; } if let Some(indexes_to_realized_cap) = self.indexes_to_realized_cap.as_mut() { @@ -2418,28 +2381,20 @@ impl Vecs { self.indexes_to_realized_price .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_divide( - starting_indexes.height, - self.height_to_realized_cap.as_ref().unwrap(), - &self.height_to_supply_value.bitcoin, - exit, - )?; - Ok(()) - }, - )?; + .compute_all(indexes, starting_indexes, exit, |vec| { + vec.compute_divide( + starting_indexes.height, + self.height_to_realized_cap.as_ref().unwrap(), + &self.height_to_supply_value.bitcoin, + exit, + )?; + Ok(()) + })?; self.indexes_to_realized_price_extra .as_mut() .unwrap() .compute_rest( - indexer, - indexes, price.as_ref().unwrap(), starting_indexes, exit, @@ -2475,21 +2430,15 @@ impl Vecs { self.indexes_to_neg_realized_loss .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_transform( - starting_indexes.height, - self.height_to_realized_loss.as_ref().unwrap(), - |(i, v, ..)| (i, v * -1_i64), - exit, - )?; - Ok(()) - }, - )?; + .compute_all(indexes, starting_indexes, exit, |vec| { + vec.compute_transform( + starting_indexes.height, + self.height_to_realized_loss.as_ref().unwrap(), + |(i, v, ..)| (i, v * -1_i64), + exit, + )?; + Ok(()) + })?; self.indexes_to_value_created .as_mut() @@ -2514,63 +2463,45 @@ impl Vecs { self.indexes_to_realized_cap_30d_delta .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_change( - starting_indexes.dateindex, - self.indexes_to_realized_cap - .as_ref() - .unwrap() - .dateindex - .unwrap_last(), - 30, - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |vec| { + vec.compute_change( + starting_indexes.dateindex, + self.indexes_to_realized_cap + .as_ref() + .unwrap() + .dateindex + .unwrap_last(), + 30, + exit, + )?; + Ok(()) + })?; self.indexes_to_net_realized_pnl .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_subtract( - starting_indexes.height, - self.height_to_realized_profit.as_ref().unwrap(), - self.height_to_realized_loss.as_ref().unwrap(), - exit, - )?; - Ok(()) - }, - )?; + .compute_all(indexes, starting_indexes, exit, |vec| { + vec.compute_subtract( + starting_indexes.height, + self.height_to_realized_profit.as_ref().unwrap(), + self.height_to_realized_loss.as_ref().unwrap(), + exit, + )?; + Ok(()) + })?; self.indexes_to_realized_value .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_add( - starting_indexes.height, - self.height_to_realized_profit.as_ref().unwrap(), - self.height_to_realized_loss.as_ref().unwrap(), - exit, - )?; - Ok(()) - }, - )?; + .compute_all(indexes, starting_indexes, exit, |vec| { + vec.compute_add( + starting_indexes.height, + self.height_to_realized_profit.as_ref().unwrap(), + self.height_to_realized_loss.as_ref().unwrap(), + exit, + )?; + Ok(()) + })?; self.dateindex_to_sopr.as_mut().unwrap().compute_divide( starting_indexes.dateindex, @@ -2649,8 +2580,6 @@ impl Vecs { .as_mut() .unwrap() .compute_rest( - indexer, - indexes, price, starting_indexes, exit, @@ -2660,8 +2589,6 @@ impl Vecs { .as_mut() .unwrap() .compute_rest( - indexer, - indexes, price, starting_indexes, exit, @@ -2671,8 +2598,6 @@ impl Vecs { .as_mut() .unwrap() .compute_rest( - indexer, - indexes, price, starting_indexes, exit, @@ -2706,21 +2631,15 @@ impl Vecs { self.indexes_to_total_unrealized_pnl .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_add( - starting_indexes.dateindex, - self.dateindex_to_unrealized_profit.as_ref().unwrap(), - self.dateindex_to_unrealized_loss.as_ref().unwrap(), - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |vec| { + vec.compute_add( + starting_indexes.dateindex, + self.dateindex_to_unrealized_profit.as_ref().unwrap(), + self.dateindex_to_unrealized_loss.as_ref().unwrap(), + exit, + )?; + Ok(()) + })?; self.height_to_total_realized_pnl .as_mut() .unwrap() @@ -2733,29 +2652,23 @@ impl Vecs { self.indexes_to_total_realized_pnl .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_add( - starting_indexes.dateindex, - self.indexes_to_realized_profit - .as_ref() - .unwrap() - .dateindex - .unwrap_sum(), - self.indexes_to_realized_loss - .as_ref() - .unwrap() - .dateindex - .unwrap_sum(), - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |vec| { + vec.compute_add( + starting_indexes.dateindex, + self.indexes_to_realized_profit + .as_ref() + .unwrap() + .dateindex + .unwrap_sum(), + self.indexes_to_realized_loss + .as_ref() + .unwrap() + .dateindex + .unwrap_sum(), + exit, + )?; + Ok(()) + })?; self.indexes_to_min_price_paid .as_mut() @@ -2788,21 +2701,15 @@ impl Vecs { self.indexes_to_neg_unrealized_loss .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_transform( - starting_indexes.dateindex, - self.dateindex_to_unrealized_loss.as_ref().unwrap(), - |(h, v, ..)| (h, v * -1_i64), - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |v| { + v.compute_transform( + starting_indexes.dateindex, + self.dateindex_to_unrealized_loss.as_ref().unwrap(), + |(h, v, ..)| (h, v * -1_i64), + exit, + )?; + Ok(()) + })?; self.height_to_net_unrealized_pnl .as_mut() .unwrap() @@ -2816,21 +2723,15 @@ impl Vecs { self.indexes_to_net_unrealized_pnl .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_subtract( - starting_indexes.dateindex, - self.dateindex_to_unrealized_profit.as_ref().unwrap(), - self.dateindex_to_unrealized_loss.as_ref().unwrap(), - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |vec| { + vec.compute_subtract( + starting_indexes.dateindex, + self.dateindex_to_unrealized_profit.as_ref().unwrap(), + self.dateindex_to_unrealized_loss.as_ref().unwrap(), + exit, + )?; + Ok(()) + })?; self.height_to_unrealized_profit_rel_to_market_cap .as_mut() .unwrap() @@ -2870,85 +2771,61 @@ impl Vecs { self.indexes_to_unrealized_profit_rel_to_market_cap .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_percentage( - starting_indexes.dateindex, - self.dateindex_to_unrealized_profit.as_ref().unwrap(), - dateindex_to_market_cap, - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |vec| { + vec.compute_percentage( + starting_indexes.dateindex, + self.dateindex_to_unrealized_profit.as_ref().unwrap(), + dateindex_to_market_cap, + exit, + )?; + Ok(()) + })?; self.indexes_to_unrealized_loss_rel_to_market_cap .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_percentage( - starting_indexes.dateindex, - self.dateindex_to_unrealized_loss.as_ref().unwrap(), - dateindex_to_market_cap, - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |vec| { + vec.compute_percentage( + starting_indexes.dateindex, + self.dateindex_to_unrealized_loss.as_ref().unwrap(), + dateindex_to_market_cap, + exit, + )?; + Ok(()) + })?; self.indexes_to_neg_unrealized_loss_rel_to_market_cap .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_percentage( - starting_indexes.dateindex, - self.indexes_to_neg_unrealized_loss - .as_ref() - .unwrap() - .dateindex - .as_ref() - .unwrap(), - dateindex_to_market_cap, - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |vec| { + vec.compute_percentage( + starting_indexes.dateindex, + self.indexes_to_neg_unrealized_loss + .as_ref() + .unwrap() + .dateindex + .as_ref() + .unwrap(), + dateindex_to_market_cap, + exit, + )?; + Ok(()) + })?; self.indexes_to_net_unrealized_pnl_rel_to_market_cap .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_percentage( - starting_indexes.dateindex, - self.indexes_to_net_unrealized_pnl - .as_ref() - .unwrap() - .dateindex - .as_ref() - .unwrap(), - dateindex_to_market_cap, - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |vec| { + vec.compute_percentage( + starting_indexes.dateindex, + self.indexes_to_net_unrealized_pnl + .as_ref() + .unwrap() + .dateindex + .as_ref() + .unwrap(), + dateindex_to_market_cap, + exit, + )?; + Ok(()) + })?; if self .height_to_unrealized_profit_rel_to_own_market_cap @@ -2993,109 +2870,85 @@ impl Vecs { self.indexes_to_unrealized_profit_rel_to_own_market_cap .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_percentage( - starting_indexes.dateindex, - self.dateindex_to_unrealized_profit.as_ref().unwrap(), - self.indexes_to_supply - .dollars - .as_ref() - .unwrap() - .dateindex - .as_ref() - .unwrap(), - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |vec| { + vec.compute_percentage( + starting_indexes.dateindex, + self.dateindex_to_unrealized_profit.as_ref().unwrap(), + self.indexes_to_supply + .dollars + .as_ref() + .unwrap() + .dateindex + .as_ref() + .unwrap(), + exit, + )?; + Ok(()) + })?; self.indexes_to_unrealized_loss_rel_to_own_market_cap .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_percentage( - starting_indexes.dateindex, - self.dateindex_to_unrealized_loss.as_ref().unwrap(), - self.indexes_to_supply - .dollars - .as_ref() - .unwrap() - .dateindex - .as_ref() - .unwrap(), - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |vec| { + vec.compute_percentage( + starting_indexes.dateindex, + self.dateindex_to_unrealized_loss.as_ref().unwrap(), + self.indexes_to_supply + .dollars + .as_ref() + .unwrap() + .dateindex + .as_ref() + .unwrap(), + exit, + )?; + Ok(()) + })?; self.indexes_to_neg_unrealized_loss_rel_to_own_market_cap .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_percentage( - starting_indexes.dateindex, - self.indexes_to_neg_unrealized_loss - .as_ref() - .unwrap() - .dateindex - .as_ref() - .unwrap(), - self.indexes_to_supply - .dollars - .as_ref() - .unwrap() - .dateindex - .as_ref() - .unwrap(), - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |vec| { + vec.compute_percentage( + starting_indexes.dateindex, + self.indexes_to_neg_unrealized_loss + .as_ref() + .unwrap() + .dateindex + .as_ref() + .unwrap(), + self.indexes_to_supply + .dollars + .as_ref() + .unwrap() + .dateindex + .as_ref() + .unwrap(), + exit, + )?; + Ok(()) + })?; self.indexes_to_net_unrealized_pnl_rel_to_own_market_cap .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_percentage( - starting_indexes.dateindex, - self.indexes_to_net_unrealized_pnl - .as_ref() - .unwrap() - .dateindex - .as_ref() - .unwrap(), - self.indexes_to_supply - .dollars - .as_ref() - .unwrap() - .dateindex - .as_ref() - .unwrap(), - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |vec| { + vec.compute_percentage( + starting_indexes.dateindex, + self.indexes_to_net_unrealized_pnl + .as_ref() + .unwrap() + .dateindex + .as_ref() + .unwrap(), + self.indexes_to_supply + .dollars + .as_ref() + .unwrap() + .dateindex + .as_ref() + .unwrap(), + exit, + )?; + Ok(()) + })?; } if self @@ -3141,168 +2994,126 @@ impl Vecs { self.indexes_to_unrealized_profit_rel_to_own_total_unrealized_pnl .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_percentage( - starting_indexes.dateindex, - self.dateindex_to_unrealized_profit.as_ref().unwrap(), - self.indexes_to_total_unrealized_pnl - .as_ref() - .unwrap() - .dateindex - .as_ref() - .unwrap(), - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |vec| { + vec.compute_percentage( + starting_indexes.dateindex, + self.dateindex_to_unrealized_profit.as_ref().unwrap(), + self.indexes_to_total_unrealized_pnl + .as_ref() + .unwrap() + .dateindex + .as_ref() + .unwrap(), + exit, + )?; + Ok(()) + })?; self.indexes_to_unrealized_loss_rel_to_own_total_unrealized_pnl .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_percentage( - starting_indexes.dateindex, - self.dateindex_to_unrealized_loss.as_ref().unwrap(), - self.indexes_to_total_unrealized_pnl - .as_ref() - .unwrap() - .dateindex - .as_ref() - .unwrap(), - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |vec| { + vec.compute_percentage( + starting_indexes.dateindex, + self.dateindex_to_unrealized_loss.as_ref().unwrap(), + self.indexes_to_total_unrealized_pnl + .as_ref() + .unwrap() + .dateindex + .as_ref() + .unwrap(), + exit, + )?; + Ok(()) + })?; self.indexes_to_neg_unrealized_loss_rel_to_own_total_unrealized_pnl .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_percentage( - starting_indexes.dateindex, - self.indexes_to_neg_unrealized_loss - .as_ref() - .unwrap() - .dateindex - .as_ref() - .unwrap(), - self.indexes_to_total_unrealized_pnl - .as_ref() - .unwrap() - .dateindex - .as_ref() - .unwrap(), - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |vec| { + vec.compute_percentage( + starting_indexes.dateindex, + self.indexes_to_neg_unrealized_loss + .as_ref() + .unwrap() + .dateindex + .as_ref() + .unwrap(), + self.indexes_to_total_unrealized_pnl + .as_ref() + .unwrap() + .dateindex + .as_ref() + .unwrap(), + exit, + )?; + Ok(()) + })?; self.indexes_to_net_unrealized_pnl_rel_to_own_total_unrealized_pnl .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_percentage( - starting_indexes.dateindex, - self.indexes_to_net_unrealized_pnl - .as_ref() - .unwrap() - .dateindex - .as_ref() - .unwrap(), - self.indexes_to_total_unrealized_pnl - .as_ref() - .unwrap() - .dateindex - .as_ref() - .unwrap(), - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |vec| { + vec.compute_percentage( + starting_indexes.dateindex, + self.indexes_to_net_unrealized_pnl + .as_ref() + .unwrap() + .dateindex + .as_ref() + .unwrap(), + self.indexes_to_total_unrealized_pnl + .as_ref() + .unwrap() + .dateindex + .as_ref() + .unwrap(), + exit, + )?; + Ok(()) + })?; } self.indexes_to_realized_profit_rel_to_realized_cap .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_percentage( - starting_indexes.height, - self.height_to_realized_profit.as_ref().unwrap(), - *height_to_realized_cap.as_ref().unwrap(), - exit, - )?; - Ok(()) - }, - )?; + .compute_all(indexes, starting_indexes, exit, |vec| { + vec.compute_percentage( + starting_indexes.height, + self.height_to_realized_profit.as_ref().unwrap(), + *height_to_realized_cap.as_ref().unwrap(), + exit, + )?; + Ok(()) + })?; self.indexes_to_realized_loss_rel_to_realized_cap .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_percentage( - starting_indexes.height, - self.height_to_realized_loss.as_ref().unwrap(), - *height_to_realized_cap.as_ref().unwrap(), - exit, - )?; - Ok(()) - }, - )?; + .compute_all(indexes, starting_indexes, exit, |vec| { + vec.compute_percentage( + starting_indexes.height, + self.height_to_realized_loss.as_ref().unwrap(), + *height_to_realized_cap.as_ref().unwrap(), + exit, + )?; + Ok(()) + })?; self.indexes_to_net_realized_pnl_rel_to_realized_cap .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |vec, _, _, starting_indexes, exit| { - vec.compute_percentage( - starting_indexes.height, - self.indexes_to_net_realized_pnl - .as_ref() - .unwrap() - .height - .as_ref() - .unwrap(), - *height_to_realized_cap.as_ref().unwrap(), - exit, - )?; - Ok(()) - }, - )?; + .compute_all(indexes, starting_indexes, exit, |vec| { + vec.compute_percentage( + starting_indexes.height, + self.indexes_to_net_realized_pnl + .as_ref() + .unwrap() + .height + .as_ref() + .unwrap(), + *height_to_realized_cap.as_ref().unwrap(), + exit, + )?; + Ok(()) + })?; self.height_to_supply_breakeven_value .as_mut() @@ -3373,146 +3184,110 @@ impl Vecs { self.indexes_to_supply_breakeven_rel_to_own_supply .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_percentage( - starting_indexes.dateindex, - self.indexes_to_supply_breakeven - .as_ref() - .unwrap() - .bitcoin - .dateindex - .as_ref() - .unwrap(), - self.indexes_to_supply.bitcoin.dateindex.as_ref().unwrap(), - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |v| { + v.compute_percentage( + starting_indexes.dateindex, + self.indexes_to_supply_breakeven + .as_ref() + .unwrap() + .bitcoin + .dateindex + .as_ref() + .unwrap(), + self.indexes_to_supply.bitcoin.dateindex.as_ref().unwrap(), + exit, + )?; + Ok(()) + })?; self.indexes_to_supply_in_loss_rel_to_own_supply .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_percentage( - starting_indexes.dateindex, - self.indexes_to_supply_in_loss - .as_ref() - .unwrap() - .bitcoin - .dateindex - .as_ref() - .unwrap(), - self.indexes_to_supply.bitcoin.dateindex.as_ref().unwrap(), - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |v| { + v.compute_percentage( + starting_indexes.dateindex, + self.indexes_to_supply_in_loss + .as_ref() + .unwrap() + .bitcoin + .dateindex + .as_ref() + .unwrap(), + self.indexes_to_supply.bitcoin.dateindex.as_ref().unwrap(), + exit, + )?; + Ok(()) + })?; self.indexes_to_supply_in_profit_rel_to_own_supply .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_percentage( - starting_indexes.dateindex, - self.indexes_to_supply_in_profit - .as_ref() - .unwrap() - .bitcoin - .dateindex - .as_ref() - .unwrap(), - self.indexes_to_supply.bitcoin.dateindex.as_ref().unwrap(), - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |v| { + v.compute_percentage( + starting_indexes.dateindex, + self.indexes_to_supply_in_profit + .as_ref() + .unwrap() + .bitcoin + .dateindex + .as_ref() + .unwrap(), + self.indexes_to_supply.bitcoin.dateindex.as_ref().unwrap(), + exit, + )?; + Ok(()) + })?; self.indexes_to_net_realized_pnl_cumulative_30d_delta .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_change( - starting_indexes.dateindex, - self.indexes_to_net_realized_pnl - .as_ref() - .unwrap() - .dateindex - .unwrap_cumulative(), - 30, - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |v| { + v.compute_change( + starting_indexes.dateindex, + self.indexes_to_net_realized_pnl + .as_ref() + .unwrap() + .dateindex + .unwrap_cumulative(), + 30, + exit, + )?; + Ok(()) + })?; self.indexes_to_net_realized_pnl_cumulative_30d_delta_rel_to_realized_cap .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_percentage( - starting_indexes.dateindex, - self.indexes_to_net_realized_pnl_cumulative_30d_delta - .as_ref() - .unwrap() - .dateindex - .as_ref() - .unwrap(), - *dateindex_to_realized_cap.as_ref().unwrap(), - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |v| { + v.compute_percentage( + starting_indexes.dateindex, + self.indexes_to_net_realized_pnl_cumulative_30d_delta + .as_ref() + .unwrap() + .dateindex + .as_ref() + .unwrap(), + *dateindex_to_realized_cap.as_ref().unwrap(), + exit, + )?; + Ok(()) + })?; self.indexes_to_net_realized_pnl_cumulative_30d_delta_rel_to_market_cap .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_percentage( - starting_indexes.dateindex, - self.indexes_to_net_realized_pnl_cumulative_30d_delta - .as_ref() - .unwrap() - .dateindex - .as_ref() - .unwrap(), - dateindex_to_market_cap, - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |v| { + v.compute_percentage( + starting_indexes.dateindex, + self.indexes_to_net_realized_pnl_cumulative_30d_delta + .as_ref() + .unwrap() + .dateindex + .as_ref() + .unwrap(), + dateindex_to_market_cap, + exit, + )?; + Ok(()) + })?; if let Some(height_to_supply_breakeven_rel_to_circulating_supply) = self .height_to_supply_breakeven_rel_to_circulating_supply @@ -3557,75 +3332,57 @@ impl Vecs { self.indexes_to_supply_breakeven_rel_to_circulating_supply .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_percentage( - starting_indexes.dateindex, - self.indexes_to_supply_breakeven - .as_ref() - .unwrap() - .bitcoin - .dateindex - .as_ref() - .unwrap(), - dateindex_to_supply, - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |v| { + v.compute_percentage( + starting_indexes.dateindex, + self.indexes_to_supply_breakeven + .as_ref() + .unwrap() + .bitcoin + .dateindex + .as_ref() + .unwrap(), + dateindex_to_supply, + exit, + )?; + Ok(()) + })?; self.indexes_to_supply_in_loss_rel_to_circulating_supply .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_percentage( - starting_indexes.dateindex, - self.indexes_to_supply_in_loss - .as_ref() - .unwrap() - .bitcoin - .dateindex - .as_ref() - .unwrap(), - dateindex_to_supply, - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |v| { + v.compute_percentage( + starting_indexes.dateindex, + self.indexes_to_supply_in_loss + .as_ref() + .unwrap() + .bitcoin + .dateindex + .as_ref() + .unwrap(), + dateindex_to_supply, + exit, + )?; + Ok(()) + })?; self.indexes_to_supply_in_profit_rel_to_circulating_supply .as_mut() .unwrap() - .compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_percentage( - starting_indexes.dateindex, - self.indexes_to_supply_in_profit - .as_ref() - .unwrap() - .bitcoin - .dateindex - .as_ref() - .unwrap(), - dateindex_to_supply, - exit, - )?; - Ok(()) - }, - )?; + .compute_all(starting_indexes, exit, |v| { + v.compute_percentage( + starting_indexes.dateindex, + self.indexes_to_supply_in_profit + .as_ref() + .unwrap() + .bitcoin + .dateindex + .as_ref() + .unwrap(), + dateindex_to_supply, + exit, + )?; + Ok(()) + })?; } if self.indexes_to_adjusted_value_created.is_some() { @@ -3692,11 +3449,10 @@ impl Vecs { self.indexes_to_realized_cap_rel_to_own_market_cap.as_mut() { indexes_to_realized_cap_rel_to_own_market_cap.compute_all( - indexer, indexes, starting_indexes, exit, - |v, _, _, starting_indexes, exit| { + |v| { v.compute_percentage( starting_indexes.height, self.height_to_realized_cap.as_ref().unwrap(), diff --git a/crates/brk_computer/src/stateful/mod.rs b/crates/brk_computer/src/stateful/mod.rs index bca4b221e..d489ede98 100644 --- a/crates/brk_computer/src/stateful/mod.rs +++ b/crates/brk_computer/src/stateful/mod.rs @@ -1309,12 +1309,8 @@ impl Vecs { info!("Computing rest part 1..."); - self.indexes_to_addr_count.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_addr_count + .compute_all(indexes, starting_indexes, exit, |v| { v.compute_sum_of_others( starting_indexes.height, &self @@ -1326,15 +1322,10 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; - self.indexes_to_empty_addr_count.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { + self.indexes_to_empty_addr_count + .compute_all(indexes, starting_indexes, exit, |v| { v.compute_sum_of_others( starting_indexes.height, &self @@ -1346,11 +1337,9 @@ impl Vecs { exit, )?; Ok(()) - }, - )?; + })?; self.indexes_to_unspendable_supply.compute_rest( - indexer, indexes, price, starting_indexes, @@ -1358,7 +1347,6 @@ impl Vecs { Some(&self.height_to_unspendable_supply), )?; self.indexes_to_opreturn_supply.compute_rest( - indexer, indexes, price, starting_indexes, @@ -1381,36 +1369,30 @@ impl Vecs { )?; self.utxo_cohorts - .compute_rest_part1(indexer, indexes, price, starting_indexes, exit)?; + .compute_rest_part1(indexes, price, starting_indexes, exit)?; 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() { - indexes_to_market_cap.compute_all( - indexer, - indexes, - starting_indexes, - exit, - |v, _, _, starting_indexes, exit| { - v.compute_transform( - starting_indexes.dateindex, - self.utxo_cohorts - .all - .1 - .indexes_to_supply - .dollars - .as_ref() - .unwrap() - .dateindex - .as_ref() - .unwrap(), - |(i, v, ..)| (i, v), - exit, - )?; - Ok(()) - }, - )?; + indexes_to_market_cap.compute_all(starting_indexes, exit, |v| { + v.compute_transform( + starting_indexes.dateindex, + self.utxo_cohorts + .all + .1 + .indexes_to_supply + .dollars + .as_ref() + .unwrap() + .dateindex + .as_ref() + .unwrap(), + |(i, v, ..)| (i, v), + exit, + )?; + Ok(()) + })?; } info!("Computing rest part 2..."); @@ -1450,7 +1432,6 @@ impl Vecs { let dateindex_to_realized_cap_ref = dateindex_to_realized_cap.as_ref(); self.utxo_cohorts.compute_rest_part2( - indexer, indexes, price, starting_indexes, @@ -1464,7 +1445,6 @@ impl Vecs { )?; self.address_cohorts.compute_rest_part2( - indexer, indexes, price, starting_indexes, diff --git a/crates/brk_computer/src/stateful/trait.rs b/crates/brk_computer/src/stateful/trait.rs index 53404da15..5de507780 100644 --- a/crates/brk_computer/src/stateful/trait.rs +++ b/crates/brk_computer/src/stateful/trait.rs @@ -1,5 +1,4 @@ use brk_error::Result; -use brk_indexer::Indexer; use brk_structs::{Bitcoin, DateIndex, Dollars, Height, Version}; use vecdb::{AnyCollectableVec, AnyIterableVec, Exit}; @@ -29,7 +28,6 @@ pub trait DynCohortVecs: Send + Sync { #[allow(clippy::too_many_arguments)] fn compute_rest_part1( &mut self, - indexer: &Indexer, indexes: &indexes::Vecs, price: Option<&price::Vecs>, starting_indexes: &Indexes, @@ -50,7 +48,6 @@ pub trait CohortVecs: DynCohortVecs { #[allow(clippy::too_many_arguments)] fn compute_rest_part2( &mut self, - indexer: &Indexer, indexes: &indexes::Vecs, price: Option<&price::Vecs>, starting_indexes: &Indexes, diff --git a/crates/brk_computer/src/stateful/utxo_cohort.rs b/crates/brk_computer/src/stateful/utxo_cohort.rs index f49e879f5..204dd66a2 100644 --- a/crates/brk_computer/src/stateful/utxo_cohort.rs +++ b/crates/brk_computer/src/stateful/utxo_cohort.rs @@ -1,7 +1,6 @@ use std::{ops::Deref, path::Path}; use brk_error::Result; -use brk_indexer::Indexer; use brk_structs::{Bitcoin, DateIndex, Dollars, Height, Version}; use vecdb::{AnyCollectableVec, AnyIterableVec, Database, Exit, Format}; @@ -122,14 +121,13 @@ impl DynCohortVecs for Vecs { #[allow(clippy::too_many_arguments)] fn compute_rest_part1( &mut self, - indexer: &Indexer, indexes: &indexes::Vecs, price: Option<&price::Vecs>, starting_indexes: &Indexes, exit: &Exit, ) -> Result<()> { 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> { @@ -154,7 +152,6 @@ impl CohortVecs for Vecs { #[allow(clippy::too_many_arguments)] fn compute_rest_part2( &mut self, - indexer: &Indexer, indexes: &indexes::Vecs, price: Option<&price::Vecs>, starting_indexes: &Indexes, @@ -167,7 +164,6 @@ impl CohortVecs for Vecs { exit: &Exit, ) -> Result<()> { self.inner.compute_rest_part2( - indexer, indexes, price, starting_indexes, diff --git a/crates/brk_computer/src/stateful/utxo_cohorts.rs b/crates/brk_computer/src/stateful/utxo_cohorts.rs index d6c2c1e43..0eb453d2f 100644 --- a/crates/brk_computer/src/stateful/utxo_cohorts.rs +++ b/crates/brk_computer/src/stateful/utxo_cohorts.rs @@ -1,7 +1,6 @@ use std::{collections::BTreeMap, ops::ControlFlow, path::Path}; use brk_error::Result; -use brk_indexer::Indexer; use brk_structs::{ Bitcoin, ByAgeRange, ByAmountRange, ByEpoch, ByGreatEqualAmount, ByLowerThanAmount, ByMaxAge, ByMinAge, BySpendableType, ByTerm, CheckedSub, DateIndex, Dollars, GroupFilter, HalvingEpoch, @@ -1736,21 +1735,19 @@ impl Vecs { pub fn compute_rest_part1( &mut self, - indexer: &Indexer, indexes: &indexes::Vecs, price: Option<&price::Vecs>, starting_indexes: &Indexes, exit: &Exit, ) -> Result<()> { - self.as_mut_vecs().into_iter().try_for_each(|(_, v)| { - v.compute_rest_part1(indexer, indexes, price, starting_indexes, exit) - }) + self.as_mut_vecs() + .into_iter() + .try_for_each(|(_, v)| v.compute_rest_part1(indexes, price, starting_indexes, exit)) } #[allow(clippy::too_many_arguments)] pub fn compute_rest_part2( &mut self, - indexer: &Indexer, indexes: &indexes::Vecs, price: Option<&price::Vecs>, starting_indexes: &Indexes, @@ -1765,7 +1762,6 @@ impl Vecs { self.0.as_boxed_mut_vecs().into_iter().try_for_each(|v| { v.into_iter().try_for_each(|(_, v)| { v.compute_rest_part2( - indexer, indexes, price, starting_indexes,