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

global: averages + ratio datasets

Browse Source
This commit is contained in:
nym21
2025-05-12 12:55:40 +02:00
parent 292ceddd66
commit b7a1ee9ebc
34 changed files with 2247 additions and 556 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
crates/brk_computer/src/lib.rs
View File

@@ -11,6 +11,7 @@ use brk_indexer::{Indexer, Indexes};
pub use brk_parser::rpc;
mod storage;
mod utils;
use brk_vec::{AnyCollectableVec, Compressed, Computation};
use log::info;

6
crates/brk_computer/src/storage/vecs/blocks.rs
View File

@@ -11,7 +11,7 @@ use brk_vec::{AnyCollectableVec, AnyIterableVec, Compressed, Computation, EagerV
use super::{
Indexes,
grouped::{ComputedVecsFromDateindex, ComputedVecsFromHeight, StorableVecGeneatorOptions},
grouped::{ComputedVecsFromDateIndex, ComputedVecsFromHeight, StorableVecGeneatorOptions},
indexes,
};
@@ -21,7 +21,7 @@ pub struct Vecs {
pub height_to_vbytes: EagerVec<Height, StoredU64>,
pub difficultyepoch_to_timestamp: EagerVec<DifficultyEpoch, Timestamp>,
pub halvingepoch_to_timestamp: EagerVec<HalvingEpoch, Timestamp>,
pub timeindexes_to_timestamp: ComputedVecsFromDateindex<Timestamp>,
pub timeindexes_to_timestamp: ComputedVecsFromDateIndex<Timestamp>,
pub indexes_to_block_count: ComputedVecsFromHeight<StoredU32>,
pub indexes_to_block_interval: ComputedVecsFromHeight<Timestamp>,
pub indexes_to_block_size: ComputedVecsFromHeight<StoredUsize>,
@@ -43,7 +43,7 @@ impl Vecs {
Version::ZERO,
compressed,
)?,
timeindexes_to_timestamp: ComputedVecsFromDateindex::forced_import(
timeindexes_to_timestamp: ComputedVecsFromDateIndex::forced_import(
path,
"timestamp",
Version::ZERO,

34
crates/brk_computer/src/storage/vecs/fetched.rs
View File

@@ -12,7 +12,7 @@ use brk_vec::{AnyCollectableVec, AnyIterableVec, Compressed, Computation, EagerV
use super::{
Indexes,
grouped::{
ComputedVecsFromDateindex, ComputedVecsFromHeightStrict, StorableVecGeneatorOptions,
ComputedVecsFromDateIndex, ComputedVecsFromHeightStrict, StorableVecGeneatorOptions,
},
indexes,
};
@@ -33,14 +33,14 @@ pub struct Vecs {
pub height_to_ohlc_in_sats: EagerVec<Height, OHLCSats>,
pub height_to_ohlc_in_cents: EagerVec<Height, OHLCCents>,
pub height_to_open_in_cents: EagerVec<Height, Open<Cents>>,
pub timeindexes_to_close: ComputedVecsFromDateindex<Close<Dollars>>,
pub timeindexes_to_high: ComputedVecsFromDateindex<High<Dollars>>,
pub timeindexes_to_low: ComputedVecsFromDateindex<Low<Dollars>>,
pub timeindexes_to_open: ComputedVecsFromDateindex<Open<Dollars>>,
pub timeindexes_to_open_in_sats: ComputedVecsFromDateindex<Open<Sats>>,
pub timeindexes_to_high_in_sats: ComputedVecsFromDateindex<High<Sats>>,
pub timeindexes_to_low_in_sats: ComputedVecsFromDateindex<Low<Sats>>,
pub timeindexes_to_close_in_sats: ComputedVecsFromDateindex<Close<Sats>>,
pub timeindexes_to_close: ComputedVecsFromDateIndex<Close<Dollars>>,
pub timeindexes_to_high: ComputedVecsFromDateIndex<High<Dollars>>,
pub timeindexes_to_low: ComputedVecsFromDateIndex<Low<Dollars>>,
pub timeindexes_to_open: ComputedVecsFromDateIndex<Open<Dollars>>,
pub timeindexes_to_open_in_sats: ComputedVecsFromDateIndex<Open<Sats>>,
pub timeindexes_to_high_in_sats: ComputedVecsFromDateIndex<High<Sats>>,
pub timeindexes_to_low_in_sats: ComputedVecsFromDateIndex<Low<Sats>>,
pub timeindexes_to_close_in_sats: ComputedVecsFromDateIndex<Close<Sats>>,
pub chainindexes_to_close: ComputedVecsFromHeightStrict<Close<Dollars>>,
pub chainindexes_to_high: ComputedVecsFromHeightStrict<High<Dollars>>,
pub chainindexes_to_low: ComputedVecsFromHeightStrict<Low<Dollars>>,
@@ -151,56 +151,56 @@ impl Vecs {
Version::ZERO,
compressed,
)?,
timeindexes_to_open: ComputedVecsFromDateindex::forced_import(
timeindexes_to_open: ComputedVecsFromDateIndex::forced_import(
path,
"open",
Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_first(),
)?,
timeindexes_to_high: ComputedVecsFromDateindex::forced_import(
timeindexes_to_high: ComputedVecsFromDateIndex::forced_import(
path,
"high",
Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_max(),
)?,
timeindexes_to_low: ComputedVecsFromDateindex::forced_import(
timeindexes_to_low: ComputedVecsFromDateIndex::forced_import(
path,
"low",
Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_min(),
)?,
timeindexes_to_close: ComputedVecsFromDateindex::forced_import(
timeindexes_to_close: ComputedVecsFromDateIndex::forced_import(
path,
"close",
Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_last(),
)?,
timeindexes_to_open_in_sats: ComputedVecsFromDateindex::forced_import(
timeindexes_to_open_in_sats: ComputedVecsFromDateIndex::forced_import(
path,
"open_in_sats",
VERSION + VERSION_IN_SATS + Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_first(),
)?,
timeindexes_to_high_in_sats: ComputedVecsFromDateindex::forced_import(
timeindexes_to_high_in_sats: ComputedVecsFromDateIndex::forced_import(
path,
"high_in_sats",
VERSION + VERSION_IN_SATS + Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_max(),
)?,
timeindexes_to_low_in_sats: ComputedVecsFromDateindex::forced_import(
timeindexes_to_low_in_sats: ComputedVecsFromDateIndex::forced_import(
path,
"low_in_sats",
VERSION + VERSION_IN_SATS + Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_min(),
)?,
timeindexes_to_close_in_sats: ComputedVecsFromDateindex::forced_import(
timeindexes_to_close_in_sats: ComputedVecsFromDateIndex::forced_import(
path,
"close_in_sats",
VERSION + VERSION_IN_SATS + Version::ZERO,

34
crates/brk_computer/src/storage/vecs/grouped/builder.rs
View File

@@ -8,6 +8,8 @@ use brk_vec::{
};
use color_eyre::eyre::ContextCompat;
use crate::utils::get_percentile;
use super::ComputedType;
#[derive(Clone, Debug)]
@@ -269,23 +271,23 @@ where
}
if let Some(_90p) = self._90p.as_mut() {
_90p.forced_push_at(i, Self::get_percentile(&values, 0.90), exit)?;
_90p.forced_push_at(i, get_percentile(&values, 0.90), exit)?;
}
if let Some(_75p) = self._75p.as_mut() {
_75p.forced_push_at(i, Self::get_percentile(&values, 0.75), exit)?;
_75p.forced_push_at(i, get_percentile(&values, 0.75), exit)?;
}
if let Some(median) = self.median.as_mut() {
median.forced_push_at(i, Self::get_percentile(&values, 0.50), exit)?;
median.forced_push_at(i, get_percentile(&values, 0.50), exit)?;
}
if let Some(_25p) = self._25p.as_mut() {
_25p.forced_push_at(i, Self::get_percentile(&values, 0.25), exit)?;
_25p.forced_push_at(i, get_percentile(&values, 0.25), exit)?;
}
if let Some(_10p) = self._10p.as_mut() {
_10p.forced_push_at(i, Self::get_percentile(&values, 0.10), exit)?;
_10p.forced_push_at(i, get_percentile(&values, 0.10), exit)?;
}
if let Some(min) = self.min.as_mut() {
@@ -472,28 +474,6 @@ where
Ok(())
}
fn get_percentile(sorted: &[T], percentile: f64) -> T {
let len = sorted.len();
if len == 0 {
panic!();
} else if len == 1 {
sorted[0].clone()
} else {
let index = (len - 1) as f64 * percentile;
let fract = index.fract();
if fract != 0.0 {
let left = sorted.get(index as usize).unwrap().clone();
let right = sorted.get(index.ceil() as usize).unwrap().clone();
left / 2 + right / 2
} else {
sorted.get(index as usize).unwrap().clone()
}
}
}
fn starting_index(&self, max_from: I) -> I {
max_from.min(I::from(
self.vecs().into_iter().map(|v| v.len()).min().unwrap(),

13
crates/brk_computer/src/storage/vecs/grouped/from_dateindex.rs
View File

@@ -10,7 +10,7 @@ use crate::storage::{Indexes, indexes};
use super::{ComputedType, ComputedVecBuilder, StorableVecGeneatorOptions};
#[derive(Clone)]
pub struct ComputedVecsFromDateindex<T>
pub struct ComputedVecsFromDateIndex<T>
where
T: ComputedType + PartialOrd,
{
@@ -25,7 +25,7 @@ where
const VERSION: Version = Version::ZERO;
impl<T> ComputedVecsFromDateindex<T>
impl<T> ComputedVecsFromDateIndex<T>
where
T: ComputedType,
{
@@ -94,6 +94,15 @@ where
exit,
)?;
self.compute_rest(indexes, starting_indexes, exit)
}
pub fn compute_rest(
&mut self,
indexes: &indexes::Vecs,
starting_indexes: &Indexes,
exit: &Exit,
) -> color_eyre::Result<()> {
self.dateindex_extra
.extend(starting_indexes.dateindex, &self.dateindex, exit)?;

2
crates/brk_computer/src/storage/vecs/grouped/mod.rs
View File

@@ -3,6 +3,7 @@ mod from_dateindex;
mod from_height;
mod from_height_strict;
mod from_txindex;
mod ratio_from_dateindex;
mod r#type;
mod value_from_height;
mod value_from_txindex;
@@ -12,6 +13,7 @@ pub use from_dateindex::*;
pub use from_height::*;
pub use from_height_strict::*;
pub use from_txindex::*;
pub use ratio_from_dateindex::*;
use r#type::*;
pub use value_from_height::*;
pub use value_from_txindex::*;

875
crates/brk_computer/src/storage/vecs/grouped/ratio_from_dateindex.rs Normal file
View File

@@ -0,0 +1,875 @@
use std::{f32, path::Path};
use brk_core::{Date, DateIndex, Dollars, StoredF32};
use brk_exit::Exit;
use brk_indexer::Indexer;
use brk_vec::{
AnyCollectableVec, AnyIterableVec, AnyVec, CollectableVec, Compressed, EagerVec, Result,
StoredIndex, VecIterator, Version,
};
// use rayon::prelude::*;
use crate::{
storage::{
fetched,
vecs::{Indexes, indexes},
},
utils::get_percentile,
};
use super::{ComputedVecsFromDateIndex, StorableVecGeneatorOptions};
#[derive(Clone)]
pub struct ComputedRatioVecsFromDateIndex {
pub price: ComputedVecsFromDateIndex<Dollars>,
pub ratio: ComputedVecsFromDateIndex<StoredF32>,
pub ratio_sma: ComputedVecsFromDateIndex<StoredF32>,
pub ratio_1w_sma: ComputedVecsFromDateIndex<StoredF32>,
pub ratio_1m_sma: ComputedVecsFromDateIndex<StoredF32>,
pub ratio_1y_sma: ComputedVecsFromDateIndex<StoredF32>,
pub ratio_1y_sma_momentum_oscillator: ComputedVecsFromDateIndex<StoredF32>,
pub ratio_standard_deviation: ComputedVecsFromDateIndex<StoredF32>,
pub ratio_p99_9: ComputedVecsFromDateIndex<StoredF32>,
pub ratio_p99_5: ComputedVecsFromDateIndex<StoredF32>,
pub ratio_p99: ComputedVecsFromDateIndex<StoredF32>,
pub ratio_p1: ComputedVecsFromDateIndex<StoredF32>,
pub ratio_p0_5: ComputedVecsFromDateIndex<StoredF32>,
pub ratio_p0_1: ComputedVecsFromDateIndex<StoredF32>,
pub ratio_p1sd: ComputedVecsFromDateIndex<StoredF32>,
pub ratio_p2sd: ComputedVecsFromDateIndex<StoredF32>,
pub ratio_p3sd: ComputedVecsFromDateIndex<StoredF32>,
pub ratio_m1sd: ComputedVecsFromDateIndex<StoredF32>,
pub ratio_m2sd: ComputedVecsFromDateIndex<StoredF32>,
pub ratio_m3sd: ComputedVecsFromDateIndex<StoredF32>,
pub ratio_p99_9_as_price: ComputedVecsFromDateIndex<Dollars>,
pub ratio_p99_5_as_price: ComputedVecsFromDateIndex<Dollars>,
pub ratio_p99_as_price: ComputedVecsFromDateIndex<Dollars>,
pub ratio_p1_as_price: ComputedVecsFromDateIndex<Dollars>,
pub ratio_p0_5_as_price: ComputedVecsFromDateIndex<Dollars>,
pub ratio_p0_1_as_price: ComputedVecsFromDateIndex<Dollars>,
pub ratio_p1sd_as_price: ComputedVecsFromDateIndex<Dollars>,
pub ratio_p2sd_as_price: ComputedVecsFromDateIndex<Dollars>,
pub ratio_p3sd_as_price: ComputedVecsFromDateIndex<Dollars>,
pub ratio_m1sd_as_price: ComputedVecsFromDateIndex<Dollars>,
pub ratio_m2sd_as_price: ComputedVecsFromDateIndex<Dollars>,
pub ratio_m3sd_as_price: ComputedVecsFromDateIndex<Dollars>,
}
const VERSION: Version = Version::ZERO;
impl ComputedRatioVecsFromDateIndex {
pub fn forced_import(
path: &Path,
name: &str,
// _compute_source: bool,
version: Version,
compressed: Compressed,
options: StorableVecGeneatorOptions,
) -> color_eyre::Result<Self> {
Ok(Self {
price: ComputedVecsFromDateIndex::forced_import(
path,
name,
VERSION + version,
compressed,
options,
)?,
ratio: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_sma: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_sma"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_1w_sma: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_1w_sma"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_1m_sma: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_1m_sma"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_1y_sma: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_1y_sma"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_1y_sma_momentum_oscillator: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_1y_sma_momentum_oscillator"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_standard_deviation: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_standard_deviation"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_p99_9: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_p99_9"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_p99_5: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_p99_5"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_p99: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_p99"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_p1: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_p1"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_p0_5: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_p0_5"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_p0_1: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_p0_1"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_p1sd: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_p1sd"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_p2sd: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_p2sd"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_p3sd: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_p3sd"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_m1sd: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_m1sd"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_m2sd: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_m2sd"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_m3sd: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_m3sd"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_p99_9_as_price: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_p99_9_as_price"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_p99_5_as_price: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_p99_5_as_price"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_p99_as_price: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_p99_as_price"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_p1_as_price: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_p1_as_price"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_p0_5_as_price: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_p0_5_as_price"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_p0_1_as_price: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_p0_1_as_price"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_p1sd_as_price: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_p1sd_as_price"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_p2sd_as_price: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_p2sd_as_price"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_p3sd_as_price: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_p3sd_as_price"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_m1sd_as_price: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_m1sd_as_price"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_m2sd_as_price: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_m2sd_as_price"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
ratio_m3sd_as_price: ComputedVecsFromDateIndex::forced_import(
path,
&format!("{name}_ratio_m3sd_as_price"),
VERSION + version + Version::TWO,
compressed,
options,
)?,
})
}
pub fn compute<F>(
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: &fetched::Vecs,
starting_indexes: &Indexes,
exit: &Exit,
compute: F,
) -> color_eyre::Result<()>
where
F: FnMut(
&mut EagerVec<DateIndex, Dollars>,
&Indexer,
&indexes::Vecs,
&Indexes,
&Exit,
) -> Result<()>,
{
self.price
.compute(indexer, indexes, starting_indexes, exit, compute)?;
let closes = &fetched.timeindexes_to_close.dateindex;
self.ratio.compute(
indexer,
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
let mut price = self.price.dateindex.into_iter();
v.compute_transform(
starting_indexes.dateindex,
closes,
|(i, close, ..)| {
let price = price.unwrap_get_inner(i);
if price == Dollars::ZERO {
(i, StoredF32::from(1.0))
} else {
(i, *close / price)
}
},
exit,
)
},
)?;
let min_ratio_date = DateIndex::try_from(Date::MIN_RATIO).unwrap();
self.ratio_sma.compute(
indexer,
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma_(
starting_indexes.dateindex,
&self.ratio.dateindex,
usize::MAX,
exit,
Some(min_ratio_date),
)
},
)?;
self.ratio_1w_sma.compute(
indexer,
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma_(
starting_indexes.dateindex,
&self.ratio.dateindex,
7,
exit,
Some(min_ratio_date),
)
},
)?;
self.ratio_1m_sma.compute(
indexer,
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma_(
starting_indexes.dateindex,
&self.ratio.dateindex,
30,
exit,
Some(min_ratio_date),
)
},
)?;
self.ratio_1y_sma.compute(
indexer,
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma_(
starting_indexes.dateindex,
&self.ratio.dateindex,
365,
exit,
Some(min_ratio_date),
)
},
)?;
self.ratio_1y_sma_momentum_oscillator.compute(
indexer,
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
let mut ratio_1y_sma_iter = self.ratio_1y_sma.dateindex.into_iter();
v.compute_transform(
starting_indexes.dateindex,
&self.ratio.dateindex,
|(i, ratio, ..)| {
(
i,
StoredF32::from(*ratio / *ratio_1y_sma_iter.unwrap_get_inner(i) - 1.0),
)
},
exit,
)
},
)?;
let ratio_version = self.ratio.dateindex.version();
self.mut_ratio_vecs()
.iter_mut()
.try_for_each(|v| -> Result<()> {
v.validate_computed_version_or_reset_file(
Version::ZERO + v.inner_version() + ratio_version,
)
})?;
let starting_dateindex = self
.mut_ratio_vecs()
.iter()
.map(|v| DateIndex::from(v.len()))
.min()
.unwrap()
.min(starting_indexes.dateindex);
let mut sorted = self.ratio.dateindex.collect_range(
Some(min_ratio_date.unwrap_to_usize()),
Some(starting_dateindex.unwrap_to_usize()),
)?;
sorted.sort_unstable();
// if sorted.len() != starting_dateindex.unwrap_to_usize() - min_ratio_date.unwrap_to_usize() {
// unreachable!();
// }
let mut sma_iter = self.ratio_sma.dateindex.into_iter();
let nan = StoredF32::from(f32::NAN);
self.ratio
.dateindex
.iter_at(starting_dateindex)
.try_for_each(|(index, ratio)| -> Result<()> {
if index < min_ratio_date {
self.ratio_p0_1.dateindex.forced_push_at(index, nan, exit)?;
self.ratio_p0_5.dateindex.forced_push_at(index, nan, exit)?;
self.ratio_p1.dateindex.forced_push_at(index, nan, exit)?;
self.ratio_p99.dateindex.forced_push_at(index, nan, exit)?;
self.ratio_p99_5
.dateindex
.forced_push_at(index, nan, exit)?;
self.ratio_p99_9
.dateindex
.forced_push_at(index, nan, exit)?;
self.ratio_standard_deviation
.dateindex
.forced_push_at(index, nan, exit)?;
self.ratio_p1sd.dateindex.forced_push_at(index, nan, exit)?;
self.ratio_p2sd.dateindex.forced_push_at(index, nan, exit)?;
self.ratio_p3sd.dateindex.forced_push_at(index, nan, exit)?;
self.ratio_m1sd.dateindex.forced_push_at(index, nan, exit)?;
self.ratio_m2sd.dateindex.forced_push_at(index, nan, exit)?;
self.ratio_m3sd.dateindex.forced_push_at(index, nan, exit)?;
} else {
let ratio = ratio.into_inner();
let pos = sorted.binary_search(&ratio).unwrap_or_else(|pos| pos);
sorted.insert(pos, ratio);
self.ratio_p0_1.dateindex.forced_push_at(
index,
get_percentile(&sorted, 0.001),
exit,
)?;
self.ratio_p0_5.dateindex.forced_push_at(
index,
get_percentile(&sorted, 0.005),
exit,
)?;
self.ratio_p1.dateindex.forced_push_at(
index,
get_percentile(&sorted, 0.01),
exit,
)?;
self.ratio_p99.dateindex.forced_push_at(
index,
get_percentile(&sorted, 0.99),
exit,
)?;
self.ratio_p99_5.dateindex.forced_push_at(
index,
get_percentile(&sorted, 0.995),
exit,
)?;
self.ratio_p99_9.dateindex.forced_push_at(
index,
get_percentile(&sorted, 0.999),
exit,
)?;
let avg = sma_iter.unwrap_get_inner(index);
let sd = StoredF32::from(
(sorted.iter().map(|v| (**v - *avg).powi(2)).sum::<f32>()
/ (index.unwrap_to_usize() + 1) as f32)
.sqrt(),
);
self.ratio_standard_deviation
.dateindex
.forced_push_at(index, sd, exit)?;
self.ratio_p1sd
.dateindex
.forced_push_at(index, avg + sd, exit)?;
self.ratio_p2sd
.dateindex
.forced_push_at(index, avg + 2 * sd, exit)?;
self.ratio_p3sd
.dateindex
.forced_push_at(index, avg + 3 * sd, exit)?;
self.ratio_m1sd
.dateindex
.forced_push_at(index, avg - sd, exit)?;
self.ratio_m2sd
.dateindex
.forced_push_at(index, avg - 2 * sd, exit)?;
self.ratio_m3sd
.dateindex
.forced_push_at(index, avg - 3 * sd, exit)?;
}
Ok(())
})?;
self.mut_ratio_vecs()
.into_iter()
.try_for_each(|v| v.safe_flush(exit))?;
self.ratio_p99_9
.compute_rest(indexes, starting_indexes, exit)?;
self.ratio_p99_5
.compute_rest(indexes, starting_indexes, exit)?;
self.ratio_p99
.compute_rest(indexes, starting_indexes, exit)?;
self.ratio_p1
.compute_rest(indexes, starting_indexes, exit)?;
self.ratio_p0_5
.compute_rest(indexes, starting_indexes, exit)?;
self.ratio_p0_1
.compute_rest(indexes, starting_indexes, exit)?;
self.ratio_standard_deviation
.compute_rest(indexes, starting_indexes, exit)?;
self.ratio_p1sd
.compute_rest(indexes, starting_indexes, exit)?;
self.ratio_p2sd
.compute_rest(indexes, starting_indexes, exit)?;
self.ratio_p3sd
.compute_rest(indexes, starting_indexes, exit)?;
self.ratio_m1sd
.compute_rest(indexes, starting_indexes, exit)?;
self.ratio_m2sd
.compute_rest(indexes, starting_indexes, exit)?;
self.ratio_m3sd
.compute_rest(indexes, starting_indexes, exit)?;
self.ratio_p99_as_price.compute(
indexer,
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
let mut iter = self.ratio_p99.dateindex.into_iter();
vec.compute_transform(
starting_indexes.dateindex,
&self.price.dateindex,
|(i, price, ..)| {
let multiplier = iter.unwrap_get_inner(i);
(i, price * multiplier)
},
exit,
)
},
)?;
self.ratio_p99_5_as_price.compute(
indexer,
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
let mut iter = self.ratio_p99_5.dateindex.into_iter();
vec.compute_transform(
starting_indexes.dateindex,
&self.price.dateindex,
|(i, price, ..)| {
let multiplier = iter.unwrap_get_inner(i);
(i, price * multiplier)
},
exit,
)
},
)?;
self.ratio_p99_9_as_price.compute(
indexer,
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
let mut iter = self.ratio_p99_9.dateindex.into_iter();
vec.compute_transform(
starting_indexes.dateindex,
&self.price.dateindex,
|(i, price, ..)| {
let multiplier = iter.unwrap_get_inner(i);
(i, price * multiplier)
},
exit,
)
},
)?;
self.ratio_p1_as_price.compute(
indexer,
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
let mut iter = self.ratio_p1.dateindex.into_iter();
vec.compute_transform(
starting_indexes.dateindex,
&self.price.dateindex,
|(i, price, ..)| {
let multiplier = iter.unwrap_get_inner(i);
(i, price * multiplier)
},
exit,
)
},
)?;
self.ratio_p0_5_as_price.compute(
indexer,
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
let mut iter = self.ratio_p0_5.dateindex.into_iter();
vec.compute_transform(
starting_indexes.dateindex,
&self.price.dateindex,
|(i, price, ..)| {
let multiplier = iter.unwrap_get_inner(i);
(i, price * multiplier)
},
exit,
)
},
)?;
self.ratio_p0_1_as_price.compute(
indexer,
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
let mut iter = self.ratio_p0_1.dateindex.into_iter();
vec.compute_transform(
starting_indexes.dateindex,
&self.price.dateindex,
|(i, price, ..)| {
let multiplier = iter.unwrap_get_inner(i);
(i, price * multiplier)
},
exit,
)
},
)?;
self.ratio_p1sd_as_price.compute(
indexer,
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
let mut iter = self.ratio_p1sd.dateindex.into_iter();
vec.compute_transform(
starting_indexes.dateindex,
&self.price.dateindex,
|(i, price, ..)| {
let multiplier = iter.unwrap_get_inner(i);
(i, price * multiplier)
},
exit,
)
},
)?;
self.ratio_p2sd_as_price.compute(
indexer,
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
let mut iter = self.ratio_p2sd.dateindex.into_iter();
vec.compute_transform(
starting_indexes.dateindex,
&self.price.dateindex,
|(i, price, ..)| {
let multiplier = iter.unwrap_get_inner(i);
(i, price * multiplier)
},
exit,
)
},
)?;
self.ratio_p3sd_as_price.compute(
indexer,
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
let mut iter = self.ratio_p3sd.dateindex.into_iter();
vec.compute_transform(
starting_indexes.dateindex,
&self.price.dateindex,
|(i, price, ..)| {
let multiplier = iter.unwrap_get_inner(i);
(i, price * multiplier)
},
exit,
)
},
)?;
self.ratio_m1sd_as_price.compute(
indexer,
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
let mut iter = self.ratio_m1sd.dateindex.into_iter();
vec.compute_transform(
starting_indexes.dateindex,
&self.price.dateindex,
|(i, price, ..)| {
let multiplier = iter.unwrap_get_inner(i);
(i, price * multiplier)
},
exit,
)
},
)?;
self.ratio_m2sd_as_price.compute(
indexer,
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
let mut iter = self.ratio_m2sd.dateindex.into_iter();
vec.compute_transform(
starting_indexes.dateindex,
&self.price.dateindex,
|(i, price, ..)| {
let multiplier = iter.unwrap_get_inner(i);
(i, price * multiplier)
},
exit,
)
},
)?;
self.ratio_m3sd_as_price.compute(
indexer,
indexes,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
let mut iter = self.ratio_m3sd.dateindex.into_iter();
vec.compute_transform(
starting_indexes.dateindex,
&self.price.dateindex,
|(i, price, ..)| {
let multiplier = iter.unwrap_get_inner(i);
(i, price * multiplier)
},
exit,
)
},
)?;
Ok(())
}
fn mut_ratio_vecs(&mut self) -> Vec<&mut EagerVec<DateIndex, StoredF32>> {
vec![
&mut self.ratio_standard_deviation.dateindex,
&mut self.ratio_p99_9.dateindex,
&mut self.ratio_p99_5.dateindex,
&mut self.ratio_p99.dateindex,
&mut self.ratio_p1.dateindex,
&mut self.ratio_p0_5.dateindex,
&mut self.ratio_p0_1.dateindex,
&mut self.ratio_p1sd.dateindex,
&mut self.ratio_p2sd.dateindex,
&mut self.ratio_p3sd.dateindex,
&mut self.ratio_m1sd.dateindex,
&mut self.ratio_m2sd.dateindex,
&mut self.ratio_m3sd.dateindex,
]
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
[
self.price.vecs(),
self.ratio.vecs(),
self.ratio_sma.vecs(),
self.ratio_1w_sma.vecs(),
self.ratio_1m_sma.vecs(),
self.ratio_1y_sma.vecs(),
self.ratio_1y_sma_momentum_oscillator.vecs(),
self.ratio_standard_deviation.vecs(),
self.ratio_p99_9.vecs(),
self.ratio_p99_5.vecs(),
self.ratio_p99.vecs(),
self.ratio_p1.vecs(),
self.ratio_p0_5.vecs(),
self.ratio_p0_1.vecs(),
self.ratio_p1sd.vecs(),
self.ratio_p2sd.vecs(),
self.ratio_p3sd.vecs(),
self.ratio_m1sd.vecs(),
self.ratio_m2sd.vecs(),
self.ratio_m3sd.vecs(),
self.ratio_p99_9_as_price.vecs(),
self.ratio_p99_5_as_price.vecs(),
self.ratio_p99_as_price.vecs(),
self.ratio_p1_as_price.vecs(),
self.ratio_p0_5_as_price.vecs(),
self.ratio_p0_1_as_price.vecs(),
self.ratio_p1sd_as_price.vecs(),
self.ratio_p2sd_as_price.vecs(),
self.ratio_p3sd_as_price.vecs(),
self.ratio_m1sd_as_price.vecs(),
self.ratio_m2sd_as_price.vecs(),
self.ratio_m3sd_as_price.vecs(),
]
.concat()
}
}

