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
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 = 3;
/// 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::wcprice_simd::indicator_by_assets;
// Sub-module exports with common naming
/// 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.
pub use crate::indicators::simd_indicators::wcprice_simd::indicator_by_assets as indicator;
}
#[derive(Serialize, Deserialize, Clone)]
pub struct IndicatorState;
impl TIndicatorState<3> for IndicatorState {
fn batch_indicator(
&mut self,
inputs: &[&[f64]; INPUTS_WIDTH],
_optional_outputs: Option<&[bool]>,
) -> Result<Vec<Vec<f64>>, IndicatorError> {
process(inputs)
}
}
pub const INFO: Info = Info {
name: "wcprice",
full_name: "Weighted Close Price",
indicator_type: IndicatorType::Price,
// Use only the necessary inputs: high, low, close.
inputs: &["high", "low", "close"],
// No options.
options: &[],
outputs: &["wcprice"],
// No state required for this indicator.
optional_outputs: &[],
display_groups: &[DisplayGroup {
offset: None,
id: "wcprice",
label: "WCPRICE",
display_type: DisplayType::Overlay,
outputs: &["wcprice"],
}],
};
/// Returns the minimum amount of data required for the Weighted Close Price indicator.
///
/// # Arguments
///
/// * `_options` - Unused; wcprice takes no options.
///
/// # Returns
///
/// The minimum amount of data required (1; each bar is computed independently).
pub fn min_data(_options: &[f64]) -> usize {
1
}
/// Calculates the output length based on the data length and options.
///
/// # Arguments
///
/// * `data_len` - The length of the input data.
/// * `_options` - Unused; wcprice takes no options.
///
/// # Returns
///
/// The output length (equal to `data_len`).
pub fn output_length(data_len: usize, _options: &[f64]) -> usize {
data_len
}
/// Calculates the Weighted Close Price indicator over the full input dataset.
///
/// # Inputs
///
/// * `inputs[0]` — `high`
/// * `inputs[1]` — `low`
/// * `inputs[2]` — `close`
///
/// # Arguments
///
/// * `inputs` - Array of input price slices (see Inputs above).
/// * `_options` - Unused; wcprice takes no options.
/// * `_optional_outputs` - Unused; this indicator has no optional outputs.
///
/// # Returns
///
/// `Ok((outputs, state))` where `outputs[0]` is `wcprice`. The returned
/// `IndicatorState` is stateless and may be passed to `batch_indicator`
/// for subsequent calls. 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> {
let outputs = process(inputs)?;
Ok((outputs, IndicatorState))
}
//#[inline(always)]
fn process(inputs: &[&[f64]; INPUTS_WIDTH]) -> Result<Vec<Vec<f64>>, IndicatorError> {
validate_inputs(inputs, 1)?;
let high = inputs[0];
let low = inputs[1];
let close = inputs[2];
let mut wcprice_line = crate::uninit_vec!(f64, inputs[0].len());
for i in 0..high.len() {
unsafe {
*wcprice_line.get_unchecked_mut(i) = calc(
high.get_unchecked(i),
low.get_unchecked(i),
close.get_unchecked(i),
)
};
}
Ok(vec![wcprice_line])
}
/// Calculates the Weighted Close Price for a single bar.
///
/// Computes `(high + low + 2 * close) / 4`.
///
/// # Arguments
///
/// * `high` - Reference to the current bar's high price.
/// * `low` - Reference to the current bar's low price.
/// * `close` - Reference to the current bar's close price.
///
/// # Returns
///
/// The weighted close price for this bar.
#[inline(always)]
pub fn calc(high: &f64, low: &f64, close: &f64) -> f64 {
close.mul_add(2.0, high + low) * 0.25
}