Mirror/brk
1
0
Fork 0
mirror of https://github.com/bitcoinresearchkit/brk.git synced 2026-06-22 12:23:04 -07:00
Code Issues Packages Projects Releases Wiki Activity

computer: big refactor

Browse Source
This commit is contained in:
nym21
2025-12-03 19:33:08 +01:00
parent fcc74ba212
commit d27cc02e8c
34 changed files with 2343 additions and 7340 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/brk_computer/src/grouped/builder_eager.rs
+42 -143
View File
@@ -6,7 +6,7 @@ use vecdb::{
PcoVec, VecIndex, VecValue,
};
use crate::utils::get_percentile;
use crate::utils::{get_percentile, OptionExt};
use super::ComputedVecValue;
@@ -44,135 +44,34 @@ where
options: VecBuilderOptions,
) -> Result<Self> {
let only_one_active = options.is_only_one_active();
let suffix = |s: &str| format!("{name}_{s}");
let maybe_suffix = |s: &str| if only_one_active { name.to_string() } else { suffix(s) };
let v = version + VERSION;
let maybe_suffix = |s: &str| {
if only_one_active {
name.to_string()
} else {
suffix(s)
}
};
macro_rules! import {
($s:expr) => { Box::new(EagerVec::forced_import(db, &maybe_suffix($s), v).unwrap()) };
}
let s = Self {
first: options.first.then(|| {
Box::new(
EagerVec::forced_import(
db,
&maybe_suffix("first"),
version + VERSION + Version::ZERO,
)
.unwrap(),
)
}),
last: options.last.then(|| {
Box::new(EagerVec::forced_import(db, name, version + Version::ZERO).unwrap())
}),
min: options.min.then(|| {
Box::new(
EagerVec::forced_import(
db,
&maybe_suffix("min"),
version + VERSION + Version::ZERO,
)
.unwrap(),
)
}),
max: options.max.then(|| {
Box::new(
EagerVec::forced_import(
db,
&maybe_suffix("max"),
version + VERSION + Version::ZERO,
)
.unwrap(),
)
}),
median: options.median.then(|| {
Box::new(
EagerVec::forced_import(
db,
&maybe_suffix("median"),
version + VERSION + Version::ZERO,
)
.unwrap(),
)
}),
average: options.average.then(|| {
Box::new(
EagerVec::forced_import(
db,
&maybe_suffix("avg"),
version + VERSION + Version::ZERO,
)
.unwrap(),
)
}),
first: options.first.then(|| import!("first")),
last: options.last.then(|| Box::new(EagerVec::forced_import(db, name, v).unwrap())),
min: options.min.then(|| import!("min")),
max: options.max.then(|| import!("max")),
median: options.median.then(|| import!("median")),
average: options.average.then(|| import!("avg")),
sum: options.sum.then(|| {
Box::new(
EagerVec::forced_import(
db,
&(if !options.last && !options.average && !options.min && !options.max {
name.to_string()
} else {
maybe_suffix("sum")
}),
version + VERSION + Version::ZERO,
)
.unwrap(),
)
}),
cumulative: options.cumulative.then(|| {
Box::new(
EagerVec::forced_import(
db,
&suffix("cumulative"),
version + VERSION + Version::ZERO,
)
.unwrap(),
)
}),
pct90: options.pct90.then(|| {
Box::new(
EagerVec::forced_import(
db,
&maybe_suffix("pct90"),
version + VERSION + Version::ZERO,
)
.unwrap(),
)
}),
pct75: options.pct75.then(|| {
Box::new(
EagerVec::forced_import(
db,
&maybe_suffix("pct75"),
version + VERSION + Version::ZERO,
)
.unwrap(),
)
}),
pct25: options.pct25.then(|| {
Box::new(
EagerVec::forced_import(
db,
&maybe_suffix("pct25"),
version + VERSION + Version::ZERO,
)
.unwrap(),
)
}),
pct10: options.pct10.then(|| {
Box::new(
EagerVec::forced_import(
db,
&maybe_suffix("pct10"),
version + VERSION + Version::ZERO,
)
.unwrap(),
)
let sum_name = if !options.last && !options.average && !options.min && !options.max {
name.to_string()
} else {
maybe_suffix("sum")
};
Box::new(EagerVec::forced_import(db, &sum_name, v).unwrap())
}),
cumulative: options.cumulative.then(|| Box::new(EagerVec::forced_import(db, &suffix("cumulative"), v).unwrap())),
pct90: options.pct90.then(|| import!("pct90")),
pct75: options.pct75.then(|| import!("pct75")),
pct25: options.pct25.then(|| import!("pct25")),
pct10: options.pct10.then(|| import!("pct10")),
};
Ok(s)
@@ -192,7 +91,7 @@ where
let index = self.starting_index(max_from);
let cumulative_vec = self.cumulative.as_mut().unwrap();
let cumulative_vec = self.cumulative.um();
let mut cumulative = index.decremented().map_or(T::from(0_usize), |index| {
cumulative_vec.iter().get_unwrap(index)
@@ -421,7 +320,7 @@ where
let count_index = count_indexes_iter.next().unwrap();
if let Some(first) = self.first.as_mut() {
let v = source_first_iter.as_mut().unwrap().get_unwrap(first_index);
let v = source_first_iter.um().get_unwrap(first_index);
first.truncate_push_at(index, v)?;
}
@@ -431,7 +330,7 @@ where
panic!("should compute last if count can be 0")
}
let last_index = first_index + (count_index - 1);
let v = source_last_iter.as_mut().unwrap().get_unwrap(last_index);
let v = source_last_iter.um().get_unwrap(last_index);
last.truncate_push_at(index, v)?;
}
@@ -444,7 +343,7 @@ where
if needs_values {
if needs_sorted {
if let Some(max) = self.max.as_mut() {
let source_max_iter = source_max_iter.as_mut().unwrap();
let source_max_iter = source_max_iter.um();
source_max_iter.set_position(first_index);
let mut values = source_max_iter
.take(*count_index as usize)
@@ -454,7 +353,7 @@ where
}
if let Some(min) = self.min.as_mut() {
let source_min_iter = source_min_iter.as_mut().unwrap();
let source_min_iter = source_min_iter.um();
source_min_iter.set_position(first_index);
let mut values = source_min_iter
.take(*count_index as usize)
@@ -466,7 +365,7 @@ where
if needs_average_sum_or_cumulative {
if let Some(average) = self.average.as_mut() {
let source_average_iter = source_average_iter.as_mut().unwrap();
let source_average_iter = source_average_iter.um();
source_average_iter.set_position(first_index);
let values = source_average_iter
.take(*count_index as usize)
@@ -481,7 +380,7 @@ where
}
if needs_sum_or_cumulative {
let source_sum_iter = source_sum_iter.as_mut().unwrap();
let source_sum_iter = source_sum_iter.um();
source_sum_iter.set_position(first_index);
let values = source_sum_iter
.take(*count_index as usize)
@@ -517,47 +416,47 @@ where
}
pub fn unwrap_first(&self) -> &EagerVec<PcoVec<I, T>> {
self.first.as_ref().unwrap()
self.first.u()
}
#[allow(unused)]
pub fn unwrap_average(&self) -> &EagerVec<PcoVec<I, T>> {
self.average.as_ref().unwrap()
self.average.u()
}
pub fn unwrap_sum(&self) -> &EagerVec<PcoVec<I, T>> {
self.sum.as_ref().unwrap()
self.sum.u()
}
pub fn unwrap_max(&self) -> &EagerVec<PcoVec<I, T>> {
self.max.as_ref().unwrap()
self.max.u()
}
#[allow(unused)]
pub fn unwrap_pct90(&self) -> &EagerVec<PcoVec<I, T>> {
self.pct90.as_ref().unwrap()
self.pct90.u()
}
#[allow(unused)]
pub fn unwrap_pct75(&self) -> &EagerVec<PcoVec<I, T>> {
self.pct75.as_ref().unwrap()
self.pct75.u()
}
#[allow(unused)]
pub fn unwrap_median(&self) -> &EagerVec<PcoVec<I, T>> {
self.median.as_ref().unwrap()
self.median.u()
}
#[allow(unused)]
pub fn unwrap_pct25(&self) -> &EagerVec<PcoVec<I, T>> {
self.pct25.as_ref().unwrap()
self.pct25.u()
}
#[allow(unused)]
pub fn unwrap_pct10(&self) -> &EagerVec<PcoVec<I, T>> {
self.pct10.as_ref().unwrap()
self.pct10.u()
}
pub fn unwrap_min(&self) -> &EagerVec<PcoVec<I, T>> {
self.min.as_ref().unwrap()
self.min.u()
}
pub fn unwrap_last(&self) -> &EagerVec<PcoVec<I, T>> {
self.last.as_ref().unwrap()
self.last.u()
}
#[allow(unused)]
pub fn unwrap_cumulative(&self) -> &EagerVec<PcoVec<I, T>> {
self.cumulative.as_ref().unwrap()
self.cumulative.u()
}
pub fn safe_flush(&mut self, exit: &Exit) -> Result<()> {
crates/brk_computer/src/grouped/builder_lazy.rs
+14 -13
View File
@@ -3,6 +3,7 @@ use brk_types::Version;
use vecdb::{FromCoarserIndex, IterableBoxedVec, IterableCloneableVec, LazyVecFrom2, VecIndex};
use crate::grouped::{EagerVecsBuilder, VecBuilderOptions};
use crate::utils::OptionExt;
use super::ComputedVecValue;
@@ -62,7 +63,7 @@ where
source_extra
.first
.as_ref()
.map_or_else(|| source.as_ref().unwrap().clone(), |v| v.clone()),
.map_or_else(|| source.u().clone(), |v| v.clone()),
len_source.clone(),
|i: I, source, len_source| {
if i.to_usize() >= len_source.vec_len() {
@@ -104,7 +105,7 @@ where
source_extra
.min
.as_ref()
.map_or_else(|| source.as_ref().unwrap().clone(), |v| v.clone()),
.map_or_else(|| source.u().clone(), |v| v.clone()),
len_source.clone(),
|i: I, source, len_source| {
if i.to_usize() >= len_source.vec_len() {
@@ -123,7 +124,7 @@ where
source_extra
.max
.as_ref()
.map_or_else(|| source.as_ref().unwrap().clone(), |v| v.clone()),
.map_or_else(|| source.u().clone(), |v| v.clone()),
len_source.clone(),
|i: I, source, len_source| {
if i.to_usize() >= len_source.vec_len() {
@@ -142,7 +143,7 @@ where
source_extra
.average
.as_ref()
.map_or_else(|| source.as_ref().unwrap().clone(), |v| v.clone()),
.map_or_else(|| source.u().clone(), |v| v.clone()),
len_source.clone(),
|i: I, source, len_source| {
if i.to_usize() >= len_source.vec_len() {
@@ -172,7 +173,7 @@ where
source_extra
.sum
.as_ref()
.map_or_else(|| source.as_ref().unwrap().clone(), |v| v.clone()),
.map_or_else(|| source.u().clone(), |v| v.clone()),
len_source.clone(),
|i: I, source, len_source| {
if i.to_usize() >= len_source.vec_len() {
@@ -194,7 +195,7 @@ where
Box::new(LazyVecFrom2::init(
&suffix("cumulative"),
version + VERSION + Version::ZERO,
source_extra.cumulative.as_ref().unwrap().boxed_clone(),
source_extra.cumulative.u().boxed_clone(),
len_source.clone(),
|i: I, source, len_source| {
if i.to_usize() >= len_source.vec_len() {
@@ -214,27 +215,27 @@ where
}
pub fn unwrap_first(&self) -> &LazyVecFrom2<I, T, S1I, T, I, S2T> {
self.first.as_ref().unwrap()
self.first.u()
}
#[allow(unused)]
pub fn unwrap_average(&self) -> &LazyVecFrom2<I, T, S1I, T, I, S2T> {
self.average.as_ref().unwrap()
self.average.u()
}
pub fn unwrap_sum(&self) -> &LazyVecFrom2<I, T, S1I, T, I, S2T> {
self.sum.as_ref().unwrap()
self.sum.u()
}
pub fn unwrap_max(&self) -> &LazyVecFrom2<I, T, S1I, T, I, S2T> {
self.max.as_ref().unwrap()
self.max.u()
}
pub fn unwrap_min(&self) -> &LazyVecFrom2<I, T, S1I, T, I, S2T> {
self.min.as_ref().unwrap()
self.min.u()
}
pub fn unwrap_last(&self) -> &LazyVecFrom2<I, T, S1I, T, I, S2T> {
self.last.as_ref().unwrap()
self.last.u()
}
#[allow(unused)]
pub fn unwrap_cumulative(&self) -> &LazyVecFrom2<I, T, S1I, T, I, S2T> {
self.cumulative.as_ref().unwrap()
self.cumulative.u()
}
}
crates/brk_computer/src/grouped/from_dateindex.rs
+3 -3
View File
@@ -9,7 +9,7 @@ use vecdb::{
PcoVec,
};
use crate::{Indexes, grouped::LazyVecsBuilder, indexes};
use crate::{Indexes, grouped::LazyVecsBuilder, indexes, utils::OptionExt};
use super::{ComputedVecValue, EagerVecsBuilder, Source, VecBuilderOptions};
@@ -121,7 +121,7 @@ where
where
F: FnMut(&mut EagerVec<PcoVec<DateIndex, T>>) -> Result<()>,
{
compute(self.dateindex.as_mut().unwrap())?;
compute(self.dateindex.um())?;
let dateindex: Option<&EagerVec<PcoVec<DateIndex, T>>> = None;
self.compute_rest(starting_indexes, exit, dateindex)
@@ -137,7 +137,7 @@ where
self.dateindex_extra
.extend(starting_indexes.dateindex, dateindex, exit)?;
} else {
let dateindex = self.dateindex.as_ref().unwrap();
let dateindex = self.dateindex.u();
self.dateindex_extra
.extend(starting_indexes.dateindex, dateindex, exit)?;
crates/brk_computer/src/grouped/from_height.rs
+3 -2
View File
@@ -14,6 +14,7 @@ use crate::{
Indexes,
grouped::{LazyVecsBuilder, Source},
indexes,
utils::OptionExt,
};
use super::{ComputedVecValue, EagerVecsBuilder, VecBuilderOptions};
@@ -140,7 +141,7 @@ where
where
F: FnMut(&mut EagerVec<PcoVec<Height, T>>) -> Result<()>,
{
compute(self.height.as_mut().unwrap())?;
compute(self.height.um())?;
let height: Option<&EagerVec<PcoVec<Height, T>>> = None;
self.compute_rest(indexes, starting_indexes, exit, height)
@@ -173,7 +174,7 @@ where
exit,
)?;
} else {
let height = self.height.as_ref().unwrap();
let height = self.height.u();
self.height_extra
.extend(starting_indexes.height, height, exit)?;
crates/brk_computer/src/grouped/from_txindex.rs
+57 -48
View File
@@ -14,6 +14,7 @@ use crate::{
Indexes,
grouped::{LazyVecsBuilder, Source},
indexes, price,
utils::OptionExt,
};
use super::{ComputedVecValue, EagerVecsBuilder, VecBuilderOptions};
@@ -146,7 +147,7 @@ where
// ) -> Result<()>,
// {
// compute(
// self.txindex.as_mut().unwrap(),
// self.txindex.um(),
// indexer,
// indexes,
// starting_indexes,
@@ -176,7 +177,7 @@ where
exit,
)?;
} else {
let txindex = self.txindex.as_ref().unwrap().as_ref();
let txindex = self.txindex.u().as_ref();
self.height.compute(
starting_indexes.height,
@@ -229,7 +230,7 @@ impl ComputedVecsFromTxindex<Bitcoin> {
let txindex_version = if let Some(txindex) = txindex {
txindex.version()
} else {
self.txindex.as_ref().unwrap().as_ref().version()
self.txindex.u().as_ref().version()
};
self.height
@@ -237,84 +238,93 @@ impl ComputedVecsFromTxindex<Bitcoin> {
let starting_index = self.height.starting_index(starting_indexes.height);
// Create iterators once before the loop to avoid repeated iterator creation
let mut first_iter = sats.height.first.as_ref().map(|v| v.into_iter());
let mut average_iter = sats.height.average.as_ref().map(|v| v.into_iter());
let mut sum_iter = sats.height.sum.as_ref().map(|v| v.into_iter());
let mut max_iter = sats.height.max.as_ref().map(|v| v.into_iter());
let mut pct90_iter = sats.height.pct90.as_ref().map(|v| v.into_iter());
let mut pct75_iter = sats.height.pct75.as_ref().map(|v| v.into_iter());
let mut median_iter = sats.height.median.as_ref().map(|v| v.into_iter());
let mut pct25_iter = sats.height.pct25.as_ref().map(|v| v.into_iter());
let mut pct10_iter = sats.height.pct10.as_ref().map(|v| v.into_iter());
let mut min_iter = sats.height.min.as_ref().map(|v| v.into_iter());
let mut last_iter = sats.height.last.as_ref().map(|v| v.into_iter());
let mut cumulative_iter = sats.height.cumulative.as_ref().map(|v| v.into_iter());
(starting_index.to_usize()..indexer.vecs.height_to_weight.len())
.map(Height::from)
.try_for_each(|height| -> Result<()> {
if let Some(first) = self.height.first.as_mut() {
first.truncate_push(
height,
Bitcoin::from(sats.height.unwrap_first().into_iter().get_unwrap(height)),
Bitcoin::from(first_iter.um().get_unwrap(height)),
)?;
}
if let Some(average) = self.height.average.as_mut() {
average.truncate_push(
height,
Bitcoin::from(sats.height.unwrap_average().into_iter().get_unwrap(height)),
Bitcoin::from(average_iter.um().get_unwrap(height)),
)?;
}
if let Some(sum) = self.height.sum.as_mut() {
sum.truncate_push(
height,
Bitcoin::from(sats.height.unwrap_sum().into_iter().get_unwrap(height)),
Bitcoin::from(sum_iter.um().get_unwrap(height)),
)?;
}
if let Some(max) = self.height.max.as_mut() {
max.truncate_push(
height,
Bitcoin::from(sats.height.unwrap_max().into_iter().get_unwrap(height)),
Bitcoin::from(max_iter.um().get_unwrap(height)),
)?;
}
if let Some(pct90) = self.height.pct90.as_mut() {
pct90.truncate_push(
height,
Bitcoin::from(sats.height.unwrap_pct90().into_iter().get_unwrap(height)),
Bitcoin::from(pct90_iter.um().get_unwrap(height)),
)?;
}
if let Some(pct75) = self.height.pct75.as_mut() {
pct75.truncate_push(
height,
Bitcoin::from(sats.height.unwrap_pct75().into_iter().get_unwrap(height)),
Bitcoin::from(pct75_iter.um().get_unwrap(height)),
)?;
}
if let Some(median) = self.height.median.as_mut() {
median.truncate_push(
height,
Bitcoin::from(sats.height.unwrap_median().into_iter().get_unwrap(height)),
Bitcoin::from(median_iter.um().get_unwrap(height)),
)?;
}
if let Some(pct25) = self.height.pct25.as_mut() {
pct25.truncate_push(
height,
Bitcoin::from(sats.height.unwrap_pct25().into_iter().get_unwrap(height)),
Bitcoin::from(pct25_iter.um().get_unwrap(height)),
)?;
}
if let Some(pct10) = self.height.pct10.as_mut() {
pct10.truncate_push(
height,
Bitcoin::from(sats.height.unwrap_pct10().into_iter().get_unwrap(height)),
Bitcoin::from(pct10_iter.um().get_unwrap(height)),
)?;
}
if let Some(min) = self.height.min.as_mut() {
min.truncate_push(
height,
Bitcoin::from(sats.height.unwrap_min().into_iter().get_unwrap(height)),
Bitcoin::from(min_iter.um().get_unwrap(height)),
)?;
}
if let Some(last) = self.height.last.as_mut() {
last.truncate_push(
height,
Bitcoin::from(sats.height.unwrap_last().into_iter().get_unwrap(height)),
Bitcoin::from(last_iter.um().get_unwrap(height)),
)?;
}
if let Some(cumulative) = self.height.cumulative.as_mut() {
cumulative.truncate_push(
height,
Bitcoin::from(
sats.height
.unwrap_cumulative()
.into_iter()
.get_unwrap(height),
),
Bitcoin::from(cumulative_iter.um().get_unwrap(height)),
)?;
}
Ok(())
@@ -341,7 +351,7 @@ impl ComputedVecsFromTxindex<Dollars> {
let txindex_version = if let Some(txindex) = txindex {
txindex.version()
} else {
self.txindex.as_ref().unwrap().as_ref().version()
self.txindex.u().as_ref().version()
};
self.height
@@ -351,6 +361,20 @@ impl ComputedVecsFromTxindex<Dollars> {
let mut close_iter = price.chainindexes_to_price_close.height.into_iter();
// Create iterators once before the loop to avoid repeated iterator creation
let mut first_iter = bitcoin.height.first.as_ref().map(|v| v.into_iter());
let mut average_iter = bitcoin.height.average.as_ref().map(|v| v.into_iter());
let mut sum_iter = bitcoin.height.sum.as_ref().map(|v| v.into_iter());
let mut max_iter = bitcoin.height.max.as_ref().map(|v| v.into_iter());
let mut pct90_iter = bitcoin.height.pct90.as_ref().map(|v| v.into_iter());
let mut pct75_iter = bitcoin.height.pct75.as_ref().map(|v| v.into_iter());
let mut median_iter = bitcoin.height.median.as_ref().map(|v| v.into_iter());
let mut pct25_iter = bitcoin.height.pct25.as_ref().map(|v| v.into_iter());
let mut pct10_iter = bitcoin.height.pct10.as_ref().map(|v| v.into_iter());
let mut min_iter = bitcoin.height.min.as_ref().map(|v| v.into_iter());
let mut last_iter = bitcoin.height.last.as_ref().map(|v| v.into_iter());
let mut cumulative_iter = bitcoin.height.cumulative.as_ref().map(|v| v.into_iter());
(starting_index.to_usize()..indexer.vecs.height_to_weight.len())
.map(Height::from)
.try_for_each(|height| -> Result<()> {
@@ -359,88 +383,73 @@ impl ComputedVecsFromTxindex<Dollars> {
if let Some(first) = self.height.first.as_mut() {
first.truncate_push(
height,
price * bitcoin.height.unwrap_first().into_iter().get_unwrap(height),
price * first_iter.um().get_unwrap(height),
)?;
}
if let Some(average) = self.height.average.as_mut() {
average.truncate_push(
height,
price
* bitcoin
.height
.unwrap_average()
.into_iter()
.get_unwrap(height),
price * average_iter.um().get_unwrap(height),
)?;
}
if let Some(sum) = self.height.sum.as_mut() {
sum.truncate_push(
height,
price * bitcoin.height.unwrap_sum().into_iter().get_unwrap(height),
price * sum_iter.um().get_unwrap(height),
)?;
}
if let Some(max) = self.height.max.as_mut() {
max.truncate_push(
height,
price * bitcoin.height.unwrap_max().into_iter().get_unwrap(height),
price * max_iter.um().get_unwrap(height),
)?;
}
if let Some(pct90) = self.height.pct90.as_mut() {
pct90.truncate_push(
height,
price * bitcoin.height.unwrap_pct90().into_iter().get_unwrap(height),
price * pct90_iter.um().get_unwrap(height),
)?;
}
if let Some(pct75) = self.height.pct75.as_mut() {
pct75.truncate_push(
height,
price * bitcoin.height.unwrap_pct75().into_iter().get_unwrap(height),
price * pct75_iter.um().get_unwrap(height),
)?;
}
if let Some(median) = self.height.median.as_mut() {
median.truncate_push(
height,
price
* bitcoin
.height
.unwrap_median()
.into_iter()
.get_unwrap(height),
price * median_iter.um().get_unwrap(height),
)?;
}
if let Some(pct25) = self.height.pct25.as_mut() {
pct25.truncate_push(
height,
price * bitcoin.height.unwrap_pct25().into_iter().get_unwrap(height),
price * pct25_iter.um().get_unwrap(height),
)?;
}
if let Some(pct10) = self.height.pct10.as_mut() {
pct10.truncate_push(
height,
price * bitcoin.height.unwrap_pct10().into_iter().get_unwrap(height),
price * pct10_iter.um().get_unwrap(height),
)?;
}
if let Some(min) = self.height.min.as_mut() {
min.truncate_push(
height,
price * bitcoin.height.unwrap_min().into_iter().get_unwrap(height),
price * min_iter.um().get_unwrap(height),
)?;
}
if let Some(last) = self.height.last.as_mut() {
last.truncate_push(
height,
price * bitcoin.height.unwrap_last().into_iter().get_unwrap(height),
price * last_iter.um().get_unwrap(height),
)?;
}
if let Some(cumulative) = self.height.cumulative.as_mut() {
cumulative.truncate_push(
height,
price
* bitcoin
.height
.unwrap_cumulative()
.into_iter()
.get_unwrap(height),
price * cumulative_iter.um().get_unwrap(height),
)?;
}
Ok(())
crates/brk_computer/src/grouped/ratio_from_dateindex.rs
+67 -249
View File
@@ -12,7 +12,7 @@ use crate::{
ComputedStandardDeviationVecsFromDateIndex, StandardDeviationVecsOptions, source::Source,
},
indexes, price,
utils::get_percentile,
utils::{get_percentile, OptionExt},
};
use super::{ComputedVecsFromDateIndex, VecBuilderOptions};
@@ -55,230 +55,48 @@ impl ComputedRatioVecsFromDateIndex {
indexes: &indexes::Vecs,
extended: bool,
) -> Result<Self> {
let options = VecBuilderOptions::default().add_last();
let opts = VecBuilderOptions::default().add_last();
let v = version + VERSION;
macro_rules! import {
($suffix:expr) => {
ComputedVecsFromDateIndex::forced_import(
db, &format!("{name}_{}", $suffix), Source::Compute, v, indexes, opts,
).unwrap()
};
}
macro_rules! import_sd {
($suffix:expr, $days:expr) => {
ComputedStandardDeviationVecsFromDateIndex::forced_import(
db, &format!("{name}_{}", $suffix), $days, Source::Compute, v, indexes,
StandardDeviationVecsOptions::default().add_all(),
).unwrap()
};
}
Ok(Self {
price: source.is_compute().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
name,
Source::Compute,
version + VERSION,
indexes,
options,
)
.unwrap()
}),
ratio: ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_ratio"),
Source::Compute,
version + VERSION + Version::ZERO,
indexes,
options,
)?,
ratio_1w_sma: extended.then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_ratio_1w_sma"),
Source::Compute,
version + VERSION + Version::ZERO,
indexes,
options,
)
.unwrap()
}),
ratio_1m_sma: extended.then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_ratio_1m_sma"),
Source::Compute,
version + VERSION + Version::ZERO,
indexes,
options,
)
.unwrap()
}),
ratio_sd: extended.then(|| {
ComputedStandardDeviationVecsFromDateIndex::forced_import(
db,
&format!("{name}_ratio"),
usize::MAX,
Source::Compute,
version + VERSION + Version::ZERO,
indexes,
StandardDeviationVecsOptions::default().add_all(),
)
.unwrap()
}),
ratio_1y_sd: extended.then(|| {
ComputedStandardDeviationVecsFromDateIndex::forced_import(
db,
&format!("{name}_ratio_1y"),
365,
Source::Compute,
version + VERSION + Version::ZERO,
indexes,
StandardDeviationVecsOptions::default().add_all(),
)
.unwrap()
}),
ratio_2y_sd: extended.then(|| {
ComputedStandardDeviationVecsFromDateIndex::forced_import(
db,
&format!("{name}_ratio_2y"),
2 * 365,
Source::Compute,
version + VERSION + Version::ZERO,
indexes,
StandardDeviationVecsOptions::default().add_all(),
)
.unwrap()
}),
ratio_4y_sd: extended.then(|| {
ComputedStandardDeviationVecsFromDateIndex::forced_import(
db,
&format!("{name}_ratio_4y"),
4 * 365,
Source::Compute,
version + VERSION + Version::ZERO,
indexes,
StandardDeviationVecsOptions::default().add_all(),
)
.unwrap()
}),
ratio_pct99: extended.then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_ratio_pct99"),
Source::Compute,
version + VERSION + Version::ZERO,
indexes,
options,
)
.unwrap()
}),
ratio_pct98: extended.then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_ratio_pct98"),
Source::Compute,
version + VERSION + Version::ZERO,
indexes,
options,
)
.unwrap()
}),
ratio_pct95: extended.then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_ratio_pct95"),
Source::Compute,
version + VERSION + Version::ZERO,
indexes,
options,
)
.unwrap()
}),
ratio_pct5: extended.then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_ratio_pct5"),
Source::Compute,
version + VERSION + Version::ZERO,
indexes,
options,
)
.unwrap()
}),
ratio_pct2: extended.then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_ratio_pct2"),
Source::Compute,
version + VERSION + Version::ZERO,
indexes,
options,
)
.unwrap()
}),
ratio_pct1: extended.then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_ratio_pct1"),
Source::Compute,
version + VERSION + Version::ZERO,
indexes,
options,
)
.unwrap()
}),
ratio_pct99_usd: extended.then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_ratio_pct99_usd"),
Source::Compute,
version + VERSION + Version::ZERO,
indexes,
options,
)
.unwrap()
}),
ratio_pct98_usd: extended.then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_ratio_pct98_usd"),
Source::Compute,
version + VERSION + Version::ZERO,
indexes,
options,
)
.unwrap()
}),
ratio_pct95_usd: extended.then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_ratio_pct95_usd"),
Source::Compute,
version + VERSION + Version::ZERO,
indexes,
options,
)
.unwrap()
}),
ratio_pct5_usd: extended.then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_ratio_pct5_usd"),
Source::Compute,
version + VERSION + Version::ZERO,
indexes,
options,
)
.unwrap()
}),
ratio_pct2_usd: extended.then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_ratio_pct2_usd"),
Source::Compute,
version + VERSION + Version::ZERO,
indexes,
options,
)
.unwrap()
}),
ratio_pct1_usd: extended.then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_ratio_pct1_usd"),
Source::Compute,
version + VERSION + Version::ZERO,
indexes,
options,
)
.unwrap()
ComputedVecsFromDateIndex::forced_import(db, name, Source::Compute, v, indexes, opts).unwrap()
}),
ratio: import!("ratio"),
ratio_1w_sma: extended.then(|| import!("ratio_1w_sma")),
ratio_1m_sma: extended.then(|| import!("ratio_1m_sma")),
ratio_sd: extended.then(|| import_sd!("ratio", usize::MAX)),
ratio_1y_sd: extended.then(|| import_sd!("ratio_1y", 365)),
ratio_2y_sd: extended.then(|| import_sd!("ratio_2y", 2 * 365)),
ratio_4y_sd: extended.then(|| import_sd!("ratio_4y", 4 * 365)),
ratio_pct99: extended.then(|| import!("ratio_pct99")),
ratio_pct98: extended.then(|| import!("ratio_pct98")),
ratio_pct95: extended.then(|| import!("ratio_pct95")),
ratio_pct5: extended.then(|| import!("ratio_pct5")),
ratio_pct2: extended.then(|| import!("ratio_pct2")),
ratio_pct1: extended.then(|| import!("ratio_pct1")),
ratio_pct99_usd: extended.then(|| import!("ratio_pct99_usd")),
ratio_pct98_usd: extended.then(|| import!("ratio_pct98_usd")),
ratio_pct95_usd: extended.then(|| import!("ratio_pct95_usd")),
ratio_pct5_usd: extended.then(|| import!("ratio_pct5_usd")),
ratio_pct2_usd: extended.then(|| import!("ratio_pct2_usd")),
ratio_pct1_usd: extended.then(|| import!("ratio_pct1_usd")),
})
}
@@ -308,10 +126,10 @@ impl ComputedRatioVecsFromDateIndex {
exit: &Exit,
price_opt: Option<&impl IterableVec<DateIndex, Dollars>>,
) -> Result<()> {
let closes = price.timeindexes_to_price_close.dateindex.as_ref().unwrap();
let closes = price.timeindexes_to_price_close.dateindex.u();
let price = price_opt.unwrap_or_else(|| unsafe {
std::mem::transmute(&self.price.as_ref().unwrap().dateindex)
std::mem::transmute(&self.price.u().dateindex)
});
self.ratio.compute_all(starting_indexes, exit, |v| {
@@ -343,7 +161,7 @@ impl ComputedRatioVecsFromDateIndex {
.compute_all(starting_indexes, exit, |v| {
v.compute_sma_(
starting_indexes.dateindex,
self.ratio.dateindex.as_ref().unwrap(),
self.ratio.dateindex.u(),
7,
exit,
Some(min_ratio_date),
@@ -357,7 +175,7 @@ impl ComputedRatioVecsFromDateIndex {
.compute_all(starting_indexes, exit, |v| {
v.compute_sma_(
starting_indexes.dateindex,
self.ratio.dateindex.as_ref().unwrap(),
self.ratio.dateindex.u(),
30,
exit,
Some(min_ratio_date),
@@ -365,7 +183,7 @@ impl ComputedRatioVecsFromDateIndex {
Ok(())
})?;
let ratio_version = self.ratio.dateindex.as_ref().unwrap().version();
let ratio_version = self.ratio.dateindex.u().version();
self.mut_ratio_vecs()
.iter_mut()
.try_for_each(|v| -> Result<()> {
@@ -385,7 +203,7 @@ impl ComputedRatioVecsFromDateIndex {
let min_ratio_date_usize = min_ratio_date.to_usize();
let mut sorted = self.ratio.dateindex.as_ref().unwrap().collect_range(
let mut sorted = self.ratio.dateindex.u().collect_range(
Some(min_ratio_date_usize),
Some(starting_dateindex.to_usize()),
);
@@ -498,39 +316,39 @@ impl ComputedRatioVecsFromDateIndex {
.into_iter()
.try_for_each(|v| v.safe_flush(exit))?;
self.ratio_pct1.as_mut().unwrap().compute_rest(
self.ratio_pct1.um().compute_rest(
starting_indexes,
exit,
None as Option<&EagerVec<PcoVec<_, _>>>,
)?;
self.ratio_pct2.as_mut().unwrap().compute_rest(
self.ratio_pct2.um().compute_rest(
starting_indexes,
exit,
None as Option<&EagerVec<PcoVec<_, _>>>,
)?;
self.ratio_pct5.as_mut().unwrap().compute_rest(
self.ratio_pct5.um().compute_rest(
starting_indexes,
exit,
None as Option<&EagerVec<PcoVec<_, _>>>,
)?;
self.ratio_pct95.as_mut().unwrap().compute_rest(
self.ratio_pct95.um().compute_rest(
starting_indexes,
exit,
None as Option<&EagerVec<PcoVec<_, _>>>,
)?;
self.ratio_pct98.as_mut().unwrap().compute_rest(
self.ratio_pct98.um().compute_rest(
starting_indexes,
exit,
None as Option<&EagerVec<PcoVec<_, _>>>,
)?;
self.ratio_pct99.as_mut().unwrap().compute_rest(
self.ratio_pct99.um().compute_rest(
starting_indexes,
exit,
None as Option<&EagerVec<PcoVec<_, _>>>,
)?;
let date_to_price = price_opt.unwrap_or_else(|| unsafe {
std::mem::transmute(&self.price.as_ref().unwrap().dateindex)
std::mem::transmute(&self.price.u().dateindex)
});
self.ratio_pct99_usd
@@ -561,7 +379,7 @@ impl ComputedRatioVecsFromDateIndex {
|usd: Option<&mut ComputedVecsFromDateIndex<Dollars>>,
source: Option<&ComputedVecsFromDateIndex<StoredF32>>| {
usd.unwrap().compute_all(starting_indexes, exit, |vec| {
let mut iter = source.unwrap().dateindex.as_ref().unwrap().into_iter();
let mut iter = source.unwrap().dateindex.u().into_iter();
vec.compute_transform(
starting_indexes.dateindex,
date_to_price,
@@ -582,28 +400,28 @@ impl ComputedRatioVecsFromDateIndex {
compute_usd(self.ratio_pct98_usd.as_mut(), self.ratio_pct98.as_ref())?;
compute_usd(self.ratio_pct99_usd.as_mut(), self.ratio_pct99.as_ref())?;
self.ratio_sd.as_mut().unwrap().compute_all(
self.ratio_sd.um().compute_all(
starting_indexes,
exit,
self.ratio.dateindex.as_ref().unwrap(),
self.ratio.dateindex.u(),
Some(date_to_price),
)?;
self.ratio_4y_sd.as_mut().unwrap().compute_all(
self.ratio_4y_sd.um().compute_all(
starting_indexes,
exit,
self.ratio.dateindex.as_ref().unwrap(),
self.ratio.dateindex.u(),
Some(date_to_price),
)?;
self.ratio_2y_sd.as_mut().unwrap().compute_all(
self.ratio_2y_sd.um().compute_all(
starting_indexes,
exit,
self.ratio.dateindex.as_ref().unwrap(),
self.ratio.dateindex.u(),
Some(date_to_price),
)?;
self.ratio_1y_sd.as_mut().unwrap().compute_all(
self.ratio_1y_sd.um().compute_all(
starting_indexes,
exit,
self.ratio.dateindex.as_ref().unwrap(),
self.ratio.dateindex.u(),
Some(date_to_price),
)?;
@@ -613,22 +431,22 @@ impl ComputedRatioVecsFromDateIndex {
fn mut_ratio_vecs(&mut self) -> Vec<&mut EagerVec<PcoVec<DateIndex, StoredF32>>> {
let mut vecs = Vec::with_capacity(6);
if let Some(v) = self.ratio_pct1.as_mut() {
vecs.push(v.dateindex.as_mut().unwrap());
vecs.push(v.dateindex.um());
}
if let Some(v) = self.ratio_pct2.as_mut() {
vecs.push(v.dateindex.as_mut().unwrap());
vecs.push(v.dateindex.um());
}
if let Some(v) = self.ratio_pct5.as_mut() {
vecs.push(v.dateindex.as_mut().unwrap());
vecs.push(v.dateindex.um());
}
if let Some(v) = self.ratio_pct95.as_mut() {
vecs.push(v.dateindex.as_mut().unwrap());
vecs.push(v.dateindex.um());
}
if let Some(v) = self.ratio_pct98.as_mut() {
vecs.push(v.dateindex.as_mut().unwrap());
vecs.push(v.dateindex.um());
}
if let Some(v) = self.ratio_pct99.as_mut() {
vecs.push(v.dateindex.as_mut().unwrap());
vecs.push(v.dateindex.um());
}
vecs
}
crates/brk_computer/src/grouped/sd_from_dateindex.rs
+66 -336
View File
@@ -6,7 +6,7 @@ use vecdb::{PcoVec,
GenericStoredVec, IterableVec, VecIndex,
};
use crate::{Indexes, grouped::source::Source, indexes};
use crate::{Indexes, grouped::source::Source, indexes, utils::OptionExt};
use super::{ComputedVecsFromDateIndex, VecBuilderOptions};
@@ -103,317 +103,47 @@ impl ComputedStandardDeviationVecsFromDateIndex {
indexes: &indexes::Vecs,
options: StandardDeviationVecsOptions,
) -> Result<Self> {
let builder_options = VecBuilderOptions::default().add_last();
let opts = VecBuilderOptions::default().add_last();
let version = parent_version + Version::ONE;
macro_rules! import {
($suffix:expr) => {
ComputedVecsFromDateIndex::forced_import(
db, &format!("{name}_{}", $suffix), Source::Compute, version, indexes, opts,
).unwrap()
};
}
Ok(Self {
days,
sma: sma.is_compute().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_sma"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
sd: ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_sd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)?,
p0_5sd: options.bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_p0_5sd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
p1sd: options.bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_p1sd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
p1_5sd: options.bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_p1_5sd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
p2sd: options.bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_p2sd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
p2_5sd: options.bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_p2_5sd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
p3sd: options.bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_p3sd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
m0_5sd: options.bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_m0_5sd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
m1sd: options.bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_m1sd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
m1_5sd: options.bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_m1_5sd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
m2sd: options.bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_m2sd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
m2_5sd: options.bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_m2_5sd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
m3sd: options.bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_m3sd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
_0sd_usd: options.price_bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_0sd_usd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
p0_5sd_usd: options.price_bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_p0_5sd_usd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
p1sd_usd: options.price_bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_p1sd_usd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
p1_5sd_usd: options.price_bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_p1_5sd_usd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
p2sd_usd: options.price_bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_p2sd_usd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
p2_5sd_usd: options.price_bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_p2_5sd_usd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
p3sd_usd: options.price_bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_p3sd_usd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
m0_5sd_usd: options.price_bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_m0_5sd_usd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
m1sd_usd: options.price_bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_m1sd_usd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
m1_5sd_usd: options.price_bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_m1_5sd_usd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
m2sd_usd: options.price_bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_m2sd_usd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
m2_5sd_usd: options.price_bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_m2_5sd_usd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
m3sd_usd: options.price_bands().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_m3sd_usd"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
zscore: options.zscore().then(|| {
ComputedVecsFromDateIndex::forced_import(
db,
&format!("{name}_zscore"),
Source::Compute,
version + Version::ZERO,
indexes,
builder_options,
)
.unwrap()
}),
sma: sma.is_compute().then(|| import!("sma")),
sd: import!("sd"),
p0_5sd: options.bands().then(|| import!("p0_5sd")),
p1sd: options.bands().then(|| import!("p1sd")),
p1_5sd: options.bands().then(|| import!("p1_5sd")),
p2sd: options.bands().then(|| import!("p2sd")),
p2_5sd: options.bands().then(|| import!("p2_5sd")),
p3sd: options.bands().then(|| import!("p3sd")),
m0_5sd: options.bands().then(|| import!("m0_5sd")),
m1sd: options.bands().then(|| import!("m1sd")),
m1_5sd: options.bands().then(|| import!("m1_5sd")),
m2sd: options.bands().then(|| import!("m2sd")),
m2_5sd: options.bands().then(|| import!("m2_5sd")),
m3sd: options.bands().then(|| import!("m3sd")),
_0sd_usd: options.price_bands().then(|| import!("0sd_usd")),
p0_5sd_usd: options.price_bands().then(|| import!("p0_5sd_usd")),
p1sd_usd: options.price_bands().then(|| import!("p1sd_usd")),
p1_5sd_usd: options.price_bands().then(|| import!("p1_5sd_usd")),
p2sd_usd: options.price_bands().then(|| import!("p2sd_usd")),
p2_5sd_usd: options.price_bands().then(|| import!("p2_5sd_usd")),
p3sd_usd: options.price_bands().then(|| import!("p3sd_usd")),
m0_5sd_usd: options.price_bands().then(|| import!("m0_5sd_usd")),
m1sd_usd: options.price_bands().then(|| import!("m1sd_usd")),
m1_5sd_usd: options.price_bands().then(|| import!("m1_5sd_usd")),
m2sd_usd: options.price_bands().then(|| import!("m2sd_usd")),
m2_5sd_usd: options.price_bands().then(|| import!("m2_5sd_usd")),
m3sd_usd: options.price_bands().then(|| import!("m3sd_usd")),
zscore: options.zscore().then(|| import!("zscore")),
})
}
@@ -454,7 +184,7 @@ impl ComputedStandardDeviationVecsFromDateIndex {
price_opt: Option<&impl IterableVec<DateIndex, Dollars>>,
) -> Result<()> {
let sma = sma_opt.unwrap_or_else(|| unsafe {
std::mem::transmute(&self.sma.as_ref().unwrap().dateindex)
std::mem::transmute(&self.sma.u().dateindex)
});
let min_date = DateIndex::try_from(Date::MIN_RATIO).unwrap();
@@ -483,18 +213,18 @@ impl ComputedStandardDeviationVecsFromDateIndex {
sorted.sort_unstable();
let mut p0_5sd = self.p0_5sd.as_mut().map(|c| c.dateindex.as_mut().unwrap());
let mut p1sd = self.p1sd.as_mut().map(|c| c.dateindex.as_mut().unwrap());
let mut p1_5sd = self.p1_5sd.as_mut().map(|c| c.dateindex.as_mut().unwrap());
let mut p2sd = self.p2sd.as_mut().map(|c| c.dateindex.as_mut().unwrap());
let mut p2_5sd = self.p2_5sd.as_mut().map(|c| c.dateindex.as_mut().unwrap());
let mut p3sd = self.p3sd.as_mut().map(|c| c.dateindex.as_mut().unwrap());
let mut m0_5sd = self.m0_5sd.as_mut().map(|c| c.dateindex.as_mut().unwrap());
let mut m1sd = self.m1sd.as_mut().map(|c| c.dateindex.as_mut().unwrap());
let mut m1_5sd = self.m1_5sd.as_mut().map(|c| c.dateindex.as_mut().unwrap());
let mut m2sd = self.m2sd.as_mut().map(|c| c.dateindex.as_mut().unwrap());
let mut m2_5sd = self.m2_5sd.as_mut().map(|c| c.dateindex.as_mut().unwrap());
let mut m3sd = self.m3sd.as_mut().map(|c| c.dateindex.as_mut().unwrap());
let mut p0_5sd = self.p0_5sd.as_mut().map(|c| c.dateindex.um());
let mut p1sd = self.p1sd.as_mut().map(|c| c.dateindex.um());
let mut p1_5sd = self.p1_5sd.as_mut().map(|c| c.dateindex.um());
let mut p2sd = self.p2sd.as_mut().map(|c| c.dateindex.um());
let mut p2_5sd = self.p2_5sd.as_mut().map(|c| c.dateindex.um());
let mut p3sd = self.p3sd.as_mut().map(|c| c.dateindex.um());
let mut m0_5sd = self.m0_5sd.as_mut().map(|c| c.dateindex.um());
let mut m1sd = self.m1sd.as_mut().map(|c| c.dateindex.um());
let mut m1_5sd = self.m1_5sd.as_mut().map(|c| c.dateindex.um());
let mut m2sd = self.m2sd.as_mut().map(|c| c.dateindex.um());
let mut m2_5sd = self.m2_5sd.as_mut().map(|c| c.dateindex.um());
let mut m3sd = self.m3sd.as_mut().map(|c| c.dateindex.um());
let min_date_usize = min_date.to_usize();
let mut sma_iter = sma.iter().skip(starting_dateindex.to_usize());
@@ -624,7 +354,7 @@ impl ComputedStandardDeviationVecsFromDateIndex {
starting_indexes.dateindex,
source,
sma,
self.sd.dateindex.as_ref().unwrap(),
self.sd.dateindex.u(),
exit,
)?;
Ok(())
@@ -656,9 +386,9 @@ impl ComputedStandardDeviationVecsFromDateIndex {
return Ok(());
}
compute_usd(self._0sd_usd.as_mut().unwrap(), sma.iter())?;
compute_usd(self._0sd_usd.um(), sma.iter())?;
compute_usd(
self.p0_5sd_usd.as_mut().unwrap(),
self.p0_5sd_usd.um(),
self.p0_5sd
.as_ref()
.unwrap()
@@ -668,7 +398,7 @@ impl ComputedStandardDeviationVecsFromDateIndex {
.iter(),
)?;
compute_usd(
self.p1sd_usd.as_mut().unwrap(),
self.p1sd_usd.um(),
self.p1sd
.as_ref()
.unwrap()
@@ -678,7 +408,7 @@ impl ComputedStandardDeviationVecsFromDateIndex {
.iter(),
)?;
compute_usd(
self.p1_5sd_usd.as_mut().unwrap(),
self.p1_5sd_usd.um(),
self.p1_5sd
.as_ref()
.unwrap()
@@ -688,7 +418,7 @@ impl ComputedStandardDeviationVecsFromDateIndex {
.iter(),
)?;
compute_usd(
self.p2sd_usd.as_mut().unwrap(),
self.p2sd_usd.um(),
self.p2sd
.as_ref()
.unwrap()
@@ -698,7 +428,7 @@ impl ComputedStandardDeviationVecsFromDateIndex {
.iter(),
)?;
compute_usd(
self.p2_5sd_usd.as_mut().unwrap(),
self.p2_5sd_usd.um(),
self.p2_5sd
.as_ref()
.unwrap()
@@ -708,7 +438,7 @@ impl ComputedStandardDeviationVecsFromDateIndex {
.iter(),
)?;
compute_usd(
self.p3sd_usd.as_mut().unwrap(),
self.p3sd_usd.um(),
self.p3sd
.as_ref()
.unwrap()
@@ -718,7 +448,7 @@ impl ComputedStandardDeviationVecsFromDateIndex {
.iter(),
)?;
compute_usd(
self.m0_5sd_usd.as_mut().unwrap(),
self.m0_5sd_usd.um(),
self.m0_5sd
.as_ref()
.unwrap()
@@ -728,7 +458,7 @@ impl ComputedStandardDeviationVecsFromDateIndex {
.iter(),
)?;
compute_usd(
self.m1sd_usd.as_mut().unwrap(),
self.m1sd_usd.um(),
self.m1sd
.as_ref()
.unwrap()
@@ -738,7 +468,7 @@ impl ComputedStandardDeviationVecsFromDateIndex {
.iter(),
)?;
compute_usd(
self.m1_5sd_usd.as_mut().unwrap(),
self.m1_5sd_usd.um(),
self.m1_5sd
.as_ref()
.unwrap()
@@ -748,7 +478,7 @@ impl ComputedStandardDeviationVecsFromDateIndex {
.iter(),
)?;
compute_usd(
self.m2sd_usd.as_mut().unwrap(),
self.m2sd_usd.um(),
self.m2sd
.as_ref()
.unwrap()
@@ -758,7 +488,7 @@ impl ComputedStandardDeviationVecsFromDateIndex {
.iter(),
)?;
compute_usd(
self.m2_5sd_usd.as_mut().unwrap(),
self.m2_5sd_usd.um(),
self.m2_5sd
.as_ref()
.unwrap()
@@ -768,7 +498,7 @@ impl ComputedStandardDeviationVecsFromDateIndex {
.iter(),
)?;
compute_usd(
self.m3sd_usd.as_mut().unwrap(),
self.m3sd_usd.um(),
self.m3sd
.as_ref()
.unwrap()
@@ -807,6 +537,6 @@ impl ComputedStandardDeviationVecsFromDateIndex {
&mut self,
) -> impl Iterator<Item = &mut EagerVec<PcoVec<DateIndex, StoredF32>>> {
self.mut_stateful_computed()
.map(|c| c.dateindex.as_mut().unwrap())
.map(|c| c.dateindex.um())
}
}
crates/brk_computer/src/grouped/value_from_dateindex.rs
+4 -3
View File
@@ -8,6 +8,7 @@ use crate::{
grouped::ComputedVecsFromDateIndex,
indexes, price,
traits::{ComputeFromBitcoin, ComputeFromSats},
utils::OptionExt,
};
use super::{Source, VecBuilderOptions};
@@ -73,7 +74,7 @@ impl ComputedValueVecsFromDateIndex {
where
F: FnMut(&mut EagerVec<PcoVec<DateIndex, Sats>>) -> Result<()>,
{
compute(self.sats.dateindex.as_mut().unwrap())?;
compute(self.sats.dateindex.um())?;
let dateindex: Option<&PcoVec<DateIndex, Sats>> = None;
self.compute_rest(price, starting_indexes, exit, dateindex)?;
@@ -103,13 +104,13 @@ impl ComputedValueVecsFromDateIndex {
self.bitcoin.compute_all(starting_indexes, exit, |v| {
v.compute_from_sats(
starting_indexes.dateindex,
self.sats.dateindex.as_ref().unwrap(),
self.sats.dateindex.u(),
exit,
)
})?;
}
let dateindex_to_bitcoin = self.bitcoin.dateindex.as_ref().unwrap();
let dateindex_to_bitcoin = self.bitcoin.dateindex.u();
let dateindex_to_price_close = price
.as_ref()
.unwrap()
crates/brk_computer/src/grouped/value_from_height.rs
+5 -4
View File
@@ -8,6 +8,7 @@ use crate::{
grouped::Source,
indexes, price,
traits::{ComputeFromBitcoin, ComputeFromSats},
utils::OptionExt,
};
use super::{ComputedVecsFromHeight, VecBuilderOptions};
@@ -74,7 +75,7 @@ impl ComputedValueVecsFromHeight {
where
F: FnMut(&mut EagerVec<PcoVec<Height, Sats>>) -> Result<()>,
{
compute(self.sats.height.as_mut().unwrap())?;
compute(self.sats.height.um())?;
let height: Option<&PcoVec<Height, Sats>> = None;
self.compute_rest(indexes, price, starting_indexes, exit, height)?;
@@ -108,14 +109,14 @@ impl ComputedValueVecsFromHeight {
.compute_all(indexes, starting_indexes, exit, |v| {
v.compute_from_sats(
starting_indexes.height,
self.sats.height.as_ref().unwrap(),
self.sats.height.u(),
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;
let height_to_bitcoin = self.bitcoin.height.u();
let height_to_price_close = &price.u().chainindexes_to_price_close.height;
if let Some(dollars) = self.dollars.as_mut() {
dollars.compute_all(indexes, starting_indexes, exit, |v| {
crates/brk_computer/src/grouped/value_from_txindex.rs
+5 -5
View File
@@ -7,7 +7,7 @@ use vecdb::{
VecIndex,
};
use crate::{Indexes, grouped::Source, indexes, price};
use crate::{Indexes, grouped::Source, indexes, price, utils::OptionExt};
use super::{ComputedVecsFromTxindex, VecBuilderOptions};
@@ -56,7 +56,7 @@ impl ComputedValueVecsFromTxindex {
let bitcoin_txindex = LazyVecFrom1::init(
&name_btc,
version + VERSION,
source_vec.map_or_else(|| sats.txindex.as_ref().unwrap().boxed_clone(), |s| s),
source_vec.map_or_else(|| sats.txindex.u().boxed_clone(), |s| s),
|txindex: TxIndex, iter| iter.get_at(txindex.to_usize()).map(Bitcoin::from),
);
@@ -130,7 +130,7 @@ impl ComputedValueVecsFromTxindex {
// ) -> Result<()>,
// {
// compute(
// self.sats.txindex.as_mut().unwrap(),
// self.sats.txindex.um(),
// indexer,
// indexes,
// starting_indexes,
@@ -178,7 +178,7 @@ impl ComputedValueVecsFromTxindex {
)?;
if let Some(dollars) = self.dollars.as_mut() {
let dollars_txindex = self.dollars_txindex.as_mut().unwrap();
let dollars_txindex = self.dollars_txindex.um();
dollars.compute_rest_from_bitcoin(
indexer,
@@ -187,7 +187,7 @@ impl ComputedValueVecsFromTxindex {
exit,
&self.bitcoin,
Some(dollars_txindex),
price.as_ref().unwrap(),
price.u(),
)?;
}
crates/brk_computer/src/grouped/value_height.rs
+4 -3
View File
@@ -8,6 +8,7 @@ use crate::{
grouped::Source,
price,
traits::{ComputeFromBitcoin, ComputeFromSats},
utils::OptionExt,
};
#[derive(Clone, Traversable)]
@@ -57,7 +58,7 @@ impl ComputedHeightValueVecs {
where
F: FnMut(&mut EagerVec<PcoVec<Height, Sats>>) -> Result<()>,
{
compute(self.sats.as_mut().unwrap())?;
compute(self.sats.um())?;
let height: Option<&PcoVec<Height, Sats>> = None;
self.compute_rest(price, starting_indexes, exit, height)?;
@@ -78,13 +79,13 @@ impl ComputedHeightValueVecs {
} else {
self.bitcoin.compute_from_sats(
starting_indexes.height,
self.sats.as_ref().unwrap(),
self.sats.u(),
exit,
)?;
}
let height_to_bitcoin = &self.bitcoin;
let height_to_price_close = &price.as_ref().unwrap().chainindexes_to_price_close.height;
let height_to_price_close = &price.u().chainindexes_to_price_close.height;
if let Some(dollars) = self.dollars.as_mut() {
dollars.compute_from_bitcoin(