wickra/bindings/go/golden_all_test.go

// Code generated by gen_golden_test.py. DO NOT EDIT.
//
// Value-parity for every one of the 514 Go indicators: the shared golden input
// is replayed through each one and checked bit-for-bit against the Rust
// reference fixtures testdata/golden/g_<Canonical>.csv. Multi-output, profile
// and bar shapes are flattened by reflection so a single comparator covers all
// archetypes. Regenerate with: python bindings/go/gen_golden_test.py

package wickra

import (
	"bufio"
	"math"
	"os"
	"reflect"
	"strings"
	"testing"
)

// readGoldenRaw keeps blank lines (a candle on which no bar closed) so bar rows
// stay aligned to the input; non-bar fixtures contain no blank lines.
func readGoldenRaw(t *testing.T, name string) [][]string {
	t.Helper()
	f, err := os.Open("../../testdata/golden/" + name + ".csv")
	if err != nil {
		t.Fatalf("open %s: %v", name, err)
	}
	defer f.Close()
	var rows [][]string
	sc := bufio.NewScanner(f)
	sc.Buffer(make([]byte, 0, 1024*1024), 1024*1024)
	first := true
	for sc.Scan() {
		line := sc.Text()
		if first {
			first = false
			continue
		}
		if line == "" {
			rows = append(rows, []string{})
			continue
		}
		rows = append(rows, strings.Split(line, ","))
	}
	return rows
}

func nanRow(n int) []float64 {
	r := make([]float64, n)
	for i := range r {
		r[i] = math.NaN()
	}
	return r
}

func reflectRow(out any, ok bool, width int) []float64 {
	if !ok {
		return nanRow(width)
	}
	v := reflect.ValueOf(out)
	row := make([]float64, 0, width)
	for k := 0; k < v.NumField(); k++ {
		row = appendField(row, v.Field(k))
	}
	return row
}

func appendField(row []float64, f reflect.Value) []float64 {
	switch f.Kind() {
	case reflect.Float64, reflect.Float32:
		return append(row, f.Float())
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return append(row, float64(f.Int()))
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
		return append(row, float64(f.Uint()))
	case reflect.Slice:
		for j := 0; j < f.Len(); j++ {
			row = appendField(row, f.Index(j))
		}
		return row
	default:
		return row
	}
}

func flattenBars(bars any) []float64 {
	v := reflect.ValueOf(bars)
	row := []float64{}
	for i := 0; i < v.Len(); i++ {
		bar := v.Index(i)
		for k := 0; k < bar.NumField(); k++ {
			row = appendField(row, bar.Field(k))
		}
	}
	return row
}

// Synthetic feeds derived from one OHLCV row, identical to gen_golden's Rust
// construction (DerivativesTick / CrossSection / OrderBook).
func derivFields(r []float64) [11]float64 {
	o, h, l, c, v := r[0], r[1], r[2], r[3], r[4]
	return [11]float64{
		(c - o) / c * 0.01, // funding_rate
		c,                  // mark_price
		c - 0.5,            // index_price
		c + 1.0,            // futures_price
		v * 10.0,           // open_interest
		v * 0.6,            // long_size
		v * 0.4,            // short_size
		v * 0.55,           // taker_buy_volume
		v * 0.45,           // taker_sell_volume
		h - c,              // long_liquidation
		c - l,              // short_liquidation
	}
}

func crossLists(r []float64) ([]float64, []float64, []bool, []bool, []bool, []bool) {
	o, c, v := r[0], r[3], r[4]
	change := make([]float64, 5)
	volume := make([]float64, 5)
	newHigh := make([]bool, 5)
	newLow := make([]bool, 5)
	aboveMa := make([]bool, 5)
	onBuy := make([]bool, 5)
	for j := 0; j < 5; j++ {
		jf := float64(j)
		change[j] = (c - o) + jf
		volume[j] = v + jf*10.0
		newHigh[j] = j%2 == 0
		newLow[j] = j%3 == 0
		aboveMa[j] = j%2 == 0
		onBuy[j] = j%3 == 0
	}
	return change, volume, newHigh, newLow, aboveMa, onBuy
}

func obLists(r []float64) ([]float64, []float64, []float64, []float64) {
	c, v := r[3], r[4]
	bidPx := make([]float64, 5)
	bidSz := make([]float64, 5)
	askPx := make([]float64, 5)
	askSz := make([]float64, 5)
	for k := 0; k < 5; k++ {
		kf := float64(k + 1)
		bidPx[k] = c - 0.1*kf
		bidSz[k] = v / kf
		askPx[k] = c + 0.1*kf
		askSz[k] = v * 0.9 / kf
	}
	return bidPx, bidSz, askPx, askSz
}

func compareGolden(t *testing.T, name string, got [][]float64) {
	t.Helper()
	exp := readGoldenRaw(t, "g_"+name)
	if len(exp) != len(got) {
		t.Fatalf("%s: %d fixture rows vs %d computed", name, len(exp), len(got))
	}
	for i := range exp {
		if len(exp[i]) != len(got[i]) {
			t.Fatalf("%s row %d: arity %d vs %d", name, i, len(got[i]), len(exp[i]))
		}
		for k := range exp[i] {
			want := goldenCell(exp[i][k])
			g := got[i][k]
			if math.IsNaN(want) {
				if !math.IsNaN(g) {
					t.Fatalf("%s row %d col %d: want NaN got %v", name, i, k, g)
				}
				continue
			}
			if math.IsInf(want, 0) {
				if !math.IsInf(g, 0) || (g > 0) != (want > 0) {
					t.Fatalf("%s row %d col %d: want %v got %v", name, i, k, want, g)
				}
				continue
			}
			tol := goldenTol * math.Max(1.0, math.Abs(want))
			if math.Abs(g-want) > tol {
				t.Fatalf("%s row %d col %d: got %v want %v", name, i, k, g, want)
			}
		}
	}
}

