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
149
//use std::vec;
use crate::common::validate_inputs;
pub use crate::indicator_types::TIndicatorState;
use crate::types::{DisplayType, IndicatorError, IndicatorType, Info};
use serde::{Deserialize, Serialize};
/// Number of input price series required by this indicator.
pub const INPUTS_WIDTH: usize = 2;
/// Number of option parameters required by this indicator.
pub const OPTIONS_WIDTH: usize = 0;
/// SIMD-parallel variant that processes `N` assets with identical options simultaneously.
/// Requires the `simd_assets` Cargo feature. See [`by_assets`] for the module form.
#[cfg(feature = "simd_assets")]
pub use crate::indicators::simd_indicators::obv_simd::indicator_by_assets;
/// Convenience module that re-exports [`indicator_by_assets`] as `indicator`,
/// allowing SIMD multi-asset computation to be used as a drop-in replacement
/// for the standard single-asset [`indicator`] function.
/// Requires the `simd_assets` Cargo feature.
#[cfg(feature = "simd_assets")]
pub mod by_assets {
/// Processes `N` assets in parallel with shared options.
/// See the parent module's [`super::indicator_by_assets`] for full documentation.
pub use crate::indicators::simd_indicators::obv_simd::indicator_by_assets as indicator;
}
/// Returns information about the On-Balance Volume (OBV) indicator.
pub fn info() -> Info<'static> {
Info {
name: "obv",
full_name: "On-Balance Volume",
indicator_type: IndicatorType::Volume,
display_type: DisplayType::Indicator,
inputs: &["close", "volume"],
options: &[],
outputs: &["obv"],
optional_outputs: &[],
}
}
#[derive(Serialize, Deserialize)]
pub struct IndicatorState {
pub obv: f64,
pub prev_close: f64,
}
impl IndicatorState {
pub fn new(obv: f64, prev_close: f64) -> Self {
Self { obv, prev_close }
}
/// Performs the core calculation for the On-Balance Volume (OBV) indicator.
#[inline(always)]
pub fn calc(&mut self, close: f64, volume: f64) -> f64 {
if close > self.prev_close {
self.obv += volume;
} else if close < self.prev_close {
self.obv -= volume
}
self.prev_close = close;
self.obv
}
}
impl TIndicatorState<2> for IndicatorState {
fn batch_indicator(
&mut self,
inputs: &[&[f64]; INPUTS_WIDTH],
_optional_outputs: Option<&[bool]>,
) -> Result<Vec<Vec<f64>>, IndicatorError> {
validate_inputs(inputs, 1)?;
let mut obv_line = crate::uninit_vec!(f64, inputs[0].len());
cycle_obv(inputs[0], inputs[1], &mut obv_line, self);
Ok(vec![obv_line])
}
}
/// Returns the minimum number of input bars required to produce accurate results.
///
/// For this indicator accuracy does not depend on decimal precision, so
/// this always returns the same value as [`min_data`].
///
/// # Arguments
///
/// * `_options` - Unused; this indicator takes no options.
/// * `_decimals` - Unused. Accuracy is independent of decimal precision for this indicator.
///
/// # Returns
///
/// The minimum number of input bars required, identical to [`min_data`].
pub fn min_data_accuracy(_options: &[f64], _decimals: usize) -> usize {
min_data(_options)
}
/// Returns the minimum amount of data required for the OBV indicator.
pub fn min_data(_options: &[f64]) -> usize {
2
}
/// Returns the output length for the OBV indicator.
pub fn output_length(data_len: usize, _options: &[f64]) -> usize {
data_len - min_data(_options) + 1
}
/// Calculates the On-Balance Volume (OBV) indicator over the full input dataset.
///
/// # Inputs
///
/// * `inputs[0]` — close prices
/// * `inputs[1]` — volume
///
/// # Arguments
///
/// * `inputs` - Array of input price slices (see Inputs above).
/// * `_options` - Unused; this indicator takes no options.
/// * `_optional_outputs` - Unused; this indicator has no optional outputs.
///
/// # Returns
///
/// `Ok((outputs, state))` where `outputs[0]` is the `obv` line and
/// `state` can be passed to `IndicatorState::batch_indicator` for streaming.
/// Returns `Err(IndicatorError)` if inputs are too short.
pub fn indicator(
inputs: &[&[f64]; INPUTS_WIDTH],
_options: &[f64; OPTIONS_WIDTH],
_optional_outputs: Option<&[bool]>,
) -> Result<(Vec<Vec<f64>>, IndicatorState), IndicatorError> {
validate_inputs(inputs, min_data(_options))?;
let mut obv_line = {
let capacity = output_length(inputs[0].len(), _options);
crate::uninit_vec!(f64, capacity)
};
let mut state = IndicatorState::new(0.0, inputs[0][0]);
cycle_obv(&inputs[0][1..], &inputs[1][1..], &mut obv_line, &mut state);
Ok((vec![obv_line], state))
}
/// Iterates over the input data and applies the calc function.
//#[inline(always)]
fn cycle_obv(close: &[f64], volume: &[f64], obv_line: &mut [f64], state: &mut IndicatorState) {
for i in 0..close.len() {
unsafe {
*obv_line.get_unchecked_mut(i) =
state.calc(*close.get_unchecked(i), *volume.get_unchecked(i));
}
}
}