stock-trek 0.4.10

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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use std::collections::HashMap;

use crate::market_data::{
    aligned_window::AlignedWindow,
    market_aligned_window::MarketAlignedWindow,
    market_candle::MarketCandle,
    market_order_book::MarketOrderBook,
    market_quote::{MarketQuote, PriceQuantity},
    market_rolling_window::MarketRollingWindow,
    market_tick::MarketTick,
    market_ticks::MarketTicks,
    rolling_window::RollingWindow,
    timestamp::TimestampMillis,
};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Market {
    pub base_increment: f64,
    pub quote_increment: f64,
    pub minimum_notional: f64,
    pub ticks: MarketTicks,
    pub rolling: MarketRollingWindow,
    pub aligned: MarketAlignedWindow,
    pub order_book: MarketOrderBook,
}

pub struct Builder {
    pub base_increment: f64,
    pub quote_increment: f64,
    pub minimum_notional: f64,
    pub ticks: Vec<MarketTick>,
    pub rolling: HashMap<RollingWindow, MarketCandle>,
    pub aligned: HashMap<AlignedWindow, Vec<MarketCandle>>,
    pub order_book_asks: Vec<MarketQuote>,
    pub order_book_bids: Vec<MarketQuote>,
}

impl Builder {
    pub fn new(base_increment: f64, quote_increment: f64, minimum_notional: f64) -> Self {
        Self {
            base_increment,
            quote_increment,
            minimum_notional,
            ticks: Vec::new(),
            rolling: HashMap::new(),
            aligned: HashMap::new(),
            order_book_bids: Vec::new(),
            order_book_asks: Vec::new(),
        }
    }
    pub fn tick(
        &mut self,
        timestamp_millis: TimestampMillis,
        bid: PriceQuantity,
        ask: PriceQuantity,
        last: PriceQuantity,
    ) -> &mut Self {
        let tick = MarketTick {
            timestamp_millis,
            bid: MarketQuote {
                price: bid.0,
                quantity: bid.1,
            },
            ask: MarketQuote {
                price: ask.0,
                quantity: ask.1,
            },
            last: MarketQuote {
                price: last.0,
                quantity: last.1,
            },
        };
        self.ticks.push(tick);
        self
    }
    pub fn rolling_set_candle(&mut self, window: RollingWindow, candle: MarketCandle) -> &mut Self {
        self.rolling.insert(window, candle);
        self
    }
    pub fn aligned_push_candle(
        &mut self,
        window: AlignedWindow,
        candle: MarketCandle,
    ) -> &mut Self {
        self.aligned.entry(window).or_default().push(candle);
        self
    }
    pub fn order_book_bid(&mut self, price: f64, quantity: f64) -> &mut Self {
        self.order_book_bids.push(MarketQuote { price, quantity });
        self
    }
    pub fn order_book_ask(&mut self, price: f64, quantity: f64) -> &mut Self {
        self.order_book_asks.push(MarketQuote { price, quantity });
        self
    }
    pub fn build(&self) -> Market {
        Market {
            base_increment: self.base_increment,
            quote_increment: self.quote_increment,
            minimum_notional: self.minimum_notional,
            ticks: MarketTicks::new(self.ticks.clone()),
            rolling: MarketRollingWindow::new(self.rolling.clone()),
            aligned: MarketAlignedWindow::new(self.aligned.clone()),
            order_book: MarketOrderBook::new(
                self.order_book_bids.clone(),
                self.order_book_asks.clone(),
            ),
        }
    }
}