egui-charts 0.2.0

High-performance financial charting engine for egui — candlesticks, 95 drawing tools, 130+ indicators, and a full design-token theme system
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

//! Strategy types and state management for Pine Script backtesting
//!
//! Contains trade tracking, position management, and performance metrics.

use super::types::TradeDirection;

/// A single trade in the strategy
#[derive(Debug, Clone)]
pub struct Trade {
    pub id: String,
    pub direction: TradeDirection,
    pub entry_bar: usize,
    pub entry_price: f64,
    pub quantity: f64,
    pub exit_bar: Option<usize>,
    pub exit_price: Option<f64>,
    pub profit_loss: Option<f64>,
}

/// Current position state
#[derive(Debug, Clone)]
pub struct Pos {
    pub direction: TradeDirection,
    pub quantity: f64,
    pub entry_price: f64,
    pub entry_bar: usize,
}

/// Strategy performance metrics
#[derive(Debug, Clone, Default)]
pub struct StrategyMetrics {
    pub total_trades: usize,
    pub winning_trades: usize,
    pub losing_trades: usize,
    pub gross_profit: f64,
    pub gross_loss: f64,
    pub net_profit: f64,
    pub max_drawdown: f64,
    pub win_rate: f64,
    pub profit_factor: f64,
}

/// Strategy state tracking
#[derive(Clone)]
pub struct StrategyState {
    /// Current open position (if any)
    pub position: Option<Pos>,
    /// Trade history
    pub trades: Vec<Trade>,
    /// Initial capital
    pub initial_capital: f64,
    /// Current equity
    pub equity: f64,
    /// Equity curve
    pub equity_curve: Vec<f64>,
    /// Computed metrics
    pub metrics: StrategyMetrics,
}

impl Default for StrategyState {
    fn default() -> Self {
        Self {
            position: None,
            trades: Vec::new(),
            initial_capital: 100_000.0,
            equity: 100_000.0,
            equity_curve: Vec::new(),
            metrics: StrategyMetrics::default(),
        }
    }
}

impl StrategyState {
    /// Create new strategy state with initial capital
    pub fn new(initial_capital: f64) -> Self {
        Self {
            initial_capital,
            equity: initial_capital,
            ..Default::default()
        }
    }

    /// Update metrics after trades
    pub fn update_metrics(&mut self) {
        let closed_trades: Vec<_> = self
            .trades
            .iter()
            .filter(|t| t.profit_loss.is_some())
            .collect();

        self.metrics.total_trades = closed_trades.len();
        self.metrics.winning_trades = closed_trades
            .iter()
            .filter(|t| t.profit_loss.unwrap_or(0.0) > 0.0)
            .count();
        self.metrics.losing_trades = closed_trades
            .iter()
            .filter(|t| t.profit_loss.unwrap_or(0.0) < 0.0)
            .count();

        self.metrics.gross_profit = closed_trades
            .iter()
            .filter_map(|t| t.profit_loss)
            .filter(|&pl| pl > 0.0)
            .sum();
        self.metrics.gross_loss = closed_trades
            .iter()
            .filter_map(|t| t.profit_loss)
            .filter(|&pl| pl < 0.0)
            .map(|pl| pl.abs())
            .sum();

        self.metrics.net_profit = self.metrics.gross_profit - self.metrics.gross_loss;

        if self.metrics.total_trades > 0 {
            self.metrics.win_rate =
                self.metrics.winning_trades as f64 / self.metrics.total_trades as f64;
        }

        if self.metrics.gross_loss > 0.0 {
            self.metrics.profit_factor = self.metrics.gross_profit / self.metrics.gross_loss;
        }

        // Calculate max drawdown from equity curve
        if !self.equity_curve.is_empty() {
            let mut peak = self.equity_curve[0];
            let mut max_dd = 0.0;
            for &equity in &self.equity_curve {
                if equity > peak {
                    peak = equity;
                }
                let drawdown = (peak - equity) / peak;
                if drawdown > max_dd {
                    max_dd = drawdown;
                }
            }
            self.metrics.max_drawdown = max_dd;
        }
    }
}

/// Plot output from indicator
#[derive(Debug, Clone)]
pub struct PlotOutput {
    pub name: String,
    pub values: Vec<f64>,
    pub color: Option<String>,
}