qust 0.1.5

A crate for finance quantative reserach
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

use qust_ds::prelude::*;
use crate::trade::prelude::*;
use crate::sig::posi::Dire;
use super::order_types::*;

pub type WithDi<'a, T> = WithInfo<T, &'a Di>; 
pub type WithTicker<T> = WithInfo<T, Ticker>;
pub type TickerTradeInfo = WithTicker<Vec<TradeInfo>>;
pub type WithDire<T> = WithInfo<T, Dire>;

#[derive(Clone)]
pub struct DiKline<'a> {
    pub di: &'a Di,
    pub i: usize,
}

impl std::fmt::Debug for DiKline<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let price = &self.di.pcon.price;
        let kline = KlineData {
            t: price.t[self.i],
            o: price.o[self.i],
            h: price.h[self.i],
            l: price.l[self.i],
            c: price.c[self.i],
            v: price.v[self.i],
            ki: price.ki[self.i].clone(),
        };
        write!(f, "{:?}", kline)
    }
}

#[derive(Debug, Clone)]
pub struct StreamApiType<'a> {
    pub tick_data: &'a TickData,
    pub hold: &'a Hold,
}

pub type FnMutBox<'a, T, N> = Box<dyn FnMut(T) -> N + 'a>;
pub type RetFnApi<'a> = Box<dyn FnMut(StreamApiType) -> OrderAction + 'a>;

pub trait BtTick<Input> {
    type Output;
    fn bt_tick(&self, input: Input) -> Self::Output;
}


pub trait BtKline<Input> {
    type Output;
    fn bt_kline(&self, input: Input) -> Self::Output;
}



pub trait ApiType: Send + Sync {
    fn api_type(&self) -> RetFnApi;
    fn api_type_box(&self) -> Box<dyn ApiType>
    where
        Self: Clone + 'static,
    {
        Box::new(self.clone())
    }
}
pub type ApiTypeBox = Box<dyn ApiType>;


#[derive(Debug, Clone)]
pub struct TradeInfo {
    pub time: dt,
    pub action: OrderAction,
}