nautilus_analysis/statistics/
long_ratio.rs1use std::fmt::Display;
17
18use nautilus_model::{enums::OrderSide, position::Position};
19
20use crate::{Returns, statistic::PortfolioStatistic};
21
22#[repr(C)]
28#[derive(Debug, Clone)]
29#[cfg_attr(
30 feature = "python",
31 pyo3::pyclass(module = "nautilus_trader.analysis", from_py_object)
32)]
33#[cfg_attr(
34 feature = "python",
35 pyo3_stub_gen::derive::gen_stub_pyclass(module = "nautilus_trader.analysis")
36)]
37pub struct LongRatio {
38 pub precision: usize,
40}
41
42impl LongRatio {
43 #[must_use]
45 pub fn new(precision: Option<usize>) -> Self {
46 Self {
47 precision: precision.unwrap_or(2),
48 }
49 }
50}
51
52impl Display for LongRatio {
53 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
54 write!(f, "Long Ratio")
55 }
56}
57
58impl PortfolioStatistic for LongRatio {
59 type Item = f64;
60
61 fn name(&self) -> String {
62 self.to_string()
63 }
64
65 fn calculate_from_positions(&self, positions: &[Position]) -> Option<Self::Item> {
66 if positions.is_empty() {
67 return None;
68 }
69
70 let long_count = positions
73 .iter()
74 .filter(|p| p.entry == OrderSide::Buy)
75 .count();
76
77 let value = long_count as f64 / positions.len() as f64;
78
79 let scale = 10f64.powi(self.precision as i32);
80 Some((value * scale).round() / scale)
81 }
82 fn calculate_from_returns(&self, _returns: &Returns) -> Option<Self::Item> {
83 None
84 }
85
86 fn calculate_from_realized_pnls(&self, _realized_pnls: &[f64]) -> Option<Self::Item> {
87 None
88 }
89}
90
91#[cfg(test)]
92mod tests {
93 use ahash::AHashSet;
94 use indexmap::IndexMap;
95 use nautilus_core::{DurationNanos, UnixNanos, approx_eq};
96 use nautilus_model::{
97 enums::{InstrumentClass, OrderSide, PositionSide},
98 identifiers::{
99 AccountId, ClientOrderId, PositionId,
100 stubs::{instrument_id_aud_usd_sim, strategy_id_ema_cross, trader_id},
101 },
102 stubs::TestDefault,
103 types::{Currency, Quantity},
104 };
105 use rstest::rstest;
106
107 use super::*;
108
109 fn create_closed_position(entry: OrderSide) -> Position {
112 Position {
113 events: Vec::new(),
114 replay_events: Vec::new(),
115 fill_voids: Vec::new(),
116 trader_id: trader_id(),
117 strategy_id: strategy_id_ema_cross(),
118 instrument_id: instrument_id_aud_usd_sim(),
119 id: PositionId::new("test-position"),
120 account_id: AccountId::new("test-account"),
121 opening_order_id: ClientOrderId::test_default(),
122 closing_order_id: None,
123 entry,
124 side: PositionSide::Flat, signed_qty: 0.into(),
126 quantity: Quantity::default(),
127 peak_qty: Quantity::default(),
128 price_precision: 2,
129 size_precision: 2,
130 multiplier: Quantity::default(),
131 is_inverse: false,
132 base_currency: None,
133 quote_currency: Currency::USD(),
134 settlement_currency: Currency::USD(),
135 ts_init: UnixNanos::default(),
136 ts_opened: UnixNanos::default(),
137 ts_last: UnixNanos::default(),
138 ts_closed: Some(UnixNanos::from(1)), duration_ns: DurationNanos::new(2),
140 avg_px_open: 0.into(),
141 avg_px_close: Some(0.into()),
142 realized_return: 0.0,
143 realized_pnl: None,
144 trade_ids: AHashSet::new(),
145 buy_qty: Quantity::default(),
146 sell_qty: Quantity::default(),
147 commissions: IndexMap::new(),
148 cost_open: 0.into(),
149 cost_close: 0.into(),
150 qty_closed: 0.into(),
151 realized_pnl_remainder: 0.into(),
152 adjustments: Vec::new(),
153 instrument_class: InstrumentClass::Spot,
154 is_currency_pair: true,
155 allows_negative_price: Some(false),
156 }
157 }
158
159 #[rstest]
160 fn test_empty_positions() {
161 let long_ratio = LongRatio::new(None);
162 let result = long_ratio.calculate_from_positions(&[]);
163 assert!(result.is_none());
164 }
165
166 #[rstest]
167 fn test_all_long_positions() {
168 let long_ratio = LongRatio::new(None);
169 let positions = vec![
170 create_closed_position(OrderSide::Buy),
171 create_closed_position(OrderSide::Buy),
172 create_closed_position(OrderSide::Buy),
173 ];
174
175 let result = long_ratio.calculate_from_positions(&positions);
176 assert!(result.is_some());
177 assert!(approx_eq!(f64, result.unwrap(), 1.00, epsilon = 1e-9));
178 }
179
180 #[rstest]
181 fn test_all_short_positions() {
182 let long_ratio = LongRatio::new(None);
183 let positions = vec![
184 create_closed_position(OrderSide::Sell),
185 create_closed_position(OrderSide::Sell),
186 create_closed_position(OrderSide::Sell),
187 ];
188
189 let result = long_ratio.calculate_from_positions(&positions);
190 assert!(result.is_some());
191 assert!(approx_eq!(f64, result.unwrap(), 0.00, epsilon = 1e-9));
192 }
193
194 #[rstest]
195 fn test_mixed_positions() {
196 let long_ratio = LongRatio::new(None);
197 let positions = vec![
198 create_closed_position(OrderSide::Buy),
199 create_closed_position(OrderSide::Sell),
200 create_closed_position(OrderSide::Buy),
201 create_closed_position(OrderSide::Sell),
202 ];
203
204 let result = long_ratio.calculate_from_positions(&positions);
205 assert!(result.is_some());
206 assert!(approx_eq!(f64, result.unwrap(), 0.50, epsilon = 1e-9));
207 }
208
209 #[rstest]
210 fn test_custom_precision() {
211 let long_ratio = LongRatio::new(Some(3));
212 let positions = vec![
213 create_closed_position(OrderSide::Buy),
214 create_closed_position(OrderSide::Buy),
215 create_closed_position(OrderSide::Sell),
216 ];
217
218 let result = long_ratio.calculate_from_positions(&positions);
219 assert!(result.is_some());
220 assert!(approx_eq!(f64, result.unwrap(), 0.667, epsilon = 1e-9));
221 }
222
223 #[rstest]
224 fn test_single_position_long() {
225 let long_ratio = LongRatio::new(None);
226 let positions = vec![create_closed_position(OrderSide::Buy)];
227
228 let result = long_ratio.calculate_from_positions(&positions);
229 assert!(result.is_some());
230 assert!(approx_eq!(f64, result.unwrap(), 1.00, epsilon = 1e-9));
231 }
232
233 #[rstest]
234 fn test_single_position_short() {
235 let long_ratio = LongRatio::new(None);
236 let positions = vec![create_closed_position(OrderSide::Sell)];
237
238 let result = long_ratio.calculate_from_positions(&positions);
239 assert!(result.is_some());
240 assert!(approx_eq!(f64, result.unwrap(), 0.00, epsilon = 1e-9));
241 }
242
243 #[rstest]
244 fn test_zero_precision() {
245 let long_ratio = LongRatio::new(Some(0));
246 let positions = vec![
247 create_closed_position(OrderSide::Buy),
248 create_closed_position(OrderSide::Buy),
249 create_closed_position(OrderSide::Sell),
250 ];
251
252 let result = long_ratio.calculate_from_positions(&positions);
253 assert!(result.is_some());
254 assert!(approx_eq!(f64, result.unwrap(), 1.00, epsilon = 1e-9));
255 }
256
257 #[rstest]
258 fn test_name() {
259 let long_ratio = LongRatio::new(None);
260 assert_eq!(long_ratio.name(), "Long Ratio");
261 }
262}