nautilus_indicators/momentum/
pressure.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2025 Posei Systems Pty Ltd. All rights reserved.
3//  https://poseitrader.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16use std::fmt::{Debug, Display};
17
18use nautilus_model::data::Bar;
19
20use crate::{
21    average::{MovingAverageFactory, MovingAverageType},
22    indicator::{Indicator, MovingAverage},
23    volatility::atr::AverageTrueRange,
24};
25
26#[repr(C)]
27#[derive(Debug)]
28#[cfg_attr(
29    feature = "python",
30    pyo3::pyclass(module = "posei_trader.core.nautilus_pyo3.indicators", unsendable)
31)]
32pub struct Pressure {
33    pub period: usize,
34    pub ma_type: MovingAverageType,
35    pub atr_floor: f64,
36    pub value: f64,
37    pub value_cumulative: f64,
38    pub initialized: bool,
39    atr: AverageTrueRange,
40    average_volume: Box<dyn MovingAverage + Send + 'static>,
41    has_inputs: bool,
42}
43
44impl Display for Pressure {
45    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
46        write!(f, "{}({},{})", self.name(), self.period, self.ma_type,)
47    }
48}
49
50impl Indicator for Pressure {
51    fn name(&self) -> String {
52        stringify!(Pressure).to_string()
53    }
54
55    fn has_inputs(&self) -> bool {
56        self.has_inputs
57    }
58
59    fn initialized(&self) -> bool {
60        self.initialized
61    }
62
63    fn handle_bar(&mut self, bar: &Bar) {
64        self.update_raw(
65            (&bar.high).into(),
66            (&bar.low).into(),
67            (&bar.close).into(),
68            (&bar.volume).into(),
69        );
70    }
71
72    fn reset(&mut self) {
73        self.atr.reset();
74        self.average_volume.reset();
75        self.value = 0.0;
76        self.value_cumulative = 0.0;
77        self.has_inputs = false;
78        self.initialized = false;
79    }
80}
81
82impl Pressure {
83    /// Creates a new [`Pressure`] instance.
84    ///
85    /// # Panics
86    ///
87    /// Panics if `period` is not positive (> 0).
88    #[must_use]
89    pub fn new(period: usize, ma_type: Option<MovingAverageType>, atr_floor: Option<f64>) -> Self {
90        assert!(period > 0, "Pressure: period must be > 0");
91        let ma_type = ma_type.unwrap_or(MovingAverageType::Exponential);
92        Self {
93            period,
94            ma_type,
95            atr_floor: atr_floor.unwrap_or(0.0),
96            value: 0.0,
97            value_cumulative: 0.0,
98            atr: AverageTrueRange::new(period, Some(ma_type), Some(false), atr_floor),
99            average_volume: MovingAverageFactory::create(ma_type, period),
100            has_inputs: false,
101            initialized: false,
102        }
103    }
104
105    pub fn update_raw(&mut self, high: f64, low: f64, close: f64, volume: f64) {
106        self.atr.update_raw(high, low, close);
107        self.average_volume.update_raw(volume);
108
109        self.has_inputs = true;
110
111        let avg_vol = self.average_volume.value();
112        if avg_vol == 0.0 {
113            self.value = 0.0;
114            return;
115        }
116
117        let atr_val = if self.atr.value > 0.0 {
118            self.atr.value
119        } else {
120            (high - low).abs().max(self.atr_floor)
121        };
122
123        if atr_val == 0.0 {
124            self.value = 0.0;
125            return;
126        }
127
128        let relative_volume = volume / avg_vol;
129        let buy_pressure = ((close - low) / atr_val) * relative_volume;
130        let sell_pressure = ((high - close) / atr_val) * relative_volume;
131
132        self.value = buy_pressure - sell_pressure;
133        self.value_cumulative += self.value;
134
135        if self.atr.initialized && self.average_volume.initialized() && !self.initialized {
136            self.initialized = true;
137        }
138    }
139}
140
141////////////////////////////////////////////////////////////////////////////////
142// Tests
143////////////////////////////////////////////////////////////////////////////////
144#[cfg(test)]
145mod tests {
146    use rstest::rstest;
147
148    use super::*;
149    use crate::stubs::{bar_ethusdt_binance_minute_bid, pressure_10};
150
151    #[rstest]
152    fn test_name_returns_expected_string(pressure_10: Pressure) {
153        assert_eq!(pressure_10.name(), "Pressure");
154    }
155
156    #[test]
157    fn test_str_repr_returns_expected_string() {
158        let pressure = Pressure::new(10, Some(MovingAverageType::Exponential), None);
159        assert_eq!(format!("{pressure}"), "Pressure(10,EXPONENTIAL)");
160    }
161
162    #[rstest]
163    fn test_period_returns_expected_value(pressure_10: Pressure) {
164        assert_eq!(pressure_10.period, 10);
165    }
166
167    #[rstest]
168    fn test_initialized_without_inputs_returns_false(pressure_10: Pressure) {
169        assert!(!pressure_10.initialized());
170    }
171
172    #[test]
173    fn test_value_with_all_higher_inputs_returns_expected_value() {
174        let mut pressure = Pressure::new(10, Some(MovingAverageType::Exponential), None);
175
176        let high_values = [
177            1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0,
178        ];
179        let low_values = [
180            0.9, 1.9, 2.9, 3.9, 4.9, 5.9, 6.9, 7.9, 8.9, 9.9, 10.1, 10.2, 10.3, 11.1, 11.4,
181        ];
182        let close_values = [
183            1.1, 2.1, 3.1, 4.1, 5.1, 6.1, 7.1, 8.1, 9.1, 10.1, 11.1, 12.1, 13.1, 14.1, 15.1,
184        ];
185        let volume_values = [
186            100.0, 200.0, 300.0, 400.0, 500.0, 600.0, 700.0, 800.0, 900.0, 1000.0, 1100.0, 1200.0,
187            1300.0, 1400.0, 1500.0,
188        ];
189
190        let mut expected_cumulative = 0.0;
191        let mut expected_last = 0.0;
192
193        for i in 0..15 {
194            pressure.update_raw(
195                high_values[i],
196                low_values[i],
197                close_values[i],
198                volume_values[i],
199            );
200
201            let atr_val = if pressure.atr.value > 0.0 {
202                pressure.atr.value
203            } else {
204                (high_values[i] - low_values[i])
205                    .abs()
206                    .max(pressure.atr_floor)
207            };
208            let avg_vol = pressure.average_volume.value();
209            if avg_vol != 0.0 && atr_val != 0.0 {
210                let relative_volume = volume_values[i] / avg_vol;
211                let buy_pressure = ((close_values[i] - low_values[i]) / atr_val) * relative_volume;
212                let sell_pressure =
213                    ((high_values[i] - close_values[i]) / atr_val) * relative_volume;
214                let bar_value = buy_pressure - sell_pressure;
215                expected_cumulative += bar_value;
216                expected_last = bar_value;
217            }
218        }
219
220        assert!(pressure.initialized());
221        assert!((pressure.value - expected_last).abs() < 1e-6);
222        assert!((pressure.value_cumulative - expected_cumulative).abs() < 1e-6);
223    }
224
225    #[rstest]
226    fn test_handle_bar(mut pressure_10: Pressure, bar_ethusdt_binance_minute_bid: Bar) {
227        pressure_10.handle_bar(&bar_ethusdt_binance_minute_bid);
228        assert_eq!(pressure_10.value, -0.018_181_818_181_818_132);
229        assert_eq!(pressure_10.value_cumulative, -0.018_181_818_181_818_132);
230        assert!(pressure_10.has_inputs);
231        assert!(!pressure_10.initialized);
232    }
233
234    #[rstest]
235    fn test_reset_successfully_returns_indicator_to_fresh_state(mut pressure_10: Pressure) {
236        pressure_10.update_raw(1.00020, 1.00050, 1.00070, 100.0);
237        pressure_10.update_raw(1.00030, 1.00060, 1.00080, 200.0);
238        pressure_10.update_raw(1.00070, 1.00080, 1.00090, 300.0);
239
240        pressure_10.reset();
241
242        assert!(!pressure_10.initialized());
243        assert_eq!(pressure_10.value, 0.0);
244        assert_eq!(pressure_10.value_cumulative, 0.0);
245        assert!(!pressure_10.has_inputs);
246    }
247
248    #[test]
249    fn test_ma_type_default_and_override() {
250        let pressure_default = Pressure::new(10, None, None);
251        assert_eq!(pressure_default.ma_type, MovingAverageType::Exponential);
252
253        let pressure_simple = Pressure::new(10, Some(MovingAverageType::Simple), None);
254        assert_eq!(pressure_simple.ma_type, MovingAverageType::Simple);
255    }
256
257    #[test]
258    fn test_initialized_after_enough_inputs() {
259        let mut pressure = Pressure::new(3, Some(MovingAverageType::Exponential), None);
260        for _ in 0..3 {
261            pressure.update_raw(1.3, 1.0, 1.1, 100.0);
262        }
263        assert!(pressure.initialized());
264    }
265
266    #[test]
267    fn test_atr_floor_applied_to_zero_range() {
268        let mut pressure = Pressure::new(1, Some(MovingAverageType::Simple), Some(0.5));
269        pressure.update_raw(1.5, 1.0, 1.2, 100.0);
270        assert!((pressure.value + 0.2).abs() < 1e-6);
271        assert!(!pressure.value_cumulative.is_nan());
272    }
273}
nautilus_indicators/momentum/pressure.rs

nautilus_indicators/momentum/
pressure.rs
