配对交易实战：GLD 与 GDX 的均值回归策略

package main

// 模拟 GLD 价格数据
var gldPrices = []float64{
    100.00, 101.20, 102.50, 101.80, 103.00,
    104.50, 103.20, 105.00, 106.50, 105.80,
    107.20, 108.50, 107.00, 109.00, 110.50,
    109.80, 111.20, 112.50, 111.00, 113.00,
}

// 模拟 GDX 价格数据
var gdxPrices = []float64{
    30.00, 30.50, 31.20, 30.80, 31.50,
    31.80, 31.00, 32.20, 32.80, 32.50,
    33.00, 33.50, 32.80, 34.00, 34.50,
    34.20, 34.80, 35.20, 34.50, 35.50,
}

package main

import "fmt"

// 计算切片的均值
func mean(data []float64) float64 {
    sum := 0.0
    for _, v := range data {
        sum += v
    }
    return sum / float64(len(data))
}

// 计算对冲比率（OLS 线性回归）
// y = alpha + beta * x
// 返回 beta（对冲比率）和 alpha（截距）
func calcHedgeRatio(x, y []float64) (beta, alpha float64) {
    n := len(x)
    if n != len(y) || n == 0 {
        return 0, 0
    }

    meanX := mean(x)
    meanY := mean(y)

    // 计算协方差和方差
    var covariance, variance float64
    for i := 0; i < n; i++ {
        dx := x[i] - meanX
        dy := y[i] - meanY
        covariance += dx * dy  // Σ(x-x̄)(y-ȳ)
        variance += dx * dx    // Σ(x-x̄)²
    }

    // β = Cov(X,Y) / Var(X)
    beta = covariance / variance

    // α = ȳ - β * x̄
    alpha = meanY - beta*meanX

    return beta, alpha
}

// 计算差价序列
func calcSpread(gld, gdx []float64, beta float64) []float64 {
    spread := make([]float64, len(gld))
    for i := range gld {
        spread[i] = gld[i] - beta*gdx[i]
    }
    return spread
}

import "math"

// 计算标准差（样本标准差，除以 n-1）
func stdDev(data []float64) float64 {
    n := len(data)
    if n < 2 {
        return 0
    }

    m := mean(data)
    var sumSquares float64
    for _, v := range data {
        diff := v - m
        sumSquares += diff * diff
    }

    // 使用 n-1（贝塞尔校正）
    return math.Sqrt(sumSquares / float64(n-1))
}

// 计算 Z-Score 序列
func calcZScore(spread []float64, meanSpread, stdSpread float64) []float64 {
    zscores := make([]float64, len(spread))
    for i, s := range spread {
        zscores[i] = (s - meanSpread) / stdSpread
    }
    return zscores
}

// Position 表示头寸
type Position struct {
    GLD int // +1: 做多, -1: 做空, 0: 空仓
    GDX int
}

// 生成交易信号
func generateSignals(zscores []float64) []Position {
    positions := make([]Position, len(zscores))
    currentPos := Position{0, 0}

    for i, z := range zscores {
        if z <= -2 {
            // 差价过低，做多差价组合
            // 做多 GLD，做空 GDX
            currentPos = Position{GLD: 1, GDX: -1}
        } else if z >= 2 {
            // 差价过高，做空差价组合
            // 做空 GLD，做多 GDX
            currentPos = Position{GLD: -1, GDX: 1}
        } else if math.Abs(z) <= 1 {
            // 差价回归，清仓
            currentPos = Position{GLD: 0, GDX: 0}
        }
        // 其他情况保持原有头寸

        positions[i] = currentPos
    }

    return positions
}

// 计算日收益率
func calcDailyReturns(prices []float64) []float64 {
    returns := make([]float64, len(prices))
    returns[0] = 0 // 第一天没有收益率

    for i := 1; i < len(prices); i++ {
        returns[i] = (prices[i] - prices[i-1]) / prices[i-1]
    }
    return returns
}

