Risk metrics.

// Module 14, Correlation matrix across a portfolio of positions.
// `returns` is: { marketSlug: number[] }, daily return series per market.

function mean(xs: number[]): number {
  return xs.reduce((a, b) => a + b, 0) / xs.length;
}

function pearson(a: number[], b: number[]): number {
  const ma = mean(a), mb = mean(b);
  let num = 0, da = 0, db = 0;
  for (let i = 0; i < a.length; i++) {
    const x = a[i] - ma, y = b[i] - mb;
    num += x * y;
    da  += x * x;
    db  += y * y;
  }
  return num / Math.sqrt(da * db);
}

function correlationMatrix(returns: Record<string, number[]>): Record<string, Record<string, number>> {
  const keys = Object.keys(returns);
  const out: Record<string, Record<string, number>> = {};
  for (const a of keys) {
    out[a] = {};
    for (const b of keys) {
      out[a][b] = pearson(returns[a], returns[b]);
    }
  }
  return out;
}

// TODO: load a real returns object
const corr = correlationMatrix({});
console.table(corr);

# Module 14, Correlation matrix across a portfolio of positions.
# `returns` is: {market_slug: list[float]}, daily return series per market.

import math
from typing import Mapping, Sequence


def mean(xs: Sequence[float]) -> float:
    return sum(xs) / len(xs)


def pearson(a: Sequence[float], b: Sequence[float]) -> float:
    ma, mb = mean(a), mean(b)
    num = da = db = 0.0
    for x, y in zip(a, b):
        dx, dy = x - ma, y - mb
        num += dx * dy
        da  += dx * dx
        db  += dy * dy
    return num / math.sqrt(da * db)


def correlation_matrix(returns: Mapping[str, Sequence[float]]) -> dict[str, dict[str, float]]:
    keys = list(returns)
    return {
        a: {b: pearson(returns[a], returns[b]) for b in keys}
        for a in keys
    }


# TODO: load a real returns dict
corr = correlation_matrix({})
for row, cols in corr.items():
    print(row, cols)

// Module 14, Correlation matrix across a portfolio of positions.
// `returns` is map[string][]float64, daily return series per market.

package main

import (
    "fmt"
    "math"
)

func mean(xs []float64) float64 {
    var s float64
    for _, v := range xs {
        s += v
    }
    return s / float64(len(xs))
}

func pearson(a, b []float64) float64 {
    ma, mb := mean(a), mean(b)
    var num, da, db float64
    for i := range a {
        x, y := a[i]-ma, b[i]-mb
        num += x * y
        da  += x * x
        db  += y * y
    }
    return num / math.Sqrt(da*db)
}

func correlationMatrix(returns map[string][]float64) map[string]map[string]float64 {
    out := map[string]map[string]float64{}
    for a := range returns {
        out[a] = map[string]float64{}
        for b := range returns {
            out[a][b] = pearson(returns[a], returns[b])
        }
    }
    return out
}

func main() {
    // TODO: load a real returns map
    corr := correlationMatrix(map[string][]float64{})
    fmt.Println(corr)
}

// Module 14, Monte Carlo stress test.
// Resample your realised fills and take the worst drawdown of each path.

function shuffled<T>(xs: T[]): T[] {
  const a = xs.slice();
  for (let i = a.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [a[i], a[j]] = [a[j], a[i]];
  }
  return a;
}

function pathDrawdown(returns: number[]): number {
  let cur = 1, peak = 1, mdd = 0;
  for (const r of returns) {
    cur *= 1 + r;
    peak = Math.max(peak, cur);
    mdd  = Math.min(mdd, (cur - peak) / peak);
  }
  return mdd;
}

function monteCarlo(tradeReturns: number[], trials = 10_000): number[] {
  const mdds: number[] = [];
  for (let i = 0; i < trials; i++) {
    mdds.push(pathDrawdown(shuffled(tradeReturns)));
  }
  mdds.sort((a, b) => a - b);
  return mdds;
}

// TODO: pull the real trade return array from your backtest
const mdds = monteCarlo([], 10_000);
if (mdds.length) {
  const p05 = mdds[Math.floor(mdds.length * 0.05)];
  console.log('5th-percentile DD:', (p05 * 100).toFixed(2), '%');
}

# Module 14, Monte Carlo stress test.
# Resample your realised fills and take the worst drawdown of each path.

import random
from typing import Sequence


def path_drawdown(returns: Sequence[float]) -> float:
    cur, peak, mdd = 1.0, 1.0, 0.0
    for r in returns:
        cur *= 1 + r
        peak = max(peak, cur)
        mdd  = min(mdd, (cur - peak) / peak)
    return mdd


def monte_carlo(trade_returns: Sequence[float], trials: int = 10_000) -> list[float]:
    mdds: list[float] = []
    xs = list(trade_returns)
    for _ in range(trials):
        random.shuffle(xs)
        mdds.append(path_drawdown(xs))
    mdds.sort()
    return mdds


# TODO: pull the real trade return list from your backtest
mdds = monte_carlo([], trials=10_000)
if mdds:
    p05 = mdds[int(len(mdds) * 0.05)]
    print(f"5th-percentile DD: {p05 * 100:.2f} %")

// Module 14, Monte Carlo stress test.
// Resample your realised fills and take the worst drawdown of each path.

package main

import (
    "fmt"
    "math/rand"
    "sort"
)

func pathDrawdown(returns []float64) float64 {
    cur, peak, mdd := 1.0, 1.0, 0.0
    for _, r := range returns {
        cur *= 1 + r
        if cur > peak {
            peak = cur
        }
        if d := (cur - peak) / peak; d < mdd {
            mdd = d
        }
    }
    return mdd
}

func monteCarlo(tradeReturns []float64, trials int) []float64 {
    xs := make([]float64, len(tradeReturns))
    copy(xs, tradeReturns)
    mdds := make([]float64, 0, trials)
    for i := 0; i < trials; i++ {
        rand.Shuffle(len(xs), func(a, b int) { xs[a], xs[b] = xs[b], xs[a] })
        mdds = append(mdds, pathDrawdown(xs))
    }
    sort.Float64s(mdds)
    return mdds
}

func main() {
    // TODO: pull the real trade return slice from your backtest
    mdds := monteCarlo([]float64{}, 10_000)
    if len(mdds) > 0 {
        p05 := mdds[int(float64(len(mdds))*0.05)]
        fmt.Printf("5th-percentile DD: %.2f %%\n", p05*100)
    }
}