@ebowwa/quant-rust 0.2.1 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ebowwa/quant-rust",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "High-performance quantitative finance library with Rust FFI bindings for Bun",
   "type": "module",
   "main": "./dist/index.js",

package/src/risk/drawdown.rs

@@ -68,21 +68,23 @@ pub fn calculate_drawdown(equity_curve: &[f64]) -> DrawdownResult {
     let mut current_drawdown_start: Option<usize> = None;
     let mut drawdowns: Vec<DrawdownPoint> = Vec::new();
 
+    let initial_peak = equity_curve[0]; // Track initial peak for start==0 case
+
     for (i, &equity) in equity_curve.iter().enumerate() {
         if equity > peak {
             // New peak - check if we had a drawdown
             if let Some(start) = current_drawdown_start {
-                if start > 0 {
-                    let trough_slice = &equity_curve[start..i];
-                    let trough = min(trough_slice);
-                    let dd = (peak - trough) / peak;
-                    drawdowns.push(DrawdownPoint {
-                        start,
-                        end: i,
-                        trough,
-                        drawdown: dd,
-                    });
-                }
+                // Use initial peak if drawdown started at index 0
+                let peak_for_dd = if start == 0 { initial_peak } else { peak };
+                let trough_slice = &equity_curve[start..i];
+                let trough = min(trough_slice);
+                let dd = (peak_for_dd - trough) / peak_for_dd;
+                drawdowns.push(DrawdownPoint {
+                    start,
+                    end: i,
+                    trough,
+                    drawdown: dd,
+                });
             }
             peak = equity;
             current_drawdown_start = None;
@@ -101,10 +103,11 @@ pub fn calculate_drawdown(equity_curve: &[f64]) -> DrawdownResult {
 
     // Handle any remaining drawdown at the end
     if let Some(start) = current_drawdown_start {
-        if start > 0 && start < equity_curve.len() {
+        if start < equity_curve.len() {
+            let peak_for_dd = if start == 0 { initial_peak } else { peak };
             let trough_slice = &equity_curve[start..];
             let trough = min(trough_slice);
-            let dd = (peak - trough) / peak;
+            let dd = (peak_for_dd - trough) / peak_for_dd;
             drawdowns.push(DrawdownPoint {
                 start,
                 end: equity_curve.len() - 1,
@@ -253,4 +256,28 @@ mod tests {
         let periods = underwater_periods(&equity);
         assert!(periods.is_empty());
     }
+
+    #[test]
+    fn test_calculate_drawdown_start_at_zero() {
+        // Edge case: drawdown starting at index 0
+        // Initial value 100 is the peak, then decline to 90, recover to 100
+        let equity = vec![100.0, 95.0, 90.0, 95.0, 100.0];
+        let result = calculate_drawdown(&equity);
+        // Should detect drawdown from 100 to 90 = 10%
+        assert!((result.max_drawdown - 0.1).abs() < 0.001, "Expected 10% drawdown, got {}", result.max_drawdown);
+        // Drawdowns are recorded when recovery happens
+        // Since 100 >= 100 at end, drawdown should be recorded
+        assert!(!result.drawdowns.is_empty(), "Expected drawdowns to be recorded");
+    }
+
+    #[test]
+    fn test_calculate_drawdown_declining_only() {
+        // Edge case: only declining, never recovers
+        let equity = vec![100.0, 95.0, 90.0, 85.0, 80.0];
+        let result = calculate_drawdown(&equity);
+        // Max drawdown: 100 to 80 = 20%
+        assert!((result.max_drawdown - 0.2).abs() < 0.001, "Expected 20% drawdown, got {}", result.max_drawdown);
+        // Should record drawdown at end since never recovered
+        assert!(!result.drawdowns.is_empty(), "Expected drawdown to be recorded at end");
+    }
 }