♻️ core 상태형 지표 nullable 입력 전환

core/src/indicators/ad.rs

@@ -1,6 +1,11 @@
 use crate::utils::calc_clv;
 
-pub fn ad(highs: &[f64], lows: &[f64], closes: &[f64], volumes: &[f64]) -> Vec<Option<f64>> {
+pub fn ad(
+    highs: &[Option<f64>],
+    lows: &[Option<f64>],
+    closes: &[Option<f64>],
+    volumes: &[Option<f64>],
+) -> Vec<Option<f64>> {
     let mut ad = vec![None; highs.len()];
 
     let len = highs.len();
@@ -11,7 +16,13 @@ pub fn ad(highs: &[f64], lows: &[f64], closes: &[f64], volumes: &[f64]) -> Vec<O
 
     let mut ad_point = 0.0;
     for i in 0..len {
-        ad_point += calc_clv(highs[i], lows[i], closes[i]) * volumes[i];
+        let (Some(high), Some(low), Some(close), Some(volume)) =
+            (highs[i], lows[i], closes[i], volumes[i])
+        else {
+            continue;
+        };
+
+        ad_point += calc_clv(high, low, close) * volume;
         ad[i] = Some(ad_point);
     }
 
@@ -28,10 +39,22 @@ mod tests {
     fn test_ad() {
         let test_cases = vec!["005930"];
         for symbol in test_cases {
-            let high = testutils::load_data(&format!("../data/{}.json", symbol), "h");
-            let low = testutils::load_data(&format!("../data/{}.json", symbol), "l");
-            let close = testutils::load_data(&format!("../data/{}.json", symbol), "c");
-            let volume = testutils::load_data(&format!("../data/{}.json", symbol), "v");
+            let high = testutils::load_data(&format!("../data/{}.json", symbol), "h")
+                .into_iter()
+                .map(Some)
+                .collect::<Vec<_>>();
+            let low = testutils::load_data(&format!("../data/{}.json", symbol), "l")
+                .into_iter()
+                .map(Some)
+                .collect::<Vec<_>>();
+            let close = testutils::load_data(&format!("../data/{}.json", symbol), "c")
+                .into_iter()
+                .map(Some)
+                .collect::<Vec<_>>();
+            let volume = testutils::load_data(&format!("../data/{}.json", symbol), "v")
+                .into_iter()
+                .map(Some)
+                .collect::<Vec<_>>();
 
             let result = ad(&high, &low, &close, &volume);
             let expected = testutils::load_expected::<Option<f64>>(&format!(
@@ -47,4 +70,16 @@ mod tests {
             );
         }
     }
+
+    #[test]
+    fn test_ad_with_gap_preserves_running_total() {
+        let highs = vec![Some(10.0), Some(12.0), None, Some(14.0)];
+        let lows = vec![Some(8.0), Some(10.0), None, Some(12.0)];
+        let closes = vec![Some(9.0), Some(11.0), None, Some(13.0)];
+        let volumes = vec![Some(100.0), Some(100.0), Some(100.0), Some(100.0)];
+
+        let result = ad(&highs, &lows, &closes, &volumes);
+
+        assert_eq!(result, vec![Some(0.0), Some(0.0), None, Some(0.0)]);
+    }
 }

core/src/indicators/adx.rs

@@ -1,36 +1,49 @@
 use crate::indicators::dmi::dmi;
 
 pub fn adx(
-    highs: &[f64],
-    lows: &[f64],
-    closes: &[f64],
+    highs: &[Option<f64>],
+    lows: &[Option<f64>],
+    closes: &[Option<f64>],
     dmi_period: usize,
     adx_period: usize,
 ) -> Vec<Option<f64>> {
     let (plus_di, minus_di) = dmi(highs, lows, closes, dmi_period);
-    let mut adx = Vec::with_capacity(plus_di.len());
+    let mut adx = vec![None; plus_di.len()];
     let mut dx_sum = 0.0;
-    let mut adx_point = 0.0;
+    let mut seeded = 0usize;
+    let mut adx_point = None;
+
+    if adx_period == 0 {
+        return adx;
+    }
 
     for i in 0..plus_di.len() {
-        let dx = match (plus_di[i], minus_di[i]) {
+        let Some(dx) = (match (plus_di[i], minus_di[i]) {
             (Some(plus), Some(minus)) if plus != 0.0 || minus != 0.0 => {
-                (plus - minus).abs() / (plus + minus) * 100.0
+                Some((plus - minus).abs() / (plus + minus) * 100.0)
+            }
+            (Some(_), Some(_)) => Some(0.0),
+            _ => None,
+        }) else {
+            if adx_point.is_none() {
+                dx_sum = 0.0;
+                seeded = 0;
             }
-            _ => 0.0,
+            continue;
         };
 
-        let initial_period = dmi_period + adx_period - 1;
-        if i < initial_period {
-            dx_sum += dx;
-            adx.push(None);
-        } else if i == initial_period {
-            dx_sum += dx;
-            adx_point = dx_sum / adx_period as f64;
-            adx.push(Some(adx_point));
+        if let Some(current_adx) = adx_point {
+            let next_adx = (current_adx * (adx_period - 1) as f64 + dx) / adx_period as f64;
+            adx_point = Some(next_adx);
+            adx[i] = Some(next_adx);
         } else {
-            adx_point = (adx_point * (adx_period - 1) as f64 + dx) / adx_period as f64;
-            adx.push(Some(adx_point));
+            dx_sum += dx;
+            seeded += 1;
+            if seeded == adx_period {
+                let initial_adx = dx_sum / adx_period as f64;
+                adx_point = Some(initial_adx);
+                adx[i] = Some(initial_adx);
+            }
         }
     }
 
@@ -51,6 +64,10 @@ mod tests {
             let lows = testutils::load_data(&format!("../data/{}.json", symbol), "l");
             let closes = testutils::load_data(&format!("../data/{}.json", symbol), "c");
 
+            let highs = highs.into_iter().map(Some).collect::<Vec<_>>();
+            let lows = lows.into_iter().map(Some).collect::<Vec<_>>();
+            let closes = closes.into_iter().map(Some).collect::<Vec<_>>();
+
             let result = adx(&highs, &lows, &closes, 14, 14);
             let expected = testutils::load_expected::<Option<f64>>(&format!(
                 "../data/expected/adx_{}.json",
@@ -65,4 +82,73 @@ mod tests {
             );
         }
     }
+
+    #[test]
+    fn test_adx_requires_contiguous_seed_window_and_resumes_after_gap() {
+        let highs = vec![
+            Some(10.0),
+            Some(12.0),
+            Some(14.0),
+            None,
+            Some(15.0),
+            Some(16.0),
+            Some(18.0),
+            None,
+            Some(19.0),
+            Some(20.0),
+        ];
+        let lows = vec![
+            Some(8.0),
+            Some(9.0),
+            Some(11.0),
+            None,
+            Some(13.0),
+            Some(14.0),
+            Some(15.0),
+            None,
+            Some(17.0),
+            Some(18.0),
+        ];
+        let closes = vec![
+            Some(9.0),
+            Some(11.0),
+            Some(13.0),
+            None,
+            Some(14.0),
+            Some(15.0),
+            Some(17.0),
+            None,
+            Some(18.0),
+            Some(19.0),
+        ];
+
+        let result = adx(&highs, &lows, &closes, 2, 2);
+
+        assert_eq!(
+            result,
+            vec![
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                Some(100.0),
+                None,
+                None,
+                Some(100.0)
+            ]
+        );
+    }
+
+    #[test]
+    fn test_adx_length_mismatch_fails_closed() {
+        let highs = vec![Some(10.0), Some(12.0), Some(14.0)];
+        let lows = vec![Some(8.0), Some(9.0)];
+        let closes = vec![Some(9.0), Some(11.0), Some(13.0)];
+
+        let result = adx(&highs, &lows, &closes, 2, 2);
+
+        assert_eq!(result, vec![None, None, None]);
+    }
 }

core/src/indicators/adxr.rs

@@ -1,9 +1,9 @@
 use crate::indicators::adx::adx;
 
 pub fn adxr(
-    highs: &[f64],
-    lows: &[f64],
-    closes: &[f64],
+    highs: &[Option<f64>],
+    lows: &[Option<f64>],
+    closes: &[Option<f64>],
     dmi_period: usize,
     adx_period: usize,
     adxr_period: usize,
@@ -35,9 +35,18 @@ mod tests {
     fn test_adxr() {
         let test_cases = vec!["005930", "TSLA"];
         for symbol in test_cases {
-            let highs = testutils::load_data(&format!("../data/{}.json", symbol), "h");
-            let lows = testutils::load_data(&format!("../data/{}.json", symbol), "l");
-            let closes = testutils::load_data(&format!("../data/{}.json", symbol), "c");
+            let highs = testutils::load_data(&format!("../data/{}.json", symbol), "h")
+                .into_iter()
+                .map(Some)
+                .collect::<Vec<_>>();
+            let lows = testutils::load_data(&format!("../data/{}.json", symbol), "l")
+                .into_iter()
+                .map(Some)
+                .collect::<Vec<_>>();
+            let closes = testutils::load_data(&format!("../data/{}.json", symbol), "c")
+                .into_iter()
+                .map(Some)
+                .collect::<Vec<_>>();
 
             let result = adxr(&highs, &lows, &closes, 14, 14, 14);
             let expected = testutils::load_expected::<Option<f64>>(&format!(
@@ -53,4 +62,73 @@ mod tests {
             );
         }
     }
+
+    #[test]
+    fn test_adxr_requires_current_and_lagged_adx_after_gaps() {
+        let highs = vec![
+            Some(10.0),
+            Some(12.0),
+            Some(14.0),
+            None,
+            Some(15.0),
+            Some(16.0),
+            Some(18.0),
+            None,
+            Some(19.0),
+            Some(20.0),
+        ];
+        let lows = vec![
+            Some(8.0),
+            Some(9.0),
+            Some(11.0),
+            None,
+            Some(13.0),
+            Some(14.0),
+            Some(15.0),
+            None,
+            Some(17.0),
+            Some(18.0),
+        ];
+        let closes = vec![
+            Some(9.0),
+            Some(11.0),
+            Some(13.0),
+            None,
+            Some(14.0),
+            Some(15.0),
+            Some(17.0),
+            None,
+            Some(18.0),
+            Some(19.0),
+        ];
+
+        let result = adxr(&highs, &lows, &closes, 2, 2, 4);
+
+        assert_eq!(
+            result,
+            vec![
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                Some(100.0)
+            ]
+        );
+    }
+
+    #[test]
+    fn test_adxr_length_mismatch_fails_closed() {
+        let highs = vec![Some(10.0), Some(12.0), Some(14.0)];
+        let lows = vec![Some(8.0), Some(9.0)];
+        let closes = vec![Some(9.0), Some(11.0), Some(13.0)];
+
+        let result = adxr(&highs, &lows, &closes, 2, 2, 2);
+
+        assert_eq!(result, vec![None, None, None]);
+    }
 }