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
150
151
152
153
154
155
156
157
use crate::common::validate_inputs;
pub use crate::indicator_types::TIndicatorState;
use crate::types::{DisplayGroup, DisplayType, IndicatorError, IndicatorType, Info};
use serde::{Deserialize, Serialize};
/// Number of input price series required by this indicator.
pub const INPUTS_WIDTH: usize = 4;
/// 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::bop_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::bop_simd::indicator_by_assets as indicator;
}
/// Returns information about the Balance of Power (BOP) indicator.
///
/// # Returns
///
/// An `Info` struct containing metadata about the BOP indicator.
pub const INFO: Info = Info {
name: "bop",
full_name: "Balance of Power",
indicator_type: IndicatorType::Momentum,
inputs: &["open", "high", "low", "close"],
options: &[],
outputs: &["bop"],
optional_outputs: &[],
display_groups: &[DisplayGroup {
offset: None,
id: "bop",
label: "BOP",
display_type: DisplayType::Indicator,
outputs: &["bop"],
}],
};
#[derive(Serialize, Deserialize, Clone)]
pub struct IndicatorState;
impl TIndicatorState<4> for IndicatorState {
fn batch_indicator(
&mut self,
inputs: &[&[f64]; INPUTS_WIDTH],
_optional_outputs: Option<&[bool]>,
) -> Result<Vec<Vec<f64>>, IndicatorError> {
process(inputs)
}
}
/// Returns the minimum amount of data required for the BOP indicator.
///
/// # Arguments
///
/// * `_options` - A slice containing the options for the BOP calculation.
///
/// # Returns
///
/// The minimum amount of data required.
pub fn min_data(_options: &[f64]) -> usize {
1
}
/// Returns the number of output values given an input data length and options.
///
/// # Arguments
///
/// * `data_len` - The length of the input data.
/// * `_options` - Options slice (unused for BOP).
///
/// # Returns
///
/// The output length, which equals `data_len` for BOP.
pub fn output_length(data_len: usize, _options: &[f64]) -> usize {
data_len
}
/// Calculates the Balance of Power (BOP) indicator over the full input dataset.
///
/// # Inputs
///
/// * `inputs[0]` — open prices
/// * `inputs[1]` — high prices
/// * `inputs[2]` — low prices
/// * `inputs[3]` — close prices
///
/// # Arguments
///
/// * `inputs` - Array of input price slices (see Inputs above).
/// * `_options` - Unused; BOP takes no options.
/// * `_optional_outputs` - Unused; BOP has no optional outputs.
///
/// # Returns
///
/// `Ok((outputs, state))` where `outputs[0]` is `bop` and `state`
/// can be passed to `IndicatorState::batch_indicator` for streaming.
/// Returns `Err(IndicatorError)` if inputs are too short or mismatched.
pub fn indicator(
inputs: &[&[f64]; INPUTS_WIDTH],
_options: &[f64; OPTIONS_WIDTH],
_optional_outputs: Option<&[bool]>,
) -> Result<(Vec<Vec<f64>>, IndicatorState), IndicatorError> {
let outputs = process(inputs)?;
Ok((outputs, IndicatorState))
}
//#[inline(always)]
fn process(inputs: &[&[f64]]) -> Result<Vec<Vec<f64>>, IndicatorError> {
validate_inputs(inputs, 1)?;
let open = inputs[0];
let high = inputs[1];
let low = inputs[2];
let close = inputs[3];
let len = open.len();
let mut bop_line = crate::uninit_vec!(f64, len);
open.iter()
.zip(high.iter())
.zip(low.iter())
.zip(close.iter())
.enumerate()
.for_each(|(i, (((&o, &h), &l), &c))| unsafe {
*bop_line.get_unchecked_mut(i) = calc(o, h, l, c);
});
Ok(vec![bop_line])
}
/// Calculates the Balance of Power (BOP) value.
///
/// # Arguments
///
/// * `open` - The open price.
/// * `high` - The high price.
/// * `low` - The low price.
/// * `close` - The close price.
///
/// # Returns
///
/// The BOP value.
#[inline(always)]
pub fn calc(open: f64, high: f64, low: f64, close: f64) -> f64 {
let hl_diff = (high - low).max(f64::EPSILON);
(close - open) / hl_diff
}