chore: prepare v1.1.0 release
Update version numbers across Rust, Python, and documentation files to 1.1.0. Enhance the .gitignore to include macOS dSYM files and plans directory. Introduce new dependencies in the Rust core library and update the README to reflect recent performance benchmarks and backtesting engine capabilities. Add new artifacts to the benchmarks manifest and improve documentation for the backtesting engine API.
This commit is contained in:
Pratik Bhadane
@@ -0,0 +1,294 @@
|
||||
//! PyO3 wrapper around `ferro_ta_core::commission::CommissionModel`.
|
||||
//!
|
||||
//! Exposes all fields as Python properties, provides static preset constructors,
|
||||
//! and supports JSON persistence (save/load).
|
||||
|
||||
use ferro_ta_core::commission::CommissionModel as CoreModel;
|
||||
use pyo3::exceptions::PyValueError;
|
||||
use pyo3::prelude::*;
|
||||
use std::fs;
|
||||
|
||||
/// Advanced commission and tax model for Indian and global markets.
|
||||
///
|
||||
/// All `_rate` fields are fractions (e.g. 0.001 = 0.1%).
|
||||
/// Per-unit fields (`flat_per_order`, `per_lot`) are in base currency units (e.g. INR).
|
||||
///
|
||||
/// ## Example
|
||||
/// ```python
|
||||
/// from ferro_ta._ferro_ta import CommissionModel
|
||||
///
|
||||
/// # Use a built-in preset
|
||||
/// m = CommissionModel.equity_delivery_india()
|
||||
/// cost = m.total_cost(100_000.0, 1.0, True)
|
||||
/// print(f"Buy cost: ₹{cost:.2f}")
|
||||
///
|
||||
/// # Save and reload
|
||||
/// m.save("/tmp/my_commission.json")
|
||||
/// m2 = CommissionModel.load("/tmp/my_commission.json")
|
||||
/// ```
|
||||
#[pyclass(module = "ferro_ta._ferro_ta", name = "CommissionModel")]
|
||||
#[derive(Clone, Default)]
|
||||
pub struct PyCommissionModel {
|
||||
pub(crate) inner: CoreModel,
|
||||
}
|
||||
|
||||
#[pymethods]
|
||||
impl PyCommissionModel {
|
||||
/// Create a zero-commission model (all fields = 0, lot_size = 1).
|
||||
#[new]
|
||||
pub fn new() -> Self {
|
||||
Self::default()
|
||||
}
|
||||
|
||||
// ---- Brokerage fields -----------------------------------------------
|
||||
|
||||
#[getter]
|
||||
pub fn flat_per_order(&self) -> f64 {
|
||||
self.inner.flat_per_order
|
||||
}
|
||||
#[setter]
|
||||
pub fn set_flat_per_order(&mut self, v: f64) {
|
||||
self.inner.flat_per_order = v;
|
||||
}
|
||||
|
||||
#[getter]
|
||||
pub fn rate_of_value(&self) -> f64 {
|
||||
self.inner.rate_of_value
|
||||
}
|
||||
#[setter]
|
||||
pub fn set_rate_of_value(&mut self, v: f64) {
|
||||
self.inner.rate_of_value = v;
|
||||
}
|
||||
|
||||
#[getter]
|
||||
pub fn per_lot(&self) -> f64 {
|
||||
self.inner.per_lot
|
||||
}
|
||||
#[setter]
|
||||
pub fn set_per_lot(&mut self, v: f64) {
|
||||
self.inner.per_lot = v;
|
||||
}
|
||||
|
||||
#[getter]
|
||||
pub fn max_brokerage(&self) -> f64 {
|
||||
self.inner.max_brokerage
|
||||
}
|
||||
#[setter]
|
||||
pub fn set_max_brokerage(&mut self, v: f64) {
|
||||
self.inner.max_brokerage = v;
|
||||
}
|
||||
|
||||
#[getter]
|
||||
pub fn spread_bps(&self) -> f64 {
|
||||
self.inner.spread_bps
|
||||
}
|
||||
#[setter]
|
||||
pub fn set_spread_bps(&mut self, v: f64) {
|
||||
self.inner.spread_bps = v;
|
||||
}
|
||||
|
||||
// ---- STT fields -----------------------------------------------------
|
||||
|
||||
#[getter]
|
||||
pub fn stt_rate(&self) -> f64 {
|
||||
self.inner.stt_rate
|
||||
}
|
||||
#[setter]
|
||||
pub fn set_stt_rate(&mut self, v: f64) {
|
||||
self.inner.stt_rate = v;
|
||||
}
|
||||
|
||||
#[getter]
|
||||
pub fn stt_on_buy(&self) -> bool {
|
||||
self.inner.stt_on_buy
|
||||
}
|
||||
#[setter]
|
||||
pub fn set_stt_on_buy(&mut self, v: bool) {
|
||||
self.inner.stt_on_buy = v;
|
||||
}
|
||||
|
||||
#[getter]
|
||||
pub fn stt_on_sell(&self) -> bool {
|
||||
self.inner.stt_on_sell
|
||||
}
|
||||
#[setter]
|
||||
pub fn set_stt_on_sell(&mut self, v: bool) {
|
||||
self.inner.stt_on_sell = v;
|
||||
}
|
||||
|
||||
// ---- Exchange / regulatory fields -----------------------------------
|
||||
|
||||
#[getter]
|
||||
pub fn exchange_charges_rate(&self) -> f64 {
|
||||
self.inner.exchange_charges_rate
|
||||
}
|
||||
#[setter]
|
||||
pub fn set_exchange_charges_rate(&mut self, v: f64) {
|
||||
self.inner.exchange_charges_rate = v;
|
||||
}
|
||||
|
||||
#[getter]
|
||||
pub fn regulatory_charges_rate(&self) -> f64 {
|
||||
self.inner.regulatory_charges_rate
|
||||
}
|
||||
#[setter]
|
||||
pub fn set_regulatory_charges_rate(&mut self, v: f64) {
|
||||
self.inner.regulatory_charges_rate = v;
|
||||
}
|
||||
|
||||
#[getter]
|
||||
pub fn gst_rate(&self) -> f64 {
|
||||
self.inner.gst_rate
|
||||
}
|
||||
#[setter]
|
||||
pub fn set_gst_rate(&mut self, v: f64) {
|
||||
self.inner.gst_rate = v;
|
||||
}
|
||||
|
||||
#[getter]
|
||||
pub fn stamp_duty_rate(&self) -> f64 {
|
||||
self.inner.stamp_duty_rate
|
||||
}
|
||||
#[setter]
|
||||
pub fn set_stamp_duty_rate(&mut self, v: f64) {
|
||||
self.inner.stamp_duty_rate = v;
|
||||
}
|
||||
|
||||
#[getter]
|
||||
pub fn lot_size(&self) -> f64 {
|
||||
self.inner.lot_size
|
||||
}
|
||||
#[setter]
|
||||
pub fn set_lot_size(&mut self, v: f64) {
|
||||
self.inner.lot_size = v;
|
||||
}
|
||||
|
||||
#[getter]
|
||||
pub fn short_borrow_rate_annual(&self) -> f64 {
|
||||
self.inner.short_borrow_rate_annual
|
||||
}
|
||||
#[setter]
|
||||
pub fn set_short_borrow_rate_annual(&mut self, v: f64) {
|
||||
self.inner.short_borrow_rate_annual = v;
|
||||
}
|
||||
|
||||
// ---- Compute --------------------------------------------------------
|
||||
|
||||
/// Total transaction cost in absolute currency units.
|
||||
///
|
||||
/// Args:
|
||||
/// trade_value: price × quantity in base currency
|
||||
/// num_lots: number of lots transacted
|
||||
/// is_buy: True for buy (entry) leg, False for sell (exit) leg
|
||||
pub fn total_cost(&self, trade_value: f64, num_lots: f64, is_buy: bool) -> f64 {
|
||||
self.inner.total_cost(trade_value, num_lots, is_buy)
|
||||
}
|
||||
|
||||
/// Cost as fraction of `initial_capital` (for normalised equity loops).
|
||||
///
|
||||
/// Returns 0.0 if `initial_capital` ≤ 0.
|
||||
pub fn cost_fraction(
|
||||
&self,
|
||||
trade_value: f64,
|
||||
num_lots: f64,
|
||||
is_buy: bool,
|
||||
initial_capital: f64,
|
||||
) -> f64 {
|
||||
self.inner
|
||||
.cost_fraction(trade_value, num_lots, is_buy, initial_capital)
|
||||
}
|
||||
|
||||
// ---- Presets (static constructors) ----------------------------------
|
||||
|
||||
/// Zero-commission model (all fields = 0).
|
||||
#[staticmethod]
|
||||
pub fn zero() -> Self {
|
||||
Self {
|
||||
inner: CoreModel::zero(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Indian equity delivery preset (0.1% brokerage capped ₹20, STT both sides, full levies).
|
||||
#[staticmethod]
|
||||
pub fn equity_delivery_india() -> Self {
|
||||
Self {
|
||||
inner: CoreModel::equity_delivery_india(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Indian equity intraday preset (0.03% brokerage capped ₹20, STT sell only, full levies).
|
||||
#[staticmethod]
|
||||
pub fn equity_intraday_india() -> Self {
|
||||
Self {
|
||||
inner: CoreModel::equity_intraday_india(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Indian index futures preset (₹20 flat, STT sell only, lot_size=25).
|
||||
#[staticmethod]
|
||||
pub fn futures_india() -> Self {
|
||||
Self {
|
||||
inner: CoreModel::futures_india(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Indian index options preset (₹20 flat, STT on premium sell side, lot_size=25).
|
||||
#[staticmethod]
|
||||
pub fn options_india() -> Self {
|
||||
Self {
|
||||
inner: CoreModel::options_india(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Simple proportional model — `rate` fraction applied both ways, no taxes.
|
||||
#[staticmethod]
|
||||
pub fn proportional(rate: f64) -> Self {
|
||||
Self {
|
||||
inner: CoreModel::proportional(rate),
|
||||
}
|
||||
}
|
||||
|
||||
// ---- JSON persistence -----------------------------------------------
|
||||
|
||||
/// Serialize this model to a JSON string.
|
||||
pub fn to_json(&self) -> PyResult<String> {
|
||||
self.inner
|
||||
.to_json()
|
||||
.map_err(|e| PyValueError::new_err(e.to_string()))
|
||||
}
|
||||
|
||||
/// Deserialize a `CommissionModel` from a JSON string.
|
||||
#[staticmethod]
|
||||
pub fn from_json(s: &str) -> PyResult<Self> {
|
||||
CoreModel::from_json(s)
|
||||
.map(|inner| Self { inner })
|
||||
.map_err(|e| PyValueError::new_err(e.to_string()))
|
||||
}
|
||||
|
||||
/// Save this model to a JSON file at `path`.
|
||||
pub fn save(&self, path: &str) -> PyResult<()> {
|
||||
let json = self.to_json()?;
|
||||
fs::write(path, json).map_err(|e| PyValueError::new_err(e.to_string()))
|
||||
}
|
||||
|
||||
/// Load a `CommissionModel` from a JSON file at `path`.
|
||||
#[staticmethod]
|
||||
pub fn load(path: &str) -> PyResult<Self> {
|
||||
let s = fs::read_to_string(path).map_err(|e| PyValueError::new_err(e.to_string()))?;
|
||||
Self::from_json(&s)
|
||||
}
|
||||
|
||||
fn __repr__(&self) -> String {
|
||||
format!(
|
||||
"CommissionModel(flat={}, rate_pct={:.4}%, stt={:.4}%, lot_size={})",
|
||||
self.inner.flat_per_order,
|
||||
self.inner.rate_of_value * 100.0,
|
||||
self.inner.stt_rate * 100.0,
|
||||
self.inner.lot_size,
|
||||
)
|
||||
}
|
||||
|
||||
fn __eq__(&self, other: &Self) -> bool {
|
||||
self.inner == other.inner
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,133 @@
|
||||
//! PyO3 wrapper around `ferro_ta_core::currency::Currency`.
|
||||
|
||||
use ferro_ta_core::currency::Currency as CoreCurrency;
|
||||
use pyo3::exceptions::PyValueError;
|
||||
use pyo3::prelude::*;
|
||||
|
||||
/// Immutable currency descriptor with formatting support.
|
||||
///
|
||||
/// ## Example
|
||||
/// ```python
|
||||
/// from ferro_ta._ferro_ta import Currency
|
||||
///
|
||||
/// inr = Currency.INR()
|
||||
/// print(inr.format(123456.78)) # ₹1,23,456.78
|
||||
///
|
||||
/// usd = Currency.from_code("USD")
|
||||
/// print(usd.format(1234567.89)) # $1,234,567.89
|
||||
/// ```
|
||||
#[pyclass(name = "Currency", module = "ferro_ta._ferro_ta", frozen)]
|
||||
#[derive(Clone)]
|
||||
pub struct PyCurrency {
|
||||
pub(crate) inner: &'static CoreCurrency,
|
||||
}
|
||||
|
||||
#[pymethods]
|
||||
impl PyCurrency {
|
||||
/// Format *amount* according to this currency's style.
|
||||
pub fn format(&self, amount: f64) -> String {
|
||||
self.inner.format(amount)
|
||||
}
|
||||
|
||||
#[getter]
|
||||
pub fn code(&self) -> &str {
|
||||
self.inner.code
|
||||
}
|
||||
|
||||
#[getter]
|
||||
pub fn symbol(&self) -> &str {
|
||||
self.inner.symbol
|
||||
}
|
||||
|
||||
#[getter]
|
||||
pub fn decimal_places(&self) -> u8 {
|
||||
self.inner.decimal_places
|
||||
}
|
||||
|
||||
#[getter]
|
||||
pub fn lakh_grouping(&self) -> bool {
|
||||
self.inner.lakh_grouping
|
||||
}
|
||||
|
||||
// ---- Static constructors (presets) ----
|
||||
|
||||
#[staticmethod]
|
||||
pub fn from_code(code: &str) -> PyResult<Self> {
|
||||
CoreCurrency::from_code(code)
|
||||
.map(|c| PyCurrency { inner: c })
|
||||
.ok_or_else(|| {
|
||||
PyValueError::new_err(format!(
|
||||
"Unknown currency code '{code}'. Supported: INR, USD, EUR, GBP, JPY, USDT"
|
||||
))
|
||||
})
|
||||
}
|
||||
|
||||
/// Indian Rupee.
|
||||
#[staticmethod]
|
||||
#[allow(non_snake_case)]
|
||||
pub fn INR() -> Self {
|
||||
PyCurrency {
|
||||
inner: &CoreCurrency::INR,
|
||||
}
|
||||
}
|
||||
|
||||
/// US Dollar.
|
||||
#[staticmethod]
|
||||
#[allow(non_snake_case)]
|
||||
pub fn USD() -> Self {
|
||||
PyCurrency {
|
||||
inner: &CoreCurrency::USD,
|
||||
}
|
||||
}
|
||||
|
||||
/// Euro.
|
||||
#[staticmethod]
|
||||
#[allow(non_snake_case)]
|
||||
pub fn EUR() -> Self {
|
||||
PyCurrency {
|
||||
inner: &CoreCurrency::EUR,
|
||||
}
|
||||
}
|
||||
|
||||
/// British Pound.
|
||||
#[staticmethod]
|
||||
#[allow(non_snake_case)]
|
||||
pub fn GBP() -> Self {
|
||||
PyCurrency {
|
||||
inner: &CoreCurrency::GBP,
|
||||
}
|
||||
}
|
||||
|
||||
/// Japanese Yen.
|
||||
#[staticmethod]
|
||||
#[allow(non_snake_case)]
|
||||
pub fn JPY() -> Self {
|
||||
PyCurrency {
|
||||
inner: &CoreCurrency::JPY,
|
||||
}
|
||||
}
|
||||
|
||||
/// Tether USD.
|
||||
#[staticmethod]
|
||||
#[allow(non_snake_case)]
|
||||
pub fn USDT() -> Self {
|
||||
PyCurrency {
|
||||
inner: &CoreCurrency::USDT,
|
||||
}
|
||||
}
|
||||
|
||||
fn __repr__(&self) -> String {
|
||||
format!("Currency({:?})", self.inner.code)
|
||||
}
|
||||
|
||||
fn __eq__(&self, other: &Self) -> bool {
|
||||
self.inner.code == other.inner.code
|
||||
}
|
||||
|
||||
fn __hash__(&self) -> u64 {
|
||||
use std::hash::{Hash, Hasher};
|
||||
let mut hasher = std::collections::hash_map::DefaultHasher::new();
|
||||
self.inner.code.hash(&mut hasher);
|
||||
hasher.finish()
|
||||
}
|
||||
}
|
||||
+714
-149
@@ -1,34 +1,126 @@
|
||||
//! Rust-backed strategy signal generation and backtest core.
|
||||
//!
|
||||
//! These functions move the hot loops from Python into Rust while preserving
|
||||
//! the public Python behavior.
|
||||
//! Thin PyO3 wrappers delegating to `ferro_ta_core::backtest`.
|
||||
|
||||
use crate::validation;
|
||||
use numpy::{IntoPyArray, PyArray1, PyReadonlyArray1};
|
||||
pub mod commission;
|
||||
pub mod currency;
|
||||
|
||||
use commission::PyCommissionModel;
|
||||
use currency::PyCurrency;
|
||||
use ferro_ta_core::backtest as core_bt;
|
||||
use ndarray::Array2;
|
||||
use numpy::{IntoPyArray, PyArray1, PyArray2, PyReadonlyArray1, PyReadonlyArray2};
|
||||
use pyo3::exceptions::PyValueError;
|
||||
use pyo3::prelude::*;
|
||||
use pyo3::types::PyDict;
|
||||
use rayon::prelude::*;
|
||||
|
||||
fn nan_to_num_with_numpy_defaults(v: f64) -> f64 {
|
||||
if v.is_nan() {
|
||||
0.0
|
||||
} else if v.is_infinite() {
|
||||
if v.is_sign_positive() {
|
||||
f64::MAX
|
||||
} else {
|
||||
-f64::MAX
|
||||
use crate::validation;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// BacktestConfig pyclass wrapping core struct
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[pyclass(name = "BacktestConfig")]
|
||||
#[derive(Clone)]
|
||||
pub struct BacktestConfig {
|
||||
#[pyo3(get, set)]
|
||||
pub fill_mode: String,
|
||||
#[pyo3(get, set)]
|
||||
pub stop_loss_pct: f64,
|
||||
#[pyo3(get, set)]
|
||||
pub take_profit_pct: f64,
|
||||
#[pyo3(get, set)]
|
||||
pub trailing_stop_pct: f64,
|
||||
#[pyo3(get, set)]
|
||||
pub slippage_bps: f64,
|
||||
#[pyo3(get, set)]
|
||||
pub initial_capital: f64,
|
||||
#[pyo3(get, set)]
|
||||
pub commission_per_trade: f64,
|
||||
#[pyo3(get, set)]
|
||||
pub max_hold_bars: usize,
|
||||
#[pyo3(get, set)]
|
||||
pub slippage_pct_range: f64,
|
||||
#[pyo3(get, set)]
|
||||
pub breakeven_pct: f64,
|
||||
#[pyo3(get, set)]
|
||||
pub periods_per_year: f64,
|
||||
#[pyo3(get, set)]
|
||||
pub margin_ratio: f64,
|
||||
#[pyo3(get, set)]
|
||||
pub margin_call_pct: f64,
|
||||
#[pyo3(get, set)]
|
||||
pub daily_loss_limit: f64,
|
||||
#[pyo3(get, set)]
|
||||
pub total_loss_limit: f64,
|
||||
#[pyo3(get, set)]
|
||||
pub commission: Option<PyCommissionModel>,
|
||||
}
|
||||
|
||||
#[pymethods]
|
||||
impl BacktestConfig {
|
||||
#[new]
|
||||
#[pyo3(signature = (
|
||||
fill_mode = "market_open",
|
||||
stop_loss_pct = 0.0,
|
||||
take_profit_pct = 0.0,
|
||||
trailing_stop_pct = 0.0,
|
||||
slippage_bps = 0.0,
|
||||
initial_capital = 100_000.0,
|
||||
commission_per_trade = 0.0,
|
||||
max_hold_bars = 0,
|
||||
slippage_pct_range = 0.0,
|
||||
breakeven_pct = 0.0,
|
||||
periods_per_year = 252.0,
|
||||
margin_ratio = 0.0,
|
||||
margin_call_pct = 0.5,
|
||||
daily_loss_limit = 0.0,
|
||||
total_loss_limit = 0.0,
|
||||
commission = None,
|
||||
))]
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn new(
|
||||
fill_mode: &str,
|
||||
stop_loss_pct: f64,
|
||||
take_profit_pct: f64,
|
||||
trailing_stop_pct: f64,
|
||||
slippage_bps: f64,
|
||||
initial_capital: f64,
|
||||
commission_per_trade: f64,
|
||||
max_hold_bars: usize,
|
||||
slippage_pct_range: f64,
|
||||
breakeven_pct: f64,
|
||||
periods_per_year: f64,
|
||||
margin_ratio: f64,
|
||||
margin_call_pct: f64,
|
||||
daily_loss_limit: f64,
|
||||
total_loss_limit: f64,
|
||||
commission: Option<PyCommissionModel>,
|
||||
) -> Self {
|
||||
BacktestConfig {
|
||||
fill_mode: fill_mode.to_string(),
|
||||
stop_loss_pct,
|
||||
take_profit_pct,
|
||||
trailing_stop_pct,
|
||||
slippage_bps,
|
||||
initial_capital,
|
||||
commission_per_trade,
|
||||
max_hold_bars,
|
||||
slippage_pct_range,
|
||||
breakeven_pct,
|
||||
periods_per_year,
|
||||
margin_ratio,
|
||||
margin_call_pct,
|
||||
daily_loss_limit,
|
||||
total_loss_limit,
|
||||
commission,
|
||||
}
|
||||
} else {
|
||||
v
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Strategy signal helpers
|
||||
// Signal generators
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// RSI threshold strategy:
|
||||
/// +1 when RSI <= oversold, -1 when RSI >= overbought, 0 otherwise.
|
||||
/// Warm-up bars are NaN.
|
||||
#[pyfunction]
|
||||
#[pyo3(signature = (close, timeperiod = 14, oversold = 30.0, overbought = 70.0))]
|
||||
pub fn rsi_threshold_signals<'py>(
|
||||
@@ -40,26 +132,10 @@ pub fn rsi_threshold_signals<'py>(
|
||||
) -> PyResult<Bound<'py, PyArray1<f64>>> {
|
||||
validation::validate_timeperiod(timeperiod, "timeperiod", 1)?;
|
||||
let prices = close.as_slice()?;
|
||||
let rsi = ferro_ta_core::momentum::rsi(prices, timeperiod);
|
||||
let out: Vec<f64> = rsi
|
||||
.iter()
|
||||
.map(|&v| {
|
||||
if v.is_nan() {
|
||||
f64::NAN
|
||||
} else if v <= oversold {
|
||||
1.0
|
||||
} else if v >= overbought {
|
||||
-1.0
|
||||
} else {
|
||||
0.0
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
let out = core_bt::rsi_threshold_signals(prices, timeperiod, oversold, overbought);
|
||||
Ok(out.into_pyarray(py))
|
||||
}
|
||||
|
||||
/// SMA crossover strategy:
|
||||
/// +1 when fast SMA > slow SMA, -1 otherwise. Warm-up bars are NaN.
|
||||
#[pyfunction]
|
||||
#[pyo3(signature = (close, fast = 10, slow = 30))]
|
||||
pub fn sma_crossover_signals<'py>(
|
||||
@@ -70,32 +146,12 @@ pub fn sma_crossover_signals<'py>(
|
||||
) -> PyResult<Bound<'py, PyArray1<f64>>> {
|
||||
validation::validate_timeperiod(fast, "fast", 1)?;
|
||||
validation::validate_timeperiod(slow, "slow", 1)?;
|
||||
if fast >= slow {
|
||||
return Err(PyValueError::new_err(format!(
|
||||
"fast ({fast}) must be less than slow ({slow})"
|
||||
)));
|
||||
}
|
||||
let prices = close.as_slice()?;
|
||||
let sma_fast = ferro_ta_core::overlap::sma(prices, fast);
|
||||
let sma_slow = ferro_ta_core::overlap::sma(prices, slow);
|
||||
let out: Vec<f64> = sma_fast
|
||||
.iter()
|
||||
.zip(sma_slow.iter())
|
||||
.map(|(&f, &s)| {
|
||||
if f.is_nan() || s.is_nan() {
|
||||
f64::NAN
|
||||
} else if f > s {
|
||||
1.0
|
||||
} else {
|
||||
-1.0
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
let out = core_bt::sma_crossover_signals(prices, fast, slow)
|
||||
.map_err(|e| PyValueError::new_err(e))?;
|
||||
Ok(out.into_pyarray(py))
|
||||
}
|
||||
|
||||
/// MACD crossover strategy:
|
||||
/// +1 when MACD line > signal line, -1 otherwise. Warm-up bars are NaN.
|
||||
#[pyfunction]
|
||||
#[pyo3(signature = (close, fastperiod = 12, slowperiod = 26, signalperiod = 9))]
|
||||
pub fn macd_crossover_signals<'py>(
|
||||
@@ -108,137 +164,646 @@ pub fn macd_crossover_signals<'py>(
|
||||
validation::validate_timeperiod(fastperiod, "fastperiod", 1)?;
|
||||
validation::validate_timeperiod(slowperiod, "slowperiod", 1)?;
|
||||
validation::validate_timeperiod(signalperiod, "signalperiod", 1)?;
|
||||
if fastperiod >= slowperiod {
|
||||
return Err(PyValueError::new_err(format!(
|
||||
"fastperiod ({fastperiod}) must be less than slowperiod ({slowperiod})"
|
||||
)));
|
||||
}
|
||||
|
||||
let prices = close.as_slice()?;
|
||||
let (macd_line, signal_line, _) =
|
||||
ferro_ta_core::overlap::macd(prices, fastperiod, slowperiod, signalperiod);
|
||||
let out: Vec<f64> = macd_line
|
||||
.iter()
|
||||
.zip(signal_line.iter())
|
||||
.map(|(&m, &s)| {
|
||||
if m.is_nan() || s.is_nan() {
|
||||
f64::NAN
|
||||
} else if m > s {
|
||||
1.0
|
||||
} else {
|
||||
-1.0
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
let out = core_bt::macd_crossover_signals(prices, fastperiod, slowperiod, signalperiod)
|
||||
.map_err(|e| PyValueError::new_err(e))?;
|
||||
Ok(out.into_pyarray(py))
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Backtest core
|
||||
// Backtest core (close-only)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Backtest core loop over close prices and strategy signals.
|
||||
///
|
||||
/// Returns `(positions, bar_returns, strategy_returns, equity)`.
|
||||
#[pyfunction]
|
||||
#[pyo3(signature = (close, signals, commission_per_trade = 0.0, slippage_bps = 0.0))]
|
||||
#[pyo3(signature = (
|
||||
close, signals,
|
||||
commission = None,
|
||||
slippage_bps = 0.0,
|
||||
initial_capital = 100_000.0,
|
||||
commission_per_trade = 0.0,
|
||||
))]
|
||||
#[allow(clippy::type_complexity)]
|
||||
pub fn backtest_core<'py>(
|
||||
py: Python<'py>,
|
||||
close: PyReadonlyArray1<'py, f64>,
|
||||
signals: PyReadonlyArray1<'py, f64>,
|
||||
commission_per_trade: f64,
|
||||
commission: Option<PyRef<'py, PyCommissionModel>>,
|
||||
slippage_bps: f64,
|
||||
initial_capital: f64,
|
||||
commission_per_trade: f64,
|
||||
) -> PyResult<(
|
||||
Bound<'py, PyArray1<f64>>,
|
||||
Bound<'py, PyArray1<f64>>,
|
||||
Bound<'py, PyArray1<f64>>,
|
||||
Bound<'py, PyArray1<f64>>,
|
||||
)> {
|
||||
let c = close.as_slice()?;
|
||||
let s = signals.as_slice()?;
|
||||
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))?;
|
||||
|
||||
Ok((
|
||||
result.positions.into_pyarray(py),
|
||||
result.bar_returns.into_pyarray(py),
|
||||
result.strategy_returns.into_pyarray(py),
|
||||
result.equity.into_pyarray(py),
|
||||
))
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// OHLCV backtest
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[pyfunction]
|
||||
#[pyo3(signature = (
|
||||
open, high, low, close, signals,
|
||||
fill_mode = "market_open",
|
||||
stop_loss_pct = 0.0,
|
||||
take_profit_pct = 0.0,
|
||||
trailing_stop_pct = 0.0,
|
||||
commission = None,
|
||||
slippage_bps = 0.0,
|
||||
initial_capital = 100_000.0,
|
||||
commission_per_trade = 0.0,
|
||||
limit_prices = None,
|
||||
max_hold_bars = 0,
|
||||
slippage_pct_range = 0.0,
|
||||
breakeven_pct = 0.0,
|
||||
periods_per_year = 252.0,
|
||||
margin_ratio = 0.0,
|
||||
margin_call_pct = 0.5,
|
||||
daily_loss_limit = 0.0,
|
||||
total_loss_limit = 0.0,
|
||||
))]
|
||||
#[allow(clippy::too_many_arguments, clippy::type_complexity)]
|
||||
pub fn backtest_ohlcv_core<'py>(
|
||||
py: Python<'py>,
|
||||
open: PyReadonlyArray1<'py, f64>,
|
||||
high: PyReadonlyArray1<'py, f64>,
|
||||
low: PyReadonlyArray1<'py, f64>,
|
||||
close: PyReadonlyArray1<'py, f64>,
|
||||
signals: PyReadonlyArray1<'py, f64>,
|
||||
fill_mode: &str,
|
||||
stop_loss_pct: f64,
|
||||
take_profit_pct: f64,
|
||||
trailing_stop_pct: f64,
|
||||
commission: Option<PyRef<'py, PyCommissionModel>>,
|
||||
slippage_bps: f64,
|
||||
initial_capital: f64,
|
||||
commission_per_trade: f64,
|
||||
limit_prices: Option<PyReadonlyArray1<'py, f64>>,
|
||||
max_hold_bars: usize,
|
||||
slippage_pct_range: f64,
|
||||
breakeven_pct: f64,
|
||||
periods_per_year: f64,
|
||||
margin_ratio: f64,
|
||||
margin_call_pct: f64,
|
||||
daily_loss_limit: f64,
|
||||
total_loss_limit: f64,
|
||||
) -> PyResult<(
|
||||
Bound<'py, PyArray1<f64>>,
|
||||
Bound<'py, PyArray1<f64>>,
|
||||
Bound<'py, PyArray1<f64>>,
|
||||
Bound<'py, PyArray1<f64>>,
|
||||
Bound<'py, PyArray1<f64>>,
|
||||
)> {
|
||||
let o = open.as_slice()?;
|
||||
let h = high.as_slice()?;
|
||||
let l = low.as_slice()?;
|
||||
let c = close.as_slice()?;
|
||||
let s = signals.as_slice()?;
|
||||
let n = c.len();
|
||||
validation::validate_equal_length(&[(n, "close"), (s.len(), "signals")])?;
|
||||
|
||||
let mut positions = vec![0.0_f64; n];
|
||||
if n > 1 {
|
||||
for i in 1..n {
|
||||
positions[i] = nan_to_num_with_numpy_defaults(s[i - 1]);
|
||||
}
|
||||
validation::validate_equal_length(&[
|
||||
(n, "close"),
|
||||
(o.len(), "open"),
|
||||
(h.len(), "high"),
|
||||
(l.len(), "low"),
|
||||
(s.len(), "signals"),
|
||||
])?;
|
||||
|
||||
let config = core_bt::BacktestConfig {
|
||||
fill_mode: fill_mode.to_string(),
|
||||
stop_loss_pct,
|
||||
take_profit_pct,
|
||||
trailing_stop_pct,
|
||||
slippage_bps,
|
||||
initial_capital,
|
||||
commission_per_trade,
|
||||
max_hold_bars,
|
||||
slippage_pct_range,
|
||||
breakeven_pct,
|
||||
periods_per_year,
|
||||
margin_ratio,
|
||||
margin_call_pct,
|
||||
daily_loss_limit,
|
||||
total_loss_limit,
|
||||
commission: commission.as_ref().map(|c| c.inner.clone()),
|
||||
};
|
||||
|
||||
let lp_opt: Option<&[f64]> = limit_prices.as_ref().and_then(|lp| lp.as_slice().ok());
|
||||
|
||||
let result = core_bt::backtest_ohlcv_core(o, h, l, c, s, &config, lp_opt)
|
||||
.map_err(|e| PyValueError::new_err(e))?;
|
||||
|
||||
Ok((
|
||||
result.positions.into_pyarray(py),
|
||||
result.fill_prices.into_pyarray(py),
|
||||
result.bar_returns.into_pyarray(py),
|
||||
result.strategy_returns.into_pyarray(py),
|
||||
result.equity.into_pyarray(py),
|
||||
))
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Performance metrics
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[pyfunction]
|
||||
#[pyo3(signature = (strategy_returns, equity, periods_per_year = 252.0, risk_free_rate = 0.0, benchmark_returns = None))]
|
||||
pub fn compute_performance_metrics<'py>(
|
||||
py: Python<'py>,
|
||||
strategy_returns: PyReadonlyArray1<'py, f64>,
|
||||
equity: PyReadonlyArray1<'py, f64>,
|
||||
periods_per_year: f64,
|
||||
risk_free_rate: f64,
|
||||
benchmark_returns: Option<PyReadonlyArray1<'py, f64>>,
|
||||
) -> PyResult<Bound<'py, PyDict>> {
|
||||
let r = strategy_returns.as_slice()?;
|
||||
let eq = equity.as_slice()?;
|
||||
let br = benchmark_returns.as_ref().and_then(|b| b.as_slice().ok());
|
||||
|
||||
let metrics = core_bt::compute_performance_metrics(r, eq, periods_per_year, risk_free_rate, br)
|
||||
.map_err(|e| PyValueError::new_err(e))?;
|
||||
|
||||
let dict = PyDict::new(py);
|
||||
dict.set_item("total_return", metrics.total_return)?;
|
||||
dict.set_item("cagr", metrics.cagr)?;
|
||||
dict.set_item("annualized_vol", metrics.annualized_vol)?;
|
||||
dict.set_item("sharpe", metrics.sharpe)?;
|
||||
dict.set_item("sortino", metrics.sortino)?;
|
||||
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("ulcer_index", metrics.ulcer_index)?;
|
||||
dict.set_item("omega_ratio", metrics.omega_ratio)?;
|
||||
dict.set_item("win_rate", metrics.win_rate)?;
|
||||
dict.set_item("profit_factor", metrics.profit_factor)?;
|
||||
dict.set_item("r_expectancy", metrics.r_expectancy)?;
|
||||
dict.set_item("avg_win", metrics.avg_win)?;
|
||||
dict.set_item("avg_loss", metrics.avg_loss)?;
|
||||
dict.set_item("tail_ratio", metrics.tail_ratio)?;
|
||||
dict.set_item("skewness", metrics.skewness)?;
|
||||
dict.set_item("kurtosis", metrics.kurtosis)?;
|
||||
dict.set_item("best_bar", metrics.best_bar)?;
|
||||
dict.set_item("worst_bar", metrics.worst_bar)?;
|
||||
dict.set_item("n_trades", metrics.n_trades as i64)?;
|
||||
dict.set_item("n_position_changes", metrics.n_position_changes as i64)?;
|
||||
|
||||
if let Some(v) = metrics.benchmark_total_return {
|
||||
dict.set_item("benchmark_total_return", v)?;
|
||||
}
|
||||
if let Some(v) = metrics.benchmark_cagr {
|
||||
dict.set_item("benchmark_cagr", v)?;
|
||||
}
|
||||
if let Some(v) = metrics.benchmark_annualized_vol {
|
||||
dict.set_item("benchmark_annualized_vol", v)?;
|
||||
}
|
||||
if let Some(v) = metrics.benchmark_sharpe {
|
||||
dict.set_item("benchmark_sharpe", v)?;
|
||||
}
|
||||
if let Some(v) = metrics.alpha {
|
||||
dict.set_item("alpha", v)?;
|
||||
}
|
||||
if let Some(v) = metrics.beta {
|
||||
dict.set_item("beta", v)?;
|
||||
}
|
||||
if let Some(v) = metrics.tracking_error {
|
||||
dict.set_item("tracking_error", v)?;
|
||||
}
|
||||
if let Some(v) = metrics.information_ratio {
|
||||
dict.set_item("information_ratio", v)?;
|
||||
}
|
||||
|
||||
let mut bar_returns = vec![0.0_f64; n];
|
||||
for i in 1..n {
|
||||
bar_returns[i] = (c[i] - c[i - 1]) / c[i - 1];
|
||||
}
|
||||
Ok(dict)
|
||||
}
|
||||
|
||||
let mut strategy_returns = vec![0.0_f64; n];
|
||||
for i in 0..n {
|
||||
strategy_returns[i] = positions[i] * bar_returns[i];
|
||||
}
|
||||
// ---------------------------------------------------------------------------
|
||||
// Trade extraction
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
let mut position_changed = vec![false; n];
|
||||
for i in 1..n {
|
||||
position_changed[i] = positions[i] != positions[i - 1];
|
||||
}
|
||||
#[pyfunction]
|
||||
#[allow(clippy::type_complexity)]
|
||||
pub fn extract_trades_ohlcv<'py>(
|
||||
py: Python<'py>,
|
||||
positions: PyReadonlyArray1<'py, f64>,
|
||||
fill_prices: PyReadonlyArray1<'py, f64>,
|
||||
high: PyReadonlyArray1<'py, f64>,
|
||||
low: PyReadonlyArray1<'py, f64>,
|
||||
) -> PyResult<(
|
||||
Bound<'py, PyArray1<i64>>,
|
||||
Bound<'py, PyArray1<i64>>,
|
||||
Bound<'py, PyArray1<f64>>,
|
||||
Bound<'py, PyArray1<f64>>,
|
||||
Bound<'py, PyArray1<f64>>,
|
||||
Bound<'py, PyArray1<f64>>,
|
||||
Bound<'py, PyArray1<i64>>,
|
||||
Bound<'py, PyArray1<f64>>,
|
||||
Bound<'py, PyArray1<f64>>,
|
||||
)> {
|
||||
let pos = positions.as_slice()?;
|
||||
let fp = fill_prices.as_slice()?;
|
||||
let h = high.as_slice()?;
|
||||
let l = low.as_slice()?;
|
||||
|
||||
if slippage_bps > 0.0 {
|
||||
let slip = slippage_bps / 10_000.0;
|
||||
for i in 0..n {
|
||||
if position_changed[i] {
|
||||
strategy_returns[i] -= slip;
|
||||
}
|
||||
}
|
||||
}
|
||||
validation::validate_equal_length(&[
|
||||
(pos.len(), "positions"),
|
||||
(fp.len(), "fill_prices"),
|
||||
(h.len(), "high"),
|
||||
(l.len(), "low"),
|
||||
])?;
|
||||
|
||||
let mut equity = vec![1.0_f64; n];
|
||||
if n > 0 {
|
||||
if commission_per_trade <= 0.0 {
|
||||
let mut gross = 1.0_f64;
|
||||
for i in 0..n {
|
||||
gross *= 1.0 + strategy_returns[i];
|
||||
equity[i] = gross;
|
||||
}
|
||||
} else {
|
||||
let mut gross_equity = vec![1.0_f64; n];
|
||||
let mut gross = 1.0_f64;
|
||||
for i in 0..n {
|
||||
gross *= 1.0 + strategy_returns[i];
|
||||
gross_equity[i] = gross;
|
||||
}
|
||||
let trades = core_bt::extract_trades_ohlcv(pos, fp, h, l)
|
||||
.map_err(|e| PyValueError::new_err(e))?;
|
||||
|
||||
if gross_equity.contains(&0.0) {
|
||||
equity[0] = 1.0;
|
||||
for i in 1..n {
|
||||
equity[i] = equity[i - 1] * (1.0 + strategy_returns[i]);
|
||||
if position_changed[i] {
|
||||
equity[i] -= commission_per_trade;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
let mut discounted_commissions = 0.0_f64;
|
||||
for i in 0..n {
|
||||
if position_changed[i] {
|
||||
discounted_commissions += commission_per_trade / gross_equity[i];
|
||||
}
|
||||
equity[i] = gross_equity[i] * (1.0 - discounted_commissions);
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut entry_bars: Vec<i64> = Vec::with_capacity(trades.len());
|
||||
let mut exit_bars: Vec<i64> = Vec::with_capacity(trades.len());
|
||||
let mut directions: Vec<f64> = Vec::with_capacity(trades.len());
|
||||
let mut entry_prices: Vec<f64> = Vec::with_capacity(trades.len());
|
||||
let mut exit_prices: Vec<f64> = Vec::with_capacity(trades.len());
|
||||
let mut pnl_pcts: Vec<f64> = Vec::with_capacity(trades.len());
|
||||
let mut duration_bars_vec: Vec<i64> = Vec::with_capacity(trades.len());
|
||||
let mut maes: Vec<f64> = Vec::with_capacity(trades.len());
|
||||
let mut mfes: Vec<f64> = Vec::with_capacity(trades.len());
|
||||
|
||||
for t in &trades {
|
||||
entry_bars.push(t.entry_bar);
|
||||
exit_bars.push(t.exit_bar);
|
||||
directions.push(t.direction);
|
||||
entry_prices.push(t.entry_price);
|
||||
exit_prices.push(t.exit_price);
|
||||
pnl_pcts.push(t.pnl_pct);
|
||||
duration_bars_vec.push(t.duration_bars);
|
||||
maes.push(t.mae);
|
||||
mfes.push(t.mfe);
|
||||
}
|
||||
|
||||
Ok((
|
||||
positions.into_pyarray(py),
|
||||
bar_returns.into_pyarray(py),
|
||||
strategy_returns.into_pyarray(py),
|
||||
equity.into_pyarray(py),
|
||||
entry_bars.into_pyarray(py),
|
||||
exit_bars.into_pyarray(py),
|
||||
directions.into_pyarray(py),
|
||||
entry_prices.into_pyarray(py),
|
||||
exit_prices.into_pyarray(py),
|
||||
pnl_pcts.into_pyarray(py),
|
||||
duration_bars_vec.into_pyarray(py),
|
||||
maes.into_pyarray(py),
|
||||
mfes.into_pyarray(py),
|
||||
))
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Multi-asset backtest
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[pyfunction]
|
||||
#[pyo3(signature = (
|
||||
close_2d, weights_2d,
|
||||
commission_per_trade = 0.0,
|
||||
slippage_bps = 0.0,
|
||||
parallel = true,
|
||||
max_asset_weight = 1.0,
|
||||
max_gross_exposure = 0.0,
|
||||
max_net_exposure = 0.0,
|
||||
))]
|
||||
#[allow(clippy::too_many_arguments, clippy::type_complexity)]
|
||||
pub fn backtest_multi_asset_core<'py>(
|
||||
py: Python<'py>,
|
||||
close_2d: PyReadonlyArray2<'py, f64>,
|
||||
weights_2d: PyReadonlyArray2<'py, f64>,
|
||||
commission_per_trade: f64,
|
||||
slippage_bps: f64,
|
||||
parallel: bool,
|
||||
max_asset_weight: f64,
|
||||
max_gross_exposure: f64,
|
||||
max_net_exposure: f64,
|
||||
) -> PyResult<(
|
||||
Bound<'py, PyArray2<f64>>,
|
||||
Bound<'py, PyArray1<f64>>,
|
||||
Bound<'py, PyArray1<f64>>,
|
||||
)> {
|
||||
let c_arr = close_2d.as_array();
|
||||
let w_arr = weights_2d.as_array();
|
||||
let (n_bars, n_assets) = c_arr.dim();
|
||||
|
||||
if w_arr.dim() != (n_bars, n_assets) {
|
||||
return Err(PyValueError::new_err(format!(
|
||||
"weights_2d shape {:?} must match close_2d shape {:?}",
|
||||
w_arr.dim(),
|
||||
c_arr.dim()
|
||||
)));
|
||||
}
|
||||
|
||||
// Transpose to (n_assets, n_bars) for the core function
|
||||
let mut close_cm: Vec<Vec<f64>> = vec![vec![0.0; n_bars]; n_assets];
|
||||
let mut weights_cm: Vec<Vec<f64>> = vec![vec![0.0; n_bars]; n_assets];
|
||||
for j in 0..n_assets {
|
||||
for i in 0..n_bars {
|
||||
close_cm[j][i] = c_arr[[i, j]];
|
||||
weights_cm[j][i] = w_arr[[i, j]];
|
||||
}
|
||||
}
|
||||
|
||||
// For parallel execution, use rayon directly on the core's single_asset_backtest.
|
||||
// Apply portfolio constraints first via the core function's logic.
|
||||
|
||||
// Apply constraints
|
||||
if max_asset_weight != 1.0 || max_gross_exposure > 0.0 || max_net_exposure > 0.0 {
|
||||
for i in 0..n_bars {
|
||||
if max_asset_weight < f64::INFINITY && max_asset_weight > 0.0 {
|
||||
for j in 0..n_assets {
|
||||
let w = weights_cm[j][i];
|
||||
if w.abs() > max_asset_weight {
|
||||
weights_cm[j][i] = w.signum() * max_asset_weight;
|
||||
}
|
||||
}
|
||||
}
|
||||
if max_gross_exposure > 0.0 {
|
||||
let gross: f64 = (0..n_assets).map(|j| weights_cm[j][i].abs()).sum();
|
||||
if gross > max_gross_exposure {
|
||||
let scale = max_gross_exposure / gross;
|
||||
for j in 0..n_assets {
|
||||
weights_cm[j][i] *= scale;
|
||||
}
|
||||
}
|
||||
}
|
||||
if max_net_exposure > 0.0 {
|
||||
let net: f64 = (0..n_assets).map(|j| weights_cm[j][i]).sum();
|
||||
if net.abs() > max_net_exposure {
|
||||
let excess = net - net.signum() * max_net_exposure;
|
||||
let adj_per_asset = excess / n_assets as f64;
|
||||
for j in 0..n_assets {
|
||||
weights_cm[j][i] -= adj_per_asset;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Run per-asset backtests (parallel or serial)
|
||||
let asset_strategy_returns: Vec<Vec<f64>> = py.allow_threads(|| {
|
||||
let run_asset = |j: usize| -> Vec<f64> {
|
||||
let (_, strat_rets, _) = core_bt::single_asset_backtest(
|
||||
&close_cm[j],
|
||||
&weights_cm[j],
|
||||
commission_per_trade,
|
||||
slippage_bps,
|
||||
);
|
||||
strat_rets
|
||||
};
|
||||
|
||||
if parallel {
|
||||
(0..n_assets).into_par_iter().map(run_asset).collect()
|
||||
} else {
|
||||
(0..n_assets).map(run_asset).collect()
|
||||
}
|
||||
});
|
||||
|
||||
// Assemble asset_returns 2D array (n_bars, n_assets)
|
||||
let mut asset_ret_arr = Array2::<f64>::zeros((n_bars, n_assets));
|
||||
for j in 0..n_assets {
|
||||
for i in 0..n_bars {
|
||||
asset_ret_arr[[i, j]] = asset_strategy_returns[j][i];
|
||||
}
|
||||
}
|
||||
|
||||
// Portfolio returns
|
||||
let mut portfolio_returns = vec![0.0_f64; n_bars];
|
||||
for i in 0..n_bars {
|
||||
let mut s = 0.0_f64;
|
||||
for j in 0..n_assets {
|
||||
s += asset_ret_arr[[i, j]];
|
||||
}
|
||||
portfolio_returns[i] = s;
|
||||
}
|
||||
|
||||
// Portfolio equity
|
||||
let mut portfolio_equity = vec![1.0_f64; n_bars];
|
||||
let mut cum = 1.0_f64;
|
||||
for i in 0..n_bars {
|
||||
cum *= 1.0 + portfolio_returns[i];
|
||||
portfolio_equity[i] = cum;
|
||||
}
|
||||
|
||||
Ok((
|
||||
asset_ret_arr.into_pyarray(py),
|
||||
portfolio_returns.into_pyarray(py),
|
||||
portfolio_equity.into_pyarray(py),
|
||||
))
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Monte Carlo bootstrap
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[pyfunction]
|
||||
#[pyo3(signature = (strategy_returns, n_sims = 1000, seed = 42, block_size = 1))]
|
||||
pub fn monte_carlo_bootstrap<'py>(
|
||||
py: Python<'py>,
|
||||
strategy_returns: PyReadonlyArray1<'py, f64>,
|
||||
n_sims: usize,
|
||||
seed: u64,
|
||||
block_size: usize,
|
||||
) -> PyResult<Bound<'py, PyArray2<f64>>> {
|
||||
let r = strategy_returns.as_slice()?;
|
||||
let n = r.len();
|
||||
|
||||
// Use rayon for parallel Monte Carlo (preserving the original parallel behavior)
|
||||
if n < 2 {
|
||||
return Err(PyValueError::new_err(
|
||||
"strategy_returns must have at least 2 elements",
|
||||
));
|
||||
}
|
||||
if n_sims == 0 {
|
||||
return Err(PyValueError::new_err("n_sims must be >= 1"));
|
||||
}
|
||||
let bsize = block_size.max(1).min(n);
|
||||
|
||||
let mut result = Array2::<f64>::zeros((n_sims, n));
|
||||
|
||||
py.allow_threads(|| {
|
||||
result
|
||||
.as_slice_mut()
|
||||
.unwrap()
|
||||
.par_chunks_mut(n)
|
||||
.enumerate()
|
||||
.for_each(|(sim_idx, row)| {
|
||||
let mut state = seed
|
||||
.wrapping_mul(6_364_136_223_846_793_005_u64)
|
||||
.wrapping_add((sim_idx as u64).wrapping_mul(2_862_933_555_777_941_757_u64));
|
||||
core_bt::lcg_next(&mut state);
|
||||
core_bt::lcg_next(&mut state);
|
||||
|
||||
if bsize == 1 {
|
||||
for dst in row.iter_mut() {
|
||||
*dst = r[core_bt::lcg_index(&mut state, n)];
|
||||
}
|
||||
} else {
|
||||
let mut filled = 0_usize;
|
||||
while filled < n {
|
||||
let start = core_bt::lcg_index(&mut state, n);
|
||||
let take = bsize.min(n - filled);
|
||||
for k in 0..take {
|
||||
row[filled + k] = r[(start + k) % n];
|
||||
}
|
||||
filled += take;
|
||||
}
|
||||
}
|
||||
|
||||
let mut cum = 1.0_f64;
|
||||
for elem in row.iter_mut().take(n) {
|
||||
cum *= 1.0 + *elem;
|
||||
*elem = cum;
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
Ok(result.into_pyarray(py))
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Walk-forward indices
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[pyfunction]
|
||||
#[pyo3(signature = (n_bars, train_bars, test_bars, anchored = false, step_bars = 0))]
|
||||
pub fn walk_forward_indices<'py>(
|
||||
py: Python<'py>,
|
||||
n_bars: usize,
|
||||
train_bars: usize,
|
||||
test_bars: usize,
|
||||
anchored: bool,
|
||||
step_bars: usize,
|
||||
) -> PyResult<Bound<'py, PyArray2<i64>>> {
|
||||
let folds = core_bt::walk_forward_indices(n_bars, train_bars, test_bars, anchored, step_bars)
|
||||
.map_err(|e| PyValueError::new_err(e))?;
|
||||
|
||||
let n_folds = folds.len();
|
||||
let mut arr = Array2::<i64>::zeros((n_folds, 4));
|
||||
for (i, fold) in folds.iter().enumerate() {
|
||||
for j in 0..4 {
|
||||
arr[[i, j]] = fold[j];
|
||||
}
|
||||
}
|
||||
|
||||
Ok(arr.into_pyarray(py))
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Kelly criterion
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[pyfunction]
|
||||
pub fn kelly_fraction(win_rate: f64, avg_win: f64, avg_loss: f64) -> PyResult<f64> {
|
||||
core_bt::kelly_fraction(win_rate, avg_win, avg_loss).map_err(|e| PyValueError::new_err(e))
|
||||
}
|
||||
|
||||
#[pyfunction]
|
||||
pub fn half_kelly_fraction(win_rate: f64, avg_win: f64, avg_loss: f64) -> PyResult<f64> {
|
||||
core_bt::half_kelly_fraction(win_rate, avg_win, avg_loss).map_err(|e| PyValueError::new_err(e))
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// StreamingBacktest
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[pyclass(name = "StreamingBacktest")]
|
||||
pub struct StreamingBacktest {
|
||||
inner: core_bt::StreamingBacktest,
|
||||
}
|
||||
|
||||
#[pymethods]
|
||||
impl StreamingBacktest {
|
||||
#[new]
|
||||
#[pyo3(signature = (commission_per_trade=0.0, slippage_bps=0.0))]
|
||||
pub fn new(commission_per_trade: f64, slippage_bps: f64) -> Self {
|
||||
StreamingBacktest {
|
||||
inner: core_bt::StreamingBacktest::new(commission_per_trade, slippage_bps),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn on_bar<'py>(
|
||||
&mut self,
|
||||
py: Python<'py>,
|
||||
close: f64,
|
||||
signal: f64,
|
||||
) -> PyResult<Bound<'py, PyDict>> {
|
||||
let result = self.inner.on_bar(close, signal);
|
||||
let d = PyDict::new(py);
|
||||
d.set_item("position", result.position)?;
|
||||
d.set_item("bar_return", result.bar_return)?;
|
||||
d.set_item("equity", result.equity)?;
|
||||
d.set_item("n_trades", result.n_trades)?;
|
||||
Ok(d)
|
||||
}
|
||||
|
||||
#[getter]
|
||||
pub fn equity(&self) -> f64 {
|
||||
self.inner.equity
|
||||
}
|
||||
|
||||
#[getter]
|
||||
pub fn position(&self) -> f64 {
|
||||
self.inner.position
|
||||
}
|
||||
|
||||
#[getter]
|
||||
pub fn n_trades(&self) -> usize {
|
||||
self.inner.n_trades
|
||||
}
|
||||
|
||||
pub fn summary<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyDict>> {
|
||||
let s = self.inner.summary();
|
||||
let d = PyDict::new(py);
|
||||
d.set_item("equity", s.equity)?;
|
||||
d.set_item("n_trades", s.n_trades)?;
|
||||
d.set_item("total_commission", s.total_commission)?;
|
||||
d.set_item("win_rate", s.win_rate)?;
|
||||
d.set_item("avg_win", s.avg_win)?;
|
||||
d.set_item("avg_loss", s.avg_loss)?;
|
||||
d.set_item("kelly_fraction", s.kelly_fraction)?;
|
||||
Ok(d)
|
||||
}
|
||||
|
||||
pub fn reset(&mut self) {
|
||||
self.inner.reset();
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Register
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
pub fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
|
||||
m.add_function(wrap_pyfunction!(rsi_threshold_signals, m)?)?;
|
||||
m.add_function(wrap_pyfunction!(sma_crossover_signals, m)?)?;
|
||||
m.add_function(wrap_pyfunction!(macd_crossover_signals, m)?)?;
|
||||
m.add_function(wrap_pyfunction!(backtest_core, m)?)?;
|
||||
m.add_function(wrap_pyfunction!(backtest_ohlcv_core, m)?)?;
|
||||
m.add_function(wrap_pyfunction!(compute_performance_metrics, m)?)?;
|
||||
m.add_function(wrap_pyfunction!(extract_trades_ohlcv, m)?)?;
|
||||
m.add_function(wrap_pyfunction!(backtest_multi_asset_core, m)?)?;
|
||||
m.add_function(wrap_pyfunction!(monte_carlo_bootstrap, m)?)?;
|
||||
m.add_function(wrap_pyfunction!(walk_forward_indices, m)?)?;
|
||||
m.add_function(wrap_pyfunction!(kelly_fraction, m)?)?;
|
||||
m.add_function(wrap_pyfunction!(half_kelly_fraction, m)?)?;
|
||||
m.add_class::<BacktestConfig>()?;
|
||||
m.add_class::<StreamingBacktest>()?;
|
||||
m.add_class::<PyCommissionModel>()?;
|
||||
m.add_class::<PyCurrency>()?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user