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

use crate::{
    idct::{
        dcon::Convert::{self, *},
        part::Part,
        ta::{ForeTa, Ta},
    },
    trade::di::Di,
};
use qust_ds::prelude::*;
use qust_derive::*;

// #[ta_derive]
#[derive(Clone, Serialize, Deserialize, AsRef, PartialEq, Eq, Hash)]
pub struct PmsType<T, N> {
    pub dcon: T,
    pub part: Part,
    pub fore: N,
}
pub type Pms = PmsType<Convert, Box<dyn Ta>>;
pub type PmsVert = PmsType<(Convert, Convert), Box<dyn Ta>>;
impl std::fmt::Debug for Pms {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?} + {:?} + {:?}", self.dcon, self.part, self.fore,)
    }
}
impl std::fmt::Debug for PmsVert {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{:?} -> {:?} + {:?} + {:?}",
            self.dcon.0, self.dcon.1, self.part, self.fore,
        )
    }
}

use std::ops::Add;

use super::{fore::ForeTaCalc, prelude::TaBox};

impl Add for Convert {
    type Output = Convert;
    fn add(self, rhs: Self) -> Self::Output {
        PreNow(Box::new(self), Box::new(rhs))
    }
}

impl Add<Part> for Convert {
    type Output = Pre;
    fn add(self, rhs: Part) -> Self::Output {
        Pre(self, rhs)
    }
}

#[ta_derive]
pub struct Pre(pub Convert, pub Part);

impl<T: Ta + Clone> Add<T> for Pre {
    type Output = Pms;
    fn add(self, rhs: T) -> Self::Output {
        PmsType {
            dcon: self.0,
            part: self.1,
            fore: Box::new(rhs),
        }
    }
}

impl Add<TaBox> for Pre {
    type Output = Pms;
    fn add(self, rhs: TaBox) -> Self::Output {
        PmsType {
            dcon: self.0,
            part: self.1,
            fore: rhs
        }
    }
}

impl<T: ForeTaCalc> Add<T> for Pms {
    type Output = Pms;
    fn add(self, rhs: T) -> Self::Output {
        let box_t: Box<dyn ForeTaCalc> = Box::new(rhs);
        let t = ForeTa(self.fore, box_t);
        PmsType {
            dcon: self.dcon,
            part: self.part,
            fore: Box::new(t),
        }
    }
}

/* #region GetPmsFromTa */
pub trait GetPmsFromTa: Send + Sync + std::fmt::Debug + Clone + 'static {
    fn get_pms_from_ta(&self, di: &Di) -> Pms;
}

impl<T: Ta + Clone> GetPmsFromTa for T {
    fn get_pms_from_ta(&self, di: &Di) -> Pms {
        let ta_box: Box<dyn Ta> = Box::new(self.clone());
        ta_box.get_pms_from_ta(di)
    }
}

impl GetPmsFromTa for Box<dyn Ta> {
    fn get_pms_from_ta(&self, di: &Di) -> Pms {
        PmsType {
            dcon: di.last_dcon(),
            part: di.last_part(),
            fore: self.clone(),
        }
    }
}

impl<T: Ta + Clone> GetPmsFromTa for (Part, T) {
    fn get_pms_from_ta(&self, di: &Di) -> Pms {
        let ta_box: Box<dyn Ta> = Box::new(self.1.clone());
        (self.0.clone(), ta_box).get_pms_from_ta(di)
    }
}

impl GetPmsFromTa for (Part, Box<dyn Ta>) {
    fn get_pms_from_ta(&self, di: &Di) -> Pms {
        PmsType {
            dcon: di.last_dcon(),
            part: self.0.clone(),
            fore: self.1.clone(),
        }
    }
}
/* #endregion */