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)
		}
		if n := ind.Name(); n != "AbandonedBaby" {
			t.Errorf("name: got %q want %q", n, "AbandonedBaby")
		}
		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)
		}
		if n := ind.Name(); n != "Abcd" {
			t.Errorf("name: got %q want %q", n, "Abcd")
		}
		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)
		}
		if n := ind.Name(); n != "AbsoluteBreadthIndex" {
			t.Errorf("name: got %q want %q", n, "AbsoluteBreadthIndex")
		}
		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)
		}
		if n := ind.Name(); n != "AccelerationBands" {
			t.Errorf("name: got %q want %q", n, "AccelerationBands")
		}
		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)
		}
		if n := ind.Name(); n != "AcceleratorOscillator" {
			t.Errorf("name: got %q want %q", n, "AcceleratorOscillator")
		}
		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)
		}
		if n := ind.Name(); n != "ADOSC" {
			t.Errorf("name: got %q want %q", n, "ADOSC")
		}
		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)
		}
		if n := ind.Name(); n != "AdVolumeLine" {
			t.Errorf("name: got %q want %q", n, "AdVolumeLine")
		}
		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)
		}
		if n := ind.Name(); n != "AdaptiveCci" {
			t.Errorf("name: got %q want %q", n, "AdaptiveCci")
		}
		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)
		}
		if n := ind.Name(); n != "AdaptiveCycle" {
			t.Errorf("name: got %q want %q", n, "AdaptiveCycle")
		}
		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)
		}
		if n := ind.Name(); n != "AdaptiveLaguerre" {
			t.Errorf("name: got %q want %q", n, "AdaptiveLaguerre")
		}
		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)
		}
		if n := ind.Name(); n != "AdaptiveRsi" {
			t.Errorf("name: got %q want %q", n, "AdaptiveRsi")
		}
		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)
		}
		if n := ind.Name(); n != "ADL" {
			t.Errorf("name: got %q want %q", n, "ADL")
		}
		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)
		}
		if n := ind.Name(); n != "AdvanceBlock" {
			t.Errorf("name: got %q want %q", n, "AdvanceBlock")
		}
		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)
		}
		if n := ind.Name(); n != "AdvanceDecline" {
			t.Errorf("name: got %q want %q", n, "AdvanceDecline")
		}
		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)
		}
		if n := ind.Name(); n != "AdvanceDeclineRatio" {
			t.Errorf("name: got %q want %q", n, "AdvanceDeclineRatio")
		}
		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)
		}
		if n := ind.Name(); n != "ADX" {
			t.Errorf("name: got %q want %q", n, "ADX")
		}
		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)
		}
		if n := ind.Name(); n != "ADXR" {
			t.Errorf("name: got %q want %q", n, "ADXR")
		}
		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)
		}
		if n := ind.Name(); n != "Alligator" {
			t.Errorf("name: got %q want %q", n, "Alligator")
		}
		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)
		}
		if n := ind.Name(); n != "ALMA" {
			t.Errorf("name: got %q want %q", n, "ALMA")
		}
		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)
		}
		if n := ind.Name(); n != "Alpha" {
			t.Errorf("name: got %q want %q", n, "Alpha")
		}
		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)
		}
		if n := ind.Name(); n != "AmihudIlliquidity" {
			t.Errorf("name: got %q want %q", n, "AmihudIlliquidity")
		}
		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)
		}
		if n := ind.Name(); n != "AnchoredRSI" {
			t.Errorf("name: got %q want %q", n, "AnchoredRSI")
		}
		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)
		}
		if n := ind.Name(); n != "AnchoredVWAP" {
			t.Errorf("name: got %q want %q", n, "AnchoredVWAP")
		}
		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)
		}
		if n := ind.Name(); n != "AndrewsPitchfork" {
			t.Errorf("name: got %q want %q", n, "AndrewsPitchfork")
		}
		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)
		}
		if n := ind.Name(); n != "APO" {
			t.Errorf("name: got %q want %q", n, "APO")
		}
		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)
		}
		if n := ind.Name(); n != "Aroon" {
			t.Errorf("name: got %q want %q", n, "Aroon")
		}
		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)
		}
		if n := ind.Name(); n != "AroonOscillator" {
			t.Errorf("name: got %q want %q", n, "AroonOscillator")
		}
		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)
		}
		if n := ind.Name(); n != "ATR" {
			t.Errorf("name: got %q want %q", n, "ATR")
		}
		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)
		}
		if n := ind.Name(); n != "AtrBands" {
			t.Errorf("name: got %q want %q", n, "AtrBands")
		}
		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)
		}
		if n := ind.Name(); n != "AtrRatchet" {
			t.Errorf("name: got %q want %q", n, "AtrRatchet")
		}
		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)
		}
		if n := ind.Name(); n != "AtrTrailingStop" {
			t.Errorf("name: got %q want %q", n, "AtrTrailingStop")
		}
		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)
		}
		if n := ind.Name(); n != "AutoFib" {
			t.Errorf("name: got %q want %q", n, "AutoFib")
		}
		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)
		}
		if n := ind.Name(); n != "Autocorrelation" {
			t.Errorf("name: got %q want %q", n, "Autocorrelation")
		}
		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)
		}
		if n := ind.Name(); n != "AutocorrelationPeriodogram" {
			t.Errorf("name: got %q want %q", n, "AutocorrelationPeriodogram")
		}
		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)
		}
		if n := ind.Name(); n != "AverageDailyRange" {
			t.Errorf("name: got %q want %q", n, "AverageDailyRange")
		}
		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)
		}
		if n := ind.Name(); n != "AverageDrawdown" {
			t.Errorf("name: got %q want %q", n, "AverageDrawdown")
		}
		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)
		}
		if n := ind.Name(); n != "AVGPRICE" {
			t.Errorf("name: got %q want %q", n, "AVGPRICE")
		}
		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)
		}
		if n := ind.Name(); n != "AwesomeOscillator" {
			t.Errorf("name: got %q want %q", n, "AwesomeOscillator")
		}
		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)
		}
		if n := ind.Name(); n != "AwesomeOscillatorHistogram" {
			t.Errorf("name: got %q want %q", n, "AwesomeOscillatorHistogram")
		}
		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)
		}
		if n := ind.Name(); n != "BalanceOfPower" {
			t.Errorf("name: got %q want %q", n, "BalanceOfPower")
		}
		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)
		}
		if n := ind.Name(); n != "BandpassFilter" {
			t.Errorf("name: got %q want %q", n, "BandpassFilter")
		}
		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)
		}
		if n := ind.Name(); n != "Bat" {
			t.Errorf("name: got %q want %q", n, "Bat")
		}
		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)
		}
		if n := ind.Name(); n != "BeltHold" {
			t.Errorf("name: got %q want %q", n, "BeltHold")
		}
		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)
		}
		if n := ind.Name(); n != "Beta" {
			t.Errorf("name: got %q want %q", n, "Beta")
		}
		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)
		}
		if n := ind.Name(); n != "BetaNeutralSpread" {
			t.Errorf("name: got %q want %q", n, "BetaNeutralSpread")
		}
		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)
		}
		if n := ind.Name(); n != "BetterVolume" {
			t.Errorf("name: got %q want %q", n, "BetterVolume")
		}
		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)
		}
		if n := ind.Name(); n != "BipowerVariation" {
			t.Errorf("name: got %q want %q", n, "BipowerVariation")
		}
		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)
		}
		if n := ind.Name(); n != "BodySizePct" {
			t.Errorf("name: got %q want %q", n, "BodySizePct")
		}
		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)
		}
		if n := ind.Name(); n != "BollingerBands" {
			t.Errorf("name: got %q want %q", n, "BollingerBands")
		}
		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)
		}
		if n := ind.Name(); n != "BollingerBandwidth" {
			t.Errorf("name: got %q want %q", n, "BollingerBandwidth")
		}
		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)
		}
		if n := ind.Name(); n != "BomarBands" {
			t.Errorf("name: got %q want %q", n, "BomarBands")
		}
		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)
		}
		if n := ind.Name(); n != "BreadthThrust" {
			t.Errorf("name: got %q want %q", n, "BreadthThrust")
		}
		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)
		}
		if n := ind.Name(); n != "Breakaway" {
			t.Errorf("name: got %q want %q", n, "Breakaway")
		}
		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)
		}
		if n := ind.Name(); n != "BullishPercentIndex" {
			t.Errorf("name: got %q want %q", n, "BullishPercentIndex")
		}
		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)
		}
		if n := ind.Name(); n != "BurkeRatio" {
			t.Errorf("name: got %q want %q", n, "BurkeRatio")
		}
		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)
		}
		if n := ind.Name(); n != "Butterfly" {
			t.Errorf("name: got %q want %q", n, "Butterfly")
		}
		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)
		}
		if n := ind.Name(); n != "CalendarSpread" {
			t.Errorf("name: got %q want %q", n, "CalendarSpread")
		}
		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)
		}
		if n := ind.Name(); n != "CalmarRatio" {
			t.Errorf("name: got %q want %q", n, "CalmarRatio")
		}
		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)
		}
		if n := ind.Name(); n != "Camarilla" {
			t.Errorf("name: got %q want %q", n, "Camarilla")
		}
		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)
		}
		if n := ind.Name(); n != "CandleVolume" {
			t.Errorf("name: got %q want %q", n, "CandleVolume")
		}
		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)
		}
		if n := ind.Name(); n != "CCI" {
			t.Errorf("name: got %q want %q", n, "CCI")
		}
		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)
		}
		if n := ind.Name(); n != "CenterOfGravity" {
			t.Errorf("name: got %q want %q", n, "CenterOfGravity")
		}
		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)
		}
		if n := ind.Name(); n != "CentralPivotRange" {
			t.Errorf("name: got %q want %q", n, "CentralPivotRange")
		}
		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)
		}
		if n := ind.Name(); n != "CFO" {
			t.Errorf("name: got %q want %q", n, "CFO")
		}
		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)
		}
		if n := ind.Name(); n != "CMF" {
			t.Errorf("name: got %q want %q", n, "CMF")
		}
		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)
		}
		if n := ind.Name(); n != "ChaikinOscillator" {
			t.Errorf("name: got %q want %q", n, "ChaikinOscillator")
		}
		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)
		}
		if n := ind.Name(); n != "ChaikinVolatility" {
			t.Errorf("name: got %q want %q", n, "ChaikinVolatility")
		}
		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)
		}
		if n := ind.Name(); n != "ChandeKrollStop" {
			t.Errorf("name: got %q want %q", n, "ChandeKrollStop")
		}
		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)
		}
		if n := ind.Name(); n != "ChandelierExit" {
			t.Errorf("name: got %q want %q", n, "ChandelierExit")
		}
		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)
		}
		if n := ind.Name(); n != "ChoppinessIndex" {
			t.Errorf("name: got %q want %q", n, "ChoppinessIndex")
		}
		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)
		}
		if n := ind.Name(); n != "ClassicPivots" {
			t.Errorf("name: got %q want %q", n, "ClassicPivots")
		}
		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)
		}
		if n := ind.Name(); n != "CloseVsOpen" {
			t.Errorf("name: got %q want %q", n, "CloseVsOpen")
		}
		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)
		}
		if n := ind.Name(); n != "ClosingMarubozu" {
			t.Errorf("name: got %q want %q", n, "ClosingMarubozu")
		}
		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)
		}
		if n := ind.Name(); n != "CMO" {
			t.Errorf("name: got %q want %q", n, "CMO")
		}
		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)
		}
		if n := ind.Name(); n != "CoefficientOfVariation" {
			t.Errorf("name: got %q want %q", n, "CoefficientOfVariation")
		}
		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)
		}
		if n := ind.Name(); n != "Cointegration" {
			t.Errorf("name: got %q want %q", n, "Cointegration")
		}
		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)
		}
		if n := ind.Name(); n != "CommonSenseRatio" {
			t.Errorf("name: got %q want %q", n, "CommonSenseRatio")
		}
		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)
		}
		if n := ind.Name(); n != "CompositeProfile" {
			t.Errorf("name: got %q want %q", n, "CompositeProfile")
		}
		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)
		}
		if n := ind.Name(); n != "ConcealingBabySwallow" {
			t.Errorf("name: got %q want %q", n, "ConcealingBabySwallow")
		}
		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)
		}
		if n := ind.Name(); n != "ConditionalValueAtRisk" {
			t.Errorf("name: got %q want %q", n, "ConditionalValueAtRisk")
		}
		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)
		}
		if n := ind.Name(); n != "ConnorsRSI" {
			t.Errorf("name: got %q want %q", n, "ConnorsRSI")
		}
		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)
		}
		if n := ind.Name(); n != "Coppock" {
			t.Errorf("name: got %q want %q", n, "Coppock")
		}
		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)
		}
		if n := ind.Name(); n != "CorrelationTrendIndicator" {
			t.Errorf("name: got %q want %q", n, "CorrelationTrendIndicator")
		}
		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)
		}
		if n := ind.Name(); n != "Counterattack" {
			t.Errorf("name: got %q want %q", n, "Counterattack")
		}
		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)
		}
		if n := ind.Name(); n != "Crab" {
			t.Errorf("name: got %q want %q", n, "Crab")
		}
		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)
		}
		if n := ind.Name(); n != "CumulativeVolumeDelta" {
			t.Errorf("name: got %q want %q", n, "CumulativeVolumeDelta")
		}
		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)
		}
		if n := ind.Name(); n != "CumulativeVolumeIndex" {
			t.Errorf("name: got %q want %q", n, "CumulativeVolumeIndex")
		}
		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)
		}
		if n := ind.Name(); n != "CupAndHandle" {
			t.Errorf("name: got %q want %q", n, "CupAndHandle")
		}
		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)
		}
		if n := ind.Name(); n != "CyberneticCycle" {
			t.Errorf("name: got %q want %q", n, "CyberneticCycle")
		}
		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)
		}
		if n := ind.Name(); n != "Cypher" {
			t.Errorf("name: got %q want %q", n, "Cypher")
		}
		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)
		}
		if n := ind.Name(); n != "DayOfWeekProfile" {
			t.Errorf("name: got %q want %q", n, "DayOfWeekProfile")
		}
		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)
		}
		if n := ind.Name(); n != "Decycler" {
			t.Errorf("name: got %q want %q", n, "Decycler")
		}
		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)
		}
		if n := ind.Name(); n != "DecyclerOscillator" {
			t.Errorf("name: got %q want %q", n, "DecyclerOscillator")
		}
		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)
		}
		if n := ind.Name(); n != "DEMA" {
			t.Errorf("name: got %q want %q", n, "DEMA")
		}
		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)
		}
		if n := ind.Name(); n != "DemandIndex" {
			t.Errorf("name: got %q want %q", n, "DemandIndex")
		}
		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)
		}
		if n := ind.Name(); n != "DemarkPivots" {
			t.Errorf("name: got %q want %q", n, "DemarkPivots")
		}
		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)
		}
		if n := ind.Name(); n != "DepthSlope" {
			t.Errorf("name: got %q want %q", n, "DepthSlope")
		}
		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)
		}
		if n := ind.Name(); n != "DerivativeOscillator" {
			t.Errorf("name: got %q want %q", n, "DerivativeOscillator")
		}
		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)
		}
		if n := ind.Name(); n != "DetrendedStdDev" {
			t.Errorf("name: got %q want %q", n, "DetrendedStdDev")
		}
		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)
		}
		if n := ind.Name(); n != "DisparityIndex" {
			t.Errorf("name: got %q want %q", n, "DisparityIndex")
		}
		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)
		}
		if n := ind.Name(); n != "DistanceSsd" {
			t.Errorf("name: got %q want %q", n, "DistanceSsd")
		}
		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)
		}
		if n := ind.Name(); n != "Doji" {
			t.Errorf("name: got %q want %q", n, "Doji")
		}
		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)
		}
		if n := ind.Name(); n != "DojiStar" {
			t.Errorf("name: got %q want %q", n, "DojiStar")
		}
		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)
		}
		if n := ind.Name(); n != "DollarBars" {
			t.Errorf("name: got %q want %q", n, "DollarBars")
		}
		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)
		}
		if n := ind.Name(); n != "DonchianChannels" {
			t.Errorf("name: got %q want %q", n, "DonchianChannels")
		}
		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)
		}
		if n := ind.Name(); n != "DonchianStop" {
			t.Errorf("name: got %q want %q", n, "DonchianStop")
		}
		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)
		}
		if n := ind.Name(); n != "DoubleBollinger" {
			t.Errorf("name: got %q want %q", n, "DoubleBollinger")
		}
		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)
		}
		if n := ind.Name(); n != "DoubleTopBottom" {
			t.Errorf("name: got %q want %q", n, "DoubleTopBottom")
		}
		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)
		}
		if n := ind.Name(); n != "DownsideGapThreeMethods" {
			t.Errorf("name: got %q want %q", n, "DownsideGapThreeMethods")
		}
		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)
		}
		if n := ind.Name(); n != "DPO" {
			t.Errorf("name: got %q want %q", n, "DPO")
		}
		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)
		}
		if n := ind.Name(); n != "DragonflyDoji" {
			t.Errorf("name: got %q want %q", n, "DragonflyDoji")
		}
		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)
		}
		if n := ind.Name(); n != "DrawdownDuration" {
			t.Errorf("name: got %q want %q", n, "DrawdownDuration")
		}
		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)
		}
		if n := ind.Name(); n != "DumplingTop" {
			t.Errorf("name: got %q want %q", n, "DumplingTop")
		}
		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)
		}
		if n := ind.Name(); n != "DX" {
			t.Errorf("name: got %q want %q", n, "DX")
		}
		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)
		}
		if n := ind.Name(); n != "DynamicMomentumIndex" {
			t.Errorf("name: got %q want %q", n, "DynamicMomentumIndex")
		}
		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)
		}
		if n := ind.Name(); n != "EaseOfMovement" {
			t.Errorf("name: got %q want %q", n, "EaseOfMovement")
		}
		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)
		}
		if n := ind.Name(); n != "EffectiveSpread" {
			t.Errorf("name: got %q want %q", n, "EffectiveSpread")
		}
		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)
		}
		if n := ind.Name(); n != "EhlersStochastic" {
			t.Errorf("name: got %q want %q", n, "EhlersStochastic")
		}
		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)
		}
		if n := ind.Name(); n != "EHMA" {
			t.Errorf("name: got %q want %q", n, "EHMA")
		}
		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)
		}
		if n := ind.Name(); n != "ElderImpulse" {
			t.Errorf("name: got %q want %q", n, "ElderImpulse")
		}
		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)
		}
		if n := ind.Name(); n != "ElderRay" {
			t.Errorf("name: got %q want %q", n, "ElderRay")
		}
		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)
		}
		if n := ind.Name(); n != "ElderSafeZone" {
			t.Errorf("name: got %q want %q", n, "ElderSafeZone")
		}
		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)
		}
		if n := ind.Name(); n != "EMA" {
			t.Errorf("name: got %q want %q", n, "EMA")
		}
		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)
		}
		if n := ind.Name(); n != "EmpiricalModeDecomposition" {
			t.Errorf("name: got %q want %q", n, "EmpiricalModeDecomposition")
		}
		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)
		}
		if n := ind.Name(); n != "Engulfing" {
			t.Errorf("name: got %q want %q", n, "Engulfing")
		}
		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)
		}
		if n := ind.Name(); n != "Equivolume" {
			t.Errorf("name: got %q want %q", n, "Equivolume")
		}
		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)
		}
		if n := ind.Name(); n != "EstimatedLeverageRatio" {
			t.Errorf("name: got %q want %q", n, "EstimatedLeverageRatio")
		}
		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)
		}
		if n := ind.Name(); n != "EvenBetterSinewave" {
			t.Errorf("name: got %q want %q", n, "EvenBetterSinewave")
		}
		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)
		}
		if n := ind.Name(); n != "EveningDojiStar" {
			t.Errorf("name: got %q want %q", n, "EveningDojiStar")
		}
		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)
		}
		if n := ind.Name(); n != "EVWMA" {
			t.Errorf("name: got %q want %q", n, "EVWMA")
		}
		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)
		}
		if n := ind.Name(); n != "EwmaVolatility" {
			t.Errorf("name: got %q want %q", n, "EwmaVolatility")
		}
		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)
		}
		if n := ind.Name(); n != "Expectancy" {
			t.Errorf("name: got %q want %q", n, "Expectancy")
		}
		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)
		}
		if n := ind.Name(); n != "FallingThreeMethods" {
			t.Errorf("name: got %q want %q", n, "FallingThreeMethods")
		}
		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)
		}
		if n := ind.Name(); n != "FAMA" {
			t.Errorf("name: got %q want %q", n, "FAMA")
		}
		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)
		}
		if n := ind.Name(); n != "FibArcs" {
			t.Errorf("name: got %q want %q", n, "FibArcs")
		}
		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)
		}
		if n := ind.Name(); n != "FibChannel" {
			t.Errorf("name: got %q want %q", n, "FibChannel")
		}
		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)
		}
		if n := ind.Name(); n != "FibConfluence" {
			t.Errorf("name: got %q want %q", n, "FibConfluence")
		}
		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)
		}
		if n := ind.Name(); n != "FibExtension" {
			t.Errorf("name: got %q want %q", n, "FibExtension")
		}
		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)
		}
		if n := ind.Name(); n != "FibFan" {
			t.Errorf("name: got %q want %q", n, "FibFan")
		}
		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)
		}
		if n := ind.Name(); n != "FibProjection" {
			t.Errorf("name: got %q want %q", n, "FibProjection")
		}
		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)
		}
		if n := ind.Name(); n != "FibRetracement" {
			t.Errorf("name: got %q want %q", n, "FibRetracement")
		}
		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)
		}
		if n := ind.Name(); n != "FibTimeZones" {
			t.Errorf("name: got %q want %q", n, "FibTimeZones")
		}
		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)
		}
		if n := ind.Name(); n != "FibonacciPivots" {
			t.Errorf("name: got %q want %q", n, "FibonacciPivots")
		}
		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)
		}
		if n := ind.Name(); n != "FisherRSI" {
			t.Errorf("name: got %q want %q", n, "FisherRSI")
		}
		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)
		}
		if n := ind.Name(); n != "FisherTransform" {
			t.Errorf("name: got %q want %q", n, "FisherTransform")
		}
		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)
		}
		if n := ind.Name(); n != "FlagPennant" {
			t.Errorf("name: got %q want %q", n, "FlagPennant")
		}
		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)
		}
		if n := ind.Name(); n != "Footprint" {
			t.Errorf("name: got %q want %q", n, "Footprint")
		}
		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)
		}
		if n := ind.Name(); n != "ForceIndex" {
			t.Errorf("name: got %q want %q", n, "ForceIndex")
		}
		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)
		}
		if n := ind.Name(); n != "FractalChaosBands" {
			t.Errorf("name: got %q want %q", n, "FractalChaosBands")
		}
		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)
		}
		if n := ind.Name(); n != "FRAMA" {
			t.Errorf("name: got %q want %q", n, "FRAMA")
		}
		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)
		}
		if n := ind.Name(); n != "FryPanBottom" {
			t.Errorf("name: got %q want %q", n, "FryPanBottom")
		}
		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)
		}
		if n := ind.Name(); n != "FundingBasis" {
			t.Errorf("name: got %q want %q", n, "FundingBasis")
		}
		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)
		}
		if n := ind.Name(); n != "FundingImpliedApr" {
			t.Errorf("name: got %q want %q", n, "FundingImpliedApr")
		}
		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)
		}
		if n := ind.Name(); n != "FundingRate" {
			t.Errorf("name: got %q want %q", n, "FundingRate")
		}
		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)
		}
		if n := ind.Name(); n != "FundingRateMean" {
			t.Errorf("name: got %q want %q", n, "FundingRateMean")
		}
		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)
		}
		if n := ind.Name(); n != "FundingRateZScore" {
			t.Errorf("name: got %q want %q", n, "FundingRateZScore")
		}
		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)
		}
		if n := ind.Name(); n != "GainLossRatio" {
			t.Errorf("name: got %q want %q", n, "GainLossRatio")
		}
		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)
		}
		if n := ind.Name(); n != "GainToPainRatio" {
			t.Errorf("name: got %q want %q", n, "GainToPainRatio")
		}
		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)
		}
		if n := ind.Name(); n != "GapSideBySideWhite" {
			t.Errorf("name: got %q want %q", n, "GapSideBySideWhite")
		}
		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)
		}
		if n := ind.Name(); n != "Garch11" {
			t.Errorf("name: got %q want %q", n, "Garch11")
		}
		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)
		}
		if n := ind.Name(); n != "GarmanKlassVolatility" {
			t.Errorf("name: got %q want %q", n, "GarmanKlassVolatility")
		}
		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)
		}
		if n := ind.Name(); n != "Gartley" {
			t.Errorf("name: got %q want %q", n, "Gartley")
		}
		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)
		}
		if n := ind.Name(); n != "GatorOscillator" {
			t.Errorf("name: got %q want %q", n, "GatorOscillator")
		}
		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)
		}
		if n := ind.Name(); n != "GD" {
			t.Errorf("name: got %q want %q", n, "GD")
		}
		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)
		}
		if n := ind.Name(); n != "GMA" {
			t.Errorf("name: got %q want %q", n, "GMA")
		}
		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)
		}
		if n := ind.Name(); n != "GoldenPocket" {
			t.Errorf("name: got %q want %q", n, "GoldenPocket")
		}
		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)
		}
		if n := ind.Name(); n != "GrangerCausality" {
			t.Errorf("name: got %q want %q", n, "GrangerCausality")
		}
		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)
		}
		if n := ind.Name(); n != "GravestoneDoji" {
			t.Errorf("name: got %q want %q", n, "GravestoneDoji")
		}
		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)
		}
		if n := ind.Name(); n != "Hammer" {
			t.Errorf("name: got %q want %q", n, "Hammer")
		}
		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)
		}
		if n := ind.Name(); n != "HangingMan" {
			t.Errorf("name: got %q want %q", n, "HangingMan")
		}
		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)
		}
		if n := ind.Name(); n != "Harami" {
			t.Errorf("name: got %q want %q", n, "Harami")
		}
		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)
		}
		if n := ind.Name(); n != "HaramiCross" {
			t.Errorf("name: got %q want %q", n, "HaramiCross")
		}
		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)
		}
		if n := ind.Name(); n != "HasbrouckInformationShare" {
			t.Errorf("name: got %q want %q", n, "HasbrouckInformationShare")
		}
		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)
		}
		if n := ind.Name(); n != "HeadAndShoulders" {
			t.Errorf("name: got %q want %q", n, "HeadAndShoulders")
		}
		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)
		}
		if n := ind.Name(); n != "HeikinAshi" {
			t.Errorf("name: got %q want %q", n, "HeikinAshi")
		}
		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)
		}
		if n := ind.Name(); n != "HeikinAshiOscillator" {
			t.Errorf("name: got %q want %q", n, "HeikinAshiOscillator")
		}
		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)
		}
		if n := ind.Name(); n != "HiLoActivator" {
			t.Errorf("name: got %q want %q", n, "HiLoActivator")
		}
		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)
		}
		if n := ind.Name(); n != "HighLowIndex" {
			t.Errorf("name: got %q want %q", n, "HighLowIndex")
		}
		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)
		}
		if n := ind.Name(); n != "HighLowRange" {
			t.Errorf("name: got %q want %q", n, "HighLowRange")
		}
		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)
		}
		if n := ind.Name(); n != "HighLowVolumeNodes" {
			t.Errorf("name: got %q want %q", n, "HighLowVolumeNodes")
		}
		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)
		}
		if n := ind.Name(); n != "HighWave" {
			t.Errorf("name: got %q want %q", n, "HighWave")
		}
		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)
		}
		if n := ind.Name(); n != "HighpassFilter" {
			t.Errorf("name: got %q want %q", n, "HighpassFilter")
		}
		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)
		}
		if n := ind.Name(); n != "Hikkake" {
			t.Errorf("name: got %q want %q", n, "Hikkake")
		}
		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)
		}
		if n := ind.Name(); n != "HikkakeModified" {
			t.Errorf("name: got %q want %q", n, "HikkakeModified")
		}
		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)
		}
		if n := ind.Name(); n != "HilbertDominantCycle" {
			t.Errorf("name: got %q want %q", n, "HilbertDominantCycle")
		}
		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)
		}
		if n := ind.Name(); n != "HistoricalVolatility" {
			t.Errorf("name: got %q want %q", n, "HistoricalVolatility")
		}
		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)
		}
		if n := ind.Name(); n != "HMA" {
			t.Errorf("name: got %q want %q", n, "HMA")
		}
		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)
		}
		if n := ind.Name(); n != "HoltWinters" {
			t.Errorf("name: got %q want %q", n, "HoltWinters")
		}
		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)
		}
		if n := ind.Name(); n != "HomingPigeon" {
			t.Errorf("name: got %q want %q", n, "HomingPigeon")
		}
		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)
		}
		if n := ind.Name(); n != "HT_DCPHASE" {
			t.Errorf("name: got %q want %q", n, "HT_DCPHASE")
		}
		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)
		}
		if n := ind.Name(); n != "HT_PHASOR" {
			t.Errorf("name: got %q want %q", n, "HT_PHASOR")
		}
		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)
		}
		if n := ind.Name(); n != "HT_TRENDMODE" {
			t.Errorf("name: got %q want %q", n, "HT_TRENDMODE")
		}
		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)
		}
		if n := ind.Name(); n != "HurstChannel" {
			t.Errorf("name: got %q want %q", n, "HurstChannel")
		}
		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)
		}
		if n := ind.Name(); n != "HurstExponent" {
			t.Errorf("name: got %q want %q", n, "HurstExponent")
		}
		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)
		}
		if n := ind.Name(); n != "Ichimoku" {
			t.Errorf("name: got %q want %q", n, "Ichimoku")
		}
		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)
		}
		if n := ind.Name(); n != "IdenticalThreeCrows" {
			t.Errorf("name: got %q want %q", n, "IdenticalThreeCrows")
		}
		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)
		}
		if n := ind.Name(); n != "ImbalanceBars" {
			t.Errorf("name: got %q want %q", n, "ImbalanceBars")
		}
		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)
		}
		if n := ind.Name(); n != "InNeck" {
			t.Errorf("name: got %q want %q", n, "InNeck")
		}
		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)
		}
		if n := ind.Name(); n != "Inertia" {
			t.Errorf("name: got %q want %q", n, "Inertia")
		}
		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)
		}
		if n := ind.Name(); n != "InformationRatio" {
			t.Errorf("name: got %q want %q", n, "InformationRatio")
		}
		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)
		}
		if n := ind.Name(); n != "InitialBalance" {
			t.Errorf("name: got %q want %q", n, "InitialBalance")
		}
		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)
		}
		if n := ind.Name(); n != "InstantaneousTrendline" {
			t.Errorf("name: got %q want %q", n, "InstantaneousTrendline")
		}
		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)
		}
		if n := ind.Name(); n != "IntradayIntensity" {
			t.Errorf("name: got %q want %q", n, "IntradayIntensity")
		}
		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)
		}
		if n := ind.Name(); n != "IMI" {
			t.Errorf("name: got %q want %q", n, "IMI")
		}
		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)
		}
		if n := ind.Name(); n != "IntradayVolatilityProfile" {
			t.Errorf("name: got %q want %q", n, "IntradayVolatilityProfile")
		}
		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)
		}
		if n := ind.Name(); n != "InverseFisherTransform" {
			t.Errorf("name: got %q want %q", n, "InverseFisherTransform")
		}
		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)
		}
		if n := ind.Name(); n != "InvertedHammer" {
			t.Errorf("name: got %q want %q", n, "InvertedHammer")
		}
		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)
		}
		if n := ind.Name(); n != "JarqueBera" {
			t.Errorf("name: got %q want %q", n, "JarqueBera")
		}
		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)
		}
		if n := ind.Name(); n != "JMA" {
			t.Errorf("name: got %q want %q", n, "JMA")
		}
		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)
		}
		if n := ind.Name(); n != "JumpIndicator" {
			t.Errorf("name: got %q want %q", n, "JumpIndicator")
		}
		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)
		}
		if n := ind.Name(); n != "KRatio" {
			t.Errorf("name: got %q want %q", n, "KRatio")
		}
		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)
		}
		if n := ind.Name(); n != "KagiBars" {
			t.Errorf("name: got %q want %q", n, "KagiBars")
		}
		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)
		}
		if n := ind.Name(); n != "KalmanHedgeRatio" {
			t.Errorf("name: got %q want %q", n, "KalmanHedgeRatio")
		}
		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)
		}
		if n := ind.Name(); n != "KAMA" {
			t.Errorf("name: got %q want %q", n, "KAMA")
		}
		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)
		}
		if n := ind.Name(); n != "KaseDevStop" {
			t.Errorf("name: got %q want %q", n, "KaseDevStop")
		}
		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)
		}
		if n := ind.Name(); n != "KasePermissionStochastic" {
			t.Errorf("name: got %q want %q", n, "KasePermissionStochastic")
		}
		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)
		}
		if n := ind.Name(); n != "KellyCriterion" {
			t.Errorf("name: got %q want %q", n, "KellyCriterion")
		}
		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)
		}
		if n := ind.Name(); n != "KeltnerChannels" {
			t.Errorf("name: got %q want %q", n, "KeltnerChannels")
		}
		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)
		}
		if n := ind.Name(); n != "KendallTau" {
			t.Errorf("name: got %q want %q", n, "KendallTau")
		}
		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)
		}
		if n := ind.Name(); n != "Kicking" {
			t.Errorf("name: got %q want %q", n, "Kicking")
		}
		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)
		}
		if n := ind.Name(); n != "KickingByLength" {
			t.Errorf("name: got %q want %q", n, "KickingByLength")
		}
		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)
		}
		if n := ind.Name(); n != "KST" {
			t.Errorf("name: got %q want %q", n, "KST")
		}
		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)
		}
		if n := ind.Name(); n != "Kurtosis" {
			t.Errorf("name: got %q want %q", n, "Kurtosis")
		}
		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)
		}
		if n := ind.Name(); n != "KVO" {
			t.Errorf("name: got %q want %q", n, "KVO")
		}
		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)
		}
		if n := ind.Name(); n != "KylesLambda" {
			t.Errorf("name: got %q want %q", n, "KylesLambda")
		}
		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)
		}
		if n := ind.Name(); n != "LadderBottom" {
			t.Errorf("name: got %q want %q", n, "LadderBottom")
		}
		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)
		}
		if n := ind.Name(); n != "LaguerreRSI" {
			t.Errorf("name: got %q want %q", n, "LaguerreRSI")
		}
		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)
		}
		if n := ind.Name(); n != "LeadLagCrossCorrelation" {
			t.Errorf("name: got %q want %q", n, "LeadLagCrossCorrelation")
		}
		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)
		}
		if n := ind.Name(); n != "LinRegAngle" {
			t.Errorf("name: got %q want %q", n, "LinRegAngle")
		}
		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)
		}
		if n := ind.Name(); n != "LinRegChannel" {
			t.Errorf("name: got %q want %q", n, "LinRegChannel")
		}
		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)
		}
		if n := ind.Name(); n != "LINEARREG_INTERCEPT" {
			t.Errorf("name: got %q want %q", n, "LINEARREG_INTERCEPT")
		}
		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)
		}
		if n := ind.Name(); n != "LinRegSlope" {
			t.Errorf("name: got %q want %q", n, "LinRegSlope")
		}
		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)
		}
		if n := ind.Name(); n != "LinearRegression" {
			t.Errorf("name: got %q want %q", n, "LinearRegression")
		}
		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)
		}
		if n := ind.Name(); n != "LiquidationFeatures" {
			t.Errorf("name: got %q want %q", n, "LiquidationFeatures")
		}
		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)
		}
		if n := ind.Name(); n != "LogReturn" {
			t.Errorf("name: got %q want %q", n, "LogReturn")
		}
		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)
		}
		if n := ind.Name(); n != "LongLeggedDoji" {
			t.Errorf("name: got %q want %q", n, "LongLeggedDoji")
		}
		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)
		}
		if n := ind.Name(); n != "LongLine" {
			t.Errorf("name: got %q want %q", n, "LongLine")
		}
		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)
		}
		if n := ind.Name(); n != "LongShortRatio" {
			t.Errorf("name: got %q want %q", n, "LongShortRatio")
		}
		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)
		}
		if n := ind.Name(); n != "M2Measure" {
			t.Errorf("name: got %q want %q", n, "M2Measure")
		}
		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)
		}
		if n := ind.Name(); n != "MaEnvelope" {
			t.Errorf("name: got %q want %q", n, "MaEnvelope")
		}
		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)
		}
		if n := ind.Name(); n != "MACDEXT" {
			t.Errorf("name: got %q want %q", n, "MACDEXT")
		}
		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)
		}
		if n := ind.Name(); n != "MACDFIX" {
			t.Errorf("name: got %q want %q", n, "MACDFIX")
		}
		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)
		}
		if n := ind.Name(); n != "MacdHistogram" {
			t.Errorf("name: got %q want %q", n, "MacdHistogram")
		}
		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)
		}
		if n := ind.Name(); n != "MACD" {
			t.Errorf("name: got %q want %q", n, "MACD")
		}
		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)
		}
		if n := ind.Name(); n != "MAMA" {
			t.Errorf("name: got %q want %q", n, "MAMA")
		}
		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)
		}
		if n := ind.Name(); n != "MarketFacilitationIndex" {
			t.Errorf("name: got %q want %q", n, "MarketFacilitationIndex")
		}
		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)
		}
		if n := ind.Name(); n != "MartinRatio" {
			t.Errorf("name: got %q want %q", n, "MartinRatio")
		}
		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)
		}
		if n := ind.Name(); n != "Marubozu" {
			t.Errorf("name: got %q want %q", n, "Marubozu")
		}
		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)
		}
		if n := ind.Name(); n != "MassIndex" {
			t.Errorf("name: got %q want %q", n, "MassIndex")
		}
		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)
		}
		if n := ind.Name(); n != "MatHold" {
			t.Errorf("name: got %q want %q", n, "MatHold")
		}
		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)
		}
		if n := ind.Name(); n != "MatchingLow" {
			t.Errorf("name: got %q want %q", n, "MatchingLow")
		}
		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)
		}
		if n := ind.Name(); n != "MaxDrawdown" {
			t.Errorf("name: got %q want %q", n, "MaxDrawdown")
		}
		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)
		}
		if n := ind.Name(); n != "McClellanOscillator" {
			t.Errorf("name: got %q want %q", n, "McClellanOscillator")
		}
		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)
		}
		if n := ind.Name(); n != "McClellanSummationIndex" {
			t.Errorf("name: got %q want %q", n, "McClellanSummationIndex")
		}
		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)
		}
		if n := ind.Name(); n != "McGinleyDynamic" {
			t.Errorf("name: got %q want %q", n, "McGinleyDynamic")
		}
		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)
		}
		if n := ind.Name(); n != "MedianAbsoluteDeviation" {
			t.Errorf("name: got %q want %q", n, "MedianAbsoluteDeviation")
		}
		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)
		}
		if n := ind.Name(); n != "MedianChannel" {
			t.Errorf("name: got %q want %q", n, "MedianChannel")
		}
		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)
		}
		if n := ind.Name(); n != "MedianMA" {
			t.Errorf("name: got %q want %q", n, "MedianMA")
		}
		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)
		}
		if n := ind.Name(); n != "MedianPrice" {
			t.Errorf("name: got %q want %q", n, "MedianPrice")
		}
		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)
		}
		if n := ind.Name(); n != "MFI" {
			t.Errorf("name: got %q want %q", n, "MFI")
		}
		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)
		}
		if n := ind.Name(); n != "Microprice" {
			t.Errorf("name: got %q want %q", n, "Microprice")
		}
		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)
		}
		if n := ind.Name(); n != "MIDPOINT" {
			t.Errorf("name: got %q want %q", n, "MIDPOINT")
		}
		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)
		}
		if n := ind.Name(); n != "MIDPRICE" {
			t.Errorf("name: got %q want %q", n, "MIDPRICE")
		}
		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)
		}
		if n := ind.Name(); n != "MINUS_DI" {
			t.Errorf("name: got %q want %q", n, "MINUS_DI")
		}
		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)
		}
		if n := ind.Name(); n != "MINUS_DM" {
			t.Errorf("name: got %q want %q", n, "MINUS_DM")
		}
		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)
		}
		if n := ind.Name(); n != "ModifiedMaStop" {
			t.Errorf("name: got %q want %q", n, "ModifiedMaStop")
		}
		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)
		}
		if n := ind.Name(); n != "MOM" {
			t.Errorf("name: got %q want %q", n, "MOM")
		}
		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)
		}
		if n := ind.Name(); n != "MorningDojiStar" {
			t.Errorf("name: got %q want %q", n, "MorningDojiStar")
		}
		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)
		}
		if n := ind.Name(); n != "MorningEveningStar" {
			t.Errorf("name: got %q want %q", n, "MorningEveningStar")
		}
		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)
		}
		if n := ind.Name(); n != "MurreyMathLines" {
			t.Errorf("name: got %q want %q", n, "MurreyMathLines")
		}
		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)
		}
		if n := ind.Name(); n != "NakedPoc" {
			t.Errorf("name: got %q want %q", n, "NakedPoc")
		}
		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)
		}
		if n := ind.Name(); n != "NATR" {
			t.Errorf("name: got %q want %q", n, "NATR")
		}
		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)
		}
		if n := ind.Name(); n != "NewHighsNewLows" {
			t.Errorf("name: got %q want %q", n, "NewHighsNewLows")
		}
		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)
		}
		if n := ind.Name(); n != "NewPriceLines" {
			t.Errorf("name: got %q want %q", n, "NewPriceLines")
		}
		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)
		}
		if n := ind.Name(); n != "Nrtr" {
			t.Errorf("name: got %q want %q", n, "Nrtr")
		}
		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)
		}
		if n := ind.Name(); n != "NVI" {
			t.Errorf("name: got %q want %q", n, "NVI")
		}
		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)
		}
		if n := ind.Name(); n != "OIPriceDivergence" {
			t.Errorf("name: got %q want %q", n, "OIPriceDivergence")
		}
		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)
		}
		if n := ind.Name(); n != "OIWeighted" {
			t.Errorf("name: got %q want %q", n, "OIWeighted")
		}
		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)
		}
		if n := ind.Name(); n != "OBV" {
			t.Errorf("name: got %q want %q", n, "OBV")
		}
		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)
		}
		if n := ind.Name(); n != "OiToVolumeRatio" {
			t.Errorf("name: got %q want %q", n, "OiToVolumeRatio")
		}
		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)
		}
		if n := ind.Name(); n != "OmegaRatio" {
			t.Errorf("name: got %q want %q", n, "OmegaRatio")
		}
		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)
		}
		if n := ind.Name(); n != "OnNeck" {
			t.Errorf("name: got %q want %q", n, "OnNeck")
		}
		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)
		}
		if n := ind.Name(); n != "OpenInterestDelta" {
			t.Errorf("name: got %q want %q", n, "OpenInterestDelta")
		}
		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)
		}
		if n := ind.Name(); n != "OpenInterestMomentum" {
			t.Errorf("name: got %q want %q", n, "OpenInterestMomentum")
		}
		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)
		}
		if n := ind.Name(); n != "OpeningMarubozu" {
			t.Errorf("name: got %q want %q", n, "OpeningMarubozu")
		}
		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)
		}
		if n := ind.Name(); n != "OpeningRange" {
			t.Errorf("name: got %q want %q", n, "OpeningRange")
		}
		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)
		}
		if n := ind.Name(); n != "OrderBookImbalanceFull" {
			t.Errorf("name: got %q want %q", n, "OrderBookImbalanceFull")
		}
		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)
		}
		if n := ind.Name(); n != "OrderBookImbalanceTop1" {
			t.Errorf("name: got %q want %q", n, "OrderBookImbalanceTop1")
		}
		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)
		}
		if n := ind.Name(); n != "OrderBookImbalanceTopN" {
			t.Errorf("name: got %q want %q", n, "OrderBookImbalanceTopN")
		}
		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)
		}
		if n := ind.Name(); n != "OrderFlowImbalance" {
			t.Errorf("name: got %q want %q", n, "OrderFlowImbalance")
		}
		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)
		}
		if n := ind.Name(); n != "OuHalfLife" {
			t.Errorf("name: got %q want %q", n, "OuHalfLife")
		}
		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)
		}
		if n := ind.Name(); n != "OvernightGap" {
			t.Errorf("name: got %q want %q", n, "OvernightGap")
		}
		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)
		}
		if n := ind.Name(); n != "OvernightIntradayReturn" {
			t.Errorf("name: got %q want %q", n, "OvernightIntradayReturn")
		}
		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)
		}
		if n := ind.Name(); n != "PainIndex" {
			t.Errorf("name: got %q want %q", n, "PainIndex")
		}
		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)
		}
		if n := ind.Name(); n != "PairSpreadZScore" {
			t.Errorf("name: got %q want %q", n, "PairSpreadZScore")
		}
		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)
		}
		if n := ind.Name(); n != "PairwiseBeta" {
			t.Errorf("name: got %q want %q", n, "PairwiseBeta")
		}
		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)
		}
		if n := ind.Name(); n != "ParkinsonVolatility" {
			t.Errorf("name: got %q want %q", n, "ParkinsonVolatility")
		}
		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)
		}
		if n := ind.Name(); n != "PearsonCorrelation" {
			t.Errorf("name: got %q want %q", n, "PearsonCorrelation")
		}
		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)
		}
		if n := ind.Name(); n != "PercentAboveMa" {
			t.Errorf("name: got %q want %q", n, "PercentAboveMa")
		}
		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)
		}
		if n := ind.Name(); n != "PercentB" {
			t.Errorf("name: got %q want %q", n, "PercentB")
		}
		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)
		}
		if n := ind.Name(); n != "PercentageTrailingStop" {
			t.Errorf("name: got %q want %q", n, "PercentageTrailingStop")
		}
		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)
		}
		if n := ind.Name(); n != "PerpetualPremiumIndex" {
			t.Errorf("name: got %q want %q", n, "PerpetualPremiumIndex")
		}
		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)
		}
		if n := ind.Name(); n != "PGO" {
			t.Errorf("name: got %q want %q", n, "PGO")
		}
		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)
		}
		if n := ind.Name(); n != "PiercingDarkCloud" {
			t.Errorf("name: got %q want %q", n, "PiercingDarkCloud")
		}
		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)
		}
		if n := ind.Name(); n != "PIN" {
			t.Errorf("name: got %q want %q", n, "PIN")
		}
		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)
		}
		if n := ind.Name(); n != "PivotReversal" {
			t.Errorf("name: got %q want %q", n, "PivotReversal")
		}
		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)
		}
		if n := ind.Name(); n != "PLUS_DI" {
			t.Errorf("name: got %q want %q", n, "PLUS_DI")
		}
		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)
		}
		if n := ind.Name(); n != "PLUS_DM" {
			t.Errorf("name: got %q want %q", n, "PLUS_DM")
		}
		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)
		}
		if n := ind.Name(); n != "PMO" {
			t.Errorf("name: got %q want %q", n, "PMO")
		}
		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)
		}
		if n := ind.Name(); n != "PointAndFigureBars" {
			t.Errorf("name: got %q want %q", n, "PointAndFigureBars")
		}
		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)
		}
		if n := ind.Name(); n != "PolarizedFractalEfficiency" {
			t.Errorf("name: got %q want %q", n, "PolarizedFractalEfficiency")
		}
		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)
		}
		if n := ind.Name(); n != "PPO" {
			t.Errorf("name: got %q want %q", n, "PPO")
		}
		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)
		}
		if n := ind.Name(); n != "PpoHistogram" {
			t.Errorf("name: got %q want %q", n, "PpoHistogram")
		}
		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)
		}
		if n := ind.Name(); n != "ProfileShape" {
			t.Errorf("name: got %q want %q", n, "ProfileShape")
		}
		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)
		}
		if n := ind.Name(); n != "ProfitFactor" {
			t.Errorf("name: got %q want %q", n, "ProfitFactor")
		}
		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)
		}
		if n := ind.Name(); n != "ProjectionBands" {
			t.Errorf("name: got %q want %q", n, "ProjectionBands")
		}
		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)
		}
		if n := ind.Name(); n != "ProjectionOscillator" {
			t.Errorf("name: got %q want %q", n, "ProjectionOscillator")
		}
		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)
		}
		if n := ind.Name(); n != "PSAR" {
			t.Errorf("name: got %q want %q", n, "PSAR")
		}
		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)
		}
		if n := ind.Name(); n != "PVI" {
			t.Errorf("name: got %q want %q", n, "PVI")
		}
		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)
		}
		if n := ind.Name(); n != "QQE" {
			t.Errorf("name: got %q want %q", n, "QQE")
		}
		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)
		}
		if n := ind.Name(); n != "Qstick" {
			t.Errorf("name: got %q want %q", n, "Qstick")
		}
		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)
		}
		if n := ind.Name(); n != "QuartileBands" {
			t.Errorf("name: got %q want %q", n, "QuartileBands")
		}
		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)
		}
		if n := ind.Name(); n != "QuotedSpread" {
			t.Errorf("name: got %q want %q", n, "QuotedSpread")
		}
		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)
		}
		if n := ind.Name(); n != "RSquared" {
			t.Errorf("name: got %q want %q", n, "RSquared")
		}
		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)
		}
		if n := ind.Name(); n != "RangeBars" {
			t.Errorf("name: got %q want %q", n, "RangeBars")
		}
		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)
		}
		if n := ind.Name(); n != "RealizedSpread" {
			t.Errorf("name: got %q want %q", n, "RealizedSpread")
		}
		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)
		}
		if n := ind.Name(); n != "RealizedVolatility" {
			t.Errorf("name: got %q want %q", n, "RealizedVolatility")
		}
		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)
		}
		if n := ind.Name(); n != "RecoveryFactor" {
			t.Errorf("name: got %q want %q", n, "RecoveryFactor")
		}
		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)
		}
		if n := ind.Name(); n != "RectangleRange" {
			t.Errorf("name: got %q want %q", n, "RectangleRange")
		}
		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)
		}
		if n := ind.Name(); n != "Reflex" {
			t.Errorf("name: got %q want %q", n, "Reflex")
		}
		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)
		}
		if n := ind.Name(); n != "RegimeLabel" {
			t.Errorf("name: got %q want %q", n, "RegimeLabel")
		}
		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)
		}
		if n := ind.Name(); n != "RelativeStrengthAB" {
			t.Errorf("name: got %q want %q", n, "RelativeStrengthAB")
		}
		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)
		}
		if n := ind.Name(); n != "RenkoBars" {
			t.Errorf("name: got %q want %q", n, "RenkoBars")
		}
		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)
		}
		if n := ind.Name(); n != "RenkoTrailingStop" {
			t.Errorf("name: got %q want %q", n, "RenkoTrailingStop")
		}
		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)
		}
		if n := ind.Name(); n != "RickshawMan" {
			t.Errorf("name: got %q want %q", n, "RickshawMan")
		}
		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)
		}
		if n := ind.Name(); n != "RisingThreeMethods" {
			t.Errorf("name: got %q want %q", n, "RisingThreeMethods")
		}
		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)
		}
		if n := ind.Name(); n != "RMI" {
			t.Errorf("name: got %q want %q", n, "RMI")
		}
		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)
		}
		if n := ind.Name(); n != "ROC" {
			t.Errorf("name: got %q want %q", n, "ROC")
		}
		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)
		}
		if n := ind.Name(); n != "ROCP" {
			t.Errorf("name: got %q want %q", n, "ROCP")
		}
		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)
		}
		if n := ind.Name(); n != "ROCR" {
			t.Errorf("name: got %q want %q", n, "ROCR")
		}
		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)
		}
		if n := ind.Name(); n != "ROCR100" {
			t.Errorf("name: got %q want %q", n, "ROCR100")
		}
		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)
		}
		if n := ind.Name(); n != "RogersSatchellVolatility" {
			t.Errorf("name: got %q want %q", n, "RogersSatchellVolatility")
		}
		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)
		}
		if n := ind.Name(); n != "RollMeasure" {
			t.Errorf("name: got %q want %q", n, "RollMeasure")
		}
		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)
		}
		if n := ind.Name(); n != "RollingCorrelation" {
			t.Errorf("name: got %q want %q", n, "RollingCorrelation")
		}
		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)
		}
		if n := ind.Name(); n != "RollingCovariance" {
			t.Errorf("name: got %q want %q", n, "RollingCovariance")
		}
		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)
		}
		if n := ind.Name(); n != "RollingIqr" {
			t.Errorf("name: got %q want %q", n, "RollingIqr")
		}
		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)
		}
		if n := ind.Name(); n != "RollingMinMaxScaler" {
			t.Errorf("name: got %q want %q", n, "RollingMinMaxScaler")
		}
		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)
		}
		if n := ind.Name(); n != "RollingPercentileRank" {
			t.Errorf("name: got %q want %q", n, "RollingPercentileRank")
		}
		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)
		}
		if n := ind.Name(); n != "RollingQuantile" {
			t.Errorf("name: got %q want %q", n, "RollingQuantile")
		}
		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)
		}
		if n := ind.Name(); n != "RollingVWAP" {
			t.Errorf("name: got %q want %q", n, "RollingVWAP")
		}
		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)
		}
		if n := ind.Name(); n != "RoofingFilter" {
			t.Errorf("name: got %q want %q", n, "RoofingFilter")
		}
		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)
		}
		if n := ind.Name(); n != "RSI" {
			t.Errorf("name: got %q want %q", n, "RSI")
		}
		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)
		}
		if n := ind.Name(); n != "RSX" {
			t.Errorf("name: got %q want %q", n, "RSX")
		}
		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)
		}
		if n := ind.Name(); n != "RunBars" {
			t.Errorf("name: got %q want %q", n, "RunBars")
		}
		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)
		}
		if n := ind.Name(); n != "RVI" {
			t.Errorf("name: got %q want %q", n, "RVI")
		}
		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)
		}
		if n := ind.Name(); n != "RVIVolatility" {
			t.Errorf("name: got %q want %q", n, "RVIVolatility")
		}
		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)
		}
		if n := ind.Name(); n != "RWI" {
			t.Errorf("name: got %q want %q", n, "RWI")
		}
		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)
		}
		if n := ind.Name(); n != "SampleEntropy" {
			t.Errorf("name: got %q want %q", n, "SampleEntropy")
		}
		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)
		}
		if n := ind.Name(); n != "SAREXT" {
			t.Errorf("name: got %q want %q", n, "SAREXT")
		}
		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)
		}
		if n := ind.Name(); n != "SeasonalZScore" {
			t.Errorf("name: got %q want %q", n, "SeasonalZScore")
		}
		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)
		}
		if n := ind.Name(); n != "SeparatingLines" {
			t.Errorf("name: got %q want %q", n, "SeparatingLines")
		}
		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)
		}
		if n := ind.Name(); n != "SessionHighLow" {
			t.Errorf("name: got %q want %q", n, "SessionHighLow")
		}
		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)
		}
		if n := ind.Name(); n != "SessionRange" {
			t.Errorf("name: got %q want %q", n, "SessionRange")
		}
		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)
		}
		if n := ind.Name(); n != "SessionVwap" {
			t.Errorf("name: got %q want %q", n, "SessionVwap")
		}
		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)
		}
		if n := ind.Name(); n != "ShannonEntropy" {
			t.Errorf("name: got %q want %q", n, "ShannonEntropy")
		}
		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)
		}
		if n := ind.Name(); n != "Shark" {
			t.Errorf("name: got %q want %q", n, "Shark")
		}
		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)
		}
		if n := ind.Name(); n != "SharpeRatio" {
			t.Errorf("name: got %q want %q", n, "SharpeRatio")
		}
		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)
		}
		if n := ind.Name(); n != "ShootingStar" {
			t.Errorf("name: got %q want %q", n, "ShootingStar")
		}
		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)
		}
		if n := ind.Name(); n != "ShortLine" {
			t.Errorf("name: got %q want %q", n, "ShortLine")
		}
		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)
		}
		if n := ind.Name(); n != "SignedVolume" {
			t.Errorf("name: got %q want %q", n, "SignedVolume")
		}
		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)
		}
		if n := ind.Name(); n != "SineWave" {
			t.Errorf("name: got %q want %q", n, "SineWave")
		}
		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)
		}
		if n := ind.Name(); n != "SWMA" {
			t.Errorf("name: got %q want %q", n, "SWMA")
		}
		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)
		}
		if n := ind.Name(); n != "SinglePrints" {
			t.Errorf("name: got %q want %q", n, "SinglePrints")
		}
		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)
		}
		if n := ind.Name(); n != "Skewness" {
			t.Errorf("name: got %q want %q", n, "Skewness")
		}
		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)
		}
		if n := ind.Name(); n != "SMA" {
			t.Errorf("name: got %q want %q", n, "SMA")
		}
		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)
		}
		if n := ind.Name(); n != "SMI" {
			t.Errorf("name: got %q want %q", n, "SMI")
		}
		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)
		}
		if n := ind.Name(); n != "SMMA" {
			t.Errorf("name: got %q want %q", n, "SMMA")
		}
		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)
		}
		if n := ind.Name(); n != "SmoothedHeikinAshi" {
			t.Errorf("name: got %q want %q", n, "SmoothedHeikinAshi")
		}
		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)
		}
		if n := ind.Name(); n != "SortinoRatio" {
			t.Errorf("name: got %q want %q", n, "SortinoRatio")
		}
		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)
		}
		if n := ind.Name(); n != "SpearmanCorrelation" {
			t.Errorf("name: got %q want %q", n, "SpearmanCorrelation")
		}
		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)
		}
		if n := ind.Name(); n != "SpinningTop" {
			t.Errorf("name: got %q want %q", n, "SpinningTop")
		}
		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)
		}
		if n := ind.Name(); n != "SpreadAr1Coefficient" {
			t.Errorf("name: got %q want %q", n, "SpreadAr1Coefficient")
		}
		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)
		}
		if n := ind.Name(); n != "SpreadBollingerBands" {
			t.Errorf("name: got %q want %q", n, "SpreadBollingerBands")
		}
		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)
		}
		if n := ind.Name(); n != "SpreadHurst" {
			t.Errorf("name: got %q want %q", n, "SpreadHurst")
		}
		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)
		}
		if n := ind.Name(); n != "StalledPattern" {
			t.Errorf("name: got %q want %q", n, "StalledPattern")
		}
		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)
		}
		if n := ind.Name(); n != "StandardError" {
			t.Errorf("name: got %q want %q", n, "StandardError")
		}
		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)
		}
		if n := ind.Name(); n != "StandardErrorBands" {
			t.Errorf("name: got %q want %q", n, "StandardErrorBands")
		}
		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)
		}
		if n := ind.Name(); n != "StarcBands" {
			t.Errorf("name: got %q want %q", n, "StarcBands")
		}
		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)
		}
		if n := ind.Name(); n != "STC" {
			t.Errorf("name: got %q want %q", n, "STC")
		}
		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)
		}
		if n := ind.Name(); n != "StdDev" {
			t.Errorf("name: got %q want %q", n, "StdDev")
		}
		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)
		}
		if n := ind.Name(); n != "StepTrailingStop" {
			t.Errorf("name: got %q want %q", n, "StepTrailingStop")
		}
		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)
		}
		if n := ind.Name(); n != "SterlingRatio" {
			t.Errorf("name: got %q want %q", n, "SterlingRatio")
		}
		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)
		}
		if n := ind.Name(); n != "StickSandwich" {
			t.Errorf("name: got %q want %q", n, "StickSandwich")
		}
		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)
		}
		if n := ind.Name(); n != "StochRSI" {
			t.Errorf("name: got %q want %q", n, "StochRSI")
		}
		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)
		}
		if n := ind.Name(); n != "Stochastic" {
			t.Errorf("name: got %q want %q", n, "Stochastic")
		}
		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)
		}
		if n := ind.Name(); n != "StochasticCCI" {
			t.Errorf("name: got %q want %q", n, "StochasticCCI")
		}
		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)
		}
		if n := ind.Name(); n != "SuperSmoother" {
			t.Errorf("name: got %q want %q", n, "SuperSmoother")
		}
		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)
		}
		if n := ind.Name(); n != "SuperTrend" {
			t.Errorf("name: got %q want %q", n, "SuperTrend")
		}
		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)
		}
		if n := ind.Name(); n != "T3" {
			t.Errorf("name: got %q want %q", n, "T3")
		}
		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)
		}
		if n := ind.Name(); n != "TailRatio" {
			t.Errorf("name: got %q want %q", n, "TailRatio")
		}
		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)
		}
		if n := ind.Name(); n != "TakerBuySellRatio" {
			t.Errorf("name: got %q want %q", n, "TakerBuySellRatio")
		}
		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)
		}
		if n := ind.Name(); n != "Takuri" {
			t.Errorf("name: got %q want %q", n, "Takuri")
		}
		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)
		}
		if n := ind.Name(); n != "TasukiGap" {
			t.Errorf("name: got %q want %q", n, "TasukiGap")
		}
		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)
		}
		if n := ind.Name(); n != "TDCamouflage" {
			t.Errorf("name: got %q want %q", n, "TDCamouflage")
		}
		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)
		}
		if n := ind.Name(); n != "TDClop" {
			t.Errorf("name: got %q want %q", n, "TDClop")
		}
		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)
		}
		if n := ind.Name(); n != "TDClopwin" {
			t.Errorf("name: got %q want %q", n, "TDClopwin")
		}
		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)
		}
		if n := ind.Name(); n != "TDCombo" {
			t.Errorf("name: got %q want %q", n, "TDCombo")
		}
		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)
		}
		if n := ind.Name(); n != "TDCountdown" {
			t.Errorf("name: got %q want %q", n, "TDCountdown")
		}
		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)
		}
		if n := ind.Name(); n != "TDDWave" {
			t.Errorf("name: got %q want %q", n, "TDDWave")
		}
		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)
		}
		if n := ind.Name(); n != "TDDeMarker" {
			t.Errorf("name: got %q want %q", n, "TDDeMarker")
		}
		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)
		}
		if n := ind.Name(); n != "TDDifferential" {
			t.Errorf("name: got %q want %q", n, "TDDifferential")
		}
		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)
		}
		if n := ind.Name(); n != "TDLines" {
			t.Errorf("name: got %q want %q", n, "TDLines")
		}
		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)
		}
		if n := ind.Name(); n != "TDMovingAverage" {
			t.Errorf("name: got %q want %q", n, "TDMovingAverage")
		}
		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)
		}
		if n := ind.Name(); n != "TDOpen" {
			t.Errorf("name: got %q want %q", n, "TDOpen")
		}
		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)
		}
		if n := ind.Name(); n != "TDPressure" {
			t.Errorf("name: got %q want %q", n, "TDPressure")
		}
		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)
		}
		if n := ind.Name(); n != "TDPropulsion" {
			t.Errorf("name: got %q want %q", n, "TDPropulsion")
		}
		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)
		}
		if n := ind.Name(); n != "TDRangeProjection" {
			t.Errorf("name: got %q want %q", n, "TDRangeProjection")
		}
		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)
		}
		if n := ind.Name(); n != "TDREI" {
			t.Errorf("name: got %q want %q", n, "TDREI")
		}
		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)
		}
		if n := ind.Name(); n != "TDRiskLevel" {
			t.Errorf("name: got %q want %q", n, "TDRiskLevel")
		}
		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)
		}
		if n := ind.Name(); n != "TDSequential" {
			t.Errorf("name: got %q want %q", n, "TDSequential")
		}
		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)
		}
		if n := ind.Name(); n != "TDSetup" {
			t.Errorf("name: got %q want %q", n, "TDSetup")
		}
		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)
		}
		if n := ind.Name(); n != "TDTrap" {
			t.Errorf("name: got %q want %q", n, "TDTrap")
		}
		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)
		}
		if n := ind.Name(); n != "TEMA" {
			t.Errorf("name: got %q want %q", n, "TEMA")
		}
		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)
		}
		if n := ind.Name(); n != "TermStructureBasis" {
			t.Errorf("name: got %q want %q", n, "TermStructureBasis")
		}
		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)
		}
		if n := ind.Name(); n != "ThreeDrives" {
			t.Errorf("name: got %q want %q", n, "ThreeDrives")
		}
		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)
		}
		if n := ind.Name(); n != "ThreeInside" {
			t.Errorf("name: got %q want %q", n, "ThreeInside")
		}
		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)
		}
		if n := ind.Name(); n != "ThreeLineBreak" {
			t.Errorf("name: got %q want %q", n, "ThreeLineBreak")
		}
		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)
		}
		if n := ind.Name(); n != "ThreeLineBreakBars" {
			t.Errorf("name: got %q want %q", n, "ThreeLineBreakBars")
		}
		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)
		}
		if n := ind.Name(); n != "ThreeLineStrike" {
			t.Errorf("name: got %q want %q", n, "ThreeLineStrike")
		}
		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)
		}
		if n := ind.Name(); n != "ThreeOutside" {
			t.Errorf("name: got %q want %q", n, "ThreeOutside")
		}
		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)
		}
		if n := ind.Name(); n != "ThreeSoldiersOrCrows" {
			t.Errorf("name: got %q want %q", n, "ThreeSoldiersOrCrows")
		}
		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)
		}
		if n := ind.Name(); n != "ThreeStarsInSouth" {
			t.Errorf("name: got %q want %q", n, "ThreeStarsInSouth")
		}
		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)
		}
		if n := ind.Name(); n != "Thrusting" {
			t.Errorf("name: got %q want %q", n, "Thrusting")
		}
		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)
		}
		if n := ind.Name(); n != "TickBars" {
			t.Errorf("name: got %q want %q", n, "TickBars")
		}
		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)
		}
		if n := ind.Name(); n != "TickIndex" {
			t.Errorf("name: got %q want %q", n, "TickIndex")
		}
		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)
		}
		if n := ind.Name(); n != "TII" {
			t.Errorf("name: got %q want %q", n, "TII")
		}
		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)
		}
		if n := ind.Name(); n != "TimeBasedStop" {
			t.Errorf("name: got %q want %q", n, "TimeBasedStop")
		}
		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)
		}
		if n := ind.Name(); n != "TimeOfDayReturnProfile" {
			t.Errorf("name: got %q want %q", n, "TimeOfDayReturnProfile")
		}
		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)
		}
		if n := ind.Name(); n != "TowerTopBottom" {
			t.Errorf("name: got %q want %q", n, "TowerTopBottom")
		}
		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)
		}
		if n := ind.Name(); n != "TpoProfile" {
			t.Errorf("name: got %q want %q", n, "TpoProfile")
		}
		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)
		}
		if n := ind.Name(); n != "TradeImbalance" {
			t.Errorf("name: got %q want %q", n, "TradeImbalance")
		}
		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)
		}
		if n := ind.Name(); n != "TradeSignAutocorrelation" {
			t.Errorf("name: got %q want %q", n, "TradeSignAutocorrelation")
		}
		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)
		}
		if n := ind.Name(); n != "TradeVolumeIndex" {
			t.Errorf("name: got %q want %q", n, "TradeVolumeIndex")
		}
		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)
		}
		if n := ind.Name(); n != "TrendLabel" {
			t.Errorf("name: got %q want %q", n, "TrendLabel")
		}
		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)
		}
		if n := ind.Name(); n != "TrendStrengthIndex" {
			t.Errorf("name: got %q want %q", n, "TrendStrengthIndex")
		}
		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)
		}
		if n := ind.Name(); n != "Trendflex" {
			t.Errorf("name: got %q want %q", n, "Trendflex")
		}
		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)
		}
		if n := ind.Name(); n != "TreynorRatio" {
			t.Errorf("name: got %q want %q", n, "TreynorRatio")
		}
		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)
		}
		if n := ind.Name(); n != "Triangle" {
			t.Errorf("name: got %q want %q", n, "Triangle")
		}
		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)
		}
		if n := ind.Name(); n != "TRIMA" {
			t.Errorf("name: got %q want %q", n, "TRIMA")
		}
		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)
		}
		if n := ind.Name(); n != "Trin" {
			t.Errorf("name: got %q want %q", n, "Trin")
		}
		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)
		}
		if n := ind.Name(); n != "TripleTopBottom" {
			t.Errorf("name: got %q want %q", n, "TripleTopBottom")
		}
		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)
		}
		if n := ind.Name(); n != "Tristar" {
			t.Errorf("name: got %q want %q", n, "Tristar")
		}
		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)
		}
		if n := ind.Name(); n != "TRIX" {
			t.Errorf("name: got %q want %q", n, "TRIX")
		}
		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)
		}
		if n := ind.Name(); n != "TrueRange" {
			t.Errorf("name: got %q want %q", n, "TrueRange")
		}
		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)
		}
		if n := ind.Name(); n != "TSF" {
			t.Errorf("name: got %q want %q", n, "TSF")
		}
		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)
		}
		if n := ind.Name(); n != "TsfOscillator" {
			t.Errorf("name: got %q want %q", n, "TsfOscillator")
		}
		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)
		}
		if n := ind.Name(); n != "TSI" {
			t.Errorf("name: got %q want %q", n, "TSI")
		}
		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)
		}
		if n := ind.Name(); n != "TSV" {
			t.Errorf("name: got %q want %q", n, "TSV")
		}
		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)
		}
		if n := ind.Name(); n != "TtmSqueeze" {
			t.Errorf("name: got %q want %q", n, "TtmSqueeze")
		}
		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)
		}
		if n := ind.Name(); n != "TtmTrend" {
			t.Errorf("name: got %q want %q", n, "TtmTrend")
		}
		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)
		}
		if n := ind.Name(); n != "TurnOfMonth" {
			t.Errorf("name: got %q want %q", n, "TurnOfMonth")
		}
		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)
		}
		if n := ind.Name(); n != "Tweezer" {
			t.Errorf("name: got %q want %q", n, "Tweezer")
		}
		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)
		}
		if n := ind.Name(); n != "TwiggsMoneyFlow" {
			t.Errorf("name: got %q want %q", n, "TwiggsMoneyFlow")
		}
		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)
		}
		if n := ind.Name(); n != "TwoCrows" {
			t.Errorf("name: got %q want %q", n, "TwoCrows")
		}
		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)
		}
		if n := ind.Name(); n != "TypicalPrice" {
			t.Errorf("name: got %q want %q", n, "TypicalPrice")
		}
		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)
		}
		if n := ind.Name(); n != "UlcerIndex" {
			t.Errorf("name: got %q want %q", n, "UlcerIndex")
		}
		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)
		}
		if n := ind.Name(); n != "UltimateOscillator" {
			t.Errorf("name: got %q want %q", n, "UltimateOscillator")
		}
		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)
		}
		if n := ind.Name(); n != "UniqueThreeRiver" {
			t.Errorf("name: got %q want %q", n, "UniqueThreeRiver")
		}
		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)
		}
		if n := ind.Name(); n != "UniversalOscillator" {
			t.Errorf("name: got %q want %q", n, "UniversalOscillator")
		}
		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)
		}
		if n := ind.Name(); n != "UpDownVolumeRatio" {
			t.Errorf("name: got %q want %q", n, "UpDownVolumeRatio")
		}
		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)
		}
		if n := ind.Name(); n != "UpsideGapThreeMethods" {
			t.Errorf("name: got %q want %q", n, "UpsideGapThreeMethods")
		}
		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)
		}
		if n := ind.Name(); n != "UpsideGapTwoCrows" {
			t.Errorf("name: got %q want %q", n, "UpsideGapTwoCrows")
		}
		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)
		}
		if n := ind.Name(); n != "UpsidePotentialRatio" {
			t.Errorf("name: got %q want %q", n, "UpsidePotentialRatio")
		}
		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)
		}
		if n := ind.Name(); n != "ValueArea" {
			t.Errorf("name: got %q want %q", n, "ValueArea")
		}
		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)
		}
		if n := ind.Name(); n != "ValueAtRisk" {
			t.Errorf("name: got %q want %q", n, "ValueAtRisk")
		}
		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)
		}
		if n := ind.Name(); n != "Variance" {
			t.Errorf("name: got %q want %q", n, "Variance")
		}
		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)
		}
		if n := ind.Name(); n != "VarianceRatio" {
			t.Errorf("name: got %q want %q", n, "VarianceRatio")
		}
		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)
		}
		if n := ind.Name(); n != "VerticalHorizontalFilter" {
			t.Errorf("name: got %q want %q", n, "VerticalHorizontalFilter")
		}
		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)
		}
		if n := ind.Name(); n != "VIDYA" {
			t.Errorf("name: got %q want %q", n, "VIDYA")
		}
		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)
		}
		if n := ind.Name(); n != "VolatilityCone" {
			t.Errorf("name: got %q want %q", n, "VolatilityCone")
		}
		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)
		}
		if n := ind.Name(); n != "VolatilityOfVolatility" {
			t.Errorf("name: got %q want %q", n, "VolatilityOfVolatility")
		}
		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)
		}
		if n := ind.Name(); n != "VolatilityRatio" {
			t.Errorf("name: got %q want %q", n, "VolatilityRatio")
		}
		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)
		}
		if n := ind.Name(); n != "VoltyStop" {
			t.Errorf("name: got %q want %q", n, "VoltyStop")
		}
		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)
		}
		if n := ind.Name(); n != "VolumeBars" {
			t.Errorf("name: got %q want %q", n, "VolumeBars")
		}
		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)
		}
		if n := ind.Name(); n != "VolumeByTimeProfile" {
			t.Errorf("name: got %q want %q", n, "VolumeByTimeProfile")
		}
		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)
		}
		if n := ind.Name(); n != "VolumeOscillator" {
			t.Errorf("name: got %q want %q", n, "VolumeOscillator")
		}
		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)
		}
		if n := ind.Name(); n != "VPT" {
			t.Errorf("name: got %q want %q", n, "VPT")
		}
		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)
		}
		if n := ind.Name(); n != "VolumeProfile" {
			t.Errorf("name: got %q want %q", n, "VolumeProfile")
		}
		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)
		}
		if n := ind.Name(); n != "VolumeRsi" {
			t.Errorf("name: got %q want %q", n, "VolumeRsi")
		}
		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)
		}
		if n := ind.Name(); n != "VolumeWeightedMacd" {
			t.Errorf("name: got %q want %q", n, "VolumeWeightedMacd")
		}
		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)
		}
		if n := ind.Name(); n != "VolumeWeightedSr" {
			t.Errorf("name: got %q want %q", n, "VolumeWeightedSr")
		}
		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)
		}
		if n := ind.Name(); n != "Vortex" {
			t.Errorf("name: got %q want %q", n, "Vortex")
		}
		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)
		}
		if n := ind.Name(); n != "Vpin" {
			t.Errorf("name: got %q want %q", n, "Vpin")
		}
		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)
		}
		if n := ind.Name(); n != "VWAP" {
			t.Errorf("name: got %q want %q", n, "VWAP")
		}
		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)
		}
		if n := ind.Name(); n != "VwapStdDevBands" {
			t.Errorf("name: got %q want %q", n, "VwapStdDevBands")
		}
		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)
		}
		if n := ind.Name(); n != "VWMA" {
			t.Errorf("name: got %q want %q", n, "VWMA")
		}
		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)
		}
		if n := ind.Name(); n != "VZO" {
			t.Errorf("name: got %q want %q", n, "VZO")
		}
		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)
		}
		if n := ind.Name(); n != "Wad" {
			t.Errorf("name: got %q want %q", n, "Wad")
		}
		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)
		}
		if n := ind.Name(); n != "WavePm" {
			t.Errorf("name: got %q want %q", n, "WavePm")
		}
		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)
		}
		if n := ind.Name(); n != "WaveTrend" {
			t.Errorf("name: got %q want %q", n, "WaveTrend")
		}
		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)
		}
		if n := ind.Name(); n != "Wedge" {
			t.Errorf("name: got %q want %q", n, "Wedge")
		}
		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)
		}
		if n := ind.Name(); n != "WeightedClose" {
			t.Errorf("name: got %q want %q", n, "WeightedClose")
		}
		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)
		}
		if n := ind.Name(); n != "WickRatio" {
			t.Errorf("name: got %q want %q", n, "WickRatio")
		}
		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)
		}
		if n := ind.Name(); n != "WilliamsFractals" {
			t.Errorf("name: got %q want %q", n, "WilliamsFractals")
		}
		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)
		}
		if n := ind.Name(); n != "WilliamsR" {
			t.Errorf("name: got %q want %q", n, "WilliamsR")
		}
		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)
		}
		if n := ind.Name(); n != "WinRate" {
			t.Errorf("name: got %q want %q", n, "WinRate")
		}
		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)
		}
		if n := ind.Name(); n != "WMA" {
			t.Errorf("name: got %q want %q", n, "WMA")
		}
		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)
		}
		if n := ind.Name(); n != "WoodiePivots" {
			t.Errorf("name: got %q want %q", n, "WoodiePivots")
		}
		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)
		}
		if n := ind.Name(); n != "YangZhangVolatility" {
			t.Errorf("name: got %q want %q", n, "YangZhangVolatility")
		}
		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)
		}
		if n := ind.Name(); n != "YoyoExit" {
			t.Errorf("name: got %q want %q", n, "YoyoExit")
		}
		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)
		}
		if n := ind.Name(); n != "ZScore" {
			t.Errorf("name: got %q want %q", n, "ZScore")
		}
		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)
		}
		if n := ind.Name(); n != "ZeroLagMACD" {
			t.Errorf("name: got %q want %q", n, "ZeroLagMACD")
		}
		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)
		}
		if n := ind.Name(); n != "ZigZag" {
			t.Errorf("name: got %q want %q", n, "ZigZag")
		}
		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)
		}
		if n := ind.Name(); n != "ZLEMA" {
			t.Errorf("name: got %q want %q", n, "ZLEMA")
		}
		got := make([][]float64, len(rows))
		for i, r := range rows {
			got[i] = []float64{ind.Update(r[3])}
		}
		compareGolden(t, "Zlema", got)
	})
}