Building the Backtester

package backtest

// MarketView is a window onto history that cannot return future data.
// The cursor is the index of the most recently CLOSED bar.
type MarketView struct {
	bars   []Bar
	cursor int
}

func (v MarketView) Latest() Bar {
	return v.bars[v.cursor]
}

func (v MarketView) Previous(back int) (Bar, bool) {
	idx := v.cursor - back
	if idx < 0 {
		return Bar{}, false
	}
	return v.bars[idx], true
}

func (v MarketView) History(n int) []Bar {
	start := v.cursor - n + 1
	if start < 0 {
		start = 0
	}
	return v.bars[start : v.cursor+1]
}

func (v MarketView) Index() int { return v.cursor }

// There is deliberately no method returning anything past cursor.

package backtest

import (
	"math"
	"sort"
)

type Engine struct {
	Costs  CostModel
	Sizer  Sizer
	Equity float64
}

func (e *Engine) Run(s Strategy, bars []Bar) (*Result, error) {
	if len(bars) == 0 {
		return nil, ErrNoBars
	}

	result := &Result{InitialEquity: e.Equity}
	equity := e.Equity

	var open *Trade
	var pending *Signal

	for i := range bars {
		bar := bars[i]

		// 1. Fill any pending entry at THIS bar's open.
		//    The signal came from the previous bar's close - you
		//    cannot act on a close at that same close.
		if pending != nil && open == nil {
			entry := e.Costs.FillPrice(bar.Open, pending.Side)
			qty := e.Sizer.Size(equity, pending.StopDistance)

			if qty > 0 {
				open = &Trade{
					Side:        pending.Side,
					EntryTime:   bar.Timestamp,
					EntryPrice:  entry,
					Quantity:    qty,
					RiskPerUnit: pending.StopDistance,
					Stop:        entry - float64(pending.Side)*pending.StopDistance,
					Target:      entry + float64(pending.Side)*pending.TargetDistance,
				}
				equity -= e.Costs.Commission(entry, qty)
			}
			pending = nil
		}

		// 2. Check exits against this bar - including the fill bar.
		if open != nil {
			if price, reason, hit := e.checkExit(open, bar); hit {
				filled := e.Costs.FillPrice(price, -open.Side)
				open.ExitTime = bar.Timestamp
				open.ExitPrice = filled
				open.ExitReason = reason

				equity += open.PnL() - e.Costs.Commission(filled, open.Quantity)
				result.Trades = append(result.Trades, *open)
				open = nil
			}
		}

		// 3. Ask the strategy for a signal from this bar's close.
		if open == nil && pending == nil {
			pending = s.OnBar(MarketView{bars: bars, cursor: i})
		}

		result.EquityCurve = append(result.EquityCurve, equity)
	}

	result.FinalEquity = equity
	return result, nil
}

// checkExit resolves stop and target. When a bar contains both, the
// stop is assumed to have hit first: the information needed to do
// better is not present in an OHLC bar.
func (e *Engine) checkExit(t *Trade, bar Bar) (float64, string, bool) {
	var hitStop, hitTarget bool

	if t.Side > 0 {
		hitStop = bar.Low <= t.Stop
		hitTarget = bar.High >= t.Target
	} else {
		hitStop = bar.High >= t.Stop
		hitTarget = bar.Low <= t.Target
	}

	switch {
	case hitStop && hitTarget:
		return t.Stop, "stop (ambiguous bar)", true
	case hitStop:
		return t.Stop, "stop", true
	case hitTarget:
		return t.Target, "target", true
	}
	return 0, "", false
}

type Result struct {
	Trades        []Trade
	EquityCurve   []float64
	InitialEquity float64
	FinalEquity   float64
}

func (r *Result) RMultiples() []float64 {
	out := make([]float64, 0, len(r.Trades))
	for _, t := range r.Trades {
		out = append(out, t.RMultiple())
	}
	return out
}

func (r *Result) Summary() Summary {
	rs := r.RMultiples()
	if len(rs) == 0 {
		return Summary{}
	}

	var wins, losses []float64
	for _, v := range rs {
		if v > 0 {
			wins = append(wins, v)
		} else {
			losses = append(losses, v)
		}
	}

	m := mean(rs)
	sd := stdDev(rs)
	stderr := sd / math.Sqrt(float64(len(rs)))

	s := Summary{
		Trades:      len(rs),
		Expectancy:  m,
		StdErr:      stderr,
		WinRate:     float64(len(wins)) / float64(len(rs)),
		MaxDrawdown: maxDrawdown(r.EquityCurve),
	}
	if stderr > 0 {
		s.TStat = m / stderr
	}
	return s
}