// 计算组合 PnL
// 注意：使用前一天的头寸乘以当天的收益（避免前视偏差）
func calcPnL(positions []Position, gldReturns, gdxReturns []float64) []float64 {
    pnl := make([]float64, len(positions))
    pnl[0] = 0

    for i := 1; i < len(positions); i++ {
        // 使用 t-1 时刻的头寸，乘以 t 时刻的收益
        prevPos := positions[i-1]
        pnl[i] = float64(prevPos.GLD)*gldReturns[i] + 
                 float64(prevPos.GDX)*gdxReturns[i]
    }
    return pnl
}

// 计算夏普比率
// riskFreeRate: 日无风险利率（年化 4% 约等于日 0.04/252）
func calcSharpeRatio(pnl []float64, riskFreeRate float64) float64 {
    if len(pnl) < 2 {
        return 0
    }

    // 计算超额收益
    excessReturns := make([]float64, len(pnl))
    for i, r := range pnl {
        excessReturns[i] = r - riskFreeRate
    }

    meanReturn := mean(excessReturns)
    stdReturn := stdDev(excessReturns)

    if stdReturn == 0 {
        return 0
    }

    // 日夏普比率
    dailySharpe := meanReturn / stdReturn

    // 年化夏普比率
    return dailySharpe * math.Sqrt(252)
}

package main

import (
    "fmt"
    "math"
)

// ========== 数据 ==========

var gldPrices = []float64{
    100.00, 101.20, 102.50, 101.80, 103.00,
    104.50, 103.20, 105.00, 106.50, 105.80,
    107.20, 108.50, 107.00, 109.00, 110.50,
    109.80, 111.20, 112.50, 111.00, 113.00,
}

var gdxPrices = []float64{
    30.00, 30.50, 31.20, 30.80, 31.50,
    31.80, 31.00, 32.20, 32.80, 32.50,
    33.00, 33.50, 32.80, 34.00, 34.50,
    34.20, 34.80, 35.20, 34.50, 35.50,
}

// ========== 工具函数 ==========

func mean(data []float64) float64 {
    if len(data) == 0 {
        return 0
    }
    sum := 0.0
    for _, v := range data {
        sum += v
    }
    return sum / float64(len(data))
}

func stdDev(data []float64) float64 {
    n := len(data)
    if n < 2 {
        return 0
    }
    m := mean(data)
    var sumSquares float64
    for _, v := range data {
        diff := v - m
        sumSquares += diff * diff
    }
    return math.Sqrt(sumSquares / float64(n-1))
}

// ========== 核心函数 ==========

// 计算对冲比率（OLS 回归）
func calcHedgeRatio(x, y []float64) (beta, alpha float64) {
    n := len(x)
    if n != len(y) || n == 0 {
        return 0, 0
    }
    meanX, meanY := mean(x), mean(y)
    var covariance, variance float64
    for i := 0; i < n; i++ {
        dx := x[i] - meanX
        dy := y[i] - meanY
        covariance += dx * dy
        variance += dx * dx
    }
    beta = covariance / variance
    alpha = meanY - beta*meanX
    return
}

// 计算差价
func calcSpread(gld, gdx []float64, beta float64) []float64 {
    spread := make([]float64, len(gld))
    for i := range gld {
        spread[i] = gld[i] - beta*gdx[i]
    }
    return spread
}

// 计算 Z-Score
func calcZScore(spread []float64, meanSpread, stdSpread float64) []float64 {
    zscores := make([]float64, len(spread))
    for i, s := range spread {
        zscores[i] = (s - meanSpread) / stdSpread
    }
    return zscores
}

// Position 头寸
type Position struct {
    GLD int
    GDX int
}

// 生成交易信号
func generateSignals(zscores []float64) []Position {
    positions := make([]Position, len(zscores))
    currentPos := Position{0, 0}
    for i, z := range zscores {
        if z <= -2 {
            currentPos = Position{GLD: 1, GDX: -1}
        } else if z >= 2 {
            currentPos = Position{GLD: -1, GDX: 1}
        } else if math.Abs(z) <= 1 {
            currentPos = Position{GLD: 0, GDX: 0}
        }
        positions[i] = currentPos
    }
    return positions
}

