stock-trek 0.6.2

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

use crate::{asset_id::AssetId, order::trading_pair::TradingPair};
use rust_decimal::{prelude::FromPrimitive, Decimal, RoundingStrategy};
use std::collections::HashMap;

#[derive(Clone)]
pub struct IncrementSizes {
    tick_size: Decimal,
    lot_size: Decimal,
}

impl IncrementSizes {
    pub fn to_valid_tick(&self, tick: f64, strategy: RoundingStrategy) -> Decimal {
        Self::to_valid_decimal(tick, self.tick_size, strategy)
    }
    pub fn to_valid_lot(&self, lot: f64, strategy: RoundingStrategy) -> Decimal {
        Self::to_valid_decimal(lot, self.lot_size, strategy)
    }
    pub fn to_valid_decimal(value: f64, step: Decimal, strategy: RoundingStrategy) -> Decimal {
        let value_as_decimal = Decimal::from_f64(value).unwrap_or(Decimal::ZERO);
        if step == Decimal::ZERO {
            return value_as_decimal;
        }
        let steps = value_as_decimal / step;
        let rounded_steps = steps.round_dp_with_strategy(0, strategy);
        rounded_steps * step
    }
}

pub struct IncrementSizesBuilder {
    map: HashMap<TradingPair, IncrementSizes>,
}

impl IncrementSizesBuilder {
    pub fn new() -> Self {
        Self {
            map: HashMap::new(),
        }
    }
    pub fn with(
        &mut self,
        base: AssetId,
        quote: AssetId,
        tick_size: Decimal,
        lot_size: Decimal,
    ) -> &mut Self {
        self.map.insert(
            TradingPair::new(base, quote),
            IncrementSizes {
                tick_size,
                lot_size,
            },
        );
        self
    }
    pub fn build(&self) -> HashMap<TradingPair, IncrementSizes> {
        self.map.clone()
    }
}

impl Default for IncrementSizesBuilder {
    fn default() -> Self {
        IncrementSizesBuilder::new()
    }
}