437
crates/brk_computer/src/storage/vecs/market.rs
View File

@@ -1,4 +1,4 @@
use std::{fs, path::Path};
use std::{fs, path::Path, thread};
use brk_core::{Dollars, StoredF64, StoredUsize};
use brk_exit::Exit;
@@ -7,32 +7,34 @@ use brk_vec::{AnyCollectableVec, Compressed, Computation, StoredIndex, VecIterat
use super::{
Indexes, fetched,
grouped::{ComputedVecsFromDateindex, StorableVecGeneatorOptions},
grouped::{
ComputedRatioVecsFromDateIndex, ComputedVecsFromDateIndex, StorableVecGeneatorOptions,
},
indexes, transactions,
};
#[derive(Clone)]
pub struct Vecs {
pub indexes_to_marketcap: ComputedVecsFromDateindex<Dollars>,
pub indexes_to_ath: ComputedVecsFromDateindex<Dollars>,
pub indexes_to_drawdown: ComputedVecsFromDateindex<StoredF64>,
pub indexes_to_days_since_ath: ComputedVecsFromDateindex<StoredUsize>,
pub indexes_to_max_days_between_ath: ComputedVecsFromDateindex<StoredUsize>,
pub indexes_to_max_years_between_ath: ComputedVecsFromDateindex<StoredF64>,
pub indexes_to_marketcap: ComputedVecsFromDateIndex<Dollars>,
pub indexes_to_ath: ComputedVecsFromDateIndex<Dollars>,
pub indexes_to_drawdown: ComputedVecsFromDateIndex<StoredF64>,
pub indexes_to_days_since_ath: ComputedVecsFromDateIndex<StoredUsize>,
pub indexes_to_max_days_between_ath: ComputedVecsFromDateIndex<StoredUsize>,
pub indexes_to_max_years_between_ath: ComputedVecsFromDateIndex<StoredF64>,
pub indexes_to_1w_sma: ComputedVecsFromDateindex<Dollars>,
pub indexes_to_8d_sma: ComputedVecsFromDateindex<Dollars>,
pub indexes_to_13d_sma: ComputedVecsFromDateindex<Dollars>,
pub indexes_to_21d_sma: ComputedVecsFromDateindex<Dollars>,
pub indexes_to_1m_sma: ComputedVecsFromDateindex<Dollars>,
pub indexes_to_34d_sma: ComputedVecsFromDateindex<Dollars>,
pub indexes_to_55d_sma: ComputedVecsFromDateindex<Dollars>,
pub indexes_to_89d_sma: ComputedVecsFromDateindex<Dollars>,
pub indexes_to_144d_sma: ComputedVecsFromDateindex<Dollars>,
pub indexes_to_1y_sma: ComputedVecsFromDateindex<Dollars>,
pub indexes_to_2y_sma: ComputedVecsFromDateindex<Dollars>,
pub indexes_to_200w_sma: ComputedVecsFromDateindex<Dollars>,
pub indexes_to_4y_sma: ComputedVecsFromDateindex<Dollars>,
pub indexes_to_1w_sma: ComputedRatioVecsFromDateIndex,
pub indexes_to_8d_sma: ComputedRatioVecsFromDateIndex,
pub indexes_to_13d_sma: ComputedRatioVecsFromDateIndex,
pub indexes_to_21d_sma: ComputedRatioVecsFromDateIndex,
pub indexes_to_1m_sma: ComputedRatioVecsFromDateIndex,
pub indexes_to_34d_sma: ComputedRatioVecsFromDateIndex,
pub indexes_to_55d_sma: ComputedRatioVecsFromDateIndex,
pub indexes_to_89d_sma: ComputedRatioVecsFromDateIndex,
pub indexes_to_144d_sma: ComputedRatioVecsFromDateIndex,
pub indexes_to_1y_sma: ComputedRatioVecsFromDateIndex,
pub indexes_to_2y_sma: ComputedRatioVecsFromDateIndex,
pub indexes_to_200w_sma: ComputedRatioVecsFromDateIndex,
pub indexes_to_4y_sma: ComputedRatioVecsFromDateIndex,
}
impl Vecs {
@@ -44,42 +46,42 @@ impl Vecs {
fs::create_dir_all(path)?;
Ok(Self {
indexes_to_marketcap: ComputedVecsFromDateindex::forced_import(
indexes_to_marketcap: ComputedVecsFromDateIndex::forced_import(
path,
"marketcap",
Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_last(),
)?,
indexes_to_ath: ComputedVecsFromDateindex::forced_import(
indexes_to_ath: ComputedVecsFromDateIndex::forced_import(
path,
"ath",
Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_last(),
)?,
indexes_to_drawdown: ComputedVecsFromDateindex::forced_import(
indexes_to_drawdown: ComputedVecsFromDateIndex::forced_import(
path,
"drawdown",
Version::ONE,
compressed,
StorableVecGeneatorOptions::default().add_last(),
)?,
indexes_to_days_since_ath: ComputedVecsFromDateindex::forced_import(
indexes_to_days_since_ath: ComputedVecsFromDateIndex::forced_import(
path,
"days_since_ath",
Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_last(),
)?,
indexes_to_max_days_between_ath: ComputedVecsFromDateindex::forced_import(
indexes_to_max_days_between_ath: ComputedVecsFromDateIndex::forced_import(
path,
"max_days_between_ath",
Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_last(),
)?,
indexes_to_max_years_between_ath: ComputedVecsFromDateindex::forced_import(
indexes_to_max_years_between_ath: ComputedVecsFromDateIndex::forced_import(
path,
"max_years_between_ath",
Version::ZERO,
@@ -87,91 +89,91 @@ impl Vecs {
StorableVecGeneatorOptions::default().add_last(),
)?,
indexes_to_1w_sma: ComputedVecsFromDateindex::forced_import(
indexes_to_1w_sma: ComputedRatioVecsFromDateIndex::forced_import(
path,
"1w_sma",
Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_last(),
)?,
indexes_to_8d_sma: ComputedVecsFromDateindex::forced_import(
indexes_to_8d_sma: ComputedRatioVecsFromDateIndex::forced_import(
path,
"8d_sma",
Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_last(),
)?,
indexes_to_13d_sma: ComputedVecsFromDateindex::forced_import(
indexes_to_13d_sma: ComputedRatioVecsFromDateIndex::forced_import(
path,
"13d_sma",
Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_last(),
)?,
indexes_to_21d_sma: ComputedVecsFromDateindex::forced_import(
indexes_to_21d_sma: ComputedRatioVecsFromDateIndex::forced_import(
path,
"21d_sma",
Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_last(),
)?,
indexes_to_1m_sma: ComputedVecsFromDateindex::forced_import(
indexes_to_1m_sma: ComputedRatioVecsFromDateIndex::forced_import(
path,
"1m_sma",
Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_last(),
)?,
indexes_to_34d_sma: ComputedVecsFromDateindex::forced_import(
indexes_to_34d_sma: ComputedRatioVecsFromDateIndex::forced_import(
path,
"34d_sma",
Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_last(),
)?,
indexes_to_55d_sma: ComputedVecsFromDateindex::forced_import(
indexes_to_55d_sma: ComputedRatioVecsFromDateIndex::forced_import(
path,
"55d_sma",
Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_last(),
)?,
indexes_to_89d_sma: ComputedVecsFromDateindex::forced_import(
indexes_to_89d_sma: ComputedRatioVecsFromDateIndex::forced_import(
path,
"89d_sma",
Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_last(),
)?,
indexes_to_144d_sma: ComputedVecsFromDateindex::forced_import(
indexes_to_144d_sma: ComputedRatioVecsFromDateIndex::forced_import(
path,
"144d_sma",
Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_last(),
)?,
indexes_to_1y_sma: ComputedVecsFromDateindex::forced_import(
indexes_to_1y_sma: ComputedRatioVecsFromDateIndex::forced_import(
path,
"1y_sma",
Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_last(),
)?,
indexes_to_2y_sma: ComputedVecsFromDateindex::forced_import(
indexes_to_2y_sma: ComputedRatioVecsFromDateIndex::forced_import(
path,
"2y_sma",
Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_last(),
)?,
indexes_to_200w_sma: ComputedVecsFromDateindex::forced_import(
indexes_to_200w_sma: ComputedRatioVecsFromDateIndex::forced_import(
path,
"200w_sma",
Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_last(),
)?,
indexes_to_4y_sma: ComputedVecsFromDateindex::forced_import(
indexes_to_4y_sma: ComputedRatioVecsFromDateIndex::forced_import(
path,
"4y_sma",
Version::ZERO,
@@ -342,202 +344,243 @@ impl Vecs {
},
)?;
self.indexes_to_1w_sma.compute(
indexer,
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
7,
thread::scope(|s| -> color_eyre::Result<()> {
s.spawn(|| -> color_eyre::Result<()> {
self.indexes_to_1w_sma.compute(
indexer,
indexes,
fetched,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
7,
exit,
)
},
)
},
)?;
});
self.indexes_to_8d_sma.compute(
indexer,
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
8,
s.spawn(|| -> color_eyre::Result<()> {
self.indexes_to_8d_sma.compute(
indexer,
indexes,
fetched,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
8,
exit,
)
},
)
},
)?;
});
self.indexes_to_13d_sma.compute(
indexer,
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
13,
s.spawn(|| -> color_eyre::Result<()> {
self.indexes_to_13d_sma.compute(
indexer,
indexes,
fetched,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
13,
exit,
)
},
)
},
)?;
});
self.indexes_to_21d_sma.compute(
indexer,
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
21,
s.spawn(|| -> color_eyre::Result<()> {
self.indexes_to_21d_sma.compute(
indexer,
indexes,
fetched,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
21,
exit,
)
},
)
},
)?;
});
self.indexes_to_1m_sma.compute(
indexer,
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
30,
s.spawn(|| -> color_eyre::Result<()> {
self.indexes_to_1m_sma.compute(
indexer,
indexes,
fetched,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
30,
exit,
)
},
)
},
)?;
});
self.indexes_to_34d_sma.compute(
indexer,
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
34,
s.spawn(|| -> color_eyre::Result<()> {
self.indexes_to_34d_sma.compute(
indexer,
indexes,
fetched,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
34,
exit,
)
},
)
},
)?;
});
self.indexes_to_55d_sma.compute(
indexer,
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
55,
s.spawn(|| -> color_eyre::Result<()> {
self.indexes_to_55d_sma.compute(
indexer,
indexes,
fetched,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
55,
exit,
)
},
)
},
)?;
});
self.indexes_to_89d_sma.compute(
indexer,
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
89,
s.spawn(|| -> color_eyre::Result<()> {
self.indexes_to_89d_sma.compute(
indexer,
indexes,
fetched,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
89,
exit,
)
},
)
},
)?;
});
self.indexes_to_144d_sma.compute(
indexer,
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
144,
s.spawn(|| -> color_eyre::Result<()> {
self.indexes_to_144d_sma.compute(
indexer,
indexes,
fetched,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
144,
exit,
)
},
)
},
)?;
});
self.indexes_to_1y_sma.compute(
indexer,
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
365,
s.spawn(|| -> color_eyre::Result<()> {
self.indexes_to_1y_sma.compute(
indexer,
indexes,
fetched,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
365,
exit,
)
},
)
},
)?;
});
self.indexes_to_2y_sma.compute(
indexer,
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
2 * 365,
s.spawn(|| -> color_eyre::Result<()> {
self.indexes_to_2y_sma.compute(
indexer,
indexes,
fetched,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
2 * 365,
exit,
)
},
)
},
)?;
});
self.indexes_to_200w_sma.compute(
indexer,
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
200 * 7,
s.spawn(|| -> color_eyre::Result<()> {
self.indexes_to_200w_sma.compute(
indexer,
indexes,
fetched,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
200 * 7,
exit,
)
},
)
},
)?;
});
self.indexes_to_4y_sma.compute(
indexer,
indexes,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
4 * 365,
s.spawn(|| -> color_eyre::Result<()> {
self.indexes_to_4y_sma.compute(
indexer,
indexes,
fetched,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
v.compute_sma(
starting_indexes.dateindex,
&fetched.timeindexes_to_close.dateindex,
4 * 365,
exit,
)
},
)
},
)?;
});
Ok(())
Ok(())
})
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {

10
crates/brk_computer/src/storage/vecs/mining.rs
View File

@@ -7,15 +7,15 @@ use brk_vec::{AnyCollectableVec, Compressed, Computation, VecIterator, Version};
use super::{
Indexes,
grouped::{ComputedVecsFromDateindex, ComputedVecsFromHeight, StorableVecGeneatorOptions},
grouped::{ComputedVecsFromDateIndex, ComputedVecsFromHeight, StorableVecGeneatorOptions},
indexes,
};
#[derive(Clone)]
pub struct Vecs {
pub indexes_to_difficulty: ComputedVecsFromHeight<StoredF64>,
pub indexes_to_difficultyepoch: ComputedVecsFromDateindex<DifficultyEpoch>,
pub indexes_to_halvingepoch: ComputedVecsFromDateindex<HalvingEpoch>,
pub indexes_to_difficultyepoch: ComputedVecsFromDateIndex<DifficultyEpoch>,
pub indexes_to_halvingepoch: ComputedVecsFromDateIndex<HalvingEpoch>,
}
impl Vecs {
@@ -35,14 +35,14 @@ impl Vecs {
compressed,
StorableVecGeneatorOptions::default().add_last(),
)?,
indexes_to_difficultyepoch: ComputedVecsFromDateindex::forced_import(
indexes_to_difficultyepoch: ComputedVecsFromDateIndex::forced_import(
path,
"difficultyepoch",
Version::ZERO,
compressed,
StorableVecGeneatorOptions::default().add_last(),
)?,
indexes_to_halvingepoch: ComputedVecsFromDateindex::forced_import(
indexes_to_halvingepoch: ComputedVecsFromDateIndex::forced_import(
path,
"halvingepoch",
Version::ZERO,

27
crates/brk_computer/src/utils.rs Normal file
View File

@@ -0,0 +1,27 @@
use std::ops::{Add, Div};
pub fn get_percentile<T>(sorted: &[T], percentile: f64) -> T
where
T: Clone + Div<usize, Output = T> + Add<T, Output = T>,
{
let len = sorted.len();
if len == 0 {
panic!();
} else if len == 1 {
sorted[0].clone()
} else {
let index = (len - 1) as f64 * percentile;
let fract = index.fract();
if fract != 0.0 {
let left = sorted.get(index as usize).unwrap().clone();
let right = sorted.get(index.ceil() as usize).unwrap().clone();
left / 2 + right / 2
} else {
// dbg!(sorted.len(), index);
sorted.get(index as usize).unwrap().clone()
}
}
}