Change settings

src/lib/strategies.js

@@ -1,11 +1,193 @@
-// Central strategy registry used by the UI to compute and display multiple strategies per agent.
-// Each strategy config maps to computeStrategyEquity/computeWinRate arguments.
+// src/lib/strategies.js
+
+// -------------------- public config --------------------
 
 export const STRATEGIES = [
-  // { id: 'baseline_ls', label: 'Baseline L/S', strategy: 'long_short', tradingMode: 'normal', fee: 0.0005 },
-  // { id: 'aggressive_ls', label: 'Aggressive L/S', strategy: 'long_short', tradingMode: 'aggressive', fee: 0.0005 },
-  // { id: 'baseline_lo', label: 'Baseline Long Only', strategy: 'long_only', tradingMode: 'normal', fee: 0.0005 },
-  { id: 'aggressive_lo', label: 'Aggressive Long Only', strategy: 'long_only', tradingMode: 'aggressive', fee: 0.0005 }
-]
+  { id: 'long_only',           label: 'Aggressive Long Only', strategy: 'long_only', tradingMode: 'aggressive', fee: 0.0005 },
+  { id: 'conservative_long',   label: 'Conservative Long',     strategy: 'long_only', tradingMode: 'conservative', fee: 0.0002 },
+  { id: 'long_short',          label: 'Long/Short',            strategy: 'long_short', tradingMode: 'aggressive',  fee: 0.0007 },
+  { id: 'neutral',             label: 'Market Neutral',        strategy: 'market_neutral', tradingMode: 'neutral', fee: 0.0005 },
+];
+
+// Simple pleasant palette (baseline uses its own dashed gray)
+const PALETTE = [
+  '#4F46E5', // indigo
+  '#EF4444', // red
+  '#10B981', // emerald
+  '#F59E0B', // amber
+  '#06B6D4', // cyan
+  '#A855F7', // violet
+  '#64748B', // slate
+];
+
+export function getStrategyColor(id, isBaseline = false, i = 0) {
+  if (isBaseline) return '#7c7c7c';
+  const map = {
+    long_only: '#4F46E5',
+    conservative_long: '#1D4ED8',
+    long_short: '#EF4444',
+    market_neutral: '#10B981',
+  };
+  return map[id] || PALETTE[i % PALETTE.length];
+}
+
+// -------------------- core exports --------------------
+
+/**
+ * Buy & Hold equity curve from prices or NAV-like fields.
+ * @param {Array<Object>} seq sorted rows (ascending by date)
+ * @param {number} start starting capital (e.g., 100000)
+ * @returns {number[]} equity series aligned to seq
+ */
+export function computeBuyHoldEquity(seq, start = 100000) {
+  if (!Array.isArray(seq) || !seq.length) return [];
+
+  // If there's a NAV-like field, just rescale to start
+  const nav = pickNavSeries(seq);
+  if (nav) {
+    const [y0] = nav;
+    if (isFinite(y0) && y0 !== 0) return nav.map(y => (y / y0) * start);
+  }
+
+  // Else use price series
+  const prices = pickPriceSeries(seq);
+  if (!prices) return Array(seq.length).fill(start);
+
+  const [p0] = prices;
+  if (!isFinite(p0) || p0 <= 0) return Array(seq.length).fill(start);
+
+  return prices.map(p => (p / p0) * start);
+}
+
+/**
+ * General strategy equity. Tries NAV first; otherwise builds from price + position.
+ * @param {Array<Object>} seq sorted rows
+ * @param {number} start starting capital
+ * @param {number} fee  per-trade proportional fee (e.g., 0.0005)
+ * @param {string} strategyId see STRATEGIES ids
+ * @param {string} tradingMode 'aggressive' | 'conservative' | 'neutral'
+ * @returns {number[]} equity series aligned to seq
+ */
+export function computeStrategyEquity(seq, start = 100000, fee = 0, strategyId = 'long_only', tradingMode = 'aggressive') {
+  if (!Array.isArray(seq) || !seq.length) return [];
+
+  // Fast path: NAV-like field available -> rescale
+  const nav = pickNavSeries(seq);
+  if (nav) {
+    const [y0] = nav;
+    if (isFinite(y0) && y0 !== 0) return nav.map(y => (y / y0) * start);
+  }
+
+  // Fallback: price + position simulation
+  const prices = pickPriceSeries(seq);
+  if (!prices) return Array(seq.length).fill(start);
+
+  // Build a position vector.
+  // If seq has explicit 'position' use it; else derive from strategyId (long only etc.)
+  let positions = seq.map(r => {
+    const v = numberOrUndefined(r.position ?? r.pos ?? r.signal);
+    if (isFinite(v)) return clampPos(v);
+    return undefined;
+  });
+
+  const hasExplicitPos = positions.some(v => v !== undefined);
+  if (!hasExplicitPos) {
+    // derive a dumb position rule based on strategyId
+    // long_only: always +1
+    // long_short: +1 if today's price >= yesterday, else -1
+    // market_neutral: 0.5 long, 0.5 short (approx 0 exposure here => 0)
+    positions = prices.map((_, i) => {
+      if (strategyId === 'market_neutral') return 0;
+      if (strategyId === 'long_short' && i > 0) return prices[i] >= prices[i - 1] ? +1 : -1;
+      return +1;
+    });
+  } else {
+    positions = positions.map(v => (v === undefined ? 0 : clampPos(v)));
+  }
+
+  // Risk scaling for conservative mode (smaller gross exposure)
+  const riskScale =
+    tradingMode === 'conservative' ? 0.5 :
+    tradingMode === 'neutral'      ? 0.5 :
+    1.0;
+
+  // Equity simulation
+  const eq = Array(seq.length).fill(NaN);
+  eq[0] = start;
+
+  for (let i = 1; i < seq.length; i++) {
+    const p0 = prices[i - 1], p1 = prices[i];
+    if (!isFinite(p0) || !isFinite(p1) || p0 <= 0) { eq[i] = eq[i - 1]; continue; }
+
+    const ret = (p1 / p0) - 1;           // raw asset return
+    const posPrev = positions[i - 1] * riskScale;
+    const posNow  = positions[i]     * riskScale;
+
+    // fee on turnover (change in absolute exposure)
+    const turnover = Math.abs(Math.abs(posNow) - Math.abs(posPrev));
+    const feeHit = fee > 0 ? (1 - fee * turnover) : 1;
+
+    const eqPrev = eq[i - 1];
+    const eqNext = eqPrev * (1 + posPrev * ret) * feeHit;
+    eq[i] = isFinite(eqNext) ? eqNext : eqPrev;
+  }
+  return eq;
+}
+
+// -------------------- internals --------------------
+
+// Try common NAV-like fields
+function pickNavSeries(seq) {
+  const fields = ['balance', 'nav', 'equity', 'account_value', 'account_equity', 'net_value', 'nav_value'];
+  const arr = tryPickNumericArray(seq, fields);
+  if (!arr) return null;
+  const finite = arr.filter(isFinite);
+  return finite.length ? arr : null;
+}
+
+// Try common price fields
+function pickPriceSeries(seq) {
+  const fields = [
+    'close','Close','closing_price',
+    'adj_close','adjClose',
+    'price','price_close','px','c','p',
+    'bh_price','last',
+  ];
+  const arr = tryPickNumericArray(seq, fields);
+  if (arr) return arr;
+
+  // If prices truly missing, but we had NAV -> approximate price from NAV ratios (rare)
+  const nav = pickNavSeries(seq);
+  if (nav) {
+    const base = nav[0];
+    if (isFinite(base) && base !== 0) return nav.map(v => v / base);
+  }
+  return null;
+}
+
+function tryPickNumericArray(seq, fields) {
+  for (const f of fields) {
+    const arr = seq.map(r => numberOrUndefined(r?.[f]));
+    if (arr.some(v => v !== undefined)) {
+      // Ensure at least half are finite numbers
+      const good = arr.filter(isFinite).length;
+      if (good >= Math.ceil(seq.length / 2)) return arr.map(v => (isFinite(v) ? v : NaN));
+    }
+  }
+  return null;
+}
 
+function numberOrUndefined(x) {
+  const n = typeof x === 'string' ? Number(x) : (typeof x === 'number' ? x : NaN);
+  return isFinite(n) ? n : undefined;
+}
 
+function clampPos(v) {
+  // Normalize any weird position magnitudes to [-1, 1]
+  if (!isFinite(v)) return 0;
+  if (v > 1) return 1;
+  if (v < -1) return -1;
+  // small noise -> 0
+  if (Math.abs(v) < 1e-6) return 0;
+  return v;
+}