⚡ Optimize stochastic rolling helpers (#8)

* Optimize rolling extrema calculations in indicators

* Optimize rolling window indicators

* 📝 Add docs for rolling window utils

* ♻️ Rename rolling arg index helper

* fix: psar 공개 export 연결

Author: sjquant

core/src/indicators/aroon.rs

@@ -1,4 +1,4 @@
-use crate::utils::{find_max, find_min};
+use crate::utils::rolling_argmax_argmin;
 
 pub fn aroon(highs: &[f64], lows: &[f64], period: usize) -> (Vec<Option<f64>>, Vec<Option<f64>>) {
     let mut aroon_up = vec![None; highs.len()];
@@ -8,14 +8,16 @@ pub fn aroon(highs: &[f64], lows: &[f64], period: usize) -> (Vec<Option<f64>>, V
         return (aroon_up, aroon_down);
     }
 
-    for i in period..highs.len() {
-        let high_slice = &highs[i - period..=i];
-        let low_slice = &lows[i - period..=i];
-        let max_high = find_max(high_slice);
-        let min_low = find_min(low_slice);
+    let window = period + 1;
+    let (max_indices, min_indices) = rolling_argmax_argmin(highs, lows, window);
 
-        let max_index = high_slice.iter().rposition(|&x| x == max_high).unwrap();
-        let min_index = low_slice.iter().rposition(|&x| x == min_low).unwrap();
+    for i in period..highs.len() {
+        let window_start = i - period;
+        let (Some(max_index), Some(min_index)) = (max_indices[i], min_indices[i]) else {
+            continue;
+        };
+        let max_index = max_index - window_start;
+        let min_index = min_index - window_start;
 
         let aroon_up_point = (max_index as f64 * 100.0) / period as f64;
         let aroon_down_point = (min_index as f64 * 100.0) / period as f64;

core/src/indicators/mod.rs

@@ -70,6 +70,7 @@ pub use nvi::*;
 pub use obv::*;
 pub use pchan::*;
 pub use ppo::*;
+pub use psar::*;
 pub use psl::*;
 pub use pvi::*;
 pub use pvo::*;

core/src/indicators/pchan.rs

@@ -1,4 +1,4 @@
-use crate::utils::{find_max, find_min};
+use crate::utils::rolling_max_min;
 
 pub fn pchan(
     highs: &[f64],
@@ -10,13 +10,17 @@ pub fn pchan(
     let mut lower = vec![None; len];
     let mut middle = vec![None; len];
 
-    if len < period {
+    if period == 0 || len < period {
         return (upper, middle, lower);
     }
 
+    let (rolling_highs, rolling_lows) =
+        rolling_max_min(&highs[..len - 1], &lows[..len - 1], period);
+
     for i in period..len {
-        let max_high = find_max(&highs[i - period..i]);
-        let min_low = find_min(&lows[i - period..i]);
+        let (Some(max_high), Some(min_low)) = (rolling_highs[i - 1], rolling_lows[i - 1]) else {
+            continue;
+        };
 
         upper[i] = Some(max_high);
         lower[i] = Some(min_low);

core/src/indicators/stochf.rs

@@ -1,4 +1,4 @@
-use crate::utils::{calc_mean, find_max, find_min};
+use crate::utils::{rolling_max_min, rolling_mean_strict};
 
 pub fn stochf_percent_k(
     highs: &[f64],
@@ -13,9 +13,12 @@ pub fn stochf_percent_k(
         return percent_k;
     }
 
+    let (rolling_highs, rolling_lows) = rolling_max_min(highs, lows, fastk_period);
+
     for i in (fastk_period - 1)..len {
-        let max_high = find_max(&highs[i + 1 - fastk_period..=i]);
-        let min_low = find_min(&lows[i + 1 - fastk_period..=i]);
+        let (Some(max_high), Some(min_low)) = (rolling_highs[i], rolling_lows[i]) else {
+            continue;
+        };
 
         percent_k[i] = if max_high == min_low {
             None
@@ -33,27 +36,16 @@ pub fn stochf_percent_d(
     fastd_period: usize,
 ) -> Vec<Option<f64>> {
     let len = percent_k.len();
-    let mut percent_d = vec![None; len];
 
     if len < fastk_period {
-        return percent_d;
+        return vec![None; len];
     }
 
-    for i in (fastk_period - 1)..len {
-        if fastd_period == 1 {
-            percent_d[i] = percent_k[i];
-        } else if i >= fastk_period - 1 + (fastd_period - 1) {
-            let slice = &percent_k[i + 1 - fastd_period..=i];
-            let valid_values: Vec<f64> = slice.iter().filter_map(|&x| x).collect();
-            percent_d[i] = if valid_values.len() == fastd_period {
-                Some(calc_mean(&valid_values))
-            } else {
-                None
-            };
-        }
+    if fastd_period == 1 {
+        percent_k.to_vec()
+    } else {
+        rolling_mean_strict(percent_k, fastd_period)
     }
-
-    percent_d
 }
 
 pub fn stochf(

core/src/indicators/stochrsi.rs

@@ -1,5 +1,5 @@
 use crate::indicators::rsi;
-use crate::utils::{calc_mean, find_max, find_min};
+use crate::utils::{rolling_max_min, rolling_mean_strict};
 
 pub fn stochrsi(
     closes: &[f64],
@@ -9,45 +9,48 @@ pub fn stochrsi(
 ) -> (Vec<Option<f64>>, Vec<Option<f64>>) {
     let len = closes.len();
     let mut percent_k = vec![None; len];
-    let mut percent_d = vec![None; len];
 
     if len < period_rsi + period_k || period_rsi <= 1 || period_k <= 1 {
-        return (percent_k, percent_d);
+        return (percent_k, vec![None; len]);
     }
 
     let rsi_values = rsi(closes, period_rsi);
+    let rsi_values_with_nan: Vec<f64> = rsi_values
+        .iter()
+        .map(|value| value.unwrap_or(f64::NAN))
+        .collect();
+    let (rolling_max, rolling_min) =
+        rolling_max_min(&rsi_values_with_nan, &rsi_values_with_nan, period_k);
 
     for i in (period_rsi + period_k - 1)..len {
-        let slice = &rsi_values[i + 1 - period_k..=i];
-        let valid_values: Vec<f64> = slice.iter().filter_map(|&x| x).collect();
+        let valid_values: Vec<f64> = rsi_values[i + 1 - period_k..=i]
+            .iter()
+            .filter_map(|&x| x)
+            .collect();
 
-        if valid_values.len() == period_k {
-            let rsi_max = find_max(&valid_values);
-            let rsi_min = find_min(&valid_values);
-
-            let k = if rsi_max == rsi_min {
-                None
-            } else {
-                rsi_values[i].map(|rsi| ((rsi - rsi_min) / (rsi_max - rsi_min)) * 100.0)
-            };
+        if valid_values.len() != period_k {
+            continue;
+        }
 
-            percent_k[i] = k;
+        let (Some(rsi), Some(rsi_max), Some(rsi_min)) =
+            (rsi_values[i], rolling_max[i], rolling_min[i])
+        else {
+            continue;
+        };
 
-            if period_d == 1 {
-                percent_d[i] = k;
-            } else if i >= period_rsi + period_k - 1 + (period_d - 1) {
-                let d_slice = &percent_k[i + 1 - period_d..=i];
-                let valid_d_values: Vec<f64> = d_slice.iter().filter_map(|&x| x).collect();
-                let d = if valid_d_values.len() == period_d {
-                    Some(calc_mean(&valid_d_values))
-                } else {
-                    None
-                };
-                percent_d[i] = d;
-            }
-        }
+        percent_k[i] = if rsi_max == rsi_min {
+            None
+        } else {
+            Some(((rsi - rsi_min) / (rsi_max - rsi_min)) * 100.0)
+        };
     }
 
+    let percent_d = if period_d == 1 {
+        percent_k.clone()
+    } else {
+        rolling_mean_strict(&percent_k, period_d)
+    };
+
     (percent_k, percent_d)
 }
 

core/src/indicators/stochs.rs

@@ -1,4 +1,4 @@
-use crate::utils::{calc_mean, find_max, find_min};
+use crate::utils::{rolling_max_min, rolling_mean_strict};
 
 fn stochs_raw_k(
     highs: &[f64],
@@ -13,9 +13,12 @@ fn stochs_raw_k(
         return raw_k;
     }
 
+    let (rolling_highs, rolling_lows) = rolling_max_min(highs, lows, fastk_period);
+
     for i in (fastk_period - 1)..len {
-        let max_high = find_max(&highs[i + 1 - fastk_period..=i]);
-        let min_low = find_min(&lows[i + 1 - fastk_period..=i]);
+        let (Some(max_high), Some(min_low)) = (rolling_highs[i], rolling_lows[i]) else {
+            continue;
+        };
 
         raw_k[i] = if max_high == min_low {
             None
@@ -35,24 +38,13 @@ pub fn stoch_percent_k(
     slowk_period: usize,
 ) -> Vec<Option<f64>> {
     let len = closes.len();
-    let mut percent_k = vec![None; len];
 
     if len < fastk_period {
-        return percent_k;
+        return vec![None; len];
     }
 
     let raw_k = stochs_raw_k(highs, lows, closes, fastk_period);
-    for i in (fastk_period + slowk_period - 2)..len {
-        let slice = &raw_k[i + 1 - slowk_period..=i];
-        let valid_values: Vec<f64> = slice.iter().filter_map(|&x| x).collect();
-        percent_k[i] = if valid_values.len() == slowk_period {
-            Some(calc_mean(&valid_values))
-        } else {
-            None
-        };
-    }
-
-    percent_k
+    rolling_mean_strict(&raw_k, slowk_period)
 }
 
 pub fn stoch_percent_d(
@@ -70,27 +62,20 @@ pub fn stoch_percent_d(
 fn stoch_percent_d_from_k(
     percent_k: &[Option<f64>],
     fastk_period: usize,
-    slowk_period: usize,
+    _slowk_period: usize,
     slowd_period: usize,
 ) -> Vec<Option<f64>> {
     let len = percent_k.len();
-    let mut percent_d = vec![None; len];
 
     if len < fastk_period {
-        return percent_d;
+        return vec![None; len];
     }
 
-    for i in (fastk_period + slowk_period + slowd_period - 3)..len {
-        let slice = &percent_k[i + 1 - slowd_period..=i];
-        let valid_values: Vec<f64> = slice.iter().filter_map(|&x| x).collect();
-        percent_d[i] = if valid_values.len() == slowd_period {
-            Some(calc_mean(&valid_values))
-        } else {
-            None
-        };
+    if slowd_period == 1 {
+        percent_k.to_vec()
+    } else {
+        rolling_mean_strict(percent_k, slowd_period)
     }
-
-    percent_d
 }
 
 pub fn stochs(

core/src/indicators/willr.rs

@@ -1,4 +1,4 @@
-use crate::utils::{find_max, find_min};
+use crate::utils::rolling_max_min;
 
 pub fn willr(highs: &[f64], lows: &[f64], closes: &[f64], period: usize) -> Vec<Option<f64>> {
     let len = closes.len();
@@ -8,9 +8,12 @@ pub fn willr(highs: &[f64], lows: &[f64], closes: &[f64], period: usize) -> Vec<
         return result;
     }
 
+    let (rolling_highs, rolling_lows) = rolling_max_min(highs, lows, period);
+
     for i in period - 1..len {
-        let max_high = find_max(&highs[i + 1 - period..=i]);
-        let min_low = find_min(&lows[i + 1 - period..=i]);
+        let (Some(max_high), Some(min_low)) = (rolling_highs[i], rolling_lows[i]) else {
+            continue;
+        };
 
         let cc = closes[i];
         if max_high == min_low {