wip markets

performance_chart.go

@@ -0,0 +1,177 @@
+package mujica
+
+import (
+	"fmt"
+	"math"
+	"strings"
+	"time"
+
+	"github.com/egoist/mygo/ui"
+
+	"mujicaui/internal"
+	"mujicaui/theme"
+)
+
+// PerformanceChartOptions configure a PerformanceChart.
+type PerformanceChartOptions struct {
+	Frame ChartFrame
+	// Times dates each value; required, ascending.
+	Times []time.Time
+	// Benchmark is compared against the portfolio; nil shows none.
+	Benchmark           []float64
+	Name, BenchmarkName string
+}
+
+// Drawdown is the deepest fall from a peak: indices and the fall in percent.
+type Drawdown struct {
+	Peak, Trough int
+	Percent      float64
+}
+
+// MaxDrawdown finds the largest peak-to-trough fall of positive values; Percent ≤ 0.
+func MaxDrawdown(values []float64) Drawdown {
+	var dd Drawdown
+	peak := 0
+	for i, v := range values {
+		if v > values[peak] {
+			peak = i
+		}
+		if f := (v/values[peak] - 1) * 100; f < dd.Percent {
+			dd = Drawdown{Peak: peak, Trough: i, Percent: f}
+		}
+	}
+	return dd
+}
+
+// PerformanceChart plots cumulative return against a benchmark and shades the maximum drawdown.
+func PerformanceChart(c *ui.Context, values []float64, opts PerformanceChartOptions) ChartResult {
+	for _, vs := range [][]float64{values, opts.Benchmark} {
+		for _, v := range vs {
+			if !(v > 0) || math.IsInf(v, 0) {
+				panic("mujica: PerformanceChart values must be positive")
+			}
+		}
+	}
+	if opts.Benchmark != nil && len(opts.Benchmark) != len(values) {
+		panic("mujica: PerformanceChart Benchmark length differs")
+	}
+	ch := newChart(c, opts.Frame)
+	k := Tokens(c)
+	pal := internal.Palette(k)
+	size := FontSize(c, theme.CaptionSize)
+	name := opts.Name
+	if name == "" {
+		name = msg(c, "performance_chart.portfolio")
+	}
+	bname := opts.BenchmarkName
+	if bname == "" {
+		bname = msg(c, "performance_chart.benchmark")
+	}
+	series := chartMemo(ch, "returns", [4]string{chartID(values), chartID(opts.Benchmark), name, bname}, func() []ChartSeries {
+		out := []ChartSeries{{Name: name, Values: performanceReturns(values)}}
+		if opts.Benchmark != nil {
+			out = append(out, ChartSeries{Name: bname, Values: performanceReturns(opts.Benchmark)})
+		}
+		return out
+	})
+	n := len(values)
+	ax := chartMemo(ch, "x", chartID(opts.Times), func() chartX { return newChartX(n, nil, opts.Times) })
+	dd := chartMemo(ch, "dd", chartID(values), func() Drawdown { return MaxDrawdown(values) })
+	lo, hi, ok := chartYRange(ch, series, true, nil)
+	if !ok {
+		n = 0
+	}
+	keys := make([]chartKey, len(series))
+	for i, s := range series {
+		keys[i] = chartKey{Name: s.Name, Color: pal[i], Shape: i}
+	}
+	var ticks []float64
+	var step float64
+	if n > 0 {
+		lo, hi, step = internal.Nice(lo, hi, 4)
+		ticks = internal.Ticks(lo, hi, step)
+	}
+	pct := func(v float64) string { return statisticSigned(v, 2) + "%" }
+	geom := func(r ui.Rect) (ui.Rect, internal.Linear, internal.Linear) {
+		plot := chartInset(r, 56, 26)
+		return plot, ax.scale(plot), internal.Linear{D0: lo, D1: hi, R0: float64(plot.Y + plot.H), R1: float64(plot.Y)}
+	}
+	spec := chartSpec{n: n, keys: keys, toggle: true}
+	spec.pick = func(r ui.Rect, x, y float32) int {
+		plot, xs, _ := geom(r)
+		if !plot.Contains(x, y) {
+			return -1
+		}
+		return ax.nearest(xs.Invert(x))
+	}
+	spec.readout = func(i int) string {
+		parts := []string{opts.Times[i].Format("2006-01-02")}
+		for _, s := range series {
+			if !ch.hidden(s.Name) {
+				parts = append(parts, s.Name+" "+pct(s.Values[i]))
+			}
+		}
+		return strings.Join(parts, " · ")
+	}
+	spec.draw = func(p *ui.Painter, r ui.Rect, active int) {
+		plot, xs, ys := geom(r)
+		x := func(i int) float32 { return internal.Snap(p, xs.Map(ax.vals[i])) }
+		if dd.Percent < 0 && !ch.hidden(name) {
+			band := ui.Rect{X: x(dd.Peak), Y: plot.Y, W: x(dd.Trough) - x(dd.Peak), H: plot.H}
+			p.Fill(band, trendColor(c, -1).Alpha(0.1), 0)
+			p.Line(band.X, plot.Y, band.X, plot.Y+plot.H, 1, trendColor(c, -1).Alpha(0.5))
+			p.Line(band.X+band.W, plot.Y, band.X+band.W, plot.Y+plot.H, 1, trendColor(c, -1).Alpha(0.5))
+			chartText(p, fmt.Sprintf(msg(c, "performance_chart.drawdown"), pct(dd.Percent)), band.X+4, plot.Y+2, size, chartInk(k, k.Surface), 0, 0)
+		}
+		internal.AxisY(p, plot, ys, ticks, func(v float64) string { return internal.FormatTick(v, step) + "%" }, size, k)
+		tx, tl := ax.ticks(plot)
+		internal.AxisX(p, plot, tx, tl, size, k)
+		zero := internal.Snap(p, ys.Map(0))
+		p.Line(plot.X, zero, plot.X+plot.W, zero, 1, k.ControlBorder)
+		for si, s := range series {
+			if ch.hidden(s.Name) {
+				continue
+			}
+			var line ui.Path
+			idx := internal.Columns(n, func(i int) float32 { return xs.Map(ax.vals[i]) }, func(i int) float64 { return s.Values[i] })
+			for j, i := range idx {
+				if j == 0 {
+					line.MoveTo(x(i), internal.Snap(p, ys.Map(s.Values[i])))
+				} else {
+					line.LineTo(x(i), internal.Snap(p, ys.Map(s.Values[i])))
+				}
+			}
+			p.StrokePath(&line, 2, keys[si].Color)
+			every := max(1, int(float32(n)/max(plot.W/48, 1)))
+			for i := 0; i < n; i += every {
+				internal.Marker(p, si, x(i), ys.Map(s.Values[i]), 7, keys[si].Color)
+			}
+		}
+		if active >= 0 {
+			p.Line(x(active), plot.Y, x(active), plot.Y+plot.H, 1, k.TextMuted)
+			for si, s := range series {
+				if !ch.hidden(s.Name) {
+					internal.Marker(p, si, x(active), ys.Map(s.Values[active]), 13, k.Surface)
+					internal.Marker(p, si, x(active), ys.Map(s.Values[active]), 9, keys[si].Color)
+				}
+			}
+		}
+	}
+	res, _ := ch.build(spec)
+	if dd.Percent < 0 && n > 0 {
+		res.Element.Children(func() {
+			ui.Text(c, fmt.Sprintf(msg(c, "performance_chart.drawdown_range"), pct(dd.Percent),
+				opts.Times[dd.Peak].Format("2006-01-02"), opts.Times[dd.Trough].Format("2006-01-02"))).FontSize(size).TextColor(k.TextMuted)
+		})
+	}
+	return res
+}
+
+// performanceReturns turns values into cumulative percent return from the first.
+func performanceReturns(values []float64) []float64 {
+	out := make([]float64, len(values))
+	for i, v := range values {
+		out[i] = (v/values[0] - 1) * 100
+	}
+	return out
+}