expand equity_balance_diff

configs/template.json

@@ -131,8 +131,10 @@
               "iters": 300000,
               "limits": {"lower_bound_drawdown_worst": 0.25,
                          "lower_bound_drawdown_worst_mean_1pct": 0.15,
-                         "lower_bound_equity_balance_diff_max": 0.35,
-                         "lower_bound_equity_balance_diff_mean": 0.005,
+                         "lower_bound_equity_balance_diff_neg_max": 0.35,
+                         "lower_bound_equity_balance_diff_neg_mean": 0.005,
+                         "lower_bound_equity_balance_diff_pos_max": 0.5,
+                         "lower_bound_equity_balance_diff_pos_mean": 0.01,
                          "lower_bound_loss_profit_ratio": 0.6},
               "mutation_probability": 0.2,
 

passivbot-rust/src/backtest.rs

@@ -1597,14 +1597,33 @@ pub fn analyze_backtest(fills: &[Fill], equities: &Vec<f64>) -> Analysis {
         bal_eq.push((last_balance, equity));
     }
 
-    let (equity_balance_diff_sum, equity_balance_diff_max) =
-        bal_eq
-            .iter()
-            .fold((0.0, 0.0), |(sum, max), &(balance, equity)| {
-                let diff = (equity - balance).abs() / balance;
-                (sum + diff, f64::max(max, diff))
-            });
-    let equity_balance_diff_mean = equity_balance_diff_sum / bal_eq.len() as f64;
+    // Calculate equity-balance differences with separate positive and negative tracking
+    let mut ebds_pos = Vec::new();
+    let mut ebds_neg = Vec::new();
+
+    for &(balance, equity) in bal_eq.iter() {
+        let ebd = (equity - balance) / balance;
+        if ebd > 0.0 {
+            ebds_pos.push(ebd);
+        } else if ebd < 0.0 {
+            ebds_neg.push(ebd);
+        }
+    }
+
+    let equity_balance_diff_pos_max = ebds_pos.iter().fold(0.0, |max, &x| f64::max(max, x));
+    let equity_balance_diff_pos_mean = if !ebds_pos.is_empty() {
+        ebds_pos.iter().sum::<f64>() / ebds_pos.len() as f64
+    } else {
+        0.0
+    };
+
+    let equity_balance_diff_neg_max = ebds_neg.iter().fold(0.0, |max, &x| f64::max(max, x.abs()));
+    let equity_balance_diff_neg_mean = if !ebds_neg.is_empty() {
+        ebds_neg.iter().map(|x| x.abs()).sum::<f64>() / ebds_neg.len() as f64
+    } else {
+        0.0
+    };
+
     let gain = fills[fills.len() - 1].balance / fills[0].balance;
 
     // Calculate profit factor
@@ -1633,8 +1652,10 @@ pub fn analyze_backtest(fills: &[Fill], equities: &Vec<f64>) -> Analysis {
         sterling_ratio,
         drawdown_worst,
         drawdown_worst_mean_1pct,
-        equity_balance_diff_mean,
-        equity_balance_diff_max,
+        equity_balance_diff_neg_max,
+        equity_balance_diff_neg_mean,
+        equity_balance_diff_pos_max,
+        equity_balance_diff_pos_mean,
         loss_profit_ratio,
     }
 }

passivbot-rust/src/python.rs

@@ -99,10 +99,21 @@ pub fn run_backtest(
             analysis.drawdown_worst_mean_1pct,
         )?;
         py_analysis.set_item(
-            "equity_balance_diff_mean",
-            analysis.equity_balance_diff_mean,
+            "equity_balance_diff_neg_max",
+            analysis.equity_balance_diff_neg_max,
+        )?;
+        py_analysis.set_item(
+            "equity_balance_diff_neg_mean",
+            analysis.equity_balance_diff_neg_mean,
+        )?;
+        py_analysis.set_item(
+            "equity_balance_diff_pos_max",
+            analysis.equity_balance_diff_pos_max,
+        )?;
+        py_analysis.set_item(
+            "equity_balance_diff_pos_mean",
+            analysis.equity_balance_diff_pos_mean,
         )?;
