stock-trek 0.8.9

Stock Trek time-series analysis
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

use crate::{
    allocations::allocation::{Allocation, AllocationTrait},
    cex::{asset_id::AssetId, cex_id::CexId},
};
use std::collections::HashMap;

#[derive(Debug, Clone, Default)]
pub struct InMemoryAllocation {
    cex_assets: HashMap<CexId, Allocations>,
}
impl InMemoryAllocation {
    pub fn new(cex_assets: HashMap<CexId, Allocations>) -> Self {
        Self { cex_assets }
    }
    pub fn builder() -> Builder {
        Builder::new()
    }
}

impl From<InMemoryAllocation> for Allocation {
    fn from(value: InMemoryAllocation) -> Self {
        Box::new(value)
    }
}

#[derive(Debug, Clone, Default)]
pub struct Allocations {
    asset_allocations: HashMap<AssetId, f64>,
}
impl Allocations {
    pub fn new(asset_allocations: HashMap<AssetId, f64>) -> Self {
        Self { asset_allocations }
    }
}

impl AllocationTrait for InMemoryAllocation {
    fn allocation_for_asset_total(&self, asset_id: &AssetId) -> f64 {
        self.cex_assets
            .values()
            .map(|assets| assets.asset_allocations.get(asset_id).unwrap_or(&0.0))
            .sum()
    }
    fn allocation_for_asset_in_cex(&self, asset_id: &AssetId, cex_id: &CexId) -> f64 {
        self.cex_assets
            .get(cex_id)
            .and_then(|assets| assets.asset_allocations.get(asset_id))
            .copied()
            .unwrap_or(0.0)
    }
}

#[derive(Clone, Default)]
pub struct Builder {
    cex_allocations: HashMap<CexId, Allocations>,
}

impl Builder {
    pub fn new() -> Self {
        Self {
            cex_allocations: HashMap::new(),
        }
    }
    pub fn allocation(&mut self, cex_id: CexId, asset_id: AssetId, quantity: f64) -> &mut Self {
        assert!(quantity > 0.0, "allocation must be greater than 0.0");
        assert!(
            quantity <= 100.0,
            "allocation must be less or equal to 100.0"
        );
        self.cex_allocations
            .entry(cex_id)
            .or_insert_with(|| Allocations::new(HashMap::new()))
            .asset_allocations
            .entry(asset_id)
            .and_modify(|prev| *prev += quantity)
            .or_insert(quantity);
        self
    }
    pub fn build(&self) -> InMemoryAllocation {
        InMemoryAllocation::new(self.cex_allocations.clone())
    }
}