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
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195

use crate::prelude::{Dire, TickData, ToNum };
use super::order_types::*;
use super::bt::*;
use qust_ds::prelude::*;
use qust_derive::*;
use dyn_clone::{clone_trait_object, DynClone};

pub type OrderTargetAndPrice = WithDire<(f32, f32)>;
pub type RetFnAlgo = Box<dyn FnMut(&StreamAlgo) -> OrderAction +  'static>;
pub type WithAlgoBox<T> = WithInfo<T, AlgoBox>;


impl ToNum for OrderTargetAndPrice {
    fn to_num(&self) -> f32 {
        match self.info {
            Dire::Lo => self.data.0,
            Dire::Sh => -self.data.0
        }
    }
}

pub struct StreamAlgo<'a> {
    pub stream_api: StreamApiType<'a>,
    pub order_target: OrderTarget,
}

#[derive(Debug, Clone)]
pub struct StreamOrderTarget {
    pub tick_data: TickData,
    pub hold: Hold,
    pub num_price: OrderTarget,
}


#[clone_trait]
pub trait Algo {
    fn algo(&self) -> RetFnAlgo;
}

#[ta_derive2]
pub struct AlgoTarget;

#[typetag::serde]
impl Algo for AlgoTarget {
    fn algo(&self) -> RetFnAlgo {
        Box::new(move |stream| {
            let target = stream.order_target.to_num();
            let hold = stream.stream_api.hold.sum();
            let gap = target - hold;
            let mut res = OrderAction::No;
            let tick_data = stream.stream_api.tick_data;
            if gap == 0. {
                return res;
            }
            if gap > 0. {
                if hold < 0. {
                    res = OrderAction::LoClose(-hold, tick_data.bid1);
                } else if hold >= 0. {
                    res = OrderAction::LoOpen(gap, tick_data.bid1);
                }
            } else if gap < 0. {
                if hold > 0. {
                    res = OrderAction::ShClose(hold, tick_data.ask1);
                } else if hold <= 0. {
                    res = OrderAction::ShOpen(-gap, tick_data.ask1);
                }
            }
            res
        })
    }
}


#[ta_derive2]
pub struct AlgoTargetQuik;

#[typetag::serde]
impl Algo for AlgoTargetQuik {
    fn algo(&self) -> RetFnAlgo {
        Box::new(move |stream| {
            let target = stream.order_target.to_num();
            let hold = stream.stream_api.hold.sum();
            let gap = target - hold;
            let mut res = OrderAction::No;
            let tick_data = stream.stream_api.tick_data;
            if gap == 0. {
                return res;
            }
            if gap > 0. {
                if hold < 0. {
                    res = OrderAction::LoClose(-hold, tick_data.ask1);
                } else if hold >= 0. {
                    res = OrderAction::LoOpen(gap, tick_data.ask1);
                }
            } else if gap < 0. {
                if hold > 0. {
                    res = OrderAction::ShClose(hold, tick_data.bid1);
                } else if hold <= 0. {
                    res = OrderAction::ShOpen(-gap, tick_data.bid1);
                }
            }
            res
        })
    }
}

// impl Algo for AlgoTarget {
//     type Output = OrderActionTarget;
//     fn algo(&self) -> FnMutBox<'static, StreamOrderTarget, Self::Output> {
//         Box::new(move |stream| {
//             let target = stream.num_price.to_num();
//             let hold = stream.hold.sum();
//             let gap = target - hold;
//             let mut res = OrderActionTarget::No;
//             if gap == 0. {
//                 return res;
//             }
//             if gap > 0. {
//                 if hold < 0. {
//                     res = OrderActionTarget::LoClose(-hold);
//                 } else if hold >= 0. {
//                     res = OrderActionTarget::LoOpen(gap);
//                 }
//             } else if gap < 0. {
//                 if hold > 0. {
//                     res = OrderActionTarget::ShClose(hold);
//                 } else if hold <= 0. {
//                     res = OrderActionTarget::ShOpen(-gap);
//                 }
//             }
//             res
//         })
        
//     }
// }

// pub struct AlgoTargetAndPrice;

// impl Algo for AlgoTargetAndPrice {
//     fn algo(&self) -> FnMutBox<'static, StreamOrderTarget, OrderAction> {
//         let mut algo_target = AlgoTarget.algo();
//         Box::new(move |stream| {
//             let tick_data = stream.tick_data.clone();
//             let order_action_target = algo_target(stream);
//             match order_action_target {
//                 OrderActionTarget::No => {
//                     OrderAction::No
//                 }
//                 OrderActionTarget::LoOpen(i) => {
//                     OrderAction::LoOpen(i, tick_data.bid1)
//                 }
//                 OrderActionTarget::LoClose(i) => {
//                     OrderAction::LoClose(i, tick_data.bid1)
//                 }
//                 OrderActionTarget::ShOpen(i) => {
//                     OrderAction::ShOpen(i, tick_data.ask1)
//                 }
//                 OrderActionTarget::ShClose(i) => {
//                     OrderAction::ShClose(i, tick_data.ask1)
//                 }
//             }
//         })
//     }
// }


// pub struct AlgoTargetAndPrice2;

// impl Algo for AlgoTargetAndPrice2 {
//     type Output = OrderAction;
//     fn algo(&self) -> FnMutBox<'static, StreamOrderTarget, Self::Output> {
//         let mut algo_target = AlgoTarget.algo();
//         Box::new(move |stream| {
//             let tick_data = stream.tick_data.clone();
//             let order_action_target = algo_target(stream);
//             match order_action_target {
//                 OrderActionTarget::No => {
//                     OrderAction::No
//                 }
//                 OrderActionTarget::LoOpen(i) => {
//                     OrderAction::LoOpen(i, tick_data.ask1)
//                 }
//                 OrderActionTarget::LoClose(i) => {
//                     OrderAction::LoClose(i, tick_data.ask1)
//                 }
//                 OrderActionTarget::ShOpen(i) => {
//                     OrderAction::ShOpen(i, tick_data.bid1)
//                 }
//                 OrderActionTarget::ShClose(i) => {
//                     OrderAction::ShClose(i, tick_data.bid1)
//                 }
//             }
//         })
//     }
// }