-        py_analysis.set_item("equity_balance_diff_max", analysis.equity_balance_diff_max)?;
         py_analysis.set_item("loss_profit_ratio", analysis.loss_profit_ratio)?;
 
         // Convert fills to a 2D array with mixed types

passivbot-rust/src/types.rs

@@ -225,8 +225,10 @@ pub struct Analysis {
     pub sterling_ratio: f64,
     pub drawdown_worst: f64,
     pub drawdown_worst_mean_1pct: f64,
-    pub equity_balance_diff_mean: f64,
-    pub equity_balance_diff_max: f64,
+    pub equity_balance_diff_neg_max: f64,
+    pub equity_balance_diff_neg_mean: f64,
+    pub equity_balance_diff_pos_max: f64,
+    pub equity_balance_diff_pos_mean: f64,
     pub loss_profit_ratio: f64,
 }
 
@@ -244,8 +246,10 @@ impl Default for Analysis {
             sterling_ratio: 0.0,
             drawdown_worst: 1.0,
             drawdown_worst_mean_1pct: 1.0,
-            equity_balance_diff_mean: 1.0,
-            equity_balance_diff_max: 1.0,
+            equity_balance_diff_neg_max: 1.0,
+            equity_balance_diff_neg_mean: 1.0,
+            equity_balance_diff_pos_max: 1.0,
+            equity_balance_diff_pos_mean: 1.0,
             loss_profit_ratio: 1.0,
         }
     }

src/optimize.py

@@ -338,23 +338,28 @@ def combine_analyses(self, analyses):
 
     def calc_fitness(self, analyses_combined):
         modifier = 0.0
-        for i, key in [
-            (6, "drawdown_worst"),
-            (5, "drawdown_worst_mean_1pct"),
-            (4, "equity_balance_diff_max"),
-            (3, "equity_balance_diff_mean"),
-            (2, "loss_profit_ratio"),
-        ]:
+        keys = [
+            "drawdown_worst",
+            "drawdown_worst_mean_1pct",
+            "equity_balance_diff_neg_max",
+            "equity_balance_diff_neg_mean",
+            "equity_balance_diff_pos_max",
+            "equity_balance_diff_pos_mean",
+            "loss_profit_ratio",
+        ]
+        i = len(keys) + 1
+        for key in keys:
             modifier += (
                 max(
                     self.config["optimize"]["limits"][f"lower_bound_{key}"],
                     analyses_combined[f"{key}_max"],
                 )
                 - self.config["optimize"]["limits"][f"lower_bound_{key}"]
             ) * 10**i
+            i -= 1
         if (
             analyses_combined["drawdown_worst_max"] >= 1.0
-            or analyses_combined["equity_balance_diff_max_max"] >= 1.0
+            or analyses_combined["equity_balance_diff_neg_max_max"] >= 1.0
         ):
             w_0 = w_1 = modifier
         else:

src/pure_funcs.py

@@ -651,8 +651,10 @@ def get_template_live_config(passivbot_mode="v7"):
                 "limits": {
                     "lower_bound_drawdown_worst": 0.25,
                     "lower_bound_drawdown_worst_mean_1pct": 0.15,
-                    "lower_bound_equity_balance_diff_max": 0.35,
-                    "lower_bound_equity_balance_diff_mean": 0.005,
+                    "lower_bound_equity_balance_diff_neg_max": 0.35,
+                    "lower_bound_equity_balance_diff_neg_mean": 0.005,
+                    "lower_bound_equity_balance_diff_pos_max": 0.5,
+                    "lower_bound_equity_balance_diff_pos_mean": 0.01,
                     "lower_bound_loss_profit_ratio": 0.6,
                 },
                 "mutation_probability": 0.2,