style: apply cargo fmt formatting

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

src/aggregation/mod.rs

@@ -71,7 +71,8 @@ pub fn aggregate_volume_bars_ticks<'py>(
             "price and size must be non-empty and equal length",
         ));
     }
-    let (ro, rh, rl, rc, rv) = ferro_ta_core::aggregation::aggregate_volume_bars_ticks(p, s, volume_threshold);
+    let (ro, rh, rl, rc, rv) =
+        ferro_ta_core::aggregation::aggregate_volume_bars_ticks(p, s, volume_threshold);
     Ok((
         ro.into_pyarray(py),
         rh.into_pyarray(py),

src/backtest/mod.rs

@@ -147,8 +147,8 @@ pub fn sma_crossover_signals<'py>(
     validation::validate_timeperiod(fast, "fast", 1)?;
     validation::validate_timeperiod(slow, "slow", 1)?;
     let prices = close.as_slice()?;
-    let out = core_bt::sma_crossover_signals(prices, fast, slow)
-        .map_err(|e| PyValueError::new_err(e))?;
+    let out =
+        core_bt::sma_crossover_signals(prices, fast, slow).map_err(|e| PyValueError::new_err(e))?;
     Ok(out.into_pyarray(py))
 }
 
@@ -202,8 +202,15 @@ pub fn backtest_core<'py>(
     validation::validate_equal_length(&[(c.len(), "close"), (s.len(), "signals")])?;
 
     let cm = commission.as_ref().map(|c| &c.inner);
-    let result = core_bt::backtest_core(c, s, cm, slippage_bps, initial_capital, commission_per_trade)
-        .map_err(|e| PyValueError::new_err(e))?;
+    let result = core_bt::backtest_core(
+        c,
+        s,
+        cm,
+        slippage_bps,
+        initial_capital,
+        commission_per_trade,
+    )
+    .map_err(|e| PyValueError::new_err(e))?;
 
     Ok((
         result.positions.into_pyarray(py),
@@ -348,8 +355,14 @@ pub fn compute_performance_metrics<'py>(
     dict.set_item("calmar", metrics.calmar)?;
     dict.set_item("max_drawdown", metrics.max_drawdown)?;
     dict.set_item("avg_drawdown", metrics.avg_drawdown)?;
-    dict.set_item("max_drawdown_duration_bars", metrics.max_drawdown_duration_bars as i64)?;
-    dict.set_item("avg_drawdown_duration_bars", metrics.avg_drawdown_duration_bars)?;
+    dict.set_item(
+        "max_drawdown_duration_bars",
+        metrics.max_drawdown_duration_bars as i64,
+    )?;
+    dict.set_item(
+        "avg_drawdown_duration_bars",
+        metrics.avg_drawdown_duration_bars,
+    )?;
     dict.set_item("ulcer_index", metrics.ulcer_index)?;
     dict.set_item("omega_ratio", metrics.omega_ratio)?;
     dict.set_item("win_rate", metrics.win_rate)?;
@@ -428,8 +441,8 @@ pub fn extract_trades_ohlcv<'py>(
         (l.len(), "low"),
     ])?;
 
-    let trades = core_bt::extract_trades_ohlcv(pos, fp, h, l)
-        .map_err(|e| PyValueError::new_err(e))?;
+    let trades =
+        core_bt::extract_trades_ohlcv(pos, fp, h, l).map_err(|e| PyValueError::new_err(e))?;
 
     let mut entry_bars: Vec<i64> = Vec::with_capacity(trades.len());
     let mut exit_bars: Vec<i64> = Vec::with_capacity(trades.len());

src/batch/mod.rs

@@ -27,9 +27,7 @@ use rayon::prelude::*;
 /// `result[j]` is column j (one time-series of length n_samples).
 fn numpy2d_to_columns(arr: &ndarray::ArrayView2<'_, f64>) -> Vec<Vec<f64>> {
     let (_n_samples, n_series) = arr.dim();
-    (0..n_series)
-        .map(|j| arr.column(j).to_vec())
-        .collect()
+    (0..n_series).map(|j| arr.column(j).to_vec()).collect()
 }
 
 /// Convert `Vec<Vec<f64>>` (columns) back into a numpy (n_samples, n_series) array.
@@ -320,9 +318,8 @@ pub fn batch_adx<'py>(
     let c_cols = numpy2d_to_columns(&arr_c);
 
     let col_results: Vec<Vec<f64>> = py.allow_threads(|| {
-        let process = |i: usize| {
-            ferro_ta_core::momentum::adx(&h_cols[i], &l_cols[i], &c_cols[i], timeperiod)
-        };
+        let process =
+            |i: usize| ferro_ta_core::momentum::adx(&h_cols[i], &l_cols[i], &c_cols[i], timeperiod);
         if parallel {
             (0..n_series).into_par_iter().map(process).collect()
         } else {
@@ -369,8 +366,9 @@ pub fn run_close_indicators<'py>(
             .map(|r| r.map(|v| v.into_pyarray(py).unbind()).map_err(map_core_err))
             .collect()
     } else {
-        let results = ferro_ta_core::batch::run_close_indicators(close_values, &names, &timeperiods)
-            .map_err(map_core_err)?;
+        let results =
+            ferro_ta_core::batch::run_close_indicators(close_values, &names, &timeperiods)
+                .map_err(map_core_err)?;
         Ok(results
             .into_iter()
             .map(|v| v.into_pyarray(py).unbind())

src/regime/mod.rs

@@ -63,12 +63,11 @@ pub fn rolling_variance_break<'py>(
 ) -> PyResult<Bound<'py, PyArray1<i8>>> {
     validation::validate_timeperiod(short_window, "short_window", 2)?;
     if long_window <= short_window {
-        return Err(PyValueError::new_err(
-            "long_window must be > short_window",
-        ));
+        return Err(PyValueError::new_err("long_window must be > short_window"));
     }
     let s = series.as_slice()?;
-    let result = ferro_ta_core::regime::rolling_variance_break(s, short_window, long_window, threshold);
+    let result =
+        ferro_ta_core::regime::rolling_variance_break(s, short_window, long_window, threshold);
     Ok(result.into_pyarray(py))
 }
 

src/resampling/mod.rs

@@ -38,7 +38,8 @@ pub fn volume_bars<'py>(
             "All input arrays must be non-empty and have equal length",
         ));
     }
-    let (ro, rh, rl, rc, rv) = ferro_ta_core::resampling::volume_bars(o, h, l, c, v, volume_threshold);
+    let (ro, rh, rl, rc, rv) =
+        ferro_ta_core::resampling::volume_bars(o, h, l, c, v, volume_threshold);
     Ok((
         ro.into_pyarray(py),
         rh.into_pyarray(py),

src/streaming/mod.rs

@@ -209,10 +209,7 @@ impl StreamingBBands {
     }
 
     fn __repr__(&self) -> String {
-        format!(
-            "StreamingBBands(period={})",
-            self.inner.period()
-        )
+        format!("StreamingBBands(period={})", self.inner.period())
     }
 }
 
@@ -287,10 +284,7 @@ impl StreamingStoch {
     }
 
     fn __repr__(&self) -> String {
-        format!(
-            "StreamingStoch(fastk_period={})",
-            self.inner.period()
-        )
+        format!("StreamingStoch(fastk_period={})", self.inner.period())
     }
 }
 
@@ -363,10 +357,7 @@ impl StreamingSupertrend {
     }
 
     fn __repr__(&self) -> String {
-        format!(
-            "StreamingSupertrend(period={})",
-            self.inner.period()
-        )
+        format!("StreamingSupertrend(period={})", self.inner.period())
     }
 }