fulid 0.1.0

Trading engine
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

use std::collections::VecDeque;

use crate::strategy_engine::Strategy;

#[derive(Debug, Clone)]
pub struct MeanReversion {
    pub prices: VecDeque<f64>,
    pub window_size: usize,
}

impl MeanReversion {
    pub fn new(window_size: usize) -> Self {
        Self {
            prices: VecDeque::with_capacity(window_size),
            window_size,
        }
    }

    pub fn update_price(&mut self, price: f64) {
        self.prices.push_back(price);

        if self.prices.len() > self.window_size {
            self.prices.pop_front();
        }
    }
}

impl Strategy for MeanReversion {
    fn evaluate(&self, _price: &f64) -> f64 {
        if self.prices.len() < self.window_size {
            return 0.0; // 如果价格数量不足，返回无信号
        }

        let avg = self.prices.iter().take(self.window_size).sum::<f64>() / self.window_size as f64;
        let last_price = self.prices.back().unwrap();

        if *last_price < avg {
            1.0 // 买入信号
        } else if *last_price > avg {
            -1.0 // 卖出信号
        } else {
            0.0 // 无信号
        }
    }

    fn calculate_indicator(&self, prices: &Vec<f64>) -> f64 {
        // 计算信息率作为指标
        let mut returns = vec![];
        for price in prices {
            let signal = self.evaluate(price);
            if signal > 0.0 {
                returns.push(*price / prices[0] - 1.0); // 买入信号，计算收益
            } else if signal < 0.0 {
                returns.push(1.0 - (*price / prices[0])); // 卖出信号，计算收益
            } else {
                returns.push(0.0); // 无信号，收益为0
            }
        }
        let avg_return = returns.iter().sum::<f64>() / returns.len() as f64;
        let std_dev = (returns.iter().map(|x| (x - avg_return).powi(2)).sum::<f64>() / returns.len() as f64).sqrt();
        avg_return / std_dev // 返回信息率
    }
}