♻️ core 상태형 지표 nullable 입력 전환 (#16)

## 요약
- 이 PR은 `#15` 위에 쌓인 stacked PR입니다. 리뷰는 `core-nullable-foundations` 대비로 봐주시면 됩니다.
- foundation layer에서 정의한 nullable contract를 상태형, pairwise, cumulative 지표에 적용합니다.
- gap을 건너뛰며 series를 압축하지 않고, 현재 row, 이전 row, 내부 state의 유효성에 따라 `None`을 반환하는 규칙을 맞춥니다.

## 변경 사항
- `rsi`, `atr`, `dmi`, `adx`, `adxr`를 nullable 입력 기준으로 전환합니다.
- `ad`, `cmf`, `co`, `efi`, `eom`, `nvi`, `obv`, `pvi`, `ultosc`, `vr` 등 pairwise/cumulative family를 같은 계약으로 정리합니다.
- `psar`를 포함한 stateful indicator가 gap row에서 output만 `None`을 내고, 다음 valid row에서 이전 state를 이어서 재개하도록 맞춥니다.
- 필요한 nullable helper를 `core/src/utils.rs`에 추가합니다.

## 리뷰 포인트
- current row나 required predecessor가 비면 해당 row는 `None`이어야 합니다.
- recursive/stateful 계산은 gap을 사이에 두고 series를 압축하지 않은 채 정렬을 유지해야 합니다.
- accumulator 기반 지표는 invalid row에서 상태를 억지로 갱신하지 않아야 합니다.
- `psar`, `dmi`, `atr`, `rsi`가 대표적인 확인 포인트입니다.

## 범위 외
- `plugin/polars`는 여전히 이번 stack 범위 밖입니다.
- composite/derived indicator의 최종 정리는 상위 PR `#17`에서 다룹니다.

## 테스트 계획
- [x] `cargo fmt --package techr-core --check`
- [x] `cargo test -p techr-core`

Author: mingi3314

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]);
+    }
 }