forexsmartbot 3.2.0__tar.gz → 3.2.1__tar.gz

{forexsmartbot-3.2.0 → forexsmartbot-3.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forexsmartbot
-Version: 3.2.0
+Version: 3.2.1
 Summary: Professional forex trading bot with advanced risk management and strategy plugins
 Author-email: VoxHash <contact@voxhash.dev>
 License: MIT
@@ -30,7 +30,7 @@ Requires-Dist: mplfinance>=0.12.10
 Requires-Dist: TA-Lib>=0.6.7
 Requires-Dist: requests>=2.31.0
 Requires-Dist: ib-insync>=0.9.86
-Requires-Dist: win10toast>=0.9
+Requires-Dist: win10toast>=0.9; sys_platform == "win32"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
@@ -42,13 +42,17 @@ Dynamic: license-file
 
 # ForexSmartBot
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
-[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
-[![PyQt6](https://img.shields.io/badge/PyQt6-6.7+-green.svg)](https://www.riverbankcomputing.com/software/pyqt/)
-[![Version](https://img.shields.io/badge/version-3.2.0-blue.svg)](https://github.com/VoxHash/ForexSmartBot/releases)
+![PyPI version](https://img.shields.io/pypi/v/forexsmartbot.svg)
+![Python Versions](https://img.shields.io/pypi/pyversions/forexsmartbot.svg)
+![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)
+![PyQt6](https://img.shields.io/badge/PyQt6-6.7+-green.svg)
+
+
 
 > Professional-grade desktop application for automated forex trading with advanced risk management, multiple trading strategies, and real-time portfolio monitoring.
 
+
+
 ## ✨ Features
 
 - **Multi-Strategy Trading**: 17+ built-in strategies including 7 ML-based approaches
@@ -60,6 +64,8 @@ Dynamic: license-file
 - **Strategy Builder**: Visual strategy construction with code generation
 - **Strategy Marketplace**: Community-driven strategy sharing platform
 
+
+
 ## 🧭 Table of Contents
 
 - [Quick Start](#-quick-start)
@@ -70,6 +76,8 @@ Dynamic: license-file
 - [Contributing](#-contributing)
 - [License](#-license)
 
+
+
 ## 🚀 Quick Start
 
 ```bash
@@ -84,12 +92,18 @@ For detailed installation instructions, see [docs/installation.md](docs/Installa
 
 ## 💿 Installation
 
+
+
 ### From PyPI (Recommended)
+
 ```bash
 pip install forexsmartbot
 ```
 
+
+
 ### From Source
+
 ```bash
 git clone https://github.com/VoxHash/ForexSmartBot.git
 cd ForexSmartBot
@@ -97,7 +111,10 @@ pip install -r requirements.txt
 python app.py
 ```
 
+
+
 ### With GPU Acceleration (Optional)
+
 ```bash
 # For CUDA 12.x
 pip install cupy-cuda12x
@@ -108,8 +125,22 @@ pip install cupy-cuda11x
 
 See [docs/GPU_ACCELERATION.md](docs/GPU_ACCELERATION.md) for detailed setup instructions.
 
+### With Native Rust Indicators (Optional)
+
+Lower-memory SMA/ATR/RSI and parallel batch SMA via PyO3 (`native/fsb_core`). Requires [Rust](https://rustup.rs/) and [maturin](https://www.maturin.rs/).
+
+```bash
+# once: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+pip install maturin
+cd native/fsb_core && maturin develop --release
+```
+
+Without the extension, the same Python APIs use a NumPy fallback automatically. See [docs/PERFORMANCE_TUNING.md](docs/PERFORMANCE_TUNING.md).
+
 ## 🛠 Usage
 
+
+
 ### Basic Workflow
 
 1. Launch the application: `python app.py`
@@ -122,12 +153,14 @@ For advanced usage, see [docs/usage.md](docs/QUICK_START_V3.1.0.md) and [docs/cl
 
 ## ⚙️ Configuration
 
-| Variable | Description | Default |
-|---|---|---|
-| `INITIAL_BALANCE` | Starting account balance | 10000.0 |
-| `RISK_PER_TRADE` | Risk percentage per trade | 0.02 |
-| `MAX_LEVERAGE` | Maximum leverage | 1:100 |
-| `DATA_INTERVAL` | Data update interval | 1h |
+
+| Variable          | Description               | Default |
+| ----------------- | ------------------------- | ------- |
+| `INITIAL_BALANCE` | Starting account balance  | 10000.0 |
+| `RISK_PER_TRADE`  | Risk percentage per trade | 0.02    |
+| `MAX_LEVERAGE`    | Maximum leverage          | 1:100   |
+| `DATA_INTERVAL`   | Data update interval      | 1h      |
+
 
 Full configuration reference: [docs/Configuration-Guide.md](docs/Configuration-Guide.md)
 
@@ -164,7 +197,7 @@ This project is licensed under the terms in [LICENSE](LICENSE).
 - **Documentation**: [docs/](docs/)
 - **FAQ**: [docs/FAQ.md](docs/FAQ.md)
 - **Issues**: [GitHub Issues](https://github.com/VoxHash/ForexSmartBot/issues)
-- **Email**: contact@voxhash.dev
+- **Email**: [contact@voxhash.dev](mailto:contact@voxhash.dev)
 
 See [SUPPORT.md](SUPPORT.md) for more support options.
 

{forexsmartbot-3.2.0 → forexsmartbot-3.2.1}/README.md

@@ -1,12 +1,16 @@
 # ForexSmartBot
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
-[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
-[![PyQt6](https://img.shields.io/badge/PyQt6-6.7+-green.svg)](https://www.riverbankcomputing.com/software/pyqt/)
-[![Version](https://img.shields.io/badge/version-3.2.0-blue.svg)](https://github.com/VoxHash/ForexSmartBot/releases)
+![PyPI version](https://img.shields.io/pypi/v/forexsmartbot.svg)
+![Python Versions](https://img.shields.io/pypi/pyversions/forexsmartbot.svg)
+![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)
+![PyQt6](https://img.shields.io/badge/PyQt6-6.7+-green.svg)
+
+
 
 > Professional-grade desktop application for automated forex trading with advanced risk management, multiple trading strategies, and real-time portfolio monitoring.
 
+
+
 ## ✨ Features
 
 - **Multi-Strategy Trading**: 17+ built-in strategies including 7 ML-based approaches
@@ -18,6 +22,8 @@
 - **Strategy Builder**: Visual strategy construction with code generation
 - **Strategy Marketplace**: Community-driven strategy sharing platform
 
+
+
 ## 🧭 Table of Contents
 
 - [Quick Start](#-quick-start)
@@ -28,6 +34,8 @@
 - [Contributing](#-contributing)
 - [License](#-license)
 
+
+
 ## 🚀 Quick Start
 
 ```bash
@@ -42,12 +50,18 @@ For detailed installation instructions, see [docs/installation.md](docs/Installa
 
 ## 💿 Installation
 
+
+
 ### From PyPI (Recommended)
+
 ```bash
 pip install forexsmartbot
 ```
 
+
+
 ### From Source
+
 ```bash
 git clone https://github.com/VoxHash/ForexSmartBot.git
 cd ForexSmartBot
@@ -55,7 +69,10 @@ pip install -r requirements.txt
 python app.py
 ```
 
+
+
 ### With GPU Acceleration (Optional)
+
 ```bash
 # For CUDA 12.x
 pip install cupy-cuda12x
@@ -66,8 +83,22 @@ pip install cupy-cuda11x
 
 See [docs/GPU_ACCELERATION.md](docs/GPU_ACCELERATION.md) for detailed setup instructions.
 
+### With Native Rust Indicators (Optional)
+
+Lower-memory SMA/ATR/RSI and parallel batch SMA via PyO3 (`native/fsb_core`). Requires [Rust](https://rustup.rs/) and [maturin](https://www.maturin.rs/).
+
+```bash
+# once: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+pip install maturin
+cd native/fsb_core && maturin develop --release
+```
+
+Without the extension, the same Python APIs use a NumPy fallback automatically. See [docs/PERFORMANCE_TUNING.md](docs/PERFORMANCE_TUNING.md).
+
 ## 🛠 Usage
 
+
+
 ### Basic Workflow
 
 1. Launch the application: `python app.py`
@@ -80,12 +111,14 @@ For advanced usage, see [docs/usage.md](docs/QUICK_START_V3.1.0.md) and [docs/cl
 
 ## ⚙️ Configuration
 
-| Variable | Description | Default |
-|---|---|---|
-| `INITIAL_BALANCE` | Starting account balance | 10000.0 |
-| `RISK_PER_TRADE` | Risk percentage per trade | 0.02 |
-| `MAX_LEVERAGE` | Maximum leverage | 1:100 |
-| `DATA_INTERVAL` | Data update interval | 1h |
+
+| Variable          | Description               | Default |
+| ----------------- | ------------------------- | ------- |
+| `INITIAL_BALANCE` | Starting account balance  | 10000.0 |
+| `RISK_PER_TRADE`  | Risk percentage per trade | 0.02    |
+| `MAX_LEVERAGE`    | Maximum leverage          | 1:100   |
+| `DATA_INTERVAL`   | Data update interval      | 1h      |
+
 
 Full configuration reference: [docs/Configuration-Guide.md](docs/Configuration-Guide.md)
 
@@ -122,7 +155,7 @@ This project is licensed under the terms in [LICENSE](LICENSE).
 - **Documentation**: [docs/](docs/)
 - **FAQ**: [docs/FAQ.md](docs/FAQ.md)
 - **Issues**: [GitHub Issues](https://github.com/VoxHash/ForexSmartBot/issues)
-- **Email**: contact@voxhash.dev
+- **Email**: [contact@voxhash.dev](mailto:contact@voxhash.dev)
 
 See [SUPPORT.md](SUPPORT.md) for more support options.
 
@@ -132,4 +165,4 @@ This application is for educational and legitimate business purposes only. Users
 
 ---
 
-Made with ❤️ by [VoxHash Technologies](https://voxhash.dev)
+Made with ❤️ by [VoxHash Technologies](https://voxhash.dev)

{forexsmartbot-3.2.0 → forexsmartbot-3.2.1}/forexsmartbot/core/strategy.py

@@ -1,5 +1,4 @@
 import pandas as pd
-import numpy as np
 
 class Strategy:
     """Simple trend/volatility aware strategy:
@@ -13,14 +12,8 @@ class Strategy:
         self.atr_window = atr_window
 
     def indicators(self, df: pd.DataFrame) -> pd.DataFrame:
-        out = df.copy()
-        out['SMA_fast'] = out['Close'].rolling(self.fast).mean()
-        out['SMA_slow'] = out['Close'].rolling(self.slow).mean()
-        tr = np.maximum(out['High']-out['Low'],
-                        np.maximum(abs(out['High']-out['Close'].shift(1)),
-                                   abs(out['Low']-out['Close'].shift(1))))
-        out['ATR'] = tr.rolling(self.atr_window).mean()
-        return out
+        from ..utils.native_indicators import apply_sma_atr_indicators
+        return apply_sma_atr_indicators(df, self.fast, self.slow, self.atr_window)
 
     def signal(self, df: pd.DataFrame) -> int:
         if len(df) < max(self.fast, self.slow) + 2:

{forexsmartbot-3.2.0 → forexsmartbot-3.2.1}/forexsmartbot/services/calculation_engine.py

@@ -68,27 +68,36 @@ class CalculationEngine:
                           columns=returns_df.columns)
         
     @staticmethod
-    @jit(nopython=True)
     def fast_rolling_mean(values: np.ndarray, window: int) -> np.ndarray:
+        """Fast rolling mean: prefer Rust ``fsb_core``, else Numba, else NumPy."""
+        from ..utils.native_indicators import native_available, sma
+
+        if native_available():
+            return sma(values, window)
+        return CalculationEngine._numba_rolling_mean(np.asarray(values, dtype=np.float64), window)
+
+    @staticmethod
+    @jit(nopython=True)
+    def _numba_rolling_mean(values: np.ndarray, window: int) -> np.ndarray:
         """Fast rolling mean calculation using numba."""
         n = len(values)
         result = np.full(n, np.nan)
-        
+
         for i in range(window - 1, n):
             result[i] = np.mean(values[i - window + 1:i + 1])
-            
+
         return result
-        
+
     @staticmethod
     @jit(nopython=True)
     def fast_rolling_std(values: np.ndarray, window: int) -> np.ndarray:
         """Fast rolling standard deviation calculation."""
         n = len(values)
         result = np.full(n, np.nan)
-        
+
         for i in range(window - 1, n):
             result[i] = np.std(values[i - window + 1:i + 1])
-            
+
         return result
         
     @lru_cache(maxsize=128)

{forexsmartbot-3.2.0 → forexsmartbot-3.2.1}/forexsmartbot/strategies/__init__.py

@@ -110,10 +110,23 @@ RISK_LEVELS = {
 }
 
 def get_strategy(name: str, **params):
-    """Get strategy instance by name."""
+    """Get strategy instance by name.
+
+    ``Multi_Timeframe`` accepts an optional ``base_strategy`` (instance or registry
+    name). When omitted, it defaults to ``SMA_Crossover`` so UI / backtest call
+    sites can use ``get_strategy('Multi_Timeframe')`` with no extra kwargs.
+    """
     if name not in STRATEGIES:
         raise ValueError(f"Unknown strategy: {name}")
-    return STRATEGIES[name](**params)
+    cls = STRATEGIES[name]
+    if name == 'Multi_Timeframe':
+        base = params.pop('base_strategy', None)
+        if isinstance(base, str):
+            if base == 'Multi_Timeframe':
+                raise ValueError("Multi_Timeframe cannot wrap itself as base_strategy")
+            base = get_strategy(base)
+        return cls(base_strategy=base, **params)
+    return cls(**params)
 
 def list_strategies():
     """List available strategies."""

{forexsmartbot-3.2.0 → forexsmartbot-3.2.1}/forexsmartbot/strategies/multi_timeframe_strategy.py

@@ -2,30 +2,51 @@
 
 import pandas as pd
 import numpy as np
-from typing import Dict, Any, Optional, List
-from ..core.interfaces import IStrategy
-from ..adapters.data import IDataProvider
+from typing import Dict, Any, Optional, List, Union
+from ..core.interfaces import IStrategy, IDataProvider
 
 
 class MultiTimeframeStrategy(IStrategy):
     """Strategy that analyzes multiple timeframes simultaneously."""
     
-    def __init__(self, base_strategy: IStrategy, timeframes: List[str] = ['1h', '4h', '1d'],
-                 timeframe_weights: Optional[Dict[str, float]] = None):
+    def __init__(
+        self,
+        base_strategy: Optional[Union[IStrategy, str]] = None,
+        timeframes: Optional[List[str]] = None,
+        timeframe_weights: Optional[Dict[str, float]] = None,
+    ):
         """
         Initialize multi-timeframe strategy.
         
         Args:
-            base_strategy: Base strategy to apply on each timeframe
+            base_strategy: Base strategy instance, registry name, or None for SMA_Crossover
             timeframes: List of timeframes to analyze (e.g., ['1h', '4h', '1d'])
             timeframe_weights: Optional weights for each timeframe (default: equal weights)
         """
-        self._base_strategy = base_strategy
-        self._timeframes = timeframes
-        self._timeframe_weights = timeframe_weights or {tf: 1.0/len(timeframes) for tf in timeframes}
-        self._name = f"Multi-Timeframe {base_strategy.name}"
+        if timeframes is None:
+            timeframes = ['1h', '4h', '1d']
+        self._base_strategy = self._resolve_base_strategy(base_strategy)
+        self._timeframes = list(timeframes)
+        self._timeframe_weights = timeframe_weights or {
+            tf: 1.0 / len(self._timeframes) for tf in self._timeframes
+        }
+        self._name = f"Multi-Timeframe {self._base_strategy.name}"
         self._data_provider = None
         self._timeframe_data = {}
+
+    @staticmethod
+    def _resolve_base_strategy(base_strategy: Optional[Union[IStrategy, str]]) -> IStrategy:
+        """Resolve base strategy from instance, registry name, or default SMA crossover."""
+        if base_strategy is None:
+            from .sma_crossover import SMACrossover
+            return SMACrossover()
+        if isinstance(base_strategy, str):
+            if base_strategy == 'Multi_Timeframe':
+                raise ValueError("Multi_Timeframe cannot wrap itself as base_strategy")
+            # Lazy import to avoid circular registry import at module load
+            from . import get_strategy
+            return get_strategy(base_strategy)
+        return base_strategy
         
     @property
     def name(self) -> str:
@@ -104,8 +125,13 @@ class MultiTimeframeStrategy(IStrategy):
         if len(df) < 2:
             return 0.0
             
-        # Use SMA crossover as trend indicator
-        if 'SMA_20' in df.columns and 'SMA_50' in df.columns:
+        # Prefer SMA_fast/SMA_slow (SMACrossover); fall back to SMA_20/SMA_50 naming
+        if 'SMA_fast' in df.columns and 'SMA_slow' in df.columns:
+            sma_fast = df['SMA_fast'].iloc[-1]
+            sma_slow = df['SMA_slow'].iloc[-1]
+            if pd.notna(sma_fast) and pd.notna(sma_slow):
+                return 1.0 if sma_fast > sma_slow else -1.0
+        elif 'SMA_20' in df.columns and 'SMA_50' in df.columns:
             sma_fast = df['SMA_20'].iloc[-1]
             sma_slow = df['SMA_50'].iloc[-1]
             if pd.notna(sma_fast) and pd.notna(sma_slow):

{forexsmartbot-3.2.0 → forexsmartbot-3.2.1}/forexsmartbot/strategies/sma_crossover.py

@@ -1,7 +1,6 @@
 """SMA Crossover strategy."""
 
 import pandas as pd
-import numpy as np
 from typing import Dict, Any, Optional
 from ..core.interfaces import IStrategy
 
@@ -36,24 +35,11 @@ class SMACrossover(IStrategy):
             self._atr_period = int(kwargs['atr_period'])
             
     def indicators(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Calculate SMA and ATR indicators."""
-        out = df.copy()
-        
-        # SMAs
-        out['SMA_fast'] = out['Close'].rolling(self._fast_period).mean()
-        out['SMA_slow'] = out['Close'].rolling(self._slow_period).mean()
-        
-        # ATR
-        tr = np.maximum(
-            out['High'] - out['Low'],
-            np.maximum(
-                abs(out['High'] - out['Close'].shift(1)),
-                abs(out['Low'] - out['Close'].shift(1))
-            )
+        """Calculate SMA and ATR indicators (Rust ``fsb_core`` when available)."""
+        from ..utils.native_indicators import apply_sma_atr_indicators
+        return apply_sma_atr_indicators(
+            df, self._fast_period, self._slow_period, self._atr_period
         )
-        out['ATR'] = tr.rolling(self._atr_period).mean()
-        
-        return out
         
     def signal(self, df: pd.DataFrame) -> int:
         """Generate trading signal based on SMA crossover."""

forexsmartbot-3.2.1/forexsmartbot/utils/native_indicators.py

@@ -0,0 +1,200 @@
+"""Native (Rust/PyO3) indicator helpers with pure-Python/NumPy fallback.
+
+Build optional extension from ``native/fsb_core``::
+
+    cd native/fsb_core && maturin develop --release
+
+When ``fsb_core`` is not installed, callers still get correct results via NumPy.
+"""
+
+from __future__ import annotations
+
+from typing import List, Optional, Sequence
+
+import numpy as np
+import pandas as pd
+
+_NATIVE = None
+_NATIVE_ERR: Optional[str] = None
+
+try:
+    import fsb_core as _NATIVE  # type: ignore
+except Exception as exc:  # pragma: no cover - optional dependency
+    _NATIVE_ERR = str(exc)
+    _NATIVE = None
+
+
+def native_available() -> bool:
+    """Return True if the Rust ``fsb_core`` extension is importable."""
+    return _NATIVE is not None
+
+
+def native_status() -> str:
+    """Human-readable status for logs / settings."""
+    if _NATIVE is not None:
+        ver = getattr(_NATIVE, "__version__", "?")
+        return f"fsb_core {ver} (Rust)"
+    return f"unavailable ({_NATIVE_ERR or 'not built'})"
+
+
+def _as_f64(values: Sequence[float] | np.ndarray | pd.Series) -> np.ndarray:
+    arr = np.asarray(values, dtype=np.float64)
+    if arr.ndim != 1:
+        raise ValueError("values must be 1-D")
+    return arr
+
+
+def sma(values: Sequence[float] | np.ndarray | pd.Series, window: int) -> np.ndarray:
+    """Simple moving average; leading values are NaN until ``window`` fills."""
+    if window < 1:
+        raise ValueError("window must be >= 1")
+    arr = _as_f64(values)
+    if _NATIVE is not None:
+        return np.asarray(_NATIVE.sma(arr.tolist(), int(window)), dtype=np.float64)
+    out = np.full(arr.shape[0], np.nan, dtype=np.float64)
+    if arr.shape[0] < window:
+        return out
+    csum = np.cumsum(arr, dtype=np.float64)
+    out[window - 1 :] = (csum[window - 1 :] - np.concatenate(([0.0], csum[:-window]))) / window
+    return out
+
+
+def atr(
+    high: Sequence[float] | np.ndarray | pd.Series,
+    low: Sequence[float] | np.ndarray | pd.Series,
+    close: Sequence[float] | np.ndarray | pd.Series,
+    period: int,
+) -> np.ndarray:
+    """Average True Range (simple mean of true range)."""
+    if period < 1:
+        raise ValueError("period must be >= 1")
+    h = _as_f64(high)
+    l = _as_f64(low)
+    c = _as_f64(close)
+    if not (h.shape == l.shape == c.shape):
+        raise ValueError("high, low, and close must have the same length")
+    if _NATIVE is not None:
+        return np.asarray(
+            _NATIVE.atr(h.tolist(), l.tolist(), c.tolist(), int(period)),
+            dtype=np.float64,
+        )
+    prev_close = np.roll(c, 1)
+    prev_close[0] = c[0]
+    tr = np.maximum(h - l, np.maximum(np.abs(h - prev_close), np.abs(l - prev_close)))
+    tr[0] = h[0] - l[0]
+    return sma(tr, period)
+
+
+def rsi(values: Sequence[float] | np.ndarray | pd.Series, period: int) -> np.ndarray:
+    """Relative Strength Index using simple rolling means of gains/losses."""
+    if period < 1:
+        raise ValueError("period must be >= 1")
+    arr = _as_f64(values)
+    if _NATIVE is not None:
+        return np.asarray(_NATIVE.rsi(arr.tolist(), int(period)), dtype=np.float64)
+    n = arr.shape[0]
+    out = np.full(n, np.nan, dtype=np.float64)
+    if n < period + 1:
+        return out
+    delta = np.diff(arr, prepend=arr[0])
+    delta[0] = 0.0
+    gains = np.where(delta > 0, delta, 0.0)
+    losses = np.where(delta < 0, -delta, 0.0)
+    avg_gain = sma(gains, period)
+    avg_loss = sma(losses, period)
+    for i in range(n):
+        g, loss = avg_gain[i], avg_loss[i]
+        if np.isnan(g) or np.isnan(loss):
+            continue
+        if loss == 0.0:
+            out[i] = 50.0 if g == 0.0 else 100.0
+        else:
+            rs = g / loss
+            out[i] = 100.0 - (100.0 / (1.0 + rs))
+    return out
+
+
+def batch_sma(
+    series_list: List[Sequence[float] | np.ndarray | pd.Series],
+    window: int,
+) -> List[np.ndarray]:
+    """SMA over many series; uses rayon inside ``fsb_core`` when available."""
+    if window < 1:
+        raise ValueError("window must be >= 1")
+    prepared = [_as_f64(s).tolist() for s in series_list]
+    if _NATIVE is not None:
+        return [np.asarray(row, dtype=np.float64) for row in _NATIVE.batch_sma(prepared, int(window))]
+    return [sma(s, window) for s in prepared]
+
+
+def equity_sma_crossover(
+    close: Sequence[float] | np.ndarray | pd.Series,
+    sma_fast: Sequence[float] | np.ndarray | pd.Series,
+    sma_slow: Sequence[float] | np.ndarray | pd.Series,
+    initial_balance: float = 10_000.0,
+    position_fraction: float = 0.1,
+) -> np.ndarray:
+    """Compact equity curve for SMA crossover (native loop when available)."""
+    c = _as_f64(close)
+    f = _as_f64(sma_fast)
+    s = _as_f64(sma_slow)
+    if not (c.shape == f.shape == s.shape):
+        raise ValueError("close, sma_fast, and sma_slow lengths must match")
+    if _NATIVE is not None:
+        return np.asarray(
+            _NATIVE.equity_sma_crossover(
+                c.tolist(),
+                f.tolist(),
+                s.tolist(),
+                float(initial_balance),
+                float(position_fraction),
+            ),
+            dtype=np.float64,
+        )
+    n = c.shape[0]
+    balance = float(initial_balance)
+    side = 0
+    size = 0.0
+    entry = 0.0
+    equity = np.empty(n, dtype=np.float64)
+    for i in range(n):
+        px = float(c[i])
+        if i >= 1:
+            fi, si, pf, ps = float(f[i]), float(s[i]), float(f[i - 1]), float(s[i - 1])
+            if not any(map(np.isnan, (fi, si, pf, ps))):
+                cross_up = fi > si and pf <= ps
+                cross_dn = fi < si and pf >= ps
+                if cross_up and side <= 0:
+                    if side < 0:
+                        balance += -size * (px - entry)
+                        side = 0
+                        size = 0.0
+                    size = (balance * position_fraction) / px
+                    entry = px
+                    side = 1
+                elif cross_dn and side >= 0:
+                    if side > 0:
+                        balance += size * (px - entry)
+                        side = 0
+                        size = 0.0
+                    size = (balance * position_fraction) / px
+                    entry = px
+                    side = -1
+        mtm = side * size * (px - entry) if side else 0.0
+        equity[i] = balance + mtm
+    return equity
+
+
+def apply_sma_atr_indicators(
+    df: pd.DataFrame,
+    fast_period: int,
+    slow_period: int,
+    atr_period: int,
+) -> pd.DataFrame:
+    """Fill ``SMA_fast``, ``SMA_slow``, and ``ATR`` columns (native when possible)."""
+    out = df.copy()
+    close = out["Close"]
+    out["SMA_fast"] = sma(close, fast_period)
+    out["SMA_slow"] = sma(close, slow_period)
+    out["ATR"] = atr(out["High"], out["Low"], close, atr_period)
+    return out