market-data-analyzer 2.0.1 → 2.1.1

package/src/utils/math.ts

@@ -1,342 +0,0 @@
-/**
- * Financial math utilities -- technical indicators, risk metrics, etc.
- * Pure functions with no external dependencies.
- */
-
-// ---------------------------------------------------------------------------
-// Basic statistics
-// ---------------------------------------------------------------------------
-
-export function mean(values: number[]): number {
-  if (values.length === 0) return 0;
-  return values.reduce((s, v) => s + v, 0) / values.length;
-}
-
-export function stdDev(values: number[]): number {
-  if (values.length < 2) return 0;
-  const m = mean(values);
-  // Use sample variance (N-1) for unbiased estimation from finite samples
-  const variance = values.reduce((s, v) => s + (v - m) ** 2, 0) / (values.length - 1);
-  return Math.sqrt(variance);
-}
-
-export function percentile(sorted: number[], p: number): number {
-  if (sorted.length === 0) return 0;
-  if (sorted.length === 1) return sorted[0]!;
-  // Clamp p to [0, 100] to avoid out-of-bounds access
-  const clampedP = Math.max(0, Math.min(100, p));
-  const idx = (clampedP / 100) * (sorted.length - 1);
-  const lower = Math.floor(idx);
-  const upper = Math.ceil(idx);
-  if (lower === upper) return sorted[lower]!;
-  const frac = idx - lower;
-  return sorted[lower]! * (1 - frac) + sorted[upper]! * frac;
-}
-
-export function pricesToReturns(prices: number[]): number[] {
-  const returns: number[] = [];
-  for (let i = 1; i < prices.length; i++) {
-    const prev = prices[i - 1]!;
-    if (prev !== 0) {
-      returns.push((prices[i]! - prev) / prev);
-    }
-  }
-  return returns;
-}
-
-export function correlation(a: number[], b: number[]): number {
-  const n = Math.min(a.length, b.length);
-  if (n < 2) return 0;
-  const ma = mean(a.slice(0, n));
-  const mb = mean(b.slice(0, n));
-  let sumAB = 0, sumA2 = 0, sumB2 = 0;
-  for (let i = 0; i < n; i++) {
-    const da = a[i]! - ma;
-    const db = b[i]! - mb;
-    sumAB += da * db;
-    sumA2 += da * da;
-    sumB2 += db * db;
-  }
-  const denom = Math.sqrt(sumA2 * sumB2);
-  return denom > 0 ? sumAB / denom : 0;
-}
-
-// ---------------------------------------------------------------------------
-// Moving averages
-// ---------------------------------------------------------------------------
-
-export function sma(values: number[], period: number): (number | null)[] {
-  if (period <= 0) return values.map(() => null);
-  const result: (number | null)[] = [];
-  for (let i = 0; i < values.length; i++) {
-    if (i < period - 1) {
-      result.push(null);
-    } else {
-      let sum = 0;
-      for (let j = i - period + 1; j <= i; j++) sum += values[j]!;
-      result.push(sum / period);
-    }
-  }
-  return result;
-}
-
-export function ema(values: number[], period: number): (number | null)[] {
-  if (period <= 0) return values.map(() => null);
-  const result: (number | null)[] = [];
-  const multiplier = 2 / (period + 1);
-  let prev: number | null = null;
-
-  for (let i = 0; i < values.length; i++) {
-    if (i < period - 1) {
-      result.push(null);
-    } else if (prev === null) {
-      let sum = 0;
-      for (let j = i - period + 1; j <= i; j++) sum += values[j]!;
-      prev = sum / period;
-      result.push(prev);
-    } else {
-      prev = (values[i]! - prev) * multiplier + prev;
-      result.push(prev);
-    }
-  }
-  return result;
-}
-
-/** Get the latest non-null value from an indicator series. */
-export function lastValue(series: (number | null)[]): number | null {
-  for (let i = series.length - 1; i >= 0; i--) {
-    if (series[i] !== null) return series[i];
-  }
-  return null;
-}
-
-// ---------------------------------------------------------------------------
-// RSI (Relative Strength Index)
-// ---------------------------------------------------------------------------
-
-export function rsi(closes: number[], period: number = 14): (number | null)[] {
-  if (closes.length < period + 1) return closes.map(() => null);
-
-  const result: (number | null)[] = [null];
-  const gains: number[] = [];
-  const losses: number[] = [];
-
-  for (let i = 1; i < closes.length; i++) {
-    const change = closes[i]! - closes[i - 1]!;
-    gains.push(change > 0 ? change : 0);
-    losses.push(change < 0 ? -change : 0);
-  }
-
-  let avgGain = 0;
-  let avgLoss = 0;
-
-  // Initial averages
-  for (let i = 0; i < period; i++) {
-    avgGain += gains[i]!;
-    avgLoss += losses[i]!;
-  }
-  avgGain /= period;
-  avgLoss /= period;
-
-  for (let i = 0; i < gains.length; i++) {
-    if (i < period - 1) {
-      result.push(null);
-    } else if (i === period - 1) {
-      if (avgLoss === 0) {
-        result.push(100);
-      } else {
-        result.push(100 - 100 / (1 + avgGain / avgLoss));
-      }
-    } else {
-      // Wilder smoothing
-      avgGain = (avgGain * (period - 1) + gains[i]!) / period;
-      avgLoss = (avgLoss * (period - 1) + losses[i]!) / period;
-      if (avgLoss === 0) {
-        result.push(100);
-      } else {
-        result.push(100 - 100 / (1 + avgGain / avgLoss));
-      }
-    }
-  }
-
-  return result;
-}
-
-// ---------------------------------------------------------------------------
-// MACD
-// ---------------------------------------------------------------------------
-
-export interface MACDResult {
-  line: (number | null)[];
-  signal: (number | null)[];
-  histogram: (number | null)[];
-}
-
-export function macd(
-  closes: number[],
-  fastPeriod = 12,
-  slowPeriod = 26,
-  signalPeriod = 9,
-): MACDResult {
-  const fastEma = ema(closes, fastPeriod);
-  const slowEma = ema(closes, slowPeriod);
-
-  const macdLine: (number | null)[] = [];
-  for (let i = 0; i < closes.length; i++) {
-    if (fastEma[i] !== null && slowEma[i] !== null) {
-      macdLine.push(fastEma[i]! - slowEma[i]!);
-    } else {
-      macdLine.push(null);
-    }
-  }
-
-  // Signal line = EMA of MACD line
-  const nonNull: number[] = [];
-  const nonNullIdx: number[] = [];
-  for (let i = 0; i < macdLine.length; i++) {
-    if (macdLine[i] !== null) {
-      nonNull.push(macdLine[i]!);
-      nonNullIdx.push(i);
-    }
-  }
-
-  const sigEma = ema(nonNull, signalPeriod);
-  const signalLine: (number | null)[] = new Array(closes.length).fill(null);
-  for (let i = 0; i < nonNullIdx.length; i++) {
-    signalLine[nonNullIdx[i]!] = sigEma[i] ?? null;
-  }
-
-  const histogram: (number | null)[] = [];
-  for (let i = 0; i < closes.length; i++) {
-    if (macdLine[i] !== null && signalLine[i] !== null) {
-      histogram.push(macdLine[i]! - signalLine[i]!);
-    } else {
-      histogram.push(null);
-    }
-  }
-
-  return { line: macdLine, signal: signalLine, histogram };
-}
-
-// ---------------------------------------------------------------------------
-// Support / Resistance (pivot-based)
-// ---------------------------------------------------------------------------
-
-export function findSupportResistance(
-  highs: number[],
-  lows: number[],
-  closes: number[],
-  lookback: number = 20,
-): { support: number[]; resistance: number[] } {
-  const support: number[] = [];
-  const resistance: number[] = [];
-
-  if (closes.length < lookback) {
-    return { support: [], resistance: [] };
-  }
-
-  const currentPrice = closes[closes.length - 1]!;
-
-  // Find local minima (support) and maxima (resistance)
-  const windowSize = Math.max(5, Math.floor(lookback / 4));
-  for (let i = windowSize; i < closes.length - windowSize; i++) {
-    let isLocalMin = true;
-    let isLocalMax = true;
-
-    for (let j = i - windowSize; j <= i + windowSize; j++) {
-      if (j === i) continue;
-      if (lows[j]! < lows[i]!) isLocalMin = false;
-      if (highs[j]! > highs[i]!) isLocalMax = false;
-    }
-
-    if (isLocalMin && lows[i]! < currentPrice) {
-      support.push(Math.round(lows[i]! * 100) / 100);
-    }
-    if (isLocalMax && highs[i]! > currentPrice) {
-      resistance.push(Math.round(highs[i]! * 100) / 100);
-    }
-  }
-
-  // Deduplicate: merge levels within 1% of each other
-  const dedup = (levels: number[]): number[] => {
-    if (levels.length === 0) return [];
-    levels.sort((a, b) => a - b);
-    const merged: number[] = [levels[0]!];
-    for (let i = 1; i < levels.length; i++) {
-      const last = merged[merged.length - 1]!;
-      if (last > 0 && Math.abs(levels[i]! - last) / last < 0.01) {
-        merged[merged.length - 1] = (last + levels[i]!) / 2;
-      } else {
-        merged.push(levels[i]!);
-      }
-    }
-    return merged;
-  };
-
-  // Return closest 3 levels each
-  const dedupedSupport = dedup(support).sort((a, b) => b - a).slice(0, 3);
-  const dedupedResistance = dedup(resistance).sort((a, b) => a - b).slice(0, 3);
-
-  return { support: dedupedSupport, resistance: dedupedResistance };
-}
-
-// ---------------------------------------------------------------------------
-// Max drawdown
-// ---------------------------------------------------------------------------
-
-export function maxDrawdown(prices: number[]): number {
-  if (prices.length < 2) return 0;
-  let peak = prices[0]!;
-  let worst = 0;
-  for (const p of prices) {
-    if (p > peak) peak = p;
-    // Guard against division by zero if peak is somehow 0
-    if (peak > 0) {
-      const dd = (peak - p) / peak;
-      if (dd > worst) worst = dd;
-    }
-  }
-  return worst;
-}
-
-// ---------------------------------------------------------------------------
-// Sharpe ratio approximation
-// ---------------------------------------------------------------------------
-
-const TRADING_DAYS = 252;
-const DEFAULT_RISK_FREE_RATE = 0.045; // ~4.5% annualized
-
-export function sharpeRatio(
-  returns: number[],
-  riskFreeRate: number = DEFAULT_RISK_FREE_RATE,
-): number {
-  if (returns.length < 2) return 0;
-  const dailyRfr = riskFreeRate / TRADING_DAYS;
-  const avgReturn = mean(returns);
-  const vol = stdDev(returns);
-  if (vol === 0) return 0;
-  return ((avgReturn - dailyRfr) / vol) * Math.sqrt(TRADING_DAYS);
-}
-
-// ---------------------------------------------------------------------------
-// Formatting helpers
-// ---------------------------------------------------------------------------
-
-export function formatCurrency(n: number): string {
-  if (Math.abs(n) >= 1e12) return `$${(n / 1e12).toFixed(2)}T`;
-  if (Math.abs(n) >= 1e9) return `$${(n / 1e9).toFixed(2)}B`;
-  if (Math.abs(n) >= 1e6) return `$${(n / 1e6).toFixed(2)}M`;
-  return `$${n.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
-}
-
-export function formatVolume(n: number): string {
-  if (n >= 1e9) return `${(n / 1e9).toFixed(1)}B`;
-  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
-  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
-  return n.toString();
-}
-
-export function formatPct(n: number, decimals: number = 2): string {
-  const sign = n >= 0 ? "+" : "";
-  return `${sign}${(n * 100).toFixed(decimals)}%`;
-}

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "Node16",
-    "moduleResolution": "Node16",
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}