func TestGoldenAll(t *testing.T) {
	rows := goldenInput(t)

	t.Run("AbandonedBaby", func(t *testing.T) {
		ind, err := NewAbandonedBaby()
		if err != nil {
			t.Fatalf("new AbandonedBaby: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "AbandonedBaby", got)
	})
	t.Run("Abcd", func(t *testing.T) {
		ind, err := NewAbcd()
		if err != nil {
			t.Fatalf("new Abcd: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Abcd", got)
	})
	t.Run("AbsoluteBreadthIndex", func(t *testing.T) {
		ind, err := NewAbsoluteBreadthIndex()
		if err != nil {
			t.Fatalf("new AbsoluteBreadthIndex: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			ch, vo, nh, nl, am, ob_ := crossLists(r)
			got[i] = []float64{ind.Update(ch, vo, nh, nl, am, ob_, int64(i))}
		}
		compareGolden(t, "AbsoluteBreadthIndex", got)
	})
	t.Run("AccelerationBands", func(t *testing.T) {
		ind, err := NewAccelerationBands(14, 2.0)
		if err != nil {
			t.Fatalf("new AccelerationBands: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "AccelerationBands", got)
	})
	t.Run("AcceleratorOscillator", func(t *testing.T) {
		ind, err := NewAcceleratorOscillator(3, 7, 14)
		if err != nil {
			t.Fatalf("new AcceleratorOscillator: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "AcceleratorOscillator", got)
	})
	t.Run("AdOscillator", func(t *testing.T) {
		ind, err := NewAdOscillator()
		if err != nil {
			t.Fatalf("new AdOscillator: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "AdOscillator", got)
	})
	t.Run("AdVolumeLine", func(t *testing.T) {
		ind, err := NewAdVolumeLine()
		if err != nil {
			t.Fatalf("new AdVolumeLine: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			ch, vo, nh, nl, am, ob_ := crossLists(r)
			got[i] = []float64{ind.Update(ch, vo, nh, nl, am, ob_, int64(i))}
		}
		compareGolden(t, "AdVolumeLine", got)
	})
	t.Run("AdaptiveCci", func(t *testing.T) {
		ind, err := NewAdaptiveCci(14)
		if err != nil {
			t.Fatalf("new AdaptiveCci: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "AdaptiveCci", got)
	})
	t.Run("AdaptiveCycle", func(t *testing.T) {
		ind, err := NewAdaptiveCycle()
		if err != nil {
			t.Fatalf("new AdaptiveCycle: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "AdaptiveCycle", got)
	})
	t.Run("AdaptiveLaguerreFilter", func(t *testing.T) {
		ind, err := NewAdaptiveLaguerreFilter(20)
		if err != nil {
			t.Fatalf("new AdaptiveLaguerreFilter: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "AdaptiveLaguerreFilter", got)
	})
	t.Run("AdaptiveRsi", func(t *testing.T) {
		ind, err := NewAdaptiveRsi(14)
		if err != nil {
			t.Fatalf("new AdaptiveRsi: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "AdaptiveRsi", got)
	})
	t.Run("Adl", func(t *testing.T) {
		ind, err := NewAdl()
		if err != nil {
			t.Fatalf("new Adl: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Adl", got)
	})
	t.Run("AdvanceBlock", func(t *testing.T) {
		ind, err := NewAdvanceBlock()
		if err != nil {
			t.Fatalf("new AdvanceBlock: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "AdvanceBlock", got)
	})
	t.Run("AdvanceDecline", func(t *testing.T) {
		ind, err := NewAdvanceDecline()
		if err != nil {
			t.Fatalf("new AdvanceDecline: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			ch, vo, nh, nl, am, ob_ := crossLists(r)
			got[i] = []float64{ind.Update(ch, vo, nh, nl, am, ob_, int64(i))}
		}
		compareGolden(t, "AdvanceDecline", got)
	})
	t.Run("AdvanceDeclineRatio", func(t *testing.T) {
		ind, err := NewAdvanceDeclineRatio()
		if err != nil {
			t.Fatalf("new AdvanceDeclineRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			ch, vo, nh, nl, am, ob_ := crossLists(r)
			got[i] = []float64{ind.Update(ch, vo, nh, nl, am, ob_, int64(i))}
		}
		compareGolden(t, "AdvanceDeclineRatio", got)
	})
	t.Run("Adx", func(t *testing.T) {
		ind, err := NewAdx(14)
		if err != nil {
			t.Fatalf("new Adx: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "Adx", got)
	})
	t.Run("Adxr", func(t *testing.T) {
		ind, err := NewAdxr(14)
		if err != nil {
			t.Fatalf("new Adxr: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Adxr", got)
	})
	t.Run("Alligator", func(t *testing.T) {
		ind, err := NewAlligator(3, 7, 14)
		if err != nil {
			t.Fatalf("new Alligator: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "Alligator", got)
	})
	t.Run("Alma", func(t *testing.T) {
		ind, err := NewAlma(9, 0.85, 6.0)
		if err != nil {
			t.Fatalf("new Alma: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Alma", got)
	})
	t.Run("Alpha", func(t *testing.T) {
		ind, err := NewAlpha(14, 2.0)
		if err != nil {
			t.Fatalf("new Alpha: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[0])}
		}
		compareGolden(t, "Alpha", got)
	})
	t.Run("AmihudIlliquidity", func(t *testing.T) {
		ind, err := NewAmihudIlliquidity(20)
		if err != nil {
			t.Fatalf("new AmihudIlliquidity: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[4], r[3] >= r[0], int64(i))}
		}
		compareGolden(t, "AmihudIlliquidity", got)
	})
	t.Run("AnchoredRsi", func(t *testing.T) {
		ind, err := NewAnchoredRsi()
		if err != nil {
			t.Fatalf("new AnchoredRsi: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "AnchoredRsi", got)
	})
	t.Run("AnchoredVwap", func(t *testing.T) {
		ind, err := NewAnchoredVwap()
		if err != nil {
			t.Fatalf("new AnchoredVwap: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "AnchoredVwap", got)
	})
	t.Run("AndrewsPitchfork", func(t *testing.T) {
		ind, err := NewAndrewsPitchfork(14)
		if err != nil {
			t.Fatalf("new AndrewsPitchfork: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "AndrewsPitchfork", got)
	})
	t.Run("Apo", func(t *testing.T) {
		ind, err := NewApo(3, 7)
		if err != nil {
			t.Fatalf("new Apo: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Apo", got)
	})
	t.Run("Aroon", func(t *testing.T) {
		ind, err := NewAroon(14)
		if err != nil {
			t.Fatalf("new Aroon: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "Aroon", got)
	})
	t.Run("AroonOscillator", func(t *testing.T) {
		ind, err := NewAroonOscillator(14)
		if err != nil {
			t.Fatalf("new AroonOscillator: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "AroonOscillator", got)
	})
	t.Run("Atr", func(t *testing.T) {
		ind, err := NewAtr(14)
		if err != nil {
			t.Fatalf("new Atr: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Atr", got)
	})
	t.Run("AtrBands", func(t *testing.T) {
		ind, err := NewAtrBands(14, 2.0)
		if err != nil {
			t.Fatalf("new AtrBands: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "AtrBands", got)
	})
	t.Run("AtrRatchet", func(t *testing.T) {
		ind, err := NewAtrRatchet(14, 2.0, 0.5)
		if err != nil {
			t.Fatalf("new AtrRatchet: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "AtrRatchet", got)
	})
	t.Run("AtrTrailingStop", func(t *testing.T) {
		ind, err := NewAtrTrailingStop(14, 2.0)
		if err != nil {
			t.Fatalf("new AtrTrailingStop: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "AtrTrailingStop", got)
	})
	t.Run("AutoFib", func(t *testing.T) {
		ind, err := NewAutoFib()
		if err != nil {
			t.Fatalf("new AutoFib: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 7)
		}
		compareGolden(t, "AutoFib", got)
	})
	t.Run("Autocorrelation", func(t *testing.T) {
		ind, err := NewAutocorrelation(10, 1)
		if err != nil {
			t.Fatalf("new Autocorrelation: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Autocorrelation", got)
	})
	t.Run("AutocorrelationPeriodogram", func(t *testing.T) {
		ind, err := NewAutocorrelationPeriodogram(10, 48)
		if err != nil {
			t.Fatalf("new AutocorrelationPeriodogram: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "AutocorrelationPeriodogram", got)
	})
	t.Run("AverageDailyRange", func(t *testing.T) {
		ind, err := NewAverageDailyRange(14, 0)
		if err != nil {
			t.Fatalf("new AverageDailyRange: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "AverageDailyRange", got)
	})
	t.Run("AverageDrawdown", func(t *testing.T) {
		ind, err := NewAverageDrawdown(14)
		if err != nil {
			t.Fatalf("new AverageDrawdown: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "AverageDrawdown", got)
	})
	t.Run("AvgPrice", func(t *testing.T) {
		ind, err := NewAvgPrice()
		if err != nil {
			t.Fatalf("new AvgPrice: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "AvgPrice", got)
	})
	t.Run("AwesomeOscillator", func(t *testing.T) {
		ind, err := NewAwesomeOscillator(3, 7)
		if err != nil {
			t.Fatalf("new AwesomeOscillator: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "AwesomeOscillator", got)
	})
	t.Run("AwesomeOscillatorHistogram", func(t *testing.T) {
		ind, err := NewAwesomeOscillatorHistogram(3, 7, 14)
		if err != nil {
			t.Fatalf("new AwesomeOscillatorHistogram: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "AwesomeOscillatorHistogram", got)
	})
	t.Run("BalanceOfPower", func(t *testing.T) {
		ind, err := NewBalanceOfPower()
		if err != nil {
			t.Fatalf("new BalanceOfPower: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "BalanceOfPower", got)
	})
	t.Run("BandpassFilter", func(t *testing.T) {
		ind, err := NewBandpassFilter(20, 0.3)
		if err != nil {
			t.Fatalf("new BandpassFilter: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "BandpassFilter", got)
	})
	t.Run("Bat", func(t *testing.T) {
		ind, err := NewBat()
		if err != nil {
			t.Fatalf("new Bat: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Bat", got)
	})
	t.Run("BeltHold", func(t *testing.T) {
		ind, err := NewBeltHold()
		if err != nil {
			t.Fatalf("new BeltHold: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "BeltHold", got)
	})
	t.Run("Beta", func(t *testing.T) {
		ind, err := NewBeta(14)
		if err != nil {
			t.Fatalf("new Beta: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[0])}
		}
		compareGolden(t, "Beta", got)
	})
	t.Run("BetaNeutralSpread", func(t *testing.T) {
		ind, err := NewBetaNeutralSpread(14)
		if err != nil {
			t.Fatalf("new BetaNeutralSpread: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[0])}
		}
		compareGolden(t, "BetaNeutralSpread", got)
	})
	t.Run("BetterVolume", func(t *testing.T) {
		ind, err := NewBetterVolume(14)
		if err != nil {
			t.Fatalf("new BetterVolume: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "BetterVolume", got)
	})
	t.Run("BipowerVariation", func(t *testing.T) {
		ind, err := NewBipowerVariation(14)
		if err != nil {
			t.Fatalf("new BipowerVariation: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "BipowerVariation", got)
	})
	t.Run("BodySizePct", func(t *testing.T) {
		ind, err := NewBodySizePct()
		if err != nil {
			t.Fatalf("new BodySizePct: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "BodySizePct", got)
	})
	t.Run("BollingerBands", func(t *testing.T) {
		ind, err := NewBollingerBands(20, 2.0)
		if err != nil {
			t.Fatalf("new BollingerBands: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[3])
			got[i] = reflectRow(out, ok, 4)
		}
		compareGolden(t, "BollingerBands", got)
	})
	t.Run("BollingerBandwidth", func(t *testing.T) {
		ind, err := NewBollingerBandwidth(14, 2.0)
		if err != nil {
			t.Fatalf("new BollingerBandwidth: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "BollingerBandwidth", got)
	})
	t.Run("BomarBands", func(t *testing.T) {
		ind, err := NewBomarBands(4, 0.85)
		if err != nil {
			t.Fatalf("new BomarBands: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[3])
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "BomarBands", got)
	})
	t.Run("BreadthThrust", func(t *testing.T) {
		ind, err := NewBreadthThrust(10)
		if err != nil {
			t.Fatalf("new BreadthThrust: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			ch, vo, nh, nl, am, ob_ := crossLists(r)
			got[i] = []float64{ind.Update(ch, vo, nh, nl, am, ob_, int64(i))}
		}
		compareGolden(t, "BreadthThrust", got)
	})
	t.Run("Breakaway", func(t *testing.T) {
		ind, err := NewBreakaway()
		if err != nil {
			t.Fatalf("new Breakaway: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Breakaway", got)
	})
	t.Run("BullishPercentIndex", func(t *testing.T) {
		ind, err := NewBullishPercentIndex()
		if err != nil {
			t.Fatalf("new BullishPercentIndex: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			ch, vo, nh, nl, am, ob_ := crossLists(r)
			got[i] = []float64{ind.Update(ch, vo, nh, nl, am, ob_, int64(i))}
		}
		compareGolden(t, "BullishPercentIndex", got)
	})
	t.Run("BurkeRatio", func(t *testing.T) {
		ind, err := NewBurkeRatio(14)
		if err != nil {
			t.Fatalf("new BurkeRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "BurkeRatio", got)
	})
	t.Run("Butterfly", func(t *testing.T) {
		ind, err := NewButterfly()
		if err != nil {
			t.Fatalf("new Butterfly: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Butterfly", got)
	})
	t.Run("CalendarSpread", func(t *testing.T) {
		ind, err := NewCalendarSpread()
		if err != nil {
			t.Fatalf("new CalendarSpread: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			d := derivFields(r)
			got[i] = []float64{ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], int64(i))}
		}
		compareGolden(t, "CalendarSpread", got)
	})
	t.Run("CalmarRatio", func(t *testing.T) {
		ind, err := NewCalmarRatio(14)
		if err != nil {
			t.Fatalf("new CalmarRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "CalmarRatio", got)
	})
	t.Run("Camarilla", func(t *testing.T) {
		ind, err := NewCamarilla()
		if err != nil {
			t.Fatalf("new Camarilla: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 9)
		}
		compareGolden(t, "Camarilla", got)
	})
	t.Run("CandleVolume", func(t *testing.T) {
		ind, err := NewCandleVolume(14)
		if err != nil {
			t.Fatalf("new CandleVolume: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "CandleVolume", got)
	})
	t.Run("Cci", func(t *testing.T) {
		ind, err := NewCci(14)
		if err != nil {
			t.Fatalf("new Cci: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Cci", got)
	})
	t.Run("CenterOfGravity", func(t *testing.T) {
		ind, err := NewCenterOfGravity(14)
		if err != nil {
			t.Fatalf("new CenterOfGravity: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "CenterOfGravity", got)
	})
	t.Run("CentralPivotRange", func(t *testing.T) {
		ind, err := NewCentralPivotRange()
		if err != nil {
			t.Fatalf("new CentralPivotRange: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "CentralPivotRange", got)
	})
	t.Run("Cfo", func(t *testing.T) {
		ind, err := NewCfo(14)
		if err != nil {
			t.Fatalf("new Cfo: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Cfo", got)
	})
	t.Run("ChaikinMoneyFlow", func(t *testing.T) {
		ind, err := NewChaikinMoneyFlow(20)
		if err != nil {
			t.Fatalf("new ChaikinMoneyFlow: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "ChaikinMoneyFlow", got)
	})
	t.Run("ChaikinOscillator", func(t *testing.T) {
		ind, err := NewChaikinOscillator(3, 7)
		if err != nil {
			t.Fatalf("new ChaikinOscillator: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "ChaikinOscillator", got)
	})
	t.Run("ChaikinVolatility", func(t *testing.T) {
		ind, err := NewChaikinVolatility(3, 7)
		if err != nil {
			t.Fatalf("new ChaikinVolatility: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "ChaikinVolatility", got)
	})
	t.Run("ChandeKrollStop", func(t *testing.T) {
		ind, err := NewChandeKrollStop(3, 2.0, 7)
		if err != nil {
			t.Fatalf("new ChandeKrollStop: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "ChandeKrollStop", got)
	})
	t.Run("ChandelierExit", func(t *testing.T) {
		ind, err := NewChandelierExit(14, 2.0)
		if err != nil {
			t.Fatalf("new ChandelierExit: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "ChandelierExit", got)
	})
	t.Run("ChoppinessIndex", func(t *testing.T) {
		ind, err := NewChoppinessIndex(14)
		if err != nil {
			t.Fatalf("new ChoppinessIndex: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "ChoppinessIndex", got)
	})
	t.Run("ClassicPivots", func(t *testing.T) {
		ind, err := NewClassicPivots()
		if err != nil {
			t.Fatalf("new ClassicPivots: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 7)
		}
		compareGolden(t, "ClassicPivots", got)
	})
	t.Run("CloseVsOpen", func(t *testing.T) {
		ind, err := NewCloseVsOpen()
		if err != nil {
			t.Fatalf("new CloseVsOpen: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "CloseVsOpen", got)
	})
	t.Run("ClosingMarubozu", func(t *testing.T) {
		ind, err := NewClosingMarubozu()
		if err != nil {
			t.Fatalf("new ClosingMarubozu: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "ClosingMarubozu", got)
	})
	t.Run("Cmo", func(t *testing.T) {
		ind, err := NewCmo(14)
		if err != nil {
			t.Fatalf("new Cmo: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Cmo", got)
	})
	t.Run("CoefficientOfVariation", func(t *testing.T) {
		ind, err := NewCoefficientOfVariation(14)
		if err != nil {
			t.Fatalf("new CoefficientOfVariation: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "CoefficientOfVariation", got)
	})
	t.Run("Cointegration", func(t *testing.T) {
		ind, err := NewCointegration(40, 1)
		if err != nil {
			t.Fatalf("new Cointegration: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[3], r[0])
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "Cointegration", got)
	})
	t.Run("CommonSenseRatio", func(t *testing.T) {
		ind, err := NewCommonSenseRatio(14)
		if err != nil {
			t.Fatalf("new CommonSenseRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "CommonSenseRatio", got)
	})
	t.Run("CompositeProfile", func(t *testing.T) {
		ind, err := NewCompositeProfile(20, 24, 0.7)
		if err != nil {
			t.Fatalf("new CompositeProfile: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "CompositeProfile", got)
	})
	t.Run("ConcealingBabySwallow", func(t *testing.T) {
		ind, err := NewConcealingBabySwallow()
		if err != nil {
			t.Fatalf("new ConcealingBabySwallow: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "ConcealingBabySwallow", got)
	})
	t.Run("ConditionalValueAtRisk", func(t *testing.T) {
		ind, err := NewConditionalValueAtRisk(20, 0.95)
		if err != nil {
			t.Fatalf("new ConditionalValueAtRisk: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "ConditionalValueAtRisk", got)
	})
	t.Run("ConnorsRsi", func(t *testing.T) {
		ind, err := NewConnorsRsi(3, 7, 14)
		if err != nil {
			t.Fatalf("new ConnorsRsi: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "ConnorsRsi", got)
	})
	t.Run("Coppock", func(t *testing.T) {
		ind, err := NewCoppock(3, 7, 14)
		if err != nil {
			t.Fatalf("new Coppock: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Coppock", got)
	})
	t.Run("CorrelationTrendIndicator", func(t *testing.T) {
		ind, err := NewCorrelationTrendIndicator(14)
		if err != nil {
			t.Fatalf("new CorrelationTrendIndicator: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "CorrelationTrendIndicator", got)
	})
	t.Run("Counterattack", func(t *testing.T) {
		ind, err := NewCounterattack()
		if err != nil {
			t.Fatalf("new Counterattack: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Counterattack", got)
	})
	t.Run("Crab", func(t *testing.T) {
		ind, err := NewCrab()
		if err != nil {
			t.Fatalf("new Crab: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Crab", got)
	})
	t.Run("CumulativeVolumeDelta", func(t *testing.T) {
		ind, err := NewCumulativeVolumeDelta()
		if err != nil {
			t.Fatalf("new CumulativeVolumeDelta: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[4], r[3] >= r[0], int64(i))}
		}
		compareGolden(t, "CumulativeVolumeDelta", got)
	})
	t.Run("CumulativeVolumeIndex", func(t *testing.T) {
		ind, err := NewCumulativeVolumeIndex()
		if err != nil {
			t.Fatalf("new CumulativeVolumeIndex: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			ch, vo, nh, nl, am, ob_ := crossLists(r)
			got[i] = []float64{ind.Update(ch, vo, nh, nl, am, ob_, int64(i))}
		}
		compareGolden(t, "CumulativeVolumeIndex", got)
	})
	t.Run("CupAndHandle", func(t *testing.T) {
		ind, err := NewCupAndHandle()
		if err != nil {
			t.Fatalf("new CupAndHandle: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "CupAndHandle", got)
	})
	t.Run("CyberneticCycle", func(t *testing.T) {
		ind, err := NewCyberneticCycle(14)
		if err != nil {
			t.Fatalf("new CyberneticCycle: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "CyberneticCycle", got)
	})
	t.Run("Cypher", func(t *testing.T) {
		ind, err := NewCypher()
		if err != nil {
			t.Fatalf("new Cypher: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Cypher", got)
	})
	t.Run("DayOfWeekProfile", func(t *testing.T) {
		ind, err := NewDayOfWeekProfile(0)
		if err != nil {
			t.Fatalf("new DayOfWeekProfile: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			bins, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			if ok {
				got[i] = bins
			} else {
				got[i] = nanRow(7)
			}
		}
		compareGolden(t, "DayOfWeekProfile", got)
	})
	t.Run("Decycler", func(t *testing.T) {
		ind, err := NewDecycler(14)
		if err != nil {
			t.Fatalf("new Decycler: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Decycler", got)
	})
	t.Run("DecyclerOscillator", func(t *testing.T) {
		ind, err := NewDecyclerOscillator(3, 7)
		if err != nil {
			t.Fatalf("new DecyclerOscillator: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "DecyclerOscillator", got)
	})
	t.Run("Dema", func(t *testing.T) {
		ind, err := NewDema(14)
		if err != nil {
			t.Fatalf("new Dema: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Dema", got)
	})
	t.Run("DemandIndex", func(t *testing.T) {
		ind, err := NewDemandIndex(14)
		if err != nil {
			t.Fatalf("new DemandIndex: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "DemandIndex", got)
	})
	t.Run("DemarkPivots", func(t *testing.T) {
		ind, err := NewDemarkPivots()
		if err != nil {
			t.Fatalf("new DemarkPivots: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "DemarkPivots", got)
	})
	t.Run("DepthSlope", func(t *testing.T) {
		ind, err := NewDepthSlope()
		if err != nil {
			t.Fatalf("new DepthSlope: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			bp, bs, ap, as_ := obLists(r)
			got[i] = []float64{ind.Update(bp, bs, ap, as_)}
		}
		compareGolden(t, "DepthSlope", got)
	})
	t.Run("DerivativeOscillator", func(t *testing.T) {
		ind, err := NewDerivativeOscillator(3, 7, 14, 28)
		if err != nil {
			t.Fatalf("new DerivativeOscillator: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "DerivativeOscillator", got)
	})
	t.Run("DetrendedStdDev", func(t *testing.T) {
		ind, err := NewDetrendedStdDev(14)
		if err != nil {
			t.Fatalf("new DetrendedStdDev: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "DetrendedStdDev", got)
	})
	t.Run("DisparityIndex", func(t *testing.T) {
		ind, err := NewDisparityIndex(14)
		if err != nil {
			t.Fatalf("new DisparityIndex: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "DisparityIndex", got)
	})
	t.Run("DistanceSsd", func(t *testing.T) {
		ind, err := NewDistanceSsd(14)
		if err != nil {
			t.Fatalf("new DistanceSsd: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[0])}
		}
		compareGolden(t, "DistanceSsd", got)
	})
	t.Run("Doji", func(t *testing.T) {
		ind, err := NewDoji()
		if err != nil {
			t.Fatalf("new Doji: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Doji", got)
	})
	t.Run("DojiStar", func(t *testing.T) {
		ind, err := NewDojiStar()
		if err != nil {
			t.Fatalf("new DojiStar: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "DojiStar", got)
	})
	t.Run("DollarBars", func(t *testing.T) {
		ind, err := NewDollarBars(50000.0)
		if err != nil {
			t.Fatalf("new DollarBars: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = flattenBars(ind.Update(r[0], r[1], r[2], r[3], r[4], 0))
		}
		compareGolden(t, "DollarBars", got)
	})
	t.Run("Donchian", func(t *testing.T) {
		ind, err := NewDonchian(14)
		if err != nil {
			t.Fatalf("new Donchian: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "Donchian", got)
	})
	t.Run("DonchianStop", func(t *testing.T) {
		ind, err := NewDonchianStop(14)
		if err != nil {
			t.Fatalf("new DonchianStop: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "DonchianStop", got)
	})
	t.Run("DoubleBollinger", func(t *testing.T) {
		ind, err := NewDoubleBollinger(20, 1.0, 2.0)
		if err != nil {
			t.Fatalf("new DoubleBollinger: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[3])
			got[i] = reflectRow(out, ok, 5)
		}
		compareGolden(t, "DoubleBollinger", got)
	})
	t.Run("DoubleTopBottom", func(t *testing.T) {
		ind, err := NewDoubleTopBottom()
		if err != nil {
			t.Fatalf("new DoubleTopBottom: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "DoubleTopBottom", got)
	})
	t.Run("DownsideGapThreeMethods", func(t *testing.T) {
		ind, err := NewDownsideGapThreeMethods()
		if err != nil {
			t.Fatalf("new DownsideGapThreeMethods: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "DownsideGapThreeMethods", got)
	})
	t.Run("Dpo", func(t *testing.T) {
		ind, err := NewDpo(14)
		if err != nil {
			t.Fatalf("new Dpo: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Dpo", got)
	})
	t.Run("DragonflyDoji", func(t *testing.T) {
		ind, err := NewDragonflyDoji()
		if err != nil {
			t.Fatalf("new DragonflyDoji: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "DragonflyDoji", got)
	})
	t.Run("DrawdownDuration", func(t *testing.T) {
		ind, err := NewDrawdownDuration()
		if err != nil {
			t.Fatalf("new DrawdownDuration: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "DrawdownDuration", got)
	})
	t.Run("DumplingTop", func(t *testing.T) {
		ind, err := NewDumplingTop(14)
		if err != nil {
			t.Fatalf("new DumplingTop: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "DumplingTop", got)
	})
	t.Run("Dx", func(t *testing.T) {
		ind, err := NewDx(14)
		if err != nil {
			t.Fatalf("new Dx: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Dx", got)
	})
	t.Run("DynamicMomentumIndex", func(t *testing.T) {
		ind, err := NewDynamicMomentumIndex(14)
		if err != nil {
			t.Fatalf("new DynamicMomentumIndex: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "DynamicMomentumIndex", got)
	})
	t.Run("EaseOfMovement", func(t *testing.T) {
		ind, err := NewEaseOfMovement(14)
		if err != nil {
			t.Fatalf("new EaseOfMovement: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "EaseOfMovement", got)
	})
	t.Run("EffectiveSpread", func(t *testing.T) {
		ind, err := NewEffectiveSpread()
		if err != nil {
			t.Fatalf("new EffectiveSpread: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[4], r[3] >= r[0], int64(i), (r[1]+r[2])/2)}
		}
		compareGolden(t, "EffectiveSpread", got)
	})
	t.Run("EhlersStochastic", func(t *testing.T) {
		ind, err := NewEhlersStochastic(14)
		if err != nil {
			t.Fatalf("new EhlersStochastic: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "EhlersStochastic", got)
	})
	t.Run("Ehma", func(t *testing.T) {
		ind, err := NewEhma(14)
		if err != nil {
			t.Fatalf("new Ehma: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Ehma", got)
	})
	t.Run("ElderImpulse", func(t *testing.T) {
		ind, err := NewElderImpulse(3, 7, 14, 28)
		if err != nil {
			t.Fatalf("new ElderImpulse: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "ElderImpulse", got)
	})
	t.Run("ElderRay", func(t *testing.T) {
		ind, err := NewElderRay(14)
		if err != nil {
			t.Fatalf("new ElderRay: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "ElderRay", got)
	})
	t.Run("ElderSafeZone", func(t *testing.T) {
		ind, err := NewElderSafeZone(10, 2.0)
		if err != nil {
			t.Fatalf("new ElderSafeZone: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "ElderSafeZone", got)
	})
	t.Run("Ema", func(t *testing.T) {
		ind, err := NewEma(14)
		if err != nil {
			t.Fatalf("new Ema: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Ema", got)
	})
	t.Run("EmpiricalModeDecomposition", func(t *testing.T) {
		ind, err := NewEmpiricalModeDecomposition(20, 0.1)
		if err != nil {
			t.Fatalf("new EmpiricalModeDecomposition: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "EmpiricalModeDecomposition", got)
	})
	t.Run("Engulfing", func(t *testing.T) {
		ind, err := NewEngulfing()
		if err != nil {
			t.Fatalf("new Engulfing: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Engulfing", got)
	})
	t.Run("Equivolume", func(t *testing.T) {
		ind, err := NewEquivolume(14)
		if err != nil {
			t.Fatalf("new Equivolume: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "Equivolume", got)
	})
	t.Run("EstimatedLeverageRatio", func(t *testing.T) {
		ind, err := NewEstimatedLeverageRatio()
		if err != nil {
			t.Fatalf("new EstimatedLeverageRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			d := derivFields(r)
			got[i] = []float64{ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], int64(i))}
		}
		compareGolden(t, "EstimatedLeverageRatio", got)
	})
	t.Run("EvenBetterSinewave", func(t *testing.T) {
		ind, err := NewEvenBetterSinewave(40, 10)
		if err != nil {
			t.Fatalf("new EvenBetterSinewave: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "EvenBetterSinewave", got)
	})
	t.Run("EveningDojiStar", func(t *testing.T) {
		ind, err := NewEveningDojiStar()
		if err != nil {
			t.Fatalf("new EveningDojiStar: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "EveningDojiStar", got)
	})
	t.Run("Evwma", func(t *testing.T) {
		ind, err := NewEvwma(14)
		if err != nil {
			t.Fatalf("new Evwma: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Evwma", got)
	})
	t.Run("EwmaVolatility", func(t *testing.T) {
		ind, err := NewEwmaVolatility(0.94)
		if err != nil {
			t.Fatalf("new EwmaVolatility: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "EwmaVolatility", got)
	})
	t.Run("Expectancy", func(t *testing.T) {
		ind, err := NewExpectancy(14)
		if err != nil {
			t.Fatalf("new Expectancy: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Expectancy", got)
	})
	t.Run("FallingThreeMethods", func(t *testing.T) {
		ind, err := NewFallingThreeMethods()
		if err != nil {
			t.Fatalf("new FallingThreeMethods: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "FallingThreeMethods", got)
	})
	t.Run("Fama", func(t *testing.T) {
		ind, err := NewFama(0.5, 0.05)
		if err != nil {
			t.Fatalf("new Fama: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Fama", got)
	})
	t.Run("FibArcs", func(t *testing.T) {
		ind, err := NewFibArcs()
		if err != nil {
			t.Fatalf("new FibArcs: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "FibArcs", got)
	})
	t.Run("FibChannel", func(t *testing.T) {
		ind, err := NewFibChannel()
		if err != nil {
			t.Fatalf("new FibChannel: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 4)
		}
		compareGolden(t, "FibChannel", got)
	})
	t.Run("FibConfluence", func(t *testing.T) {
		ind, err := NewFibConfluence()
		if err != nil {
			t.Fatalf("new FibConfluence: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "FibConfluence", got)
	})
	t.Run("FibExtension", func(t *testing.T) {
		ind, err := NewFibExtension()
		if err != nil {
			t.Fatalf("new FibExtension: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 5)
		}
		compareGolden(t, "FibExtension", got)
	})
	t.Run("FibFan", func(t *testing.T) {
		ind, err := NewFibFan()
		if err != nil {
			t.Fatalf("new FibFan: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "FibFan", got)
	})
	t.Run("FibProjection", func(t *testing.T) {
		ind, err := NewFibProjection()
		if err != nil {
			t.Fatalf("new FibProjection: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 4)
		}
		compareGolden(t, "FibProjection", got)
	})
	t.Run("FibRetracement", func(t *testing.T) {
		ind, err := NewFibRetracement()
		if err != nil {
			t.Fatalf("new FibRetracement: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 7)
		}
		compareGolden(t, "FibRetracement", got)
	})
	t.Run("FibTimeZones", func(t *testing.T) {
		ind, err := NewFibTimeZones()
		if err != nil {
			t.Fatalf("new FibTimeZones: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "FibTimeZones", got)
	})
	t.Run("FibonacciPivots", func(t *testing.T) {
		ind, err := NewFibonacciPivots()
		if err != nil {
			t.Fatalf("new FibonacciPivots: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 7)
		}
		compareGolden(t, "FibonacciPivots", got)
	})
	t.Run("FisherRsi", func(t *testing.T) {
		ind, err := NewFisherRsi(14)
		if err != nil {
			t.Fatalf("new FisherRsi: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "FisherRsi", got)
	})
	t.Run("FisherTransform", func(t *testing.T) {
		ind, err := NewFisherTransform(14)
		if err != nil {
			t.Fatalf("new FisherTransform: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "FisherTransform", got)
	})
	t.Run("FlagPennant", func(t *testing.T) {
		ind, err := NewFlagPennant()
		if err != nil {
			t.Fatalf("new FlagPennant: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "FlagPennant", got)
	})
	t.Run("Footprint", func(t *testing.T) {
		ind, err := NewFootprint(1.0)
		if err != nil {
			t.Fatalf("new Footprint: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = flattenBars(ind.Update(r[3], r[4], r[3] >= r[0], int64(i)))
		}
		compareGolden(t, "Footprint", got)
	})
	t.Run("ForceIndex", func(t *testing.T) {
		ind, err := NewForceIndex(14)
		if err != nil {
			t.Fatalf("new ForceIndex: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "ForceIndex", got)
	})
	t.Run("FractalChaosBands", func(t *testing.T) {
		ind, err := NewFractalChaosBands(14)
		if err != nil {
			t.Fatalf("new FractalChaosBands: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "FractalChaosBands", got)
	})
	t.Run("Frama", func(t *testing.T) {
		ind, err := NewFrama(14)
		if err != nil {
			t.Fatalf("new Frama: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Frama", got)
	})
	t.Run("FryPanBottom", func(t *testing.T) {
		ind, err := NewFryPanBottom(14)
		if err != nil {
			t.Fatalf("new FryPanBottom: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "FryPanBottom", got)
	})
	t.Run("FundingBasis", func(t *testing.T) {
		ind, err := NewFundingBasis()
		if err != nil {
			t.Fatalf("new FundingBasis: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			d := derivFields(r)
			got[i] = []float64{ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], int64(i))}
		}
		compareGolden(t, "FundingBasis", got)
	})
	t.Run("FundingImpliedApr", func(t *testing.T) {
		ind, err := NewFundingImpliedApr(1095.0)
		if err != nil {
			t.Fatalf("new FundingImpliedApr: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			d := derivFields(r)
			got[i] = []float64{ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], int64(i))}
		}
		compareGolden(t, "FundingImpliedApr", got)
	})
	t.Run("FundingRate", func(t *testing.T) {
		ind, err := NewFundingRate()
		if err != nil {
			t.Fatalf("new FundingRate: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			d := derivFields(r)
			got[i] = []float64{ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], int64(i))}
		}
		compareGolden(t, "FundingRate", got)
	})
	t.Run("FundingRateMean", func(t *testing.T) {
		ind, err := NewFundingRateMean(20)
		if err != nil {
			t.Fatalf("new FundingRateMean: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			d := derivFields(r)
			got[i] = []float64{ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], int64(i))}
		}
		compareGolden(t, "FundingRateMean", got)
	})
	t.Run("FundingRateZScore", func(t *testing.T) {
		ind, err := NewFundingRateZScore(20)
		if err != nil {
			t.Fatalf("new FundingRateZScore: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			d := derivFields(r)
			got[i] = []float64{ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], int64(i))}
		}
		compareGolden(t, "FundingRateZScore", got)
	})
	t.Run("GainLossRatio", func(t *testing.T) {
		ind, err := NewGainLossRatio(14)
		if err != nil {
			t.Fatalf("new GainLossRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "GainLossRatio", got)
	})
	t.Run("GainToPainRatio", func(t *testing.T) {
		ind, err := NewGainToPainRatio(14)
		if err != nil {
			t.Fatalf("new GainToPainRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "GainToPainRatio", got)
	})
	t.Run("GapSideBySideWhite", func(t *testing.T) {
		ind, err := NewGapSideBySideWhite()
		if err != nil {
			t.Fatalf("new GapSideBySideWhite: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "GapSideBySideWhite", got)
	})
	t.Run("Garch11", func(t *testing.T) {
		ind, err := NewGarch11(2e-06, 0.1, 0.88)
		if err != nil {
			t.Fatalf("new Garch11: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Garch11", got)
	})
	t.Run("GarmanKlassVolatility", func(t *testing.T) {
		ind, err := NewGarmanKlassVolatility(20, 252)
		if err != nil {
			t.Fatalf("new GarmanKlassVolatility: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "GarmanKlassVolatility", got)
	})
	t.Run("Gartley", func(t *testing.T) {
		ind, err := NewGartley()
		if err != nil {
			t.Fatalf("new Gartley: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Gartley", got)
	})
	t.Run("GatorOscillator", func(t *testing.T) {
		ind, err := NewGatorOscillator(3, 7, 14)
		if err != nil {
			t.Fatalf("new GatorOscillator: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "GatorOscillator", got)
	})
	t.Run("GeneralizedDema", func(t *testing.T) {
		ind, err := NewGeneralizedDema(5, 0.7)
		if err != nil {
			t.Fatalf("new GeneralizedDema: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "GeneralizedDema", got)
	})
	t.Run("GeometricMa", func(t *testing.T) {
		ind, err := NewGeometricMa(14)
		if err != nil {
			t.Fatalf("new GeometricMa: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "GeometricMa", got)
	})
	t.Run("GoldenPocket", func(t *testing.T) {
		ind, err := NewGoldenPocket()
		if err != nil {
			t.Fatalf("new GoldenPocket: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "GoldenPocket", got)
	})
	t.Run("GrangerCausality", func(t *testing.T) {
		ind, err := NewGrangerCausality(60, 1)
		if err != nil {
			t.Fatalf("new GrangerCausality: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[0])}
		}
		compareGolden(t, "GrangerCausality", got)
	})
	t.Run("GravestoneDoji", func(t *testing.T) {
		ind, err := NewGravestoneDoji()
		if err != nil {
			t.Fatalf("new GravestoneDoji: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "GravestoneDoji", got)
	})
	t.Run("Hammer", func(t *testing.T) {
		ind, err := NewHammer()
		if err != nil {
			t.Fatalf("new Hammer: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Hammer", got)
	})
	t.Run("HangingMan", func(t *testing.T) {
		ind, err := NewHangingMan()
		if err != nil {
			t.Fatalf("new HangingMan: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "HangingMan", got)
	})
	t.Run("Harami", func(t *testing.T) {
		ind, err := NewHarami()
		if err != nil {
			t.Fatalf("new Harami: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Harami", got)
	})
	t.Run("HaramiCross", func(t *testing.T) {
		ind, err := NewHaramiCross()
		if err != nil {
			t.Fatalf("new HaramiCross: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "HaramiCross", got)
	})
	t.Run("HasbrouckInformationShare", func(t *testing.T) {
		ind, err := NewHasbrouckInformationShare(14)
		if err != nil {
			t.Fatalf("new HasbrouckInformationShare: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[0])}
		}
		compareGolden(t, "HasbrouckInformationShare", got)
	})
	t.Run("HeadAndShoulders", func(t *testing.T) {
		ind, err := NewHeadAndShoulders()
		if err != nil {
			t.Fatalf("new HeadAndShoulders: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "HeadAndShoulders", got)
	})
	t.Run("HeikinAshi", func(t *testing.T) {
		ind, err := NewHeikinAshi()
		if err != nil {
			t.Fatalf("new HeikinAshi: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 4)
		}
		compareGolden(t, "HeikinAshi", got)
	})
	t.Run("HeikinAshiOscillator", func(t *testing.T) {
		ind, err := NewHeikinAshiOscillator(14)
		if err != nil {
			t.Fatalf("new HeikinAshiOscillator: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "HeikinAshiOscillator", got)
	})
	t.Run("HiLoActivator", func(t *testing.T) {
		ind, err := NewHiLoActivator(14)
		if err != nil {
			t.Fatalf("new HiLoActivator: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "HiLoActivator", got)
	})
	t.Run("HighLowIndex", func(t *testing.T) {
		ind, err := NewHighLowIndex(10)
		if err != nil {
			t.Fatalf("new HighLowIndex: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			ch, vo, nh, nl, am, ob_ := crossLists(r)
			got[i] = []float64{ind.Update(ch, vo, nh, nl, am, ob_, int64(i))}
		}
		compareGolden(t, "HighLowIndex", got)
	})
	t.Run("HighLowRange", func(t *testing.T) {
		ind, err := NewHighLowRange()
		if err != nil {
			t.Fatalf("new HighLowRange: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "HighLowRange", got)
	})
	t.Run("HighLowVolumeNodes", func(t *testing.T) {
		ind, err := NewHighLowVolumeNodes(3, 7)
		if err != nil {
			t.Fatalf("new HighLowVolumeNodes: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "HighLowVolumeNodes", got)
	})
	t.Run("HighWave", func(t *testing.T) {
		ind, err := NewHighWave()
		if err != nil {
			t.Fatalf("new HighWave: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "HighWave", got)
	})
	t.Run("HighpassFilter", func(t *testing.T) {
		ind, err := NewHighpassFilter(14)
		if err != nil {
			t.Fatalf("new HighpassFilter: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "HighpassFilter", got)
	})
	t.Run("Hikkake", func(t *testing.T) {
		ind, err := NewHikkake()
		if err != nil {
			t.Fatalf("new Hikkake: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Hikkake", got)
	})
	t.Run("HikkakeModified", func(t *testing.T) {
		ind, err := NewHikkakeModified()
		if err != nil {
			t.Fatalf("new HikkakeModified: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "HikkakeModified", got)
	})
	t.Run("HilbertDominantCycle", func(t *testing.T) {
		ind, err := NewHilbertDominantCycle()
		if err != nil {
			t.Fatalf("new HilbertDominantCycle: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "HilbertDominantCycle", got)
	})
	t.Run("HistoricalVolatility", func(t *testing.T) {
		ind, err := NewHistoricalVolatility(3, 7)
		if err != nil {
			t.Fatalf("new HistoricalVolatility: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "HistoricalVolatility", got)
	})
	t.Run("Hma", func(t *testing.T) {
		ind, err := NewHma(14)
		if err != nil {
			t.Fatalf("new Hma: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Hma", got)
	})
	t.Run("HoltWinters", func(t *testing.T) {
		ind, err := NewHoltWinters(0.5, 0.1)
		if err != nil {
			t.Fatalf("new HoltWinters: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "HoltWinters", got)
	})
	t.Run("HomingPigeon", func(t *testing.T) {
		ind, err := NewHomingPigeon()
		if err != nil {
			t.Fatalf("new HomingPigeon: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "HomingPigeon", got)
	})
	t.Run("HtDcPhase", func(t *testing.T) {
		ind, err := NewHtDcPhase()
		if err != nil {
			t.Fatalf("new HtDcPhase: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "HtDcPhase", got)
	})
	t.Run("HtPhasor", func(t *testing.T) {
		ind, err := NewHtPhasor()
		if err != nil {
			t.Fatalf("new HtPhasor: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[3])
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "HtPhasor", got)
	})
	t.Run("HtTrendMode", func(t *testing.T) {
		ind, err := NewHtTrendMode()
		if err != nil {
			t.Fatalf("new HtTrendMode: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "HtTrendMode", got)
	})
	t.Run("HurstChannel", func(t *testing.T) {
		ind, err := NewHurstChannel(14, 2.0)
		if err != nil {
			t.Fatalf("new HurstChannel: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "HurstChannel", got)
	})
	t.Run("HurstExponent", func(t *testing.T) {
		ind, err := NewHurstExponent(100, 4)
		if err != nil {
			t.Fatalf("new HurstExponent: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "HurstExponent", got)
	})
	t.Run("Ichimoku", func(t *testing.T) {
		ind, err := NewIchimoku(9, 26, 52, 26)
		if err != nil {
			t.Fatalf("new Ichimoku: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 5)
		}
		compareGolden(t, "Ichimoku", got)
	})
	t.Run("IdenticalThreeCrows", func(t *testing.T) {
		ind, err := NewIdenticalThreeCrows()
		if err != nil {
			t.Fatalf("new IdenticalThreeCrows: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "IdenticalThreeCrows", got)
	})
	t.Run("ImbalanceBars", func(t *testing.T) {
		ind, err := NewImbalanceBars(5.0)
		if err != nil {
			t.Fatalf("new ImbalanceBars: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = flattenBars(ind.Update(r[0], r[1], r[2], r[3], 1.0, 0))
		}
		compareGolden(t, "ImbalanceBars", got)
	})
	t.Run("InNeck", func(t *testing.T) {
		ind, err := NewInNeck()
		if err != nil {
			t.Fatalf("new InNeck: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "InNeck", got)
	})
	t.Run("Inertia", func(t *testing.T) {
		ind, err := NewInertia(3, 7)
		if err != nil {
			t.Fatalf("new Inertia: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Inertia", got)
	})
	t.Run("InformationRatio", func(t *testing.T) {
		ind, err := NewInformationRatio(14)
		if err != nil {
			t.Fatalf("new InformationRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[0])}
		}
		compareGolden(t, "InformationRatio", got)
	})
	t.Run("InitialBalance", func(t *testing.T) {
		ind, err := NewInitialBalance(14)
		if err != nil {
			t.Fatalf("new InitialBalance: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "InitialBalance", got)
	})
	t.Run("InstantaneousTrendline", func(t *testing.T) {
		ind, err := NewInstantaneousTrendline(14)
		if err != nil {
			t.Fatalf("new InstantaneousTrendline: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "InstantaneousTrendline", got)
	})
	t.Run("IntradayIntensity", func(t *testing.T) {
		ind, err := NewIntradayIntensity()
		if err != nil {
			t.Fatalf("new IntradayIntensity: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "IntradayIntensity", got)
	})
	t.Run("IntradayMomentumIndex", func(t *testing.T) {
		ind, err := NewIntradayMomentumIndex(14)
		if err != nil {
			t.Fatalf("new IntradayMomentumIndex: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "IntradayMomentumIndex", got)
	})
	t.Run("IntradayVolatilityProfile", func(t *testing.T) {
		ind, err := NewIntradayVolatilityProfile(24, 0)
		if err != nil {
			t.Fatalf("new IntradayVolatilityProfile: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			bins, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			if ok {
				got[i] = bins
			} else {
				got[i] = nanRow(24)
			}
		}
		compareGolden(t, "IntradayVolatilityProfile", got)
	})
	t.Run("InverseFisherTransform", func(t *testing.T) {
		ind, err := NewInverseFisherTransform(2.0)
		if err != nil {
			t.Fatalf("new InverseFisherTransform: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "InverseFisherTransform", got)
	})
	t.Run("InvertedHammer", func(t *testing.T) {
		ind, err := NewInvertedHammer()
		if err != nil {
			t.Fatalf("new InvertedHammer: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "InvertedHammer", got)
	})
	t.Run("JarqueBera", func(t *testing.T) {
		ind, err := NewJarqueBera(14)
		if err != nil {
			t.Fatalf("new JarqueBera: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "JarqueBera", got)
	})
	t.Run("Jma", func(t *testing.T) {
		ind, err := NewJma(7, 0.0, 2.0)
		if err != nil {
			t.Fatalf("new Jma: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Jma", got)
	})
	t.Run("JumpIndicator", func(t *testing.T) {
		ind, err := NewJumpIndicator(14, 2.0)
		if err != nil {
			t.Fatalf("new JumpIndicator: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "JumpIndicator", got)
	})
	t.Run("KRatio", func(t *testing.T) {
		ind, err := NewKRatio(14)
		if err != nil {
			t.Fatalf("new KRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "KRatio", got)
	})
	t.Run("KagiBars", func(t *testing.T) {
		ind, err := NewKagiBars(2.0)
		if err != nil {
			t.Fatalf("new KagiBars: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = flattenBars(ind.Update(r[3], r[3], r[3], r[3], 1.0, 0))
		}
		compareGolden(t, "KagiBars", got)
	})
	t.Run("KalmanHedgeRatio", func(t *testing.T) {
		ind, err := NewKalmanHedgeRatio(0.01, 0.001)
		if err != nil {
			t.Fatalf("new KalmanHedgeRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[3], r[0])
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "KalmanHedgeRatio", got)
	})
	t.Run("Kama", func(t *testing.T) {
		ind, err := NewKama(3, 7, 14)
		if err != nil {
			t.Fatalf("new Kama: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Kama", got)
	})
	t.Run("KaseDevStop", func(t *testing.T) {
		ind, err := NewKaseDevStop(14, 2.0)
		if err != nil {
			t.Fatalf("new KaseDevStop: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "KaseDevStop", got)
	})
	t.Run("KasePermissionStochastic", func(t *testing.T) {
		ind, err := NewKasePermissionStochastic(3, 7)
		if err != nil {
			t.Fatalf("new KasePermissionStochastic: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "KasePermissionStochastic", got)
	})
	t.Run("KellyCriterion", func(t *testing.T) {
		ind, err := NewKellyCriterion(14)
		if err != nil {
			t.Fatalf("new KellyCriterion: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "KellyCriterion", got)
	})
	t.Run("Keltner", func(t *testing.T) {
		ind, err := NewKeltner(3, 7, 2.0)
		if err != nil {
			t.Fatalf("new Keltner: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "Keltner", got)
	})
	t.Run("KendallTau", func(t *testing.T) {
		ind, err := NewKendallTau(14)
		if err != nil {
			t.Fatalf("new KendallTau: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[0])}
		}
		compareGolden(t, "KendallTau", got)
	})
	t.Run("Kicking", func(t *testing.T) {
		ind, err := NewKicking()
		if err != nil {
			t.Fatalf("new Kicking: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Kicking", got)
	})
	t.Run("KickingByLength", func(t *testing.T) {
		ind, err := NewKickingByLength()
		if err != nil {
			t.Fatalf("new KickingByLength: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "KickingByLength", got)
	})
	t.Run("Kst", func(t *testing.T) {
		ind, err := NewKst(3, 7, 14, 28, 35, 42, 56, 63, 70)
		if err != nil {
			t.Fatalf("new Kst: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[3])
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "Kst", got)
	})
	t.Run("Kurtosis", func(t *testing.T) {
		ind, err := NewKurtosis(14)
		if err != nil {
			t.Fatalf("new Kurtosis: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Kurtosis", got)
	})
	t.Run("Kvo", func(t *testing.T) {
		ind, err := NewKvo(3, 7)
		if err != nil {
			t.Fatalf("new Kvo: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Kvo", got)
	})
	t.Run("KylesLambda", func(t *testing.T) {
		ind, err := NewKylesLambda(20)
		if err != nil {
			t.Fatalf("new KylesLambda: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[4], r[3] >= r[0], int64(i), (r[1]+r[2])/2)}
		}
		compareGolden(t, "KylesLambda", got)
	})
	t.Run("LadderBottom", func(t *testing.T) {
		ind, err := NewLadderBottom()
		if err != nil {
			t.Fatalf("new LadderBottom: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "LadderBottom", got)
	})
	t.Run("LaguerreRsi", func(t *testing.T) {
		ind, err := NewLaguerreRsi(0.5)
		if err != nil {
			t.Fatalf("new LaguerreRsi: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "LaguerreRsi", got)
	})
	t.Run("LeadLagCrossCorrelation", func(t *testing.T) {
		ind, err := NewLeadLagCrossCorrelation(20, 10)
		if err != nil {
			t.Fatalf("new LeadLagCrossCorrelation: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[3], r[0])
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "LeadLagCrossCorrelation", got)
	})
	t.Run("LinRegAngle", func(t *testing.T) {
		ind, err := NewLinRegAngle(14)
		if err != nil {
			t.Fatalf("new LinRegAngle: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "LinRegAngle", got)
	})
	t.Run("LinRegChannel", func(t *testing.T) {
		ind, err := NewLinRegChannel(14, 2.0)
		if err != nil {
			t.Fatalf("new LinRegChannel: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[3])
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "LinRegChannel", got)
	})
	t.Run("LinRegIntercept", func(t *testing.T) {
		ind, err := NewLinRegIntercept(14)
		if err != nil {
			t.Fatalf("new LinRegIntercept: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "LinRegIntercept", got)
	})
	t.Run("LinRegSlope", func(t *testing.T) {
		ind, err := NewLinRegSlope(14)
		if err != nil {
			t.Fatalf("new LinRegSlope: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "LinRegSlope", got)
	})
	t.Run("LinearRegression", func(t *testing.T) {
		ind, err := NewLinearRegression(14)
		if err != nil {
			t.Fatalf("new LinearRegression: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "LinearRegression", got)
	})
	t.Run("LiquidationFeatures", func(t *testing.T) {
		ind, err := NewLiquidationFeatures()
		if err != nil {
			t.Fatalf("new LiquidationFeatures: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			d := derivFields(r)
			out, ok := ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], int64(i))
			got[i] = reflectRow(out, ok, 5)
		}
		compareGolden(t, "LiquidationFeatures", got)
	})
	t.Run("LogReturn", func(t *testing.T) {
		ind, err := NewLogReturn(14)
		if err != nil {
			t.Fatalf("new LogReturn: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "LogReturn", got)
	})
	t.Run("LongLeggedDoji", func(t *testing.T) {
		ind, err := NewLongLeggedDoji()
		if err != nil {
			t.Fatalf("new LongLeggedDoji: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "LongLeggedDoji", got)
	})
	t.Run("LongLine", func(t *testing.T) {
		ind, err := NewLongLine()
		if err != nil {
			t.Fatalf("new LongLine: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "LongLine", got)
	})
	t.Run("LongShortRatio", func(t *testing.T) {
		ind, err := NewLongShortRatio()
		if err != nil {
			t.Fatalf("new LongShortRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			d := derivFields(r)
			got[i] = []float64{ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], int64(i))}
		}
		compareGolden(t, "LongShortRatio", got)
	})
	t.Run("M2Measure", func(t *testing.T) {
		ind, err := NewM2Measure(14, 2.0, 0.5)
		if err != nil {
			t.Fatalf("new M2Measure: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "M2Measure", got)
	})
	t.Run("MaEnvelope", func(t *testing.T) {
		ind, err := NewMaEnvelope(14, 2.0)
		if err != nil {
			t.Fatalf("new MaEnvelope: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[3])
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "MaEnvelope", got)
	})
	t.Run("MacdExt", func(t *testing.T) {
		ind, err := NewMacdExt(12, 0.0, 26, 0.0, 9, 0.0)
		if err != nil {
			t.Fatalf("new MacdExt: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[3])
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "MacdExt", got)
	})
	t.Run("MacdFix", func(t *testing.T) {
		ind, err := NewMacdFix(9)
		if err != nil {
			t.Fatalf("new MacdFix: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[3])
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "MacdFix", got)
	})
	t.Run("MacdHistogram", func(t *testing.T) {
		ind, err := NewMacdHistogram(3, 7, 14)
		if err != nil {
			t.Fatalf("new MacdHistogram: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "MacdHistogram", got)
	})
	t.Run("MacdIndicator", func(t *testing.T) {
		ind, err := NewMacdIndicator(12, 26, 9)
		if err != nil {
			t.Fatalf("new MacdIndicator: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[3])
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "MacdIndicator", got)
	})
	t.Run("Mama", func(t *testing.T) {
		ind, err := NewMama(0.5, 0.05)
		if err != nil {
			t.Fatalf("new Mama: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[3])
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "Mama", got)
	})
	t.Run("MarketFacilitationIndex", func(t *testing.T) {
		ind, err := NewMarketFacilitationIndex()
		if err != nil {
			t.Fatalf("new MarketFacilitationIndex: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "MarketFacilitationIndex", got)
	})
	t.Run("MartinRatio", func(t *testing.T) {
		ind, err := NewMartinRatio(14)
		if err != nil {
			t.Fatalf("new MartinRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "MartinRatio", got)
	})
	t.Run("Marubozu", func(t *testing.T) {
		ind, err := NewMarubozu()
		if err != nil {
			t.Fatalf("new Marubozu: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Marubozu", got)
	})
	t.Run("MassIndex", func(t *testing.T) {
		ind, err := NewMassIndex(3, 7)
		if err != nil {
			t.Fatalf("new MassIndex: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "MassIndex", got)
	})
	t.Run("MatHold", func(t *testing.T) {
		ind, err := NewMatHold()
		if err != nil {
			t.Fatalf("new MatHold: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "MatHold", got)
	})
	t.Run("MatchingLow", func(t *testing.T) {
		ind, err := NewMatchingLow()
		if err != nil {
			t.Fatalf("new MatchingLow: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "MatchingLow", got)
	})
	t.Run("MaxDrawdown", func(t *testing.T) {
		ind, err := NewMaxDrawdown(14)
		if err != nil {
			t.Fatalf("new MaxDrawdown: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "MaxDrawdown", got)
	})
	t.Run("McClellanOscillator", func(t *testing.T) {
		ind, err := NewMcClellanOscillator()
		if err != nil {
			t.Fatalf("new McClellanOscillator: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			ch, vo, nh, nl, am, ob_ := crossLists(r)
			got[i] = []float64{ind.Update(ch, vo, nh, nl, am, ob_, int64(i))}
		}
		compareGolden(t, "McClellanOscillator", got)
	})
	t.Run("McClellanSummationIndex", func(t *testing.T) {
		ind, err := NewMcClellanSummationIndex()
		if err != nil {
			t.Fatalf("new McClellanSummationIndex: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			ch, vo, nh, nl, am, ob_ := crossLists(r)
			got[i] = []float64{ind.Update(ch, vo, nh, nl, am, ob_, int64(i))}
		}
		compareGolden(t, "McClellanSummationIndex", got)
	})
	t.Run("McGinleyDynamic", func(t *testing.T) {
		ind, err := NewMcGinleyDynamic(14)
		if err != nil {
			t.Fatalf("new McGinleyDynamic: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "McGinleyDynamic", got)
	})
	t.Run("MedianAbsoluteDeviation", func(t *testing.T) {
		ind, err := NewMedianAbsoluteDeviation(14)
		if err != nil {
			t.Fatalf("new MedianAbsoluteDeviation: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "MedianAbsoluteDeviation", got)
	})
	t.Run("MedianChannel", func(t *testing.T) {
		ind, err := NewMedianChannel(14, 2.0)
		if err != nil {
			t.Fatalf("new MedianChannel: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[3])
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "MedianChannel", got)
	})
	t.Run("MedianMa", func(t *testing.T) {
		ind, err := NewMedianMa(14)
		if err != nil {
			t.Fatalf("new MedianMa: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "MedianMa", got)
	})
	t.Run("MedianPrice", func(t *testing.T) {
		ind, err := NewMedianPrice()
		if err != nil {
			t.Fatalf("new MedianPrice: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "MedianPrice", got)
	})
	t.Run("Mfi", func(t *testing.T) {
		ind, err := NewMfi(14)
		if err != nil {
			t.Fatalf("new Mfi: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Mfi", got)
	})
	t.Run("Microprice", func(t *testing.T) {
		ind, err := NewMicroprice()
		if err != nil {
			t.Fatalf("new Microprice: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			bp, bs, ap, as_ := obLists(r)
			got[i] = []float64{ind.Update(bp, bs, ap, as_)}
		}
		compareGolden(t, "Microprice", got)
	})
	t.Run("MidPoint", func(t *testing.T) {
		ind, err := NewMidPoint(14)
		if err != nil {
			t.Fatalf("new MidPoint: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "MidPoint", got)
	})
	t.Run("MidPrice", func(t *testing.T) {
		ind, err := NewMidPrice(14)
		if err != nil {
			t.Fatalf("new MidPrice: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "MidPrice", got)
	})
	t.Run("MinusDi", func(t *testing.T) {
		ind, err := NewMinusDi(14)
		if err != nil {
			t.Fatalf("new MinusDi: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "MinusDi", got)
	})
	t.Run("MinusDm", func(t *testing.T) {
		ind, err := NewMinusDm(14)
		if err != nil {
			t.Fatalf("new MinusDm: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "MinusDm", got)
	})
	t.Run("ModifiedMaStop", func(t *testing.T) {
		ind, err := NewModifiedMaStop(14)
		if err != nil {
			t.Fatalf("new ModifiedMaStop: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "ModifiedMaStop", got)
	})
	t.Run("Mom", func(t *testing.T) {
		ind, err := NewMom(14)
		if err != nil {
			t.Fatalf("new Mom: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Mom", got)
	})
	t.Run("MorningDojiStar", func(t *testing.T) {
		ind, err := NewMorningDojiStar()
		if err != nil {
			t.Fatalf("new MorningDojiStar: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "MorningDojiStar", got)
	})
	t.Run("MorningEveningStar", func(t *testing.T) {
		ind, err := NewMorningEveningStar()
		if err != nil {
			t.Fatalf("new MorningEveningStar: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "MorningEveningStar", got)
	})
	t.Run("MurreyMathLines", func(t *testing.T) {
		ind, err := NewMurreyMathLines(14)
		if err != nil {
			t.Fatalf("new MurreyMathLines: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 9)
		}
		compareGolden(t, "MurreyMathLines", got)
	})
	t.Run("NakedPoc", func(t *testing.T) {
		ind, err := NewNakedPoc(3, 7)
		if err != nil {
			t.Fatalf("new NakedPoc: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "NakedPoc", got)
	})
	t.Run("Natr", func(t *testing.T) {
		ind, err := NewNatr(14)
		if err != nil {
			t.Fatalf("new Natr: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Natr", got)
	})
	t.Run("NewHighsNewLows", func(t *testing.T) {
		ind, err := NewNewHighsNewLows()
		if err != nil {
			t.Fatalf("new NewHighsNewLows: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			ch, vo, nh, nl, am, ob_ := crossLists(r)
			got[i] = []float64{ind.Update(ch, vo, nh, nl, am, ob_, int64(i))}
		}
		compareGolden(t, "NewHighsNewLows", got)
	})
	t.Run("NewPriceLines", func(t *testing.T) {
		ind, err := NewNewPriceLines(14)
		if err != nil {
			t.Fatalf("new NewPriceLines: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "NewPriceLines", got)
	})
	t.Run("Nrtr", func(t *testing.T) {
		ind, err := NewNrtr(2.0)
		if err != nil {
			t.Fatalf("new Nrtr: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "Nrtr", got)
	})
	t.Run("Nvi", func(t *testing.T) {
		ind, err := NewNvi()
		if err != nil {
			t.Fatalf("new Nvi: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Nvi", got)
	})
	t.Run("OIPriceDivergence", func(t *testing.T) {
		ind, err := NewOIPriceDivergence(20)
		if err != nil {
			t.Fatalf("new OIPriceDivergence: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			d := derivFields(r)
			got[i] = []float64{ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], int64(i))}
		}
		compareGolden(t, "OIPriceDivergence", got)
	})
	t.Run("OIWeighted", func(t *testing.T) {
		ind, err := NewOIWeighted()
		if err != nil {
			t.Fatalf("new OIWeighted: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			d := derivFields(r)
			got[i] = []float64{ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], int64(i))}
		}
		compareGolden(t, "OIWeighted", got)
	})
	t.Run("Obv", func(t *testing.T) {
		ind, err := NewObv()
		if err != nil {
			t.Fatalf("new Obv: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Obv", got)
	})
	t.Run("OiToVolumeRatio", func(t *testing.T) {
		ind, err := NewOiToVolumeRatio()
		if err != nil {
			t.Fatalf("new OiToVolumeRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			d := derivFields(r)
			got[i] = []float64{ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], int64(i))}
		}
		compareGolden(t, "OiToVolumeRatio", got)
	})
	t.Run("OmegaRatio", func(t *testing.T) {
		ind, err := NewOmegaRatio(14, 2.0)
		if err != nil {
			t.Fatalf("new OmegaRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "OmegaRatio", got)
	})
	t.Run("OnNeck", func(t *testing.T) {
		ind, err := NewOnNeck()
		if err != nil {
			t.Fatalf("new OnNeck: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "OnNeck", got)
	})
	t.Run("OpenInterestDelta", func(t *testing.T) {
		ind, err := NewOpenInterestDelta()
		if err != nil {
			t.Fatalf("new OpenInterestDelta: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			d := derivFields(r)
			got[i] = []float64{ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], int64(i))}
		}
		compareGolden(t, "OpenInterestDelta", got)
	})
	t.Run("OpenInterestMomentum", func(t *testing.T) {
		ind, err := NewOpenInterestMomentum(10)
		if err != nil {
			t.Fatalf("new OpenInterestMomentum: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			d := derivFields(r)
			got[i] = []float64{ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], int64(i))}
		}
		compareGolden(t, "OpenInterestMomentum", got)
	})
	t.Run("OpeningMarubozu", func(t *testing.T) {
		ind, err := NewOpeningMarubozu()
		if err != nil {
			t.Fatalf("new OpeningMarubozu: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "OpeningMarubozu", got)
	})
	t.Run("OpeningRange", func(t *testing.T) {
		ind, err := NewOpeningRange(14)
		if err != nil {
			t.Fatalf("new OpeningRange: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "OpeningRange", got)
	})
	t.Run("OrderBookImbalanceFull", func(t *testing.T) {
		ind, err := NewOrderBookImbalanceFull()
		if err != nil {
			t.Fatalf("new OrderBookImbalanceFull: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			bp, bs, ap, as_ := obLists(r)
			got[i] = []float64{ind.Update(bp, bs, ap, as_)}
		}
		compareGolden(t, "OrderBookImbalanceFull", got)
	})
	t.Run("OrderBookImbalanceTop1", func(t *testing.T) {
		ind, err := NewOrderBookImbalanceTop1()
		if err != nil {
			t.Fatalf("new OrderBookImbalanceTop1: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			bp, bs, ap, as_ := obLists(r)
			got[i] = []float64{ind.Update(bp, bs, ap, as_)}
		}
		compareGolden(t, "OrderBookImbalanceTop1", got)
	})
	t.Run("OrderBookImbalanceTopN", func(t *testing.T) {
		ind, err := NewOrderBookImbalanceTopN(5)
		if err != nil {
			t.Fatalf("new OrderBookImbalanceTopN: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			bp, bs, ap, as_ := obLists(r)
			got[i] = []float64{ind.Update(bp, bs, ap, as_)}
		}
		compareGolden(t, "OrderBookImbalanceTopN", got)
	})
	t.Run("OrderFlowImbalance", func(t *testing.T) {
		ind, err := NewOrderFlowImbalance(20)
		if err != nil {
			t.Fatalf("new OrderFlowImbalance: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			bp, bs, ap, as_ := obLists(r)
			got[i] = []float64{ind.Update(bp, bs, ap, as_)}
		}
		compareGolden(t, "OrderFlowImbalance", got)
	})
	t.Run("OuHalfLife", func(t *testing.T) {
		ind, err := NewOuHalfLife(14)
		if err != nil {
			t.Fatalf("new OuHalfLife: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[0])}
		}
		compareGolden(t, "OuHalfLife", got)
	})
	t.Run("OvernightGap", func(t *testing.T) {
		ind, err := NewOvernightGap(0)
		if err != nil {
			t.Fatalf("new OvernightGap: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "OvernightGap", got)
	})
	t.Run("OvernightIntradayReturn", func(t *testing.T) {
		ind, err := NewOvernightIntradayReturn(14)
		if err != nil {
			t.Fatalf("new OvernightIntradayReturn: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "OvernightIntradayReturn", got)
	})
	t.Run("PainIndex", func(t *testing.T) {
		ind, err := NewPainIndex(14)
		if err != nil {
			t.Fatalf("new PainIndex: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "PainIndex", got)
	})
	t.Run("PairSpreadZScore", func(t *testing.T) {
		ind, err := NewPairSpreadZScore(20, 20)
		if err != nil {
			t.Fatalf("new PairSpreadZScore: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[0])}
		}
		compareGolden(t, "PairSpreadZScore", got)
	})
	t.Run("PairwiseBeta", func(t *testing.T) {
		ind, err := NewPairwiseBeta(14)
		if err != nil {
			t.Fatalf("new PairwiseBeta: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[0])}
		}
		compareGolden(t, "PairwiseBeta", got)
	})
	t.Run("ParkinsonVolatility", func(t *testing.T) {
		ind, err := NewParkinsonVolatility(20, 252)
		if err != nil {
			t.Fatalf("new ParkinsonVolatility: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "ParkinsonVolatility", got)
	})
	t.Run("PearsonCorrelation", func(t *testing.T) {
		ind, err := NewPearsonCorrelation(14)
		if err != nil {
			t.Fatalf("new PearsonCorrelation: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[0])}
		}
		compareGolden(t, "PearsonCorrelation", got)
	})
	t.Run("PercentAboveMa", func(t *testing.T) {
		ind, err := NewPercentAboveMa()
		if err != nil {
			t.Fatalf("new PercentAboveMa: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			ch, vo, nh, nl, am, ob_ := crossLists(r)
			got[i] = []float64{ind.Update(ch, vo, nh, nl, am, ob_, int64(i))}
		}
		compareGolden(t, "PercentAboveMa", got)
	})
	t.Run("PercentB", func(t *testing.T) {
		ind, err := NewPercentB(14, 2.0)
		if err != nil {
			t.Fatalf("new PercentB: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "PercentB", got)
	})
	t.Run("PercentageTrailingStop", func(t *testing.T) {
		ind, err := NewPercentageTrailingStop(2.0)
		if err != nil {
			t.Fatalf("new PercentageTrailingStop: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "PercentageTrailingStop", got)
	})
	t.Run("PerpetualPremiumIndex", func(t *testing.T) {
		ind, err := NewPerpetualPremiumIndex()
		if err != nil {
			t.Fatalf("new PerpetualPremiumIndex: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			d := derivFields(r)
			got[i] = []float64{ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], int64(i))}
		}
		compareGolden(t, "PerpetualPremiumIndex", got)
	})
	t.Run("Pgo", func(t *testing.T) {
		ind, err := NewPgo(14)
		if err != nil {
			t.Fatalf("new Pgo: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Pgo", got)
	})
	t.Run("PiercingDarkCloud", func(t *testing.T) {
		ind, err := NewPiercingDarkCloud()
		if err != nil {
			t.Fatalf("new PiercingDarkCloud: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "PiercingDarkCloud", got)
	})
	t.Run("Pin", func(t *testing.T) {
		ind, err := NewPin(20)
		if err != nil {
			t.Fatalf("new Pin: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[4], r[3] >= r[0], int64(i))}
		}
		compareGolden(t, "Pin", got)
	})
	t.Run("PivotReversal", func(t *testing.T) {
		ind, err := NewPivotReversal(3, 7)
		if err != nil {
			t.Fatalf("new PivotReversal: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "PivotReversal", got)
	})
	t.Run("PlusDi", func(t *testing.T) {
		ind, err := NewPlusDi(14)
		if err != nil {
			t.Fatalf("new PlusDi: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "PlusDi", got)
	})
	t.Run("PlusDm", func(t *testing.T) {
		ind, err := NewPlusDm(14)
		if err != nil {
			t.Fatalf("new PlusDm: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "PlusDm", got)
	})
	t.Run("Pmo", func(t *testing.T) {
		ind, err := NewPmo(3, 7)
		if err != nil {
			t.Fatalf("new Pmo: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Pmo", got)
	})
	t.Run("PointAndFigureBars", func(t *testing.T) {
		ind, err := NewPointAndFigureBars(2.0, 3)
		if err != nil {
			t.Fatalf("new PointAndFigureBars: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = flattenBars(ind.Update(r[3], r[3], r[3], r[3], 1.0, 0))
		}
		compareGolden(t, "PointAndFigureBars", got)
	})
	t.Run("PolarizedFractalEfficiency", func(t *testing.T) {
		ind, err := NewPolarizedFractalEfficiency(10, 5)
		if err != nil {
			t.Fatalf("new PolarizedFractalEfficiency: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "PolarizedFractalEfficiency", got)
	})
	t.Run("Ppo", func(t *testing.T) {
		ind, err := NewPpo(3, 7)
		if err != nil {
			t.Fatalf("new Ppo: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Ppo", got)
	})
	t.Run("PpoHistogram", func(t *testing.T) {
		ind, err := NewPpoHistogram(3, 7, 14)
		if err != nil {
			t.Fatalf("new PpoHistogram: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "PpoHistogram", got)
	})
	t.Run("ProfileShape", func(t *testing.T) {
		ind, err := NewProfileShape(3, 7)
		if err != nil {
			t.Fatalf("new ProfileShape: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "ProfileShape", got)
	})
	t.Run("ProfitFactor", func(t *testing.T) {
		ind, err := NewProfitFactor(14)
		if err != nil {
			t.Fatalf("new ProfitFactor: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "ProfitFactor", got)
	})
	t.Run("ProjectionBands", func(t *testing.T) {
		ind, err := NewProjectionBands(14)
		if err != nil {
			t.Fatalf("new ProjectionBands: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "ProjectionBands", got)
	})
	t.Run("ProjectionOscillator", func(t *testing.T) {
		ind, err := NewProjectionOscillator(14)
		if err != nil {
			t.Fatalf("new ProjectionOscillator: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "ProjectionOscillator", got)
	})
	t.Run("Psar", func(t *testing.T) {
		ind, err := NewPsar(0.02, 0.02, 0.2)
		if err != nil {
			t.Fatalf("new Psar: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Psar", got)
	})
	t.Run("Pvi", func(t *testing.T) {
		ind, err := NewPvi()
		if err != nil {
			t.Fatalf("new Pvi: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Pvi", got)
	})
	t.Run("Qqe", func(t *testing.T) {
		ind, err := NewQqe(3, 7, 2.0)
		if err != nil {
			t.Fatalf("new Qqe: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[3])
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "Qqe", got)
	})
	t.Run("Qstick", func(t *testing.T) {
		ind, err := NewQstick(14)
		if err != nil {
			t.Fatalf("new Qstick: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Qstick", got)
	})
	t.Run("QuartileBands", func(t *testing.T) {
		ind, err := NewQuartileBands(14)
		if err != nil {
			t.Fatalf("new QuartileBands: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[3])
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "QuartileBands", got)
	})
	t.Run("QuotedSpread", func(t *testing.T) {
		ind, err := NewQuotedSpread()
		if err != nil {
			t.Fatalf("new QuotedSpread: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			bp, bs, ap, as_ := obLists(r)
			got[i] = []float64{ind.Update(bp, bs, ap, as_)}
		}
		compareGolden(t, "QuotedSpread", got)
	})
	t.Run("RSquared", func(t *testing.T) {
		ind, err := NewRSquared(14)
		if err != nil {
			t.Fatalf("new RSquared: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "RSquared", got)
	})
	t.Run("RangeBars", func(t *testing.T) {
		ind, err := NewRangeBars(2.0)
		if err != nil {
			t.Fatalf("new RangeBars: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = flattenBars(ind.Update(r[3], r[3], r[3], r[3], 1.0, 0))
		}
		compareGolden(t, "RangeBars", got)
	})
	t.Run("RealizedSpread", func(t *testing.T) {
		ind, err := NewRealizedSpread(20)
		if err != nil {
			t.Fatalf("new RealizedSpread: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[4], r[3] >= r[0], int64(i), (r[1]+r[2])/2)}
		}
		compareGolden(t, "RealizedSpread", got)
	})
	t.Run("RealizedVolatility", func(t *testing.T) {
		ind, err := NewRealizedVolatility(14)
		if err != nil {
			t.Fatalf("new RealizedVolatility: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "RealizedVolatility", got)
	})
	t.Run("RecoveryFactor", func(t *testing.T) {
		ind, err := NewRecoveryFactor()
		if err != nil {
			t.Fatalf("new RecoveryFactor: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "RecoveryFactor", got)
	})
	t.Run("RectangleRange", func(t *testing.T) {
		ind, err := NewRectangleRange()
		if err != nil {
			t.Fatalf("new RectangleRange: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "RectangleRange", got)
	})
	t.Run("Reflex", func(t *testing.T) {
		ind, err := NewReflex(14)
		if err != nil {
			t.Fatalf("new Reflex: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Reflex", got)
	})
	t.Run("RegimeLabel", func(t *testing.T) {
		ind, err := NewRegimeLabel(3, 7)
		if err != nil {
			t.Fatalf("new RegimeLabel: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "RegimeLabel", got)
	})
	t.Run("RelativeStrengthAB", func(t *testing.T) {
		ind, err := NewRelativeStrengthAB(14, 14)
		if err != nil {
			t.Fatalf("new RelativeStrengthAB: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[3], r[0])
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "RelativeStrengthAB", got)
	})
	t.Run("RenkoBars", func(t *testing.T) {
		ind, err := NewRenkoBars(2.0)
		if err != nil {
			t.Fatalf("new RenkoBars: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = flattenBars(ind.Update(r[3], r[3], r[3], r[3], 1.0, 0))
		}
		compareGolden(t, "RenkoBars", got)
	})
	t.Run("RenkoTrailingStop", func(t *testing.T) {
		ind, err := NewRenkoTrailingStop(2.0)
		if err != nil {
			t.Fatalf("new RenkoTrailingStop: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "RenkoTrailingStop", got)
	})
	t.Run("RickshawMan", func(t *testing.T) {
		ind, err := NewRickshawMan()
		if err != nil {
			t.Fatalf("new RickshawMan: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "RickshawMan", got)
	})
	t.Run("RisingThreeMethods", func(t *testing.T) {
		ind, err := NewRisingThreeMethods()
		if err != nil {
			t.Fatalf("new RisingThreeMethods: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "RisingThreeMethods", got)
	})
	t.Run("Rmi", func(t *testing.T) {
		ind, err := NewRmi(3, 7)
		if err != nil {
			t.Fatalf("new Rmi: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Rmi", got)
	})
	t.Run("Roc", func(t *testing.T) {
		ind, err := NewRoc(14)
		if err != nil {
			t.Fatalf("new Roc: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Roc", got)
	})
	t.Run("Rocp", func(t *testing.T) {
		ind, err := NewRocp(14)
		if err != nil {
			t.Fatalf("new Rocp: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Rocp", got)
	})
	t.Run("Rocr", func(t *testing.T) {
		ind, err := NewRocr(14)
		if err != nil {
			t.Fatalf("new Rocr: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Rocr", got)
	})
	t.Run("Rocr100", func(t *testing.T) {
		ind, err := NewRocr100(14)
		if err != nil {
			t.Fatalf("new Rocr100: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Rocr100", got)
	})
	t.Run("RogersSatchellVolatility", func(t *testing.T) {
		ind, err := NewRogersSatchellVolatility(20, 252)
		if err != nil {
			t.Fatalf("new RogersSatchellVolatility: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "RogersSatchellVolatility", got)
	})
	t.Run("RollMeasure", func(t *testing.T) {
		ind, err := NewRollMeasure(20)
		if err != nil {
			t.Fatalf("new RollMeasure: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[4], r[3] >= r[0], int64(i))}
		}
		compareGolden(t, "RollMeasure", got)
	})
	t.Run("RollingCorrelation", func(t *testing.T) {
		ind, err := NewRollingCorrelation(14)
		if err != nil {
			t.Fatalf("new RollingCorrelation: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[0])}
		}
		compareGolden(t, "RollingCorrelation", got)
	})
	t.Run("RollingCovariance", func(t *testing.T) {
		ind, err := NewRollingCovariance(14)
		if err != nil {
			t.Fatalf("new RollingCovariance: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[0])}
		}
		compareGolden(t, "RollingCovariance", got)
	})
	t.Run("RollingIqr", func(t *testing.T) {
		ind, err := NewRollingIqr(14)
		if err != nil {
			t.Fatalf("new RollingIqr: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "RollingIqr", got)
	})
	t.Run("RollingMinMaxScaler", func(t *testing.T) {
		ind, err := NewRollingMinMaxScaler(14)
		if err != nil {
			t.Fatalf("new RollingMinMaxScaler: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "RollingMinMaxScaler", got)
	})
	t.Run("RollingPercentileRank", func(t *testing.T) {
		ind, err := NewRollingPercentileRank(14)
		if err != nil {
			t.Fatalf("new RollingPercentileRank: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "RollingPercentileRank", got)
	})
	t.Run("RollingQuantile", func(t *testing.T) {
		ind, err := NewRollingQuantile(20, 0.5)
		if err != nil {
			t.Fatalf("new RollingQuantile: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "RollingQuantile", got)
	})
	t.Run("RollingVwap", func(t *testing.T) {
		ind, err := NewRollingVwap(14)
		if err != nil {
			t.Fatalf("new RollingVwap: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "RollingVwap", got)
	})
	t.Run("RoofingFilter", func(t *testing.T) {
		ind, err := NewRoofingFilter(3, 7)
		if err != nil {
			t.Fatalf("new RoofingFilter: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "RoofingFilter", got)
	})
	t.Run("Rsi", func(t *testing.T) {
		ind, err := NewRsi(14)
		if err != nil {
			t.Fatalf("new Rsi: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Rsi", got)
	})
	t.Run("Rsx", func(t *testing.T) {
		ind, err := NewRsx(14)
		if err != nil {
			t.Fatalf("new Rsx: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Rsx", got)
	})
	t.Run("RunBars", func(t *testing.T) {
		ind, err := NewRunBars(3)
		if err != nil {
			t.Fatalf("new RunBars: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = flattenBars(ind.Update(r[0], r[1], r[2], r[3], 1.0, 0))
		}
		compareGolden(t, "RunBars", got)
	})
	t.Run("Rvi", func(t *testing.T) {
		ind, err := NewRvi(14)
		if err != nil {
			t.Fatalf("new Rvi: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Rvi", got)
	})
	t.Run("RviVolatility", func(t *testing.T) {
		ind, err := NewRviVolatility(14)
		if err != nil {
			t.Fatalf("new RviVolatility: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "RviVolatility", got)
	})
	t.Run("Rwi", func(t *testing.T) {
		ind, err := NewRwi(14)
		if err != nil {
			t.Fatalf("new Rwi: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "Rwi", got)
	})
	t.Run("SampleEntropy", func(t *testing.T) {
		ind, err := NewSampleEntropy(20, 2, 0.2)
		if err != nil {
			t.Fatalf("new SampleEntropy: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "SampleEntropy", got)
	})
	t.Run("SarExt", func(t *testing.T) {
		ind, err := NewSarExt(2.0, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5)
		if err != nil {
			t.Fatalf("new SarExt: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "SarExt", got)
	})
	t.Run("SeasonalZScore", func(t *testing.T) {
		ind, err := NewSeasonalZScore(14)
		if err != nil {
			t.Fatalf("new SeasonalZScore: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "SeasonalZScore", got)
	})
	t.Run("SeparatingLines", func(t *testing.T) {
		ind, err := NewSeparatingLines()
		if err != nil {
			t.Fatalf("new SeparatingLines: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "SeparatingLines", got)
	})
	t.Run("SessionHighLow", func(t *testing.T) {
		ind, err := NewSessionHighLow(14)
		if err != nil {
			t.Fatalf("new SessionHighLow: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "SessionHighLow", got)
	})
	t.Run("SessionRange", func(t *testing.T) {
		ind, err := NewSessionRange(14)
		if err != nil {
			t.Fatalf("new SessionRange: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "SessionRange", got)
	})
	t.Run("SessionVwap", func(t *testing.T) {
		ind, err := NewSessionVwap(14)
		if err != nil {
			t.Fatalf("new SessionVwap: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "SessionVwap", got)
	})
	t.Run("ShannonEntropy", func(t *testing.T) {
		ind, err := NewShannonEntropy(3, 7)
		if err != nil {
			t.Fatalf("new ShannonEntropy: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "ShannonEntropy", got)
	})
	t.Run("Shark", func(t *testing.T) {
		ind, err := NewShark()
		if err != nil {
			t.Fatalf("new Shark: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Shark", got)
	})
	t.Run("SharpeRatio", func(t *testing.T) {
		ind, err := NewSharpeRatio(14, 2.0)
		if err != nil {
			t.Fatalf("new SharpeRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "SharpeRatio", got)
	})
	t.Run("ShootingStar", func(t *testing.T) {
		ind, err := NewShootingStar()
		if err != nil {
			t.Fatalf("new ShootingStar: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "ShootingStar", got)
	})
	t.Run("ShortLine", func(t *testing.T) {
		ind, err := NewShortLine()
		if err != nil {
			t.Fatalf("new ShortLine: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "ShortLine", got)
	})
	t.Run("SignedVolume", func(t *testing.T) {
		ind, err := NewSignedVolume()
		if err != nil {
			t.Fatalf("new SignedVolume: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[4], r[3] >= r[0], int64(i))}
		}
		compareGolden(t, "SignedVolume", got)
	})
	t.Run("SineWave", func(t *testing.T) {
		ind, err := NewSineWave()
		if err != nil {
			t.Fatalf("new SineWave: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "SineWave", got)
	})
	t.Run("SineWeightedMa", func(t *testing.T) {
		ind, err := NewSineWeightedMa(14)
		if err != nil {
			t.Fatalf("new SineWeightedMa: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "SineWeightedMa", got)
	})
	t.Run("SinglePrints", func(t *testing.T) {
		ind, err := NewSinglePrints(3, 7)
		if err != nil {
			t.Fatalf("new SinglePrints: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "SinglePrints", got)
	})
	t.Run("Skewness", func(t *testing.T) {
		ind, err := NewSkewness(14)
		if err != nil {
			t.Fatalf("new Skewness: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Skewness", got)
	})
	t.Run("Sma", func(t *testing.T) {
		ind, err := NewSma(14)
		if err != nil {
			t.Fatalf("new Sma: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Sma", got)
	})
	t.Run("Smi", func(t *testing.T) {
		ind, err := NewSmi(3, 7, 14)
		if err != nil {
			t.Fatalf("new Smi: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Smi", got)
	})
	t.Run("Smma", func(t *testing.T) {
		ind, err := NewSmma(14)
		if err != nil {
			t.Fatalf("new Smma: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Smma", got)
	})
	t.Run("SmoothedHeikinAshi", func(t *testing.T) {
		ind, err := NewSmoothedHeikinAshi(14)
		if err != nil {
			t.Fatalf("new SmoothedHeikinAshi: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 4)
		}
		compareGolden(t, "SmoothedHeikinAshi", got)
	})
	t.Run("SortinoRatio", func(t *testing.T) {
		ind, err := NewSortinoRatio(14, 2.0)
		if err != nil {
			t.Fatalf("new SortinoRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "SortinoRatio", got)
	})
	t.Run("SpearmanCorrelation", func(t *testing.T) {
		ind, err := NewSpearmanCorrelation(14)
		if err != nil {
			t.Fatalf("new SpearmanCorrelation: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[0])}
		}
		compareGolden(t, "SpearmanCorrelation", got)
	})
	t.Run("SpinningTop", func(t *testing.T) {
		ind, err := NewSpinningTop()
		if err != nil {
			t.Fatalf("new SpinningTop: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "SpinningTop", got)
	})
	t.Run("SpreadAr1Coefficient", func(t *testing.T) {
		ind, err := NewSpreadAr1Coefficient(14)
		if err != nil {
			t.Fatalf("new SpreadAr1Coefficient: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[0])}
		}
		compareGolden(t, "SpreadAr1Coefficient", got)
	})
	t.Run("SpreadBollingerBands", func(t *testing.T) {
		ind, err := NewSpreadBollingerBands(14, 2.0)
		if err != nil {
			t.Fatalf("new SpreadBollingerBands: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[3], r[0])
			got[i] = reflectRow(out, ok, 4)
		}
		compareGolden(t, "SpreadBollingerBands", got)
	})
	t.Run("SpreadHurst", func(t *testing.T) {
		ind, err := NewSpreadHurst(14)
		if err != nil {
			t.Fatalf("new SpreadHurst: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[0])}
		}
		compareGolden(t, "SpreadHurst", got)
	})
	t.Run("StalledPattern", func(t *testing.T) {
		ind, err := NewStalledPattern()
		if err != nil {
			t.Fatalf("new StalledPattern: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "StalledPattern", got)
	})
	t.Run("StandardError", func(t *testing.T) {
		ind, err := NewStandardError(14)
		if err != nil {
			t.Fatalf("new StandardError: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "StandardError", got)
	})
	t.Run("StandardErrorBands", func(t *testing.T) {
		ind, err := NewStandardErrorBands(14, 2.0)
		if err != nil {
			t.Fatalf("new StandardErrorBands: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[3])
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "StandardErrorBands", got)
	})
	t.Run("StarcBands", func(t *testing.T) {
		ind, err := NewStarcBands(3, 7, 2.0)
		if err != nil {
			t.Fatalf("new StarcBands: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "StarcBands", got)
	})
	t.Run("Stc", func(t *testing.T) {
		ind, err := NewStc(10, 23, 10, 0.5)
		if err != nil {
			t.Fatalf("new Stc: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Stc", got)
	})
	t.Run("StdDev", func(t *testing.T) {
		ind, err := NewStdDev(14)
		if err != nil {
			t.Fatalf("new StdDev: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "StdDev", got)
	})
	t.Run("StepTrailingStop", func(t *testing.T) {
		ind, err := NewStepTrailingStop(2.0)
		if err != nil {
			t.Fatalf("new StepTrailingStop: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "StepTrailingStop", got)
	})
	t.Run("SterlingRatio", func(t *testing.T) {
		ind, err := NewSterlingRatio(14)
		if err != nil {
			t.Fatalf("new SterlingRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "SterlingRatio", got)
	})
	t.Run("StickSandwich", func(t *testing.T) {
		ind, err := NewStickSandwich()
		if err != nil {
			t.Fatalf("new StickSandwich: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "StickSandwich", got)
	})
	t.Run("StochRsi", func(t *testing.T) {
		ind, err := NewStochRsi(3, 7)
		if err != nil {
			t.Fatalf("new StochRsi: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "StochRsi", got)
	})
	t.Run("Stochastic", func(t *testing.T) {
		ind, err := NewStochastic(3, 7)
		if err != nil {
			t.Fatalf("new Stochastic: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "Stochastic", got)
	})
	t.Run("StochasticCci", func(t *testing.T) {
		ind, err := NewStochasticCci(14)
		if err != nil {
			t.Fatalf("new StochasticCci: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "StochasticCci", got)
	})
	t.Run("SuperSmoother", func(t *testing.T) {
		ind, err := NewSuperSmoother(14)
		if err != nil {
			t.Fatalf("new SuperSmoother: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "SuperSmoother", got)
	})
	t.Run("SuperTrend", func(t *testing.T) {
		ind, err := NewSuperTrend(14, 2.0)
		if err != nil {
			t.Fatalf("new SuperTrend: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "SuperTrend", got)
	})
	t.Run("T3", func(t *testing.T) {
		ind, err := NewT3(5, 0.7)
		if err != nil {
			t.Fatalf("new T3: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "T3", got)
	})
	t.Run("TailRatio", func(t *testing.T) {
		ind, err := NewTailRatio(14)
		if err != nil {
			t.Fatalf("new TailRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "TailRatio", got)
	})
	t.Run("TakerBuySellRatio", func(t *testing.T) {
		ind, err := NewTakerBuySellRatio()
		if err != nil {
			t.Fatalf("new TakerBuySellRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			d := derivFields(r)
			got[i] = []float64{ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], int64(i))}
		}
		compareGolden(t, "TakerBuySellRatio", got)
	})
	t.Run("Takuri", func(t *testing.T) {
		ind, err := NewTakuri()
		if err != nil {
			t.Fatalf("new Takuri: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Takuri", got)
	})
	t.Run("TasukiGap", func(t *testing.T) {
		ind, err := NewTasukiGap()
		if err != nil {
			t.Fatalf("new TasukiGap: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TasukiGap", got)
	})
	t.Run("TdCamouflage", func(t *testing.T) {
		ind, err := NewTdCamouflage()
		if err != nil {
			t.Fatalf("new TdCamouflage: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TdCamouflage", got)
	})
	t.Run("TdClop", func(t *testing.T) {
		ind, err := NewTdClop()
		if err != nil {
			t.Fatalf("new TdClop: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TdClop", got)
	})
	t.Run("TdClopwin", func(t *testing.T) {
		ind, err := NewTdClopwin()
		if err != nil {
			t.Fatalf("new TdClopwin: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TdClopwin", got)
	})
	t.Run("TdCombo", func(t *testing.T) {
		ind, err := NewTdCombo(3, 7, 14, 28)
		if err != nil {
			t.Fatalf("new TdCombo: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TdCombo", got)
	})
	t.Run("TdCountdown", func(t *testing.T) {
		ind, err := NewTdCountdown(3, 7, 14, 28)
		if err != nil {
			t.Fatalf("new TdCountdown: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TdCountdown", got)
	})
	t.Run("TdDWave", func(t *testing.T) {
		ind, err := NewTdDWave(2)
		if err != nil {
			t.Fatalf("new TdDWave: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TdDWave", got)
	})
	t.Run("TdDeMarker", func(t *testing.T) {
		ind, err := NewTdDeMarker(14)
		if err != nil {
			t.Fatalf("new TdDeMarker: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TdDeMarker", got)
	})
	t.Run("TdDifferential", func(t *testing.T) {
		ind, err := NewTdDifferential()
		if err != nil {
			t.Fatalf("new TdDifferential: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TdDifferential", got)
	})
	t.Run("TdLines", func(t *testing.T) {
		ind, err := NewTdLines(3, 7)
		if err != nil {
			t.Fatalf("new TdLines: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "TdLines", got)
	})
	t.Run("TdMovingAverage", func(t *testing.T) {
		ind, err := NewTdMovingAverage(3, 7)
		if err != nil {
			t.Fatalf("new TdMovingAverage: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "TdMovingAverage", got)
	})
	t.Run("TdOpen", func(t *testing.T) {
		ind, err := NewTdOpen()
		if err != nil {
			t.Fatalf("new TdOpen: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TdOpen", got)
	})
	t.Run("TdPressure", func(t *testing.T) {
		ind, err := NewTdPressure(14)
		if err != nil {
			t.Fatalf("new TdPressure: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TdPressure", got)
	})
	t.Run("TdPropulsion", func(t *testing.T) {
		ind, err := NewTdPropulsion()
		if err != nil {
			t.Fatalf("new TdPropulsion: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TdPropulsion", got)
	})
	t.Run("TdRangeProjection", func(t *testing.T) {
		ind, err := NewTdRangeProjection()
		if err != nil {
			t.Fatalf("new TdRangeProjection: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "TdRangeProjection", got)
	})
	t.Run("TdRei", func(t *testing.T) {
		ind, err := NewTdRei(14)
		if err != nil {
			t.Fatalf("new TdRei: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TdRei", got)
	})
	t.Run("TdRiskLevel", func(t *testing.T) {
		ind, err := NewTdRiskLevel(3, 7)
		if err != nil {
			t.Fatalf("new TdRiskLevel: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "TdRiskLevel", got)
	})
	t.Run("TdSequential", func(t *testing.T) {
		ind, err := NewTdSequential(3, 7, 14, 28)
		if err != nil {
			t.Fatalf("new TdSequential: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "TdSequential", got)
	})
	t.Run("TdSetup", func(t *testing.T) {
		ind, err := NewTdSetup(3, 7)
		if err != nil {
			t.Fatalf("new TdSetup: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TdSetup", got)
	})
	t.Run("TdTrap", func(t *testing.T) {
		ind, err := NewTdTrap()
		if err != nil {
			t.Fatalf("new TdTrap: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TdTrap", got)
	})
	t.Run("Tema", func(t *testing.T) {
		ind, err := NewTema(14)
		if err != nil {
			t.Fatalf("new Tema: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Tema", got)
	})
	t.Run("TermStructureBasis", func(t *testing.T) {
		ind, err := NewTermStructureBasis()
		if err != nil {
			t.Fatalf("new TermStructureBasis: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			d := derivFields(r)
			got[i] = []float64{ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], int64(i))}
		}
		compareGolden(t, "TermStructureBasis", got)
	})
	t.Run("ThreeDrives", func(t *testing.T) {
		ind, err := NewThreeDrives()
		if err != nil {
			t.Fatalf("new ThreeDrives: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "ThreeDrives", got)
	})
	t.Run("ThreeInside", func(t *testing.T) {
		ind, err := NewThreeInside()
		if err != nil {
			t.Fatalf("new ThreeInside: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "ThreeInside", got)
	})
	t.Run("ThreeLineBreak", func(t *testing.T) {
		ind, err := NewThreeLineBreak(14)
		if err != nil {
			t.Fatalf("new ThreeLineBreak: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "ThreeLineBreak", got)
	})
	t.Run("ThreeLineBreakBars", func(t *testing.T) {
		ind, err := NewThreeLineBreakBars(3)
		if err != nil {
			t.Fatalf("new ThreeLineBreakBars: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = flattenBars(ind.Update(r[3], r[3], r[3], r[3], 1.0, 0))
		}
		compareGolden(t, "ThreeLineBreakBars", got)
	})
	t.Run("ThreeLineStrike", func(t *testing.T) {
		ind, err := NewThreeLineStrike()
		if err != nil {
			t.Fatalf("new ThreeLineStrike: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "ThreeLineStrike", got)
	})
	t.Run("ThreeOutside", func(t *testing.T) {
		ind, err := NewThreeOutside()
		if err != nil {
			t.Fatalf("new ThreeOutside: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "ThreeOutside", got)
	})
	t.Run("ThreeSoldiersOrCrows", func(t *testing.T) {
		ind, err := NewThreeSoldiersOrCrows()
		if err != nil {
			t.Fatalf("new ThreeSoldiersOrCrows: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "ThreeSoldiersOrCrows", got)
	})
	t.Run("ThreeStarsInSouth", func(t *testing.T) {
		ind, err := NewThreeStarsInSouth()
		if err != nil {
			t.Fatalf("new ThreeStarsInSouth: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "ThreeStarsInSouth", got)
	})
	t.Run("Thrusting", func(t *testing.T) {
		ind, err := NewThrusting()
		if err != nil {
			t.Fatalf("new Thrusting: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Thrusting", got)
	})
	t.Run("TickBars", func(t *testing.T) {
		ind, err := NewTickBars(2)
		if err != nil {
			t.Fatalf("new TickBars: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = flattenBars(ind.Update(r[0], r[1], r[2], r[3], r[4], 0))
		}
		compareGolden(t, "TickBars", got)
	})
	t.Run("TickIndex", func(t *testing.T) {
		ind, err := NewTickIndex()
		if err != nil {
			t.Fatalf("new TickIndex: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			ch, vo, nh, nl, am, ob_ := crossLists(r)
			got[i] = []float64{ind.Update(ch, vo, nh, nl, am, ob_, int64(i))}
		}
		compareGolden(t, "TickIndex", got)
	})
	t.Run("Tii", func(t *testing.T) {
		ind, err := NewTii(3, 7)
		if err != nil {
			t.Fatalf("new Tii: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Tii", got)
	})
	t.Run("TimeBasedStop", func(t *testing.T) {
		ind, err := NewTimeBasedStop(14)
		if err != nil {
			t.Fatalf("new TimeBasedStop: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TimeBasedStop", got)
	})
	t.Run("TimeOfDayReturnProfile", func(t *testing.T) {
		ind, err := NewTimeOfDayReturnProfile(24, 0)
		if err != nil {
			t.Fatalf("new TimeOfDayReturnProfile: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			bins, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			if ok {
				got[i] = bins
			} else {
				got[i] = nanRow(24)
			}
		}
		compareGolden(t, "TimeOfDayReturnProfile", got)
	})
	t.Run("TowerTopBottom", func(t *testing.T) {
		ind, err := NewTowerTopBottom()
		if err != nil {
			t.Fatalf("new TowerTopBottom: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TowerTopBottom", got)
	})
	t.Run("TpoProfile", func(t *testing.T) {
		ind, err := NewTpoProfile(30, 50)
		if err != nil {
			t.Fatalf("new TpoProfile: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 52)
		}
		compareGolden(t, "TpoProfile", got)
	})
	t.Run("TradeImbalance", func(t *testing.T) {
		ind, err := NewTradeImbalance(20)
		if err != nil {
			t.Fatalf("new TradeImbalance: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[4], r[3] >= r[0], int64(i))}
		}
		compareGolden(t, "TradeImbalance", got)
	})
	t.Run("TradeSignAutocorrelation", func(t *testing.T) {
		ind, err := NewTradeSignAutocorrelation(20)
		if err != nil {
			t.Fatalf("new TradeSignAutocorrelation: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[4], r[3] >= r[0], int64(i))}
		}
		compareGolden(t, "TradeSignAutocorrelation", got)
	})
	t.Run("TradeVolumeIndex", func(t *testing.T) {
		ind, err := NewTradeVolumeIndex(2.0)
		if err != nil {
			t.Fatalf("new TradeVolumeIndex: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TradeVolumeIndex", got)
	})
	t.Run("TrendLabel", func(t *testing.T) {
		ind, err := NewTrendLabel(14)
		if err != nil {
			t.Fatalf("new TrendLabel: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "TrendLabel", got)
	})
	t.Run("TrendStrengthIndex", func(t *testing.T) {
		ind, err := NewTrendStrengthIndex(14)
		if err != nil {
			t.Fatalf("new TrendStrengthIndex: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "TrendStrengthIndex", got)
	})
	t.Run("Trendflex", func(t *testing.T) {
		ind, err := NewTrendflex(14)
		if err != nil {
			t.Fatalf("new Trendflex: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Trendflex", got)
	})
	t.Run("TreynorRatio", func(t *testing.T) {
		ind, err := NewTreynorRatio(14, 2.0)
		if err != nil {
			t.Fatalf("new TreynorRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[0])}
		}
		compareGolden(t, "TreynorRatio", got)
	})
	t.Run("Triangle", func(t *testing.T) {
		ind, err := NewTriangle()
		if err != nil {
			t.Fatalf("new Triangle: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Triangle", got)
	})
	t.Run("Trima", func(t *testing.T) {
		ind, err := NewTrima(14)
		if err != nil {
			t.Fatalf("new Trima: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Trima", got)
	})
	t.Run("Trin", func(t *testing.T) {
		ind, err := NewTrin()
		if err != nil {
			t.Fatalf("new Trin: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			ch, vo, nh, nl, am, ob_ := crossLists(r)
			got[i] = []float64{ind.Update(ch, vo, nh, nl, am, ob_, int64(i))}
		}
		compareGolden(t, "Trin", got)
	})
	t.Run("TripleTopBottom", func(t *testing.T) {
		ind, err := NewTripleTopBottom()
		if err != nil {
			t.Fatalf("new TripleTopBottom: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TripleTopBottom", got)
	})
	t.Run("Tristar", func(t *testing.T) {
		ind, err := NewTristar()
		if err != nil {
			t.Fatalf("new Tristar: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Tristar", got)
	})
	t.Run("Trix", func(t *testing.T) {
		ind, err := NewTrix(14)
		if err != nil {
			t.Fatalf("new Trix: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Trix", got)
	})
	t.Run("TrueRange", func(t *testing.T) {
		ind, err := NewTrueRange()
		if err != nil {
			t.Fatalf("new TrueRange: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TrueRange", got)
	})
	t.Run("Tsf", func(t *testing.T) {
		ind, err := NewTsf(14)
		if err != nil {
			t.Fatalf("new Tsf: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Tsf", got)
	})
	t.Run("TsfOscillator", func(t *testing.T) {
		ind, err := NewTsfOscillator(14)
		if err != nil {
			t.Fatalf("new TsfOscillator: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "TsfOscillator", got)
	})
	t.Run("Tsi", func(t *testing.T) {
		ind, err := NewTsi(3, 7)
		if err != nil {
			t.Fatalf("new Tsi: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Tsi", got)
	})
	t.Run("Tsv", func(t *testing.T) {
		ind, err := NewTsv(14)
		if err != nil {
			t.Fatalf("new Tsv: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Tsv", got)
	})
	t.Run("TtmSqueeze", func(t *testing.T) {
		ind, err := NewTtmSqueeze(14, 2.0, 0.5)
		if err != nil {
			t.Fatalf("new TtmSqueeze: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "TtmSqueeze", got)
	})
	t.Run("TtmTrend", func(t *testing.T) {
		ind, err := NewTtmTrend(14)
		if err != nil {
			t.Fatalf("new TtmTrend: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TtmTrend", got)
	})
	t.Run("TurnOfMonth", func(t *testing.T) {
		ind, err := NewTurnOfMonth(3.0, 3.0, 0)
		if err != nil {
			t.Fatalf("new TurnOfMonth: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TurnOfMonth", got)
	})
	t.Run("Tweezer", func(t *testing.T) {
		ind, err := NewTweezer()
		if err != nil {
			t.Fatalf("new Tweezer: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Tweezer", got)
	})
	t.Run("TwiggsMoneyFlow", func(t *testing.T) {
		ind, err := NewTwiggsMoneyFlow(14)
		if err != nil {
			t.Fatalf("new TwiggsMoneyFlow: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TwiggsMoneyFlow", got)
	})
	t.Run("TwoCrows", func(t *testing.T) {
		ind, err := NewTwoCrows()
		if err != nil {
			t.Fatalf("new TwoCrows: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TwoCrows", got)
	})
	t.Run("TypicalPrice", func(t *testing.T) {
		ind, err := NewTypicalPrice()
		if err != nil {
			t.Fatalf("new TypicalPrice: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "TypicalPrice", got)
	})
	t.Run("UlcerIndex", func(t *testing.T) {
		ind, err := NewUlcerIndex(14)
		if err != nil {
			t.Fatalf("new UlcerIndex: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "UlcerIndex", got)
	})
	t.Run("UltimateOscillator", func(t *testing.T) {
		ind, err := NewUltimateOscillator(3, 7, 14)
		if err != nil {
			t.Fatalf("new UltimateOscillator: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "UltimateOscillator", got)
	})
	t.Run("UniqueThreeRiver", func(t *testing.T) {
		ind, err := NewUniqueThreeRiver()
		if err != nil {
			t.Fatalf("new UniqueThreeRiver: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "UniqueThreeRiver", got)
	})
	t.Run("UniversalOscillator", func(t *testing.T) {
		ind, err := NewUniversalOscillator(14)
		if err != nil {
			t.Fatalf("new UniversalOscillator: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "UniversalOscillator", got)
	})
	t.Run("UpDownVolumeRatio", func(t *testing.T) {
		ind, err := NewUpDownVolumeRatio()
		if err != nil {
			t.Fatalf("new UpDownVolumeRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			ch, vo, nh, nl, am, ob_ := crossLists(r)
			got[i] = []float64{ind.Update(ch, vo, nh, nl, am, ob_, int64(i))}
		}
		compareGolden(t, "UpDownVolumeRatio", got)
	})
	t.Run("UpsideGapThreeMethods", func(t *testing.T) {
		ind, err := NewUpsideGapThreeMethods()
		if err != nil {
			t.Fatalf("new UpsideGapThreeMethods: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "UpsideGapThreeMethods", got)
	})
	t.Run("UpsideGapTwoCrows", func(t *testing.T) {
		ind, err := NewUpsideGapTwoCrows()
		if err != nil {
			t.Fatalf("new UpsideGapTwoCrows: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "UpsideGapTwoCrows", got)
	})
	t.Run("UpsidePotentialRatio", func(t *testing.T) {
		ind, err := NewUpsidePotentialRatio(14, 2.0)
		if err != nil {
			t.Fatalf("new UpsidePotentialRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "UpsidePotentialRatio", got)
	})
	t.Run("ValueArea", func(t *testing.T) {
		ind, err := NewValueArea(20, 50, 0.7)
		if err != nil {
			t.Fatalf("new ValueArea: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "ValueArea", got)
	})
	t.Run("ValueAtRisk", func(t *testing.T) {
		ind, err := NewValueAtRisk(20, 0.95)
		if err != nil {
			t.Fatalf("new ValueAtRisk: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "ValueAtRisk", got)
	})
	t.Run("Variance", func(t *testing.T) {
		ind, err := NewVariance(14)
		if err != nil {
			t.Fatalf("new Variance: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Variance", got)
	})
	t.Run("VarianceRatio", func(t *testing.T) {
		ind, err := NewVarianceRatio(60, 2)
		if err != nil {
			t.Fatalf("new VarianceRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[0])}
		}
		compareGolden(t, "VarianceRatio", got)
	})
	t.Run("VerticalHorizontalFilter", func(t *testing.T) {
		ind, err := NewVerticalHorizontalFilter(14)
		if err != nil {
			t.Fatalf("new VerticalHorizontalFilter: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "VerticalHorizontalFilter", got)
	})
	t.Run("Vidya", func(t *testing.T) {
		ind, err := NewVidya(3, 7)
		if err != nil {
			t.Fatalf("new Vidya: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Vidya", got)
	})
	t.Run("VolatilityCone", func(t *testing.T) {
		ind, err := NewVolatilityCone(3, 7)
		if err != nil {
			t.Fatalf("new VolatilityCone: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 5)
		}
		compareGolden(t, "VolatilityCone", got)
	})
	t.Run("VolatilityOfVolatility", func(t *testing.T) {
		ind, err := NewVolatilityOfVolatility(3, 7)
		if err != nil {
			t.Fatalf("new VolatilityOfVolatility: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "VolatilityOfVolatility", got)
	})
	t.Run("VolatilityRatio", func(t *testing.T) {
		ind, err := NewVolatilityRatio(14)
		if err != nil {
			t.Fatalf("new VolatilityRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "VolatilityRatio", got)
	})
	t.Run("VoltyStop", func(t *testing.T) {
		ind, err := NewVoltyStop(14, 2.0)
		if err != nil {
			t.Fatalf("new VoltyStop: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "VoltyStop", got)
	})
	t.Run("VolumeBars", func(t *testing.T) {
		ind, err := NewVolumeBars(500.0)
		if err != nil {
			t.Fatalf("new VolumeBars: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = flattenBars(ind.Update(r[0], r[1], r[2], r[3], r[4], 0))
		}
		compareGolden(t, "VolumeBars", got)
	})
	t.Run("VolumeByTimeProfile", func(t *testing.T) {
		ind, err := NewVolumeByTimeProfile(24, 0)
		if err != nil {
			t.Fatalf("new VolumeByTimeProfile: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			bins, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			if ok {
				got[i] = bins
			} else {
				got[i] = nanRow(24)
			}
		}
		compareGolden(t, "VolumeByTimeProfile", got)
	})
	t.Run("VolumeOscillator", func(t *testing.T) {
		ind, err := NewVolumeOscillator(3, 7)
		if err != nil {
			t.Fatalf("new VolumeOscillator: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "VolumeOscillator", got)
	})
	t.Run("VolumePriceTrend", func(t *testing.T) {
		ind, err := NewVolumePriceTrend()
		if err != nil {
			t.Fatalf("new VolumePriceTrend: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "VolumePriceTrend", got)
	})
	t.Run("VolumeProfile", func(t *testing.T) {
		ind, err := NewVolumeProfile(20, 50)
		if err != nil {
			t.Fatalf("new VolumeProfile: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 52)
		}
		compareGolden(t, "VolumeProfile", got)
	})
	t.Run("VolumeRsi", func(t *testing.T) {
		ind, err := NewVolumeRsi(14)
		if err != nil {
			t.Fatalf("new VolumeRsi: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "VolumeRsi", got)
	})
	t.Run("VolumeWeightedMacd", func(t *testing.T) {
		ind, err := NewVolumeWeightedMacd(3, 7, 14)
		if err != nil {
			t.Fatalf("new VolumeWeightedMacd: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "VolumeWeightedMacd", got)
	})
	t.Run("VolumeWeightedSr", func(t *testing.T) {
		ind, err := NewVolumeWeightedSr(14)
		if err != nil {
			t.Fatalf("new VolumeWeightedSr: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "VolumeWeightedSr", got)
	})
	t.Run("Vortex", func(t *testing.T) {
		ind, err := NewVortex(14)
		if err != nil {
			t.Fatalf("new Vortex: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "Vortex", got)
	})
	t.Run("Vpin", func(t *testing.T) {
		ind, err := NewVpin(5000.0, 10)
		if err != nil {
			t.Fatalf("new Vpin: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3], r[4], r[3] >= r[0], int64(i))}
		}
		compareGolden(t, "Vpin", got)
	})
	t.Run("Vwap", func(t *testing.T) {
		ind, err := NewVwap()
		if err != nil {
			t.Fatalf("new Vwap: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Vwap", got)
	})
	t.Run("VwapStdDevBands", func(t *testing.T) {
		ind, err := NewVwapStdDevBands(2.0)
		if err != nil {
			t.Fatalf("new VwapStdDevBands: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 4)
		}
		compareGolden(t, "VwapStdDevBands", got)
	})
	t.Run("Vwma", func(t *testing.T) {
		ind, err := NewVwma(14)
		if err != nil {
			t.Fatalf("new Vwma: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Vwma", got)
	})
	t.Run("Vzo", func(t *testing.T) {
		ind, err := NewVzo(14)
		if err != nil {
			t.Fatalf("new Vzo: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Vzo", got)
	})
	t.Run("Wad", func(t *testing.T) {
		ind, err := NewWad()
		if err != nil {
			t.Fatalf("new Wad: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Wad", got)
	})
	t.Run("WavePm", func(t *testing.T) {
		ind, err := NewWavePm(3, 7)
		if err != nil {
			t.Fatalf("new WavePm: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "WavePm", got)
	})
	t.Run("WaveTrend", func(t *testing.T) {
		ind, err := NewWaveTrend(3, 7, 14)
		if err != nil {
			t.Fatalf("new WaveTrend: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "WaveTrend", got)
	})
	t.Run("Wedge", func(t *testing.T) {
		ind, err := NewWedge()
		if err != nil {
			t.Fatalf("new Wedge: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "Wedge", got)
	})
	t.Run("WeightedClose", func(t *testing.T) {
		ind, err := NewWeightedClose()
		if err != nil {
			t.Fatalf("new WeightedClose: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "WeightedClose", got)
	})
	t.Run("WickRatio", func(t *testing.T) {
		ind, err := NewWickRatio()
		if err != nil {
			t.Fatalf("new WickRatio: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "WickRatio", got)
	})
	t.Run("WilliamsFractals", func(t *testing.T) {
		ind, err := NewWilliamsFractals()
		if err != nil {
			t.Fatalf("new WilliamsFractals: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "WilliamsFractals", got)
	})
	t.Run("WilliamsR", func(t *testing.T) {
		ind, err := NewWilliamsR(14)
		if err != nil {
			t.Fatalf("new WilliamsR: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "WilliamsR", got)
	})
	t.Run("WinRate", func(t *testing.T) {
		ind, err := NewWinRate(14)
		if err != nil {
			t.Fatalf("new WinRate: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "WinRate", got)
	})
	t.Run("Wma", func(t *testing.T) {
		ind, err := NewWma(14)
		if err != nil {
			t.Fatalf("new Wma: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Wma", got)
	})
	t.Run("WoodiePivots", func(t *testing.T) {
		ind, err := NewWoodiePivots()
		if err != nil {
			t.Fatalf("new WoodiePivots: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 5)
		}
		compareGolden(t, "WoodiePivots", got)
	})
	t.Run("YangZhangVolatility", func(t *testing.T) {
		ind, err := NewYangZhangVolatility(20, 252)
		if err != nil {
			t.Fatalf("new YangZhangVolatility: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "YangZhangVolatility", got)
	})
	t.Run("YoyoExit", func(t *testing.T) {
		ind, err := NewYoyoExit(14, 2.0)
		if err != nil {
			t.Fatalf("new YoyoExit: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}
		}
		compareGolden(t, "YoyoExit", got)
	})
	t.Run("ZScore", func(t *testing.T) {
		ind, err := NewZScore(14)
		if err != nil {
			t.Fatalf("new ZScore: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "ZScore", got)
	})
	t.Run("ZeroLagMacd", func(t *testing.T) {
		ind, err := NewZeroLagMacd(3, 7, 14)
		if err != nil {
			t.Fatalf("new ZeroLagMacd: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[3])
			got[i] = reflectRow(out, ok, 3)
		}
		compareGolden(t, "ZeroLagMacd", got)
	})
	t.Run("ZigZag", func(t *testing.T) {
		ind, err := NewZigZag(0.02)
		if err != nil {
			t.Fatalf("new ZigZag: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			out, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))
			got[i] = reflectRow(out, ok, 2)
		}
		compareGolden(t, "ZigZag", got)
	})
	t.Run("Zlema", func(t *testing.T) {
		ind, err := NewZlema(14)
		if err != nil {
			t.Fatalf("new Zlema: %v", err)
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Zlema", got)
	})
}