// 计算日收益率
func calcDailyReturns(prices []float64) []float64 {
    returns := make([]float64, len(prices))
    for i := 1; i < len(prices); i++ {
        returns[i] = (prices[i] - prices[i-1]) / prices[i-1]
    }
    return returns
}

// 计算组合 PnL
func calcPnL(positions []Position, gldRet, gdxRet []float64) []float64 {
    pnl := make([]float64, len(positions))
    for i := 1; i < len(positions); i++ {
        prev := positions[i-1]
        pnl[i] = float64(prev.GLD)*gldRet[i] + float64(prev.GDX)*gdxRet[i]
    }
    return pnl
}

// 计算夏普比率
func calcSharpeRatio(pnl []float64) float64 {
    if len(pnl) < 2 {
        return 0
    }
    m := mean(pnl)
    s := stdDev(pnl)
    if s == 0 {
        return 0
    }
    return (m / s) * math.Sqrt(252)
}

// ========== 主函数 ==========

func main() {
    // 划分训练集和测试集
    trainSize := 10
    trainGLD := gldPrices[:trainSize]
    trainGDX := gdxPrices[:trainSize]

    fmt.Println("========== 配对交易策略回测 ==========")
    fmt.Println()

    // 1. 计算对冲比率（仅用训练集）
    beta, alpha := calcHedgeRatio(trainGDX, trainGLD)
    fmt.Printf("【对冲比率】β = %.4f, α = %.4f\n", beta, alpha)
    fmt.Println()

    // 2. 计算全部数据的差价
    spread := calcSpread(gldPrices, gdxPrices, beta)
    fmt.Println("【差价序列】")
    fmt.Println("日期\tGLD\tGDX\tSpread")
    for i := 0; i < len(spread); i++ {
        fmt.Printf("Day %d\t%.2f\t%.2f\t%.4f\n", 
            i+1, gldPrices[i], gdxPrices[i], spread[i])
    }
    fmt.Println()

    // 3. 计算 Z-Score（使用训练集参数）
    trainSpread := spread[:trainSize]
    spreadMean := mean(trainSpread)
    spreadStd := stdDev(trainSpread)
    fmt.Printf("【训练集统计】均值 = %.4f, 标准差 = %.4f\n", spreadMean, spreadStd)

    zscores := calcZScore(spread, spreadMean, spreadStd)
    fmt.Println()
    fmt.Println("【Z-Score 序列】")
    fmt.Println("日期\tSpread\tZ-Score\t信号")
    for i, z := range zscores {
        signal := "持有"
        if z <= -2 {
            signal = "做多差价"
        } else if z >= 2 {
            signal = "做空差价"
        } else if math.Abs(z) <= 1 {
            signal = "清仓"
        }
        fmt.Printf("Day %d\t%.4f\t%.4f\t%s\n", i+1, spread[i], z, signal)
    }
    fmt.Println()

    // 4. 生成交易信号
    positions := generateSignals(zscores)

    // 5. 计算收益
    gldReturns := calcDailyReturns(gldPrices)
    gdxReturns := calcDailyReturns(gdxPrices)
    pnl := calcPnL(positions, gldReturns, gdxReturns)

    // 6. 计算夏普比率
    trainPnL := pnl[1:trainSize]
    testPnL := pnl[trainSize:]

    trainSharpe := calcSharpeRatio(trainPnL)
    testSharpe := calcSharpeRatio(testPnL)

    fmt.Println("【回测结果】")
    fmt.Printf("训练集夏普比率: %.4f\n", trainSharpe)
    fmt.Printf("测试集夏普比率: %.4f\n", testSharpe)

    // 累计收益
    trainCumReturn := 0.0
    for _, r := range trainPnL {
        trainCumReturn += r
    }
    testCumReturn := 0.0
    for _, r := range testPnL {
        testCumReturn += r
    }
    fmt.Printf("训练集累计收益: %.2f%%\n", trainCumReturn*100)
    fmt.Printf("测试集累计收益: %.2f%%\n", testCumReturn*100)
}