// <auto-generated>
// Generated by gen_golden_test.py. DO NOT EDIT.
//
// Value-parity for every one of the 514 C# 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 one comparator covers all
// archetypes. Regenerate with: python bindings/csharp/gen_golden_test.py
// </auto-generated>
#nullable enable
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using Xunit;

namespace Wickra.Tests;

public class GoldenAllTests
{
    private const double Tol = 1e-6;

    private static readonly double[][] Rows = LoadInput();

    private static string GoldenDir([System.Runtime.CompilerServices.CallerFilePath] string file = "") =>
        Path.GetFullPath(Path.Combine(Path.GetDirectoryName(file)!, "..", "..", "..", "testdata", "golden"));

    private static double Cell(string s) =>
        s == "nan" ? double.NaN
        : s == "inf" ? double.PositiveInfinity
        : s == "-inf" ? double.NegativeInfinity
        : double.Parse(s, CultureInfo.InvariantCulture);

    private static double[][] LoadInput()
    {
        var lines = File.ReadAllLines(Path.Combine(GoldenDir(), "input.csv"));
        return lines.Skip(1).Where(l => l.Length > 0)
            .Select(l => l.Split(',').Select(x => double.Parse(x, CultureInfo.InvariantCulture)).ToArray())
            .ToArray();
    }

    // Keep blank lines (a candle on which no bar closed) so rows stay aligned.
    private static double[]?[] ReadFixture(string name)
    {
        var lines = File.ReadAllLines(Path.Combine(GoldenDir(), "g_" + name + ".csv"));
        return lines.Skip(1).Select(l => l.Length == 0 ? Array.Empty<double>() : l.Split(',').Select(Cell).ToArray()).ToArray();
    }

    private static double[] NanRow(int n)
    {
        var r = new double[n];
        for (var i = 0; i < n; i++) r[i] = double.NaN;
        return r;
    }

    private static double[] FlattenStruct(object o)
    {
        var props = o.GetType()
            .GetProperties(BindingFlags.Public | BindingFlags.Instance)
            .OrderBy(p => p.MetadataToken);
        var list = new List<double>();
        foreach (var p in props)
        {
            var v = p.GetValue(o);
            switch (v)
            {
                case double d: list.Add(d); break;
                case float f: list.Add(f); break;
                case long l: list.Add(l); break;
                case int n: list.Add(n); break;
                case double[] arr: list.AddRange(arr); break;
            }
        }
        return list.ToArray();
    }

    private static double[] FlattenNullable<T>(T? value, int width) where T : struct =>
        value.HasValue ? FlattenStruct(value.Value) : NanRow(width);

    private static double[] FlattenBars<T>(T[] bars)
    {
        var list = new List<double>();
        foreach (var bar in bars) list.AddRange(FlattenStruct(bar!));
        return list.ToArray();
    }

    private static double[] DerivFields(double[] r)
    {
        double o = r[0], h = r[1], l = r[2], c = r[3], v = r[4];
        return new[]
        {
            (c - o) / c * 0.01, c, c - 0.5, c + 1.0, v * 10.0, v * 0.6, v * 0.4,
            v * 0.55, v * 0.45, h - c, c - l,
        };
    }

    private static (double[], double[], bool[], bool[], bool[], bool[]) CrossLists(double[] r)
    {
        double o = r[0], c = r[3], v = r[4];
        var change = new double[5];
        var volume = new double[5];
        var nh = new bool[5];
        var nl = new bool[5];
        var am = new bool[5];
        var ob = new bool[5];
        for (var j = 0; j < 5; j++)
        {
            change[j] = (c - o) + j;
            volume[j] = v + j * 10.0;
            nh[j] = j % 2 == 0;
            nl[j] = j % 3 == 0;
            am[j] = j % 2 == 0;
            ob[j] = j % 3 == 0;
        }
        return (change, volume, nh, nl, am, ob);
    }

    private static (double[], double[], double[], double[]) ObLists(double[] r)
    {
        double c = r[3], v = r[4];
        var bp = new double[5];
        var bs = new double[5];
        var ap = new double[5];
        var asz = new double[5];
        for (var k = 0; k < 5; k++)
        {
            var kf = k + 1;
            bp[k] = c - 0.1 * kf;
            bs[k] = v / kf;
            ap[k] = c + 0.1 * kf;
            asz[k] = v * 0.9 / kf;
        }
        return (bp, bs, ap, asz);
    }

    private static void Compare(string name, List<double[]> got)
    {
        var exp = ReadFixture(name);
        Assert.True(exp.Length == got.Count, $"{name}: {exp.Length} fixture rows vs {got.Count} computed");
        for (var i = 0; i < exp.Length; i++)
        {
            var want = exp[i]!;
            var g = got[i];
            Assert.True(want.Length == g.Length, $"{name} row {i}: arity {g.Length} vs {want.Length}");
            for (var k = 0; k < want.Length; k++)
            {
                var w = want[k];
                if (double.IsNaN(w)) { Assert.True(double.IsNaN(g[k]), $"{name} row {i} col {k}: want NaN got {g[k]}"); continue; }
                if (double.IsInfinity(w)) { Assert.True(double.IsInfinity(g[k]) && Math.Sign(g[k]) == Math.Sign(w), $"{name} row {i} col {k}: want {w} got {g[k]}"); continue; }
                var tol = Tol * Math.Max(1.0, Math.Abs(w));
                Assert.True(Math.Abs(g[k] - w) <= tol, $"{name} row {i} col {k}: got {g[k]} want {w}");
            }
        }
    }

    [Fact]
    public void Golden_AbandonedBaby()
    {
        using var ind = new Wickra.AbandonedBaby();
        Assert.Equal("AbandonedBaby", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("AbandonedBaby", got);
    }
    [Fact]
    public void Golden_Abcd()
    {
        using var ind = new Wickra.Abcd();
        Assert.Equal("Abcd", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Abcd", got);
    }
    [Fact]
    public void Golden_AbsoluteBreadthIndex()
    {
        using var ind = new Wickra.AbsoluteBreadthIndex();
        Assert.Equal("AbsoluteBreadthIndex", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var (ch, vo, nh, nl, am, ob) = CrossLists(r);
            got.Add(new[] { ind.Update(ch, vo, nh, nl, am, ob, i) });
        }
        Compare("AbsoluteBreadthIndex", got);
    }
    [Fact]
    public void Golden_AccelerationBands()
    {
        using var ind = new Wickra.AccelerationBands(14, 2.0);
        Assert.Equal("AccelerationBands", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 3));
        }
        Compare("AccelerationBands", got);
    }
    [Fact]
    public void Golden_AcceleratorOscillator()
    {
        using var ind = new Wickra.AcceleratorOscillator(3, 7, 14);
        Assert.Equal("AcceleratorOscillator", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("AcceleratorOscillator", got);
    }
    [Fact]
    public void Golden_AdOscillator()
    {
        using var ind = new Wickra.AdOscillator();
        Assert.Equal("ADOSC", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("AdOscillator", got);
    }
    [Fact]
    public void Golden_AdVolumeLine()
    {
        using var ind = new Wickra.AdVolumeLine();
        Assert.Equal("AdVolumeLine", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var (ch, vo, nh, nl, am, ob) = CrossLists(r);
            got.Add(new[] { ind.Update(ch, vo, nh, nl, am, ob, i) });
        }
        Compare("AdVolumeLine", got);
    }
    [Fact]
    public void Golden_AdaptiveCci()
    {
        using var ind = new Wickra.AdaptiveCci(14);
        Assert.Equal("AdaptiveCci", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("AdaptiveCci", got);
    }
    [Fact]
    public void Golden_AdaptiveCycle()
    {
        using var ind = new Wickra.AdaptiveCycle();
        Assert.Equal("AdaptiveCycle", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("AdaptiveCycle", got);
    }
    [Fact]
    public void Golden_AdaptiveLaguerreFilter()
    {
        using var ind = new Wickra.AdaptiveLaguerreFilter(20);
        Assert.Equal("AdaptiveLaguerre", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("AdaptiveLaguerreFilter", got);
    }
    [Fact]
    public void Golden_AdaptiveRsi()
    {
        using var ind = new Wickra.AdaptiveRsi(14);
        Assert.Equal("AdaptiveRsi", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("AdaptiveRsi", got);
    }
    [Fact]
    public void Golden_Adl()
    {
        using var ind = new Wickra.Adl();
        Assert.Equal("ADL", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Adl", got);
    }
    [Fact]
    public void Golden_AdvanceBlock()
    {
        using var ind = new Wickra.AdvanceBlock();
        Assert.Equal("AdvanceBlock", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("AdvanceBlock", got);
    }
    [Fact]
    public void Golden_AdvanceDecline()
    {
        using var ind = new Wickra.AdvanceDecline();
        Assert.Equal("AdvanceDecline", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var (ch, vo, nh, nl, am, ob) = CrossLists(r);
            got.Add(new[] { ind.Update(ch, vo, nh, nl, am, ob, i) });
        }
        Compare("AdvanceDecline", got);
    }
    [Fact]
    public void Golden_AdvanceDeclineRatio()
    {
        using var ind = new Wickra.AdvanceDeclineRatio();
        Assert.Equal("AdvanceDeclineRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var (ch, vo, nh, nl, am, ob) = CrossLists(r);
            got.Add(new[] { ind.Update(ch, vo, nh, nl, am, ob, i) });
        }
        Compare("AdvanceDeclineRatio", got);
    }
    [Fact]
    public void Golden_Adx()
    {
        using var ind = new Wickra.Adx(14);
        Assert.Equal("ADX", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 3));
        }
        Compare("Adx", got);
    }
    [Fact]
    public void Golden_Adxr()
    {
        using var ind = new Wickra.Adxr(14);
        Assert.Equal("ADXR", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Adxr", got);
    }
    [Fact]
    public void Golden_Alligator()
    {
        using var ind = new Wickra.Alligator(3, 7, 14);
        Assert.Equal("Alligator", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 3));
        }
        Compare("Alligator", got);
    }
    [Fact]
    public void Golden_Alma()
    {
        using var ind = new Wickra.Alma(9, 0.85, 6.0);
        Assert.Equal("ALMA", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Alma", got);
    }
    [Fact]
    public void Golden_Alpha()
    {
        using var ind = new Wickra.Alpha(14, 2.0);
        Assert.Equal("Alpha", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[0]) });
        }
        Compare("Alpha", got);
    }
    [Fact]
    public void Golden_AmihudIlliquidity()
    {
        using var ind = new Wickra.AmihudIlliquidity(20);
        Assert.Equal("AmihudIlliquidity", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[4], r[3] >= r[0], i) });
        }
        Compare("AmihudIlliquidity", got);
    }
    [Fact]
    public void Golden_AnchoredRsi()
    {
        using var ind = new Wickra.AnchoredRsi();
        Assert.Equal("AnchoredRSI", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("AnchoredRsi", got);
    }
    [Fact]
    public void Golden_AnchoredVwap()
    {
        using var ind = new Wickra.AnchoredVwap();
        Assert.Equal("AnchoredVWAP", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("AnchoredVwap", got);
    }
    [Fact]
    public void Golden_AndrewsPitchfork()
    {
        using var ind = new Wickra.AndrewsPitchfork(14);
        Assert.Equal("AndrewsPitchfork", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 3));
        }
        Compare("AndrewsPitchfork", got);
    }
    [Fact]
    public void Golden_Apo()
    {
        using var ind = new Wickra.Apo(3, 7);
        Assert.Equal("APO", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Apo", got);
    }
    [Fact]
    public void Golden_Aroon()
    {
        using var ind = new Wickra.Aroon(14);
        Assert.Equal("Aroon", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("Aroon", got);
    }
    [Fact]
    public void Golden_AroonOscillator()
    {
        using var ind = new Wickra.AroonOscillator(14);
        Assert.Equal("AroonOscillator", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("AroonOscillator", got);
    }
    [Fact]
    public void Golden_Atr()
    {
        using var ind = new Wickra.Atr(14);
        Assert.Equal("ATR", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Atr", got);
    }
    [Fact]
    public void Golden_AtrBands()
    {
        using var ind = new Wickra.AtrBands(14, 2.0);
        Assert.Equal("AtrBands", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 3));
        }
        Compare("AtrBands", got);
    }
    [Fact]
    public void Golden_AtrRatchet()
    {
        using var ind = new Wickra.AtrRatchet(14, 2.0, 0.5);
        Assert.Equal("AtrRatchet", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("AtrRatchet", got);
    }
    [Fact]
    public void Golden_AtrTrailingStop()
    {
        using var ind = new Wickra.AtrTrailingStop(14, 2.0);
        Assert.Equal("AtrTrailingStop", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("AtrTrailingStop", got);
    }
    [Fact]
    public void Golden_AutoFib()
    {
        using var ind = new Wickra.AutoFib();
        Assert.Equal("AutoFib", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 7));
        }
        Compare("AutoFib", got);
    }
    [Fact]
    public void Golden_Autocorrelation()
    {
        using var ind = new Wickra.Autocorrelation(10, 1);
        Assert.Equal("Autocorrelation", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Autocorrelation", got);
    }
    [Fact]
    public void Golden_AutocorrelationPeriodogram()
    {
        using var ind = new Wickra.AutocorrelationPeriodogram(10, 48);
        Assert.Equal("AutocorrelationPeriodogram", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("AutocorrelationPeriodogram", got);
    }
    [Fact]
    public void Golden_AverageDailyRange()
    {
        using var ind = new Wickra.AverageDailyRange(14, 0);
        Assert.Equal("AverageDailyRange", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("AverageDailyRange", got);
    }
    [Fact]
    public void Golden_AverageDrawdown()
    {
        using var ind = new Wickra.AverageDrawdown(14);
        Assert.Equal("AverageDrawdown", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("AverageDrawdown", got);
    }
    [Fact]
    public void Golden_AvgPrice()
    {
        using var ind = new Wickra.AvgPrice();
        Assert.Equal("AVGPRICE", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("AvgPrice", got);
    }
    [Fact]
    public void Golden_AwesomeOscillator()
    {
        using var ind = new Wickra.AwesomeOscillator(3, 7);
        Assert.Equal("AwesomeOscillator", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("AwesomeOscillator", got);
    }
    [Fact]
    public void Golden_AwesomeOscillatorHistogram()
    {
        using var ind = new Wickra.AwesomeOscillatorHistogram(3, 7, 14);
        Assert.Equal("AwesomeOscillatorHistogram", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("AwesomeOscillatorHistogram", got);
    }
    [Fact]
    public void Golden_BalanceOfPower()
    {
        using var ind = new Wickra.BalanceOfPower();
        Assert.Equal("BalanceOfPower", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("BalanceOfPower", got);
    }
    [Fact]
    public void Golden_BandpassFilter()
    {
        using var ind = new Wickra.BandpassFilter(20, 0.3);
        Assert.Equal("BandpassFilter", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("BandpassFilter", got);
    }
    [Fact]
    public void Golden_Bat()
    {
        using var ind = new Wickra.Bat();
        Assert.Equal("Bat", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Bat", got);
    }
    [Fact]
    public void Golden_BeltHold()
    {
        using var ind = new Wickra.BeltHold();
        Assert.Equal("BeltHold", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("BeltHold", got);
    }
    [Fact]
    public void Golden_Beta()
    {
        using var ind = new Wickra.Beta(14);
        Assert.Equal("Beta", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[0]) });
        }
        Compare("Beta", got);
    }
    [Fact]
    public void Golden_BetaNeutralSpread()
    {
        using var ind = new Wickra.BetaNeutralSpread(14);
        Assert.Equal("BetaNeutralSpread", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[0]) });
        }
        Compare("BetaNeutralSpread", got);
    }
    [Fact]
    public void Golden_BetterVolume()
    {
        using var ind = new Wickra.BetterVolume(14);
        Assert.Equal("BetterVolume", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("BetterVolume", got);
    }
    [Fact]
    public void Golden_BipowerVariation()
    {
        using var ind = new Wickra.BipowerVariation(14);
        Assert.Equal("BipowerVariation", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("BipowerVariation", got);
    }
    [Fact]
    public void Golden_BodySizePct()
    {
        using var ind = new Wickra.BodySizePct();
        Assert.Equal("BodySizePct", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("BodySizePct", got);
    }
    [Fact]
    public void Golden_BollingerBands()
    {
        using var ind = new Wickra.BollingerBands(20, 2.0);
        Assert.Equal("BollingerBands", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[3]), 4));
        }
        Compare("BollingerBands", got);
    }
    [Fact]
    public void Golden_BollingerBandwidth()
    {
        using var ind = new Wickra.BollingerBandwidth(14, 2.0);
        Assert.Equal("BollingerBandwidth", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("BollingerBandwidth", got);
    }
    [Fact]
    public void Golden_BomarBands()
    {
        using var ind = new Wickra.BomarBands(4, 0.85);
        Assert.Equal("BomarBands", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[3]), 3));
        }
        Compare("BomarBands", got);
    }
    [Fact]
    public void Golden_BreadthThrust()
    {
        using var ind = new Wickra.BreadthThrust(10);
        Assert.Equal("BreadthThrust", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var (ch, vo, nh, nl, am, ob) = CrossLists(r);
            got.Add(new[] { ind.Update(ch, vo, nh, nl, am, ob, i) });
        }
        Compare("BreadthThrust", got);
    }
    [Fact]
    public void Golden_Breakaway()
    {
        using var ind = new Wickra.Breakaway();
        Assert.Equal("Breakaway", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Breakaway", got);
    }
    [Fact]
    public void Golden_BullishPercentIndex()
    {
        using var ind = new Wickra.BullishPercentIndex();
        Assert.Equal("BullishPercentIndex", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var (ch, vo, nh, nl, am, ob) = CrossLists(r);
            got.Add(new[] { ind.Update(ch, vo, nh, nl, am, ob, i) });
        }
        Compare("BullishPercentIndex", got);
    }
    [Fact]
    public void Golden_BurkeRatio()
    {
        using var ind = new Wickra.BurkeRatio(14);
        Assert.Equal("BurkeRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("BurkeRatio", got);
    }
    [Fact]
    public void Golden_Butterfly()
    {
        using var ind = new Wickra.Butterfly();
        Assert.Equal("Butterfly", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Butterfly", got);
    }
    [Fact]
    public void Golden_CalendarSpread()
    {
        using var ind = new Wickra.CalendarSpread();
        Assert.Equal("CalendarSpread", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var d = DerivFields(r);
            got.Add(new[] { ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], i) });
        }
        Compare("CalendarSpread", got);
    }
    [Fact]
    public void Golden_CalmarRatio()
    {
        using var ind = new Wickra.CalmarRatio(14);
        Assert.Equal("CalmarRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("CalmarRatio", got);
    }
    [Fact]
    public void Golden_Camarilla()
    {
        using var ind = new Wickra.Camarilla();
        Assert.Equal("Camarilla", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 9));
        }
        Compare("Camarilla", got);
    }
    [Fact]
    public void Golden_CandleVolume()
    {
        using var ind = new Wickra.CandleVolume(14);
        Assert.Equal("CandleVolume", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("CandleVolume", got);
    }
    [Fact]
    public void Golden_Cci()
    {
        using var ind = new Wickra.Cci(14);
        Assert.Equal("CCI", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Cci", got);
    }
    [Fact]
    public void Golden_CenterOfGravity()
    {
        using var ind = new Wickra.CenterOfGravity(14);
        Assert.Equal("CenterOfGravity", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("CenterOfGravity", got);
    }
    [Fact]
    public void Golden_CentralPivotRange()
    {
        using var ind = new Wickra.CentralPivotRange();
        Assert.Equal("CentralPivotRange", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 3));
        }
        Compare("CentralPivotRange", got);
    }
    [Fact]
    public void Golden_Cfo()
    {
        using var ind = new Wickra.Cfo(14);
        Assert.Equal("CFO", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Cfo", got);
    }
    [Fact]
    public void Golden_ChaikinMoneyFlow()
    {
        using var ind = new Wickra.ChaikinMoneyFlow(20);
        Assert.Equal("CMF", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("ChaikinMoneyFlow", got);
    }
    [Fact]
    public void Golden_ChaikinOscillator()
    {
        using var ind = new Wickra.ChaikinOscillator(3, 7);
        Assert.Equal("ChaikinOscillator", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("ChaikinOscillator", got);
    }
    [Fact]
    public void Golden_ChaikinVolatility()
    {
        using var ind = new Wickra.ChaikinVolatility(3, 7);
        Assert.Equal("ChaikinVolatility", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("ChaikinVolatility", got);
    }
    [Fact]
    public void Golden_ChandeKrollStop()
    {
        using var ind = new Wickra.ChandeKrollStop(3, 2.0, 7);
        Assert.Equal("ChandeKrollStop", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("ChandeKrollStop", got);
    }
    [Fact]
    public void Golden_ChandelierExit()
    {
        using var ind = new Wickra.ChandelierExit(14, 2.0);
        Assert.Equal("ChandelierExit", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("ChandelierExit", got);
    }
    [Fact]
    public void Golden_ChoppinessIndex()
    {
        using var ind = new Wickra.ChoppinessIndex(14);
        Assert.Equal("ChoppinessIndex", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("ChoppinessIndex", got);
    }
    [Fact]
    public void Golden_ClassicPivots()
    {
        using var ind = new Wickra.ClassicPivots();
        Assert.Equal("ClassicPivots", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 7));
        }
        Compare("ClassicPivots", got);
    }
    [Fact]
    public void Golden_CloseVsOpen()
    {
        using var ind = new Wickra.CloseVsOpen();
        Assert.Equal("CloseVsOpen", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("CloseVsOpen", got);
    }
    [Fact]
    public void Golden_ClosingMarubozu()
    {
        using var ind = new Wickra.ClosingMarubozu();
        Assert.Equal("ClosingMarubozu", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("ClosingMarubozu", got);
    }
    [Fact]
    public void Golden_Cmo()
    {
        using var ind = new Wickra.Cmo(14);
        Assert.Equal("CMO", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Cmo", got);
    }
    [Fact]
    public void Golden_CoefficientOfVariation()
    {
        using var ind = new Wickra.CoefficientOfVariation(14);
        Assert.Equal("CoefficientOfVariation", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("CoefficientOfVariation", got);
    }
    [Fact]
    public void Golden_Cointegration()
    {
        using var ind = new Wickra.Cointegration(40, 1);
        Assert.Equal("Cointegration", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[3], r[0]), 3));
        }
        Compare("Cointegration", got);
    }
    [Fact]
    public void Golden_CommonSenseRatio()
    {
        using var ind = new Wickra.CommonSenseRatio(14);
        Assert.Equal("CommonSenseRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("CommonSenseRatio", got);
    }
    [Fact]
    public void Golden_CompositeProfile()
    {
        using var ind = new Wickra.CompositeProfile(20, 24, 0.7);
        Assert.Equal("CompositeProfile", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 3));
        }
        Compare("CompositeProfile", got);
    }
    [Fact]
    public void Golden_ConcealingBabySwallow()
    {
        using var ind = new Wickra.ConcealingBabySwallow();
        Assert.Equal("ConcealingBabySwallow", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("ConcealingBabySwallow", got);
    }
    [Fact]
    public void Golden_ConditionalValueAtRisk()
    {
        using var ind = new Wickra.ConditionalValueAtRisk(20, 0.95);
        Assert.Equal("ConditionalValueAtRisk", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("ConditionalValueAtRisk", got);
    }
    [Fact]
    public void Golden_ConnorsRsi()
    {
        using var ind = new Wickra.ConnorsRsi(3, 7, 14);
        Assert.Equal("ConnorsRSI", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("ConnorsRsi", got);
    }
    [Fact]
    public void Golden_Coppock()
    {
        using var ind = new Wickra.Coppock(3, 7, 14);
        Assert.Equal("Coppock", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Coppock", got);
    }
    [Fact]
    public void Golden_CorrelationTrendIndicator()
    {
        using var ind = new Wickra.CorrelationTrendIndicator(14);
        Assert.Equal("CorrelationTrendIndicator", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("CorrelationTrendIndicator", got);
    }
    [Fact]
    public void Golden_Counterattack()
    {
        using var ind = new Wickra.Counterattack();
        Assert.Equal("Counterattack", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Counterattack", got);
    }
    [Fact]
    public void Golden_Crab()
    {
        using var ind = new Wickra.Crab();
        Assert.Equal("Crab", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Crab", got);
    }
    [Fact]
    public void Golden_CumulativeVolumeDelta()
    {
        using var ind = new Wickra.CumulativeVolumeDelta();
        Assert.Equal("CumulativeVolumeDelta", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[4], r[3] >= r[0], i) });
        }
        Compare("CumulativeVolumeDelta", got);
    }
    [Fact]
    public void Golden_CumulativeVolumeIndex()
    {
        using var ind = new Wickra.CumulativeVolumeIndex();
        Assert.Equal("CumulativeVolumeIndex", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var (ch, vo, nh, nl, am, ob) = CrossLists(r);
            got.Add(new[] { ind.Update(ch, vo, nh, nl, am, ob, i) });
        }
        Compare("CumulativeVolumeIndex", got);
    }
    [Fact]
    public void Golden_CupAndHandle()
    {
        using var ind = new Wickra.CupAndHandle();
        Assert.Equal("CupAndHandle", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("CupAndHandle", got);
    }
    [Fact]
    public void Golden_CyberneticCycle()
    {
        using var ind = new Wickra.CyberneticCycle(14);
        Assert.Equal("CyberneticCycle", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("CyberneticCycle", got);
    }
    [Fact]
    public void Golden_Cypher()
    {
        using var ind = new Wickra.Cypher();
        Assert.Equal("Cypher", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Cypher", got);
    }
    [Fact]
    public void Golden_DayOfWeekProfile()
    {
        using var ind = new Wickra.DayOfWeekProfile(0);
        Assert.Equal("DayOfWeekProfile", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var bins = ind.Update(r[0], r[1], r[2], r[3], r[4], i);
            got.Add(bins ?? NanRow(7));
        }
        Compare("DayOfWeekProfile", got);
    }
    [Fact]
    public void Golden_Decycler()
    {
        using var ind = new Wickra.Decycler(14);
        Assert.Equal("Decycler", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Decycler", got);
    }
    [Fact]
    public void Golden_DecyclerOscillator()
    {
        using var ind = new Wickra.DecyclerOscillator(3, 7);
        Assert.Equal("DecyclerOscillator", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("DecyclerOscillator", got);
    }
    [Fact]
    public void Golden_Dema()
    {
        using var ind = new Wickra.Dema(14);
        Assert.Equal("DEMA", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Dema", got);
    }
    [Fact]
    public void Golden_DemandIndex()
    {
        using var ind = new Wickra.DemandIndex(14);
        Assert.Equal("DemandIndex", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("DemandIndex", got);
    }
    [Fact]
    public void Golden_DemarkPivots()
    {
        using var ind = new Wickra.DemarkPivots();
        Assert.Equal("DemarkPivots", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 3));
        }
        Compare("DemarkPivots", got);
    }
    [Fact]
    public void Golden_DepthSlope()
    {
        using var ind = new Wickra.DepthSlope();
        Assert.Equal("DepthSlope", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var (bp, bs, ap, asz) = ObLists(r);
            got.Add(new[] { ind.Update(bp, bs, ap, asz) });
        }
        Compare("DepthSlope", got);
    }
    [Fact]
    public void Golden_DerivativeOscillator()
    {
        using var ind = new Wickra.DerivativeOscillator(3, 7, 14, 28);
        Assert.Equal("DerivativeOscillator", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("DerivativeOscillator", got);
    }
    [Fact]
    public void Golden_DetrendedStdDev()
    {
        using var ind = new Wickra.DetrendedStdDev(14);
        Assert.Equal("DetrendedStdDev", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("DetrendedStdDev", got);
    }
    [Fact]
    public void Golden_DisparityIndex()
    {
        using var ind = new Wickra.DisparityIndex(14);
        Assert.Equal("DisparityIndex", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("DisparityIndex", got);
    }
    [Fact]
    public void Golden_DistanceSsd()
    {
        using var ind = new Wickra.DistanceSsd(14);
        Assert.Equal("DistanceSsd", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[0]) });
        }
        Compare("DistanceSsd", got);
    }
    [Fact]
    public void Golden_Doji()
    {
        using var ind = new Wickra.Doji();
        Assert.Equal("Doji", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Doji", got);
    }
    [Fact]
    public void Golden_DojiStar()
    {
        using var ind = new Wickra.DojiStar();
        Assert.Equal("DojiStar", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("DojiStar", got);
    }
    [Fact]
    public void Golden_DollarBars()
    {
        using var ind = new Wickra.DollarBars(50000.0);
        Assert.Equal("DollarBars", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenBars(ind.Update(r[0], r[1], r[2], r[3], r[4], 0)));
        }
        Compare("DollarBars", got);
    }
    [Fact]
    public void Golden_Donchian()
    {
        using var ind = new Wickra.Donchian(14);
        Assert.Equal("DonchianChannels", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 3));
        }
        Compare("Donchian", got);
    }
    [Fact]
    public void Golden_DonchianStop()
    {
        using var ind = new Wickra.DonchianStop(14);
        Assert.Equal("DonchianStop", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("DonchianStop", got);
    }
    [Fact]
    public void Golden_DoubleBollinger()
    {
        using var ind = new Wickra.DoubleBollinger(20, 1.0, 2.0);
        Assert.Equal("DoubleBollinger", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[3]), 5));
        }
        Compare("DoubleBollinger", got);
    }
    [Fact]
    public void Golden_DoubleTopBottom()
    {
        using var ind = new Wickra.DoubleTopBottom();
        Assert.Equal("DoubleTopBottom", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("DoubleTopBottom", got);
    }
    [Fact]
    public void Golden_DownsideGapThreeMethods()
    {
        using var ind = new Wickra.DownsideGapThreeMethods();
        Assert.Equal("DownsideGapThreeMethods", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("DownsideGapThreeMethods", got);
    }
    [Fact]
    public void Golden_Dpo()
    {
        using var ind = new Wickra.Dpo(14);
        Assert.Equal("DPO", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Dpo", got);
    }
    [Fact]
    public void Golden_DragonflyDoji()
    {
        using var ind = new Wickra.DragonflyDoji();
        Assert.Equal("DragonflyDoji", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("DragonflyDoji", got);
    }
    [Fact]
    public void Golden_DrawdownDuration()
    {
        using var ind = new Wickra.DrawdownDuration();
        Assert.Equal("DrawdownDuration", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("DrawdownDuration", got);
    }
    [Fact]
    public void Golden_DumplingTop()
    {
        using var ind = new Wickra.DumplingTop(14);
        Assert.Equal("DumplingTop", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("DumplingTop", got);
    }
    [Fact]
    public void Golden_Dx()
    {
        using var ind = new Wickra.Dx(14);
        Assert.Equal("DX", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Dx", got);
    }
    [Fact]
    public void Golden_DynamicMomentumIndex()
    {
        using var ind = new Wickra.DynamicMomentumIndex(14);
        Assert.Equal("DynamicMomentumIndex", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("DynamicMomentumIndex", got);
    }
    [Fact]
    public void Golden_EaseOfMovement()
    {
        using var ind = new Wickra.EaseOfMovement(14);
        Assert.Equal("EaseOfMovement", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("EaseOfMovement", got);
    }
    [Fact]
    public void Golden_EffectiveSpread()
    {
        using var ind = new Wickra.EffectiveSpread();
        Assert.Equal("EffectiveSpread", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[4], r[3] >= r[0], i, (r[1] + r[2]) / 2) });
        }
        Compare("EffectiveSpread", got);
    }
    [Fact]
    public void Golden_EhlersStochastic()
    {
        using var ind = new Wickra.EhlersStochastic(14);
        Assert.Equal("EhlersStochastic", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("EhlersStochastic", got);
    }
    [Fact]
    public void Golden_Ehma()
    {
        using var ind = new Wickra.Ehma(14);
        Assert.Equal("EHMA", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Ehma", got);
    }
    [Fact]
    public void Golden_ElderImpulse()
    {
        using var ind = new Wickra.ElderImpulse(3, 7, 14, 28);
        Assert.Equal("ElderImpulse", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("ElderImpulse", got);
    }
    [Fact]
    public void Golden_ElderRay()
    {
        using var ind = new Wickra.ElderRay(14);
        Assert.Equal("ElderRay", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("ElderRay", got);
    }
    [Fact]
    public void Golden_ElderSafeZone()
    {
        using var ind = new Wickra.ElderSafeZone(10, 2.0);
        Assert.Equal("ElderSafeZone", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("ElderSafeZone", got);
    }
    [Fact]
    public void Golden_Ema()
    {
        using var ind = new Wickra.Ema(14);
        Assert.Equal("EMA", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Ema", got);
    }
    [Fact]
    public void Golden_EmpiricalModeDecomposition()
    {
        using var ind = new Wickra.EmpiricalModeDecomposition(20, 0.1);
        Assert.Equal("EmpiricalModeDecomposition", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("EmpiricalModeDecomposition", got);
    }
    [Fact]
    public void Golden_Engulfing()
    {
        using var ind = new Wickra.Engulfing();
        Assert.Equal("Engulfing", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Engulfing", got);
    }
    [Fact]
    public void Golden_Equivolume()
    {
        using var ind = new Wickra.Equivolume(14);
        Assert.Equal("Equivolume", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("Equivolume", got);
    }
    [Fact]
    public void Golden_EstimatedLeverageRatio()
    {
        using var ind = new Wickra.EstimatedLeverageRatio();
        Assert.Equal("EstimatedLeverageRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var d = DerivFields(r);
            got.Add(new[] { ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], i) });
        }
        Compare("EstimatedLeverageRatio", got);
    }
    [Fact]
    public void Golden_EvenBetterSinewave()
    {
        using var ind = new Wickra.EvenBetterSinewave(40, 10);
        Assert.Equal("EvenBetterSinewave", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("EvenBetterSinewave", got);
    }
    [Fact]
    public void Golden_EveningDojiStar()
    {
        using var ind = new Wickra.EveningDojiStar();
        Assert.Equal("EveningDojiStar", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("EveningDojiStar", got);
    }
    [Fact]
    public void Golden_Evwma()
    {
        using var ind = new Wickra.Evwma(14);
        Assert.Equal("EVWMA", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Evwma", got);
    }
    [Fact]
    public void Golden_EwmaVolatility()
    {
        using var ind = new Wickra.EwmaVolatility(0.94);
        Assert.Equal("EwmaVolatility", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("EwmaVolatility", got);
    }
    [Fact]
    public void Golden_Expectancy()
    {
        using var ind = new Wickra.Expectancy(14);
        Assert.Equal("Expectancy", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Expectancy", got);
    }
    [Fact]
    public void Golden_FallingThreeMethods()
    {
        using var ind = new Wickra.FallingThreeMethods();
        Assert.Equal("FallingThreeMethods", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("FallingThreeMethods", got);
    }
    [Fact]
    public void Golden_Fama()
    {
        using var ind = new Wickra.Fama(0.5, 0.05);
        Assert.Equal("FAMA", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Fama", got);
    }
    [Fact]
    public void Golden_FibArcs()
    {
        using var ind = new Wickra.FibArcs();
        Assert.Equal("FibArcs", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 3));
        }
        Compare("FibArcs", got);
    }
    [Fact]
    public void Golden_FibChannel()
    {
        using var ind = new Wickra.FibChannel();
        Assert.Equal("FibChannel", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 4));
        }
        Compare("FibChannel", got);
    }
    [Fact]
    public void Golden_FibConfluence()
    {
        using var ind = new Wickra.FibConfluence();
        Assert.Equal("FibConfluence", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("FibConfluence", got);
    }
    [Fact]
    public void Golden_FibExtension()
    {
        using var ind = new Wickra.FibExtension();
        Assert.Equal("FibExtension", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 5));
        }
        Compare("FibExtension", got);
    }
    [Fact]
    public void Golden_FibFan()
    {
        using var ind = new Wickra.FibFan();
        Assert.Equal("FibFan", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 3));
        }
        Compare("FibFan", got);
    }
    [Fact]
    public void Golden_FibProjection()
    {
        using var ind = new Wickra.FibProjection();
        Assert.Equal("FibProjection", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 4));
        }
        Compare("FibProjection", got);
    }
    [Fact]
    public void Golden_FibRetracement()
    {
        using var ind = new Wickra.FibRetracement();
        Assert.Equal("FibRetracement", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 7));
        }
        Compare("FibRetracement", got);
    }
    [Fact]
    public void Golden_FibTimeZones()
    {
        using var ind = new Wickra.FibTimeZones();
        Assert.Equal("FibTimeZones", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("FibTimeZones", got);
    }
    [Fact]
    public void Golden_FibonacciPivots()
    {
        using var ind = new Wickra.FibonacciPivots();
        Assert.Equal("FibonacciPivots", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 7));
        }
        Compare("FibonacciPivots", got);
    }
    [Fact]
    public void Golden_FisherRsi()
    {
        using var ind = new Wickra.FisherRsi(14);
        Assert.Equal("FisherRSI", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("FisherRsi", got);
    }
    [Fact]
    public void Golden_FisherTransform()
    {
        using var ind = new Wickra.FisherTransform(14);
        Assert.Equal("FisherTransform", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("FisherTransform", got);
    }
    [Fact]
    public void Golden_FlagPennant()
    {
        using var ind = new Wickra.FlagPennant();
        Assert.Equal("FlagPennant", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("FlagPennant", got);
    }
    [Fact]
    public void Golden_Footprint()
    {
        using var ind = new Wickra.Footprint(1.0);
        Assert.Equal("Footprint", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenBars(ind.Update(r[3], r[4], r[3] >= r[0], i)));
        }
        Compare("Footprint", got);
    }
    [Fact]
    public void Golden_ForceIndex()
    {
        using var ind = new Wickra.ForceIndex(14);
        Assert.Equal("ForceIndex", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("ForceIndex", got);
    }
    [Fact]
    public void Golden_FractalChaosBands()
    {
        using var ind = new Wickra.FractalChaosBands(14);
        Assert.Equal("FractalChaosBands", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("FractalChaosBands", got);
    }
    [Fact]
    public void Golden_Frama()
    {
        using var ind = new Wickra.Frama(14);
        Assert.Equal("FRAMA", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Frama", got);
    }
    [Fact]
    public void Golden_FryPanBottom()
    {
        using var ind = new Wickra.FryPanBottom(14);
        Assert.Equal("FryPanBottom", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("FryPanBottom", got);
    }
    [Fact]
    public void Golden_FundingBasis()
    {
        using var ind = new Wickra.FundingBasis();
        Assert.Equal("FundingBasis", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var d = DerivFields(r);
            got.Add(new[] { ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], i) });
        }
        Compare("FundingBasis", got);
    }
    [Fact]
    public void Golden_FundingImpliedApr()
    {
        using var ind = new Wickra.FundingImpliedApr(1095.0);
        Assert.Equal("FundingImpliedApr", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var d = DerivFields(r);
            got.Add(new[] { ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], i) });
        }
        Compare("FundingImpliedApr", got);
    }
    [Fact]
    public void Golden_FundingRate()
    {
        using var ind = new Wickra.FundingRate();
        Assert.Equal("FundingRate", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var d = DerivFields(r);
            got.Add(new[] { ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], i) });
        }
        Compare("FundingRate", got);
    }
    [Fact]
    public void Golden_FundingRateMean()
    {
        using var ind = new Wickra.FundingRateMean(20);
        Assert.Equal("FundingRateMean", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var d = DerivFields(r);
            got.Add(new[] { ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], i) });
        }
        Compare("FundingRateMean", got);
    }
    [Fact]
    public void Golden_FundingRateZScore()
    {
        using var ind = new Wickra.FundingRateZScore(20);
        Assert.Equal("FundingRateZScore", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var d = DerivFields(r);
            got.Add(new[] { ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], i) });
        }
        Compare("FundingRateZScore", got);
    }
    [Fact]
    public void Golden_GainLossRatio()
    {
        using var ind = new Wickra.GainLossRatio(14);
        Assert.Equal("GainLossRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("GainLossRatio", got);
    }
    [Fact]
    public void Golden_GainToPainRatio()
    {
        using var ind = new Wickra.GainToPainRatio(14);
        Assert.Equal("GainToPainRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("GainToPainRatio", got);
    }
    [Fact]
    public void Golden_GapSideBySideWhite()
    {
        using var ind = new Wickra.GapSideBySideWhite();
        Assert.Equal("GapSideBySideWhite", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("GapSideBySideWhite", got);
    }
    [Fact]
    public void Golden_Garch11()
    {
        using var ind = new Wickra.Garch11(2e-06, 0.1, 0.88);
        Assert.Equal("Garch11", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Garch11", got);
    }
    [Fact]
    public void Golden_GarmanKlassVolatility()
    {
        using var ind = new Wickra.GarmanKlassVolatility(20, 252);
        Assert.Equal("GarmanKlassVolatility", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("GarmanKlassVolatility", got);
    }
    [Fact]
    public void Golden_Gartley()
    {
        using var ind = new Wickra.Gartley();
        Assert.Equal("Gartley", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Gartley", got);
    }
    [Fact]
    public void Golden_GatorOscillator()
    {
        using var ind = new Wickra.GatorOscillator(3, 7, 14);
        Assert.Equal("GatorOscillator", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("GatorOscillator", got);
    }
    [Fact]
    public void Golden_GeneralizedDema()
    {
        using var ind = new Wickra.GeneralizedDema(5, 0.7);
        Assert.Equal("GD", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("GeneralizedDema", got);
    }
    [Fact]
    public void Golden_GeometricMa()
    {
        using var ind = new Wickra.GeometricMa(14);
        Assert.Equal("GMA", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("GeometricMa", got);
    }
    [Fact]
    public void Golden_GoldenPocket()
    {
        using var ind = new Wickra.GoldenPocket();
        Assert.Equal("GoldenPocket", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 3));
        }
        Compare("GoldenPocket", got);
    }
    [Fact]
    public void Golden_GrangerCausality()
    {
        using var ind = new Wickra.GrangerCausality(60, 1);
        Assert.Equal("GrangerCausality", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[0]) });
        }
        Compare("GrangerCausality", got);
    }
    [Fact]
    public void Golden_GravestoneDoji()
    {
        using var ind = new Wickra.GravestoneDoji();
        Assert.Equal("GravestoneDoji", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("GravestoneDoji", got);
    }
    [Fact]
    public void Golden_Hammer()
    {
        using var ind = new Wickra.Hammer();
        Assert.Equal("Hammer", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Hammer", got);
    }
    [Fact]
    public void Golden_HangingMan()
    {
        using var ind = new Wickra.HangingMan();
        Assert.Equal("HangingMan", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("HangingMan", got);
    }
    [Fact]
    public void Golden_Harami()
    {
        using var ind = new Wickra.Harami();
        Assert.Equal("Harami", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Harami", got);
    }
    [Fact]
    public void Golden_HaramiCross()
    {
        using var ind = new Wickra.HaramiCross();
        Assert.Equal("HaramiCross", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("HaramiCross", got);
    }
    [Fact]
    public void Golden_HasbrouckInformationShare()
    {
        using var ind = new Wickra.HasbrouckInformationShare(14);
        Assert.Equal("HasbrouckInformationShare", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[0]) });
        }
        Compare("HasbrouckInformationShare", got);
    }
    [Fact]
    public void Golden_HeadAndShoulders()
    {
        using var ind = new Wickra.HeadAndShoulders();
        Assert.Equal("HeadAndShoulders", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("HeadAndShoulders", got);
    }
    [Fact]
    public void Golden_HeikinAshi()
    {
        using var ind = new Wickra.HeikinAshi();
        Assert.Equal("HeikinAshi", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 4));
        }
        Compare("HeikinAshi", got);
    }
    [Fact]
    public void Golden_HeikinAshiOscillator()
    {
        using var ind = new Wickra.HeikinAshiOscillator(14);
        Assert.Equal("HeikinAshiOscillator", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("HeikinAshiOscillator", got);
    }
    [Fact]
    public void Golden_HiLoActivator()
    {
        using var ind = new Wickra.HiLoActivator(14);
        Assert.Equal("HiLoActivator", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("HiLoActivator", got);
    }
    [Fact]
    public void Golden_HighLowIndex()
    {
        using var ind = new Wickra.HighLowIndex(10);
        Assert.Equal("HighLowIndex", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var (ch, vo, nh, nl, am, ob) = CrossLists(r);
            got.Add(new[] { ind.Update(ch, vo, nh, nl, am, ob, i) });
        }
        Compare("HighLowIndex", got);
    }
    [Fact]
    public void Golden_HighLowRange()
    {
        using var ind = new Wickra.HighLowRange();
        Assert.Equal("HighLowRange", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("HighLowRange", got);
    }
    [Fact]
    public void Golden_HighLowVolumeNodes()
    {
        using var ind = new Wickra.HighLowVolumeNodes(3, 7);
        Assert.Equal("HighLowVolumeNodes", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("HighLowVolumeNodes", got);
    }
    [Fact]
    public void Golden_HighWave()
    {
        using var ind = new Wickra.HighWave();
        Assert.Equal("HighWave", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("HighWave", got);
    }
    [Fact]
    public void Golden_HighpassFilter()
    {
        using var ind = new Wickra.HighpassFilter(14);
        Assert.Equal("HighpassFilter", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("HighpassFilter", got);
    }
    [Fact]
    public void Golden_Hikkake()
    {
        using var ind = new Wickra.Hikkake();
        Assert.Equal("Hikkake", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Hikkake", got);
    }
    [Fact]
    public void Golden_HikkakeModified()
    {
        using var ind = new Wickra.HikkakeModified();
        Assert.Equal("HikkakeModified", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("HikkakeModified", got);
    }
    [Fact]
    public void Golden_HilbertDominantCycle()
    {
        using var ind = new Wickra.HilbertDominantCycle();
        Assert.Equal("HilbertDominantCycle", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("HilbertDominantCycle", got);
    }
    [Fact]
    public void Golden_HistoricalVolatility()
    {
        using var ind = new Wickra.HistoricalVolatility(3, 7);
        Assert.Equal("HistoricalVolatility", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("HistoricalVolatility", got);
    }
    [Fact]
    public void Golden_Hma()
    {
        using var ind = new Wickra.Hma(14);
        Assert.Equal("HMA", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Hma", got);
    }
    [Fact]
    public void Golden_HoltWinters()
    {
        using var ind = new Wickra.HoltWinters(0.5, 0.1);
        Assert.Equal("HoltWinters", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("HoltWinters", got);
    }
    [Fact]
    public void Golden_HomingPigeon()
    {
        using var ind = new Wickra.HomingPigeon();
        Assert.Equal("HomingPigeon", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("HomingPigeon", got);
    }
    [Fact]
    public void Golden_HtDcPhase()
    {
        using var ind = new Wickra.HtDcPhase();
        Assert.Equal("HT_DCPHASE", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("HtDcPhase", got);
    }
    [Fact]
    public void Golden_HtPhasor()
    {
        using var ind = new Wickra.HtPhasor();
        Assert.Equal("HT_PHASOR", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[3]), 2));
        }
        Compare("HtPhasor", got);
    }
    [Fact]
    public void Golden_HtTrendMode()
    {
        using var ind = new Wickra.HtTrendMode();
        Assert.Equal("HT_TRENDMODE", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("HtTrendMode", got);
    }
    [Fact]
    public void Golden_HurstChannel()
    {
        using var ind = new Wickra.HurstChannel(14, 2.0);
        Assert.Equal("HurstChannel", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 3));
        }
        Compare("HurstChannel", got);
    }
    [Fact]
    public void Golden_HurstExponent()
    {
        using var ind = new Wickra.HurstExponent(100, 4);
        Assert.Equal("HurstExponent", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("HurstExponent", got);
    }
    [Fact]
    public void Golden_Ichimoku()
    {
        using var ind = new Wickra.Ichimoku(9, 26, 52, 26);
        Assert.Equal("Ichimoku", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 5));
        }
        Compare("Ichimoku", got);
    }
    [Fact]
    public void Golden_IdenticalThreeCrows()
    {
        using var ind = new Wickra.IdenticalThreeCrows();
        Assert.Equal("IdenticalThreeCrows", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("IdenticalThreeCrows", got);
    }
    [Fact]
    public void Golden_ImbalanceBars()
    {
        using var ind = new Wickra.ImbalanceBars(5.0);
        Assert.Equal("ImbalanceBars", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenBars(ind.Update(r[0], r[1], r[2], r[3], 1.0, 0)));
        }
        Compare("ImbalanceBars", got);
    }
    [Fact]
    public void Golden_InNeck()
    {
        using var ind = new Wickra.InNeck();
        Assert.Equal("InNeck", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("InNeck", got);
    }
    [Fact]
    public void Golden_Inertia()
    {
        using var ind = new Wickra.Inertia(3, 7);
        Assert.Equal("Inertia", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Inertia", got);
    }
    [Fact]
    public void Golden_InformationRatio()
    {
        using var ind = new Wickra.InformationRatio(14);
        Assert.Equal("InformationRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[0]) });
        }
        Compare("InformationRatio", got);
    }
    [Fact]
    public void Golden_InitialBalance()
    {
        using var ind = new Wickra.InitialBalance(14);
        Assert.Equal("InitialBalance", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("InitialBalance", got);
    }
    [Fact]
    public void Golden_InstantaneousTrendline()
    {
        using var ind = new Wickra.InstantaneousTrendline(14);
        Assert.Equal("InstantaneousTrendline", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("InstantaneousTrendline", got);
    }
    [Fact]
    public void Golden_IntradayIntensity()
    {
        using var ind = new Wickra.IntradayIntensity();
        Assert.Equal("IntradayIntensity", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("IntradayIntensity", got);
    }
    [Fact]
    public void Golden_IntradayMomentumIndex()
    {
        using var ind = new Wickra.IntradayMomentumIndex(14);
        Assert.Equal("IMI", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("IntradayMomentumIndex", got);
    }
    [Fact]
    public void Golden_IntradayVolatilityProfile()
    {
        using var ind = new Wickra.IntradayVolatilityProfile(24, 0);
        Assert.Equal("IntradayVolatilityProfile", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var bins = ind.Update(r[0], r[1], r[2], r[3], r[4], i);
            got.Add(bins ?? NanRow(24));
        }
        Compare("IntradayVolatilityProfile", got);
    }
    [Fact]
    public void Golden_InverseFisherTransform()
    {
        using var ind = new Wickra.InverseFisherTransform(2.0);
        Assert.Equal("InverseFisherTransform", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("InverseFisherTransform", got);
    }
    [Fact]
    public void Golden_InvertedHammer()
    {
        using var ind = new Wickra.InvertedHammer();
        Assert.Equal("InvertedHammer", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("InvertedHammer", got);
    }
    [Fact]
    public void Golden_JarqueBera()
    {
        using var ind = new Wickra.JarqueBera(14);
        Assert.Equal("JarqueBera", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("JarqueBera", got);
    }
    [Fact]
    public void Golden_Jma()
    {
        using var ind = new Wickra.Jma(7, 0.0, 2u);
        Assert.Equal("JMA", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Jma", got);
    }
    [Fact]
    public void Golden_JumpIndicator()
    {
        using var ind = new Wickra.JumpIndicator(14, 2.0);
        Assert.Equal("JumpIndicator", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("JumpIndicator", got);
    }
    [Fact]
    public void Golden_KRatio()
    {
        using var ind = new Wickra.KRatio(14);
        Assert.Equal("KRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("KRatio", got);
    }
    [Fact]
    public void Golden_KagiBars()
    {
        using var ind = new Wickra.KagiBars(2.0);
        Assert.Equal("KagiBars", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenBars(ind.Update(r[3], r[3], r[3], r[3], 1.0, 0)));
        }
        Compare("KagiBars", got);
    }
    [Fact]
    public void Golden_KalmanHedgeRatio()
    {
        using var ind = new Wickra.KalmanHedgeRatio(0.01, 0.001);
        Assert.Equal("KalmanHedgeRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[3], r[0]), 3));
        }
        Compare("KalmanHedgeRatio", got);
    }
    [Fact]
    public void Golden_Kama()
    {
        using var ind = new Wickra.Kama(3, 7, 14);
        Assert.Equal("KAMA", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Kama", got);
    }
    [Fact]
    public void Golden_KaseDevStop()
    {
        using var ind = new Wickra.KaseDevStop(14, 2.0);
        Assert.Equal("KaseDevStop", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("KaseDevStop", got);
    }
    [Fact]
    public void Golden_KasePermissionStochastic()
    {
        using var ind = new Wickra.KasePermissionStochastic(3, 7);
        Assert.Equal("KasePermissionStochastic", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("KasePermissionStochastic", got);
    }
    [Fact]
    public void Golden_KellyCriterion()
    {
        using var ind = new Wickra.KellyCriterion(14);
        Assert.Equal("KellyCriterion", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("KellyCriterion", got);
    }
    [Fact]
    public void Golden_Keltner()
    {
        using var ind = new Wickra.Keltner(3, 7, 2.0);
        Assert.Equal("KeltnerChannels", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 3));
        }
        Compare("Keltner", got);
    }
    [Fact]
    public void Golden_KendallTau()
    {
        using var ind = new Wickra.KendallTau(14);
        Assert.Equal("KendallTau", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[0]) });
        }
        Compare("KendallTau", got);
    }
    [Fact]
    public void Golden_Kicking()
    {
        using var ind = new Wickra.Kicking();
        Assert.Equal("Kicking", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Kicking", got);
    }
    [Fact]
    public void Golden_KickingByLength()
    {
        using var ind = new Wickra.KickingByLength();
        Assert.Equal("KickingByLength", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("KickingByLength", got);
    }
    [Fact]
    public void Golden_Kst()
    {
        using var ind = new Wickra.Kst(3, 7, 14, 28, 35, 42, 56, 63, 70);
        Assert.Equal("KST", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[3]), 2));
        }
        Compare("Kst", got);
    }
    [Fact]
    public void Golden_Kurtosis()
    {
        using var ind = new Wickra.Kurtosis(14);
        Assert.Equal("Kurtosis", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Kurtosis", got);
    }
    [Fact]
    public void Golden_Kvo()
    {
        using var ind = new Wickra.Kvo(3, 7);
        Assert.Equal("KVO", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Kvo", got);
    }
    [Fact]
    public void Golden_KylesLambda()
    {
        using var ind = new Wickra.KylesLambda(20);
        Assert.Equal("KylesLambda", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[4], r[3] >= r[0], i, (r[1] + r[2]) / 2) });
        }
        Compare("KylesLambda", got);
    }
    [Fact]
    public void Golden_LadderBottom()
    {
        using var ind = new Wickra.LadderBottom();
        Assert.Equal("LadderBottom", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("LadderBottom", got);
    }
    [Fact]
    public void Golden_LaguerreRsi()
    {
        using var ind = new Wickra.LaguerreRsi(0.5);
        Assert.Equal("LaguerreRSI", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("LaguerreRsi", got);
    }
    [Fact]
    public void Golden_LeadLagCrossCorrelation()
    {
        using var ind = new Wickra.LeadLagCrossCorrelation(20, 10);
        Assert.Equal("LeadLagCrossCorrelation", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[3], r[0]), 2));
        }
        Compare("LeadLagCrossCorrelation", got);
    }
    [Fact]
    public void Golden_LinRegAngle()
    {
        using var ind = new Wickra.LinRegAngle(14);
        Assert.Equal("LinRegAngle", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("LinRegAngle", got);
    }
    [Fact]
    public void Golden_LinRegChannel()
    {
        using var ind = new Wickra.LinRegChannel(14, 2.0);
        Assert.Equal("LinRegChannel", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[3]), 3));
        }
        Compare("LinRegChannel", got);
    }
    [Fact]
    public void Golden_LinRegIntercept()
    {
        using var ind = new Wickra.LinRegIntercept(14);
        Assert.Equal("LINEARREG_INTERCEPT", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("LinRegIntercept", got);
    }
    [Fact]
    public void Golden_LinRegSlope()
    {
        using var ind = new Wickra.LinRegSlope(14);
        Assert.Equal("LinRegSlope", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("LinRegSlope", got);
    }
    [Fact]
    public void Golden_LinearRegression()
    {
        using var ind = new Wickra.LinearRegression(14);
        Assert.Equal("LinearRegression", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("LinearRegression", got);
    }
    [Fact]
    public void Golden_LiquidationFeatures()
    {
        using var ind = new Wickra.LiquidationFeatures();
        Assert.Equal("LiquidationFeatures", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var d = DerivFields(r);
            got.Add(FlattenNullable(ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], i), 5));
        }
        Compare("LiquidationFeatures", got);
    }
    [Fact]
    public void Golden_LogReturn()
    {
        using var ind = new Wickra.LogReturn(14);
        Assert.Equal("LogReturn", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("LogReturn", got);
    }
    [Fact]
    public void Golden_LongLeggedDoji()
    {
        using var ind = new Wickra.LongLeggedDoji();
        Assert.Equal("LongLeggedDoji", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("LongLeggedDoji", got);
    }
    [Fact]
    public void Golden_LongLine()
    {
        using var ind = new Wickra.LongLine();
        Assert.Equal("LongLine", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("LongLine", got);
    }
    [Fact]
    public void Golden_LongShortRatio()
    {
        using var ind = new Wickra.LongShortRatio();
        Assert.Equal("LongShortRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var d = DerivFields(r);
            got.Add(new[] { ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], i) });
        }
        Compare("LongShortRatio", got);
    }
    [Fact]
    public void Golden_M2Measure()
    {
        using var ind = new Wickra.M2Measure(14, 2.0, 0.5);
        Assert.Equal("M2Measure", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("M2Measure", got);
    }
    [Fact]
    public void Golden_MaEnvelope()
    {
        using var ind = new Wickra.MaEnvelope(14, 2.0);
        Assert.Equal("MaEnvelope", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[3]), 3));
        }
        Compare("MaEnvelope", got);
    }
    [Fact]
    public void Golden_MacdExt()
    {
        using var ind = new Wickra.MacdExt(12, (byte)0, 26, (byte)0, 9, (byte)0);
        Assert.Equal("MACDEXT", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[3]), 3));
        }
        Compare("MacdExt", got);
    }
    [Fact]
    public void Golden_MacdFix()
    {
        using var ind = new Wickra.MacdFix(9);
        Assert.Equal("MACDFIX", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[3]), 3));
        }
        Compare("MacdFix", got);
    }
    [Fact]
    public void Golden_MacdHistogram()
    {
        using var ind = new Wickra.MacdHistogram(3, 7, 14);
        Assert.Equal("MacdHistogram", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("MacdHistogram", got);
    }
    [Fact]
    public void Golden_MacdIndicator()
    {
        using var ind = new Wickra.MacdIndicator(12, 26, 9);
        Assert.Equal("MACD", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[3]), 3));
        }
        Compare("MacdIndicator", got);
    }
    [Fact]
    public void Golden_Mama()
    {
        using var ind = new Wickra.Mama(0.5, 0.05);
        Assert.Equal("MAMA", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[3]), 2));
        }
        Compare("Mama", got);
    }
    [Fact]
    public void Golden_MarketFacilitationIndex()
    {
        using var ind = new Wickra.MarketFacilitationIndex();
        Assert.Equal("MarketFacilitationIndex", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("MarketFacilitationIndex", got);
    }
    [Fact]
    public void Golden_MartinRatio()
    {
        using var ind = new Wickra.MartinRatio(14);
        Assert.Equal("MartinRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("MartinRatio", got);
    }
    [Fact]
    public void Golden_Marubozu()
    {
        using var ind = new Wickra.Marubozu();
        Assert.Equal("Marubozu", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Marubozu", got);
    }
    [Fact]
    public void Golden_MassIndex()
    {
        using var ind = new Wickra.MassIndex(3, 7);
        Assert.Equal("MassIndex", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("MassIndex", got);
    }
    [Fact]
    public void Golden_MatHold()
    {
        using var ind = new Wickra.MatHold();
        Assert.Equal("MatHold", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("MatHold", got);
    }
    [Fact]
    public void Golden_MatchingLow()
    {
        using var ind = new Wickra.MatchingLow();
        Assert.Equal("MatchingLow", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("MatchingLow", got);
    }
    [Fact]
    public void Golden_MaxDrawdown()
    {
        using var ind = new Wickra.MaxDrawdown(14);
        Assert.Equal("MaxDrawdown", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("MaxDrawdown", got);
    }
    [Fact]
    public void Golden_McClellanOscillator()
    {
        using var ind = new Wickra.McClellanOscillator();
        Assert.Equal("McClellanOscillator", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var (ch, vo, nh, nl, am, ob) = CrossLists(r);
            got.Add(new[] { ind.Update(ch, vo, nh, nl, am, ob, i) });
        }
        Compare("McClellanOscillator", got);
    }
    [Fact]
    public void Golden_McClellanSummationIndex()
    {
        using var ind = new Wickra.McClellanSummationIndex();
        Assert.Equal("McClellanSummationIndex", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var (ch, vo, nh, nl, am, ob) = CrossLists(r);
            got.Add(new[] { ind.Update(ch, vo, nh, nl, am, ob, i) });
        }
        Compare("McClellanSummationIndex", got);
    }
    [Fact]
    public void Golden_McGinleyDynamic()
    {
        using var ind = new Wickra.McGinleyDynamic(14);
        Assert.Equal("McGinleyDynamic", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("McGinleyDynamic", got);
    }
    [Fact]
    public void Golden_MedianAbsoluteDeviation()
    {
        using var ind = new Wickra.MedianAbsoluteDeviation(14);
        Assert.Equal("MedianAbsoluteDeviation", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("MedianAbsoluteDeviation", got);
    }
    [Fact]
    public void Golden_MedianChannel()
    {
        using var ind = new Wickra.MedianChannel(14, 2.0);
        Assert.Equal("MedianChannel", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[3]), 3));
        }
        Compare("MedianChannel", got);
    }
    [Fact]
    public void Golden_MedianMa()
    {
        using var ind = new Wickra.MedianMa(14);
        Assert.Equal("MedianMA", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("MedianMa", got);
    }
    [Fact]
    public void Golden_MedianPrice()
    {
        using var ind = new Wickra.MedianPrice();
        Assert.Equal("MedianPrice", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("MedianPrice", got);
    }
    [Fact]
    public void Golden_Mfi()
    {
        using var ind = new Wickra.Mfi(14);
        Assert.Equal("MFI", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Mfi", got);
    }
    [Fact]
    public void Golden_Microprice()
    {
        using var ind = new Wickra.Microprice();
        Assert.Equal("Microprice", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var (bp, bs, ap, asz) = ObLists(r);
            got.Add(new[] { ind.Update(bp, bs, ap, asz) });
        }
        Compare("Microprice", got);
    }
    [Fact]
    public void Golden_MidPoint()
    {
        using var ind = new Wickra.MidPoint(14);
        Assert.Equal("MIDPOINT", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("MidPoint", got);
    }
    [Fact]
    public void Golden_MidPrice()
    {
        using var ind = new Wickra.MidPrice(14);
        Assert.Equal("MIDPRICE", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("MidPrice", got);
    }
    [Fact]
    public void Golden_MinusDi()
    {
        using var ind = new Wickra.MinusDi(14);
        Assert.Equal("MINUS_DI", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("MinusDi", got);
    }
    [Fact]
    public void Golden_MinusDm()
    {
        using var ind = new Wickra.MinusDm(14);
        Assert.Equal("MINUS_DM", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("MinusDm", got);
    }
    [Fact]
    public void Golden_ModifiedMaStop()
    {
        using var ind = new Wickra.ModifiedMaStop(14);
        Assert.Equal("ModifiedMaStop", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("ModifiedMaStop", got);
    }
    [Fact]
    public void Golden_Mom()
    {
        using var ind = new Wickra.Mom(14);
        Assert.Equal("MOM", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Mom", got);
    }
    [Fact]
    public void Golden_MorningDojiStar()
    {
        using var ind = new Wickra.MorningDojiStar();
        Assert.Equal("MorningDojiStar", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("MorningDojiStar", got);
    }
    [Fact]
    public void Golden_MorningEveningStar()
    {
        using var ind = new Wickra.MorningEveningStar();
        Assert.Equal("MorningEveningStar", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("MorningEveningStar", got);
    }
    [Fact]
    public void Golden_MurreyMathLines()
    {
        using var ind = new Wickra.MurreyMathLines(14);
        Assert.Equal("MurreyMathLines", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 9));
        }
        Compare("MurreyMathLines", got);
    }
    [Fact]
    public void Golden_NakedPoc()
    {
        using var ind = new Wickra.NakedPoc(3, 7);
        Assert.Equal("NakedPoc", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("NakedPoc", got);
    }
    [Fact]
    public void Golden_Natr()
    {
        using var ind = new Wickra.Natr(14);
        Assert.Equal("NATR", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Natr", got);
    }
    [Fact]
    public void Golden_NewHighsNewLows()
    {
        using var ind = new Wickra.NewHighsNewLows();
        Assert.Equal("NewHighsNewLows", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var (ch, vo, nh, nl, am, ob) = CrossLists(r);
            got.Add(new[] { ind.Update(ch, vo, nh, nl, am, ob, i) });
        }
        Compare("NewHighsNewLows", got);
    }
    [Fact]
    public void Golden_NewPriceLines()
    {
        using var ind = new Wickra.NewPriceLines(14);
        Assert.Equal("NewPriceLines", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("NewPriceLines", got);
    }
    [Fact]
    public void Golden_Nrtr()
    {
        using var ind = new Wickra.Nrtr(2.0);
        Assert.Equal("Nrtr", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("Nrtr", got);
    }
    [Fact]
    public void Golden_Nvi()
    {
        using var ind = new Wickra.Nvi();
        Assert.Equal("NVI", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Nvi", got);
    }
    [Fact]
    public void Golden_OIPriceDivergence()
    {
        using var ind = new Wickra.OIPriceDivergence(20);
        Assert.Equal("OIPriceDivergence", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var d = DerivFields(r);
            got.Add(new[] { ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], i) });
        }
        Compare("OIPriceDivergence", got);
    }
    [Fact]
    public void Golden_OIWeighted()
    {
        using var ind = new Wickra.OIWeighted();
        Assert.Equal("OIWeighted", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var d = DerivFields(r);
            got.Add(new[] { ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], i) });
        }
        Compare("OIWeighted", got);
    }
    [Fact]
    public void Golden_Obv()
    {
        using var ind = new Wickra.Obv();
        Assert.Equal("OBV", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Obv", got);
    }
    [Fact]
    public void Golden_OiToVolumeRatio()
    {
        using var ind = new Wickra.OiToVolumeRatio();
        Assert.Equal("OiToVolumeRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var d = DerivFields(r);
            got.Add(new[] { ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], i) });
        }
        Compare("OiToVolumeRatio", got);
    }
    [Fact]
    public void Golden_OmegaRatio()
    {
        using var ind = new Wickra.OmegaRatio(14, 2.0);
        Assert.Equal("OmegaRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("OmegaRatio", got);
    }
    [Fact]
    public void Golden_OnNeck()
    {
        using var ind = new Wickra.OnNeck();
        Assert.Equal("OnNeck", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("OnNeck", got);
    }
    [Fact]
    public void Golden_OpenInterestDelta()
    {
        using var ind = new Wickra.OpenInterestDelta();
        Assert.Equal("OpenInterestDelta", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var d = DerivFields(r);
            got.Add(new[] { ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], i) });
        }
        Compare("OpenInterestDelta", got);
    }
    [Fact]
    public void Golden_OpenInterestMomentum()
    {
        using var ind = new Wickra.OpenInterestMomentum(10);
        Assert.Equal("OpenInterestMomentum", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var d = DerivFields(r);
            got.Add(new[] { ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], i) });
        }
        Compare("OpenInterestMomentum", got);
    }
    [Fact]
    public void Golden_OpeningMarubozu()
    {
        using var ind = new Wickra.OpeningMarubozu();
        Assert.Equal("OpeningMarubozu", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("OpeningMarubozu", got);
    }
    [Fact]
    public void Golden_OpeningRange()
    {
        using var ind = new Wickra.OpeningRange(14);
        Assert.Equal("OpeningRange", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 3));
        }
        Compare("OpeningRange", got);
    }
    [Fact]
    public void Golden_OrderBookImbalanceFull()
    {
        using var ind = new Wickra.OrderBookImbalanceFull();
        Assert.Equal("OrderBookImbalanceFull", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var (bp, bs, ap, asz) = ObLists(r);
            got.Add(new[] { ind.Update(bp, bs, ap, asz) });
        }
        Compare("OrderBookImbalanceFull", got);
    }
    [Fact]
    public void Golden_OrderBookImbalanceTop1()
    {
        using var ind = new Wickra.OrderBookImbalanceTop1();
        Assert.Equal("OrderBookImbalanceTop1", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var (bp, bs, ap, asz) = ObLists(r);
            got.Add(new[] { ind.Update(bp, bs, ap, asz) });
        }
        Compare("OrderBookImbalanceTop1", got);
    }
    [Fact]
    public void Golden_OrderBookImbalanceTopN()
    {
        using var ind = new Wickra.OrderBookImbalanceTopN(5);
        Assert.Equal("OrderBookImbalanceTopN", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var (bp, bs, ap, asz) = ObLists(r);
            got.Add(new[] { ind.Update(bp, bs, ap, asz) });
        }
        Compare("OrderBookImbalanceTopN", got);
    }
    [Fact]
    public void Golden_OrderFlowImbalance()
    {
        using var ind = new Wickra.OrderFlowImbalance(20);
        Assert.Equal("OrderFlowImbalance", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var (bp, bs, ap, asz) = ObLists(r);
            got.Add(new[] { ind.Update(bp, bs, ap, asz) });
        }
        Compare("OrderFlowImbalance", got);
    }
    [Fact]
    public void Golden_OuHalfLife()
    {
        using var ind = new Wickra.OuHalfLife(14);
        Assert.Equal("OuHalfLife", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[0]) });
        }
        Compare("OuHalfLife", got);
    }
    [Fact]
    public void Golden_OvernightGap()
    {
        using var ind = new Wickra.OvernightGap(0);
        Assert.Equal("OvernightGap", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("OvernightGap", got);
    }
    [Fact]
    public void Golden_OvernightIntradayReturn()
    {
        using var ind = new Wickra.OvernightIntradayReturn(14);
        Assert.Equal("OvernightIntradayReturn", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("OvernightIntradayReturn", got);
    }
    [Fact]
    public void Golden_PainIndex()
    {
        using var ind = new Wickra.PainIndex(14);
        Assert.Equal("PainIndex", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("PainIndex", got);
    }
    [Fact]
    public void Golden_PairSpreadZScore()
    {
        using var ind = new Wickra.PairSpreadZScore(20, 20);
        Assert.Equal("PairSpreadZScore", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[0]) });
        }
        Compare("PairSpreadZScore", got);
    }
    [Fact]
    public void Golden_PairwiseBeta()
    {
        using var ind = new Wickra.PairwiseBeta(14);
        Assert.Equal("PairwiseBeta", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[0]) });
        }
        Compare("PairwiseBeta", got);
    }
    [Fact]
    public void Golden_ParkinsonVolatility()
    {
        using var ind = new Wickra.ParkinsonVolatility(20, 252);
        Assert.Equal("ParkinsonVolatility", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("ParkinsonVolatility", got);
    }
    [Fact]
    public void Golden_PearsonCorrelation()
    {
        using var ind = new Wickra.PearsonCorrelation(14);
        Assert.Equal("PearsonCorrelation", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[0]) });
        }
        Compare("PearsonCorrelation", got);
    }
    [Fact]
    public void Golden_PercentAboveMa()
    {
        using var ind = new Wickra.PercentAboveMa();
        Assert.Equal("PercentAboveMa", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var (ch, vo, nh, nl, am, ob) = CrossLists(r);
            got.Add(new[] { ind.Update(ch, vo, nh, nl, am, ob, i) });
        }
        Compare("PercentAboveMa", got);
    }
    [Fact]
    public void Golden_PercentB()
    {
        using var ind = new Wickra.PercentB(14, 2.0);
        Assert.Equal("PercentB", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("PercentB", got);
    }
    [Fact]
    public void Golden_PercentageTrailingStop()
    {
        using var ind = new Wickra.PercentageTrailingStop(2.0);
        Assert.Equal("PercentageTrailingStop", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("PercentageTrailingStop", got);
    }
    [Fact]
    public void Golden_PerpetualPremiumIndex()
    {
        using var ind = new Wickra.PerpetualPremiumIndex();
        Assert.Equal("PerpetualPremiumIndex", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var d = DerivFields(r);
            got.Add(new[] { ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], i) });
        }
        Compare("PerpetualPremiumIndex", got);
    }
    [Fact]
    public void Golden_Pgo()
    {
        using var ind = new Wickra.Pgo(14);
        Assert.Equal("PGO", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Pgo", got);
    }
    [Fact]
    public void Golden_PiercingDarkCloud()
    {
        using var ind = new Wickra.PiercingDarkCloud();
        Assert.Equal("PiercingDarkCloud", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("PiercingDarkCloud", got);
    }
    [Fact]
    public void Golden_Pin()
    {
        using var ind = new Wickra.Pin(20);
        Assert.Equal("PIN", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[4], r[3] >= r[0], i) });
        }
        Compare("Pin", got);
    }
    [Fact]
    public void Golden_PivotReversal()
    {
        using var ind = new Wickra.PivotReversal(3, 7);
        Assert.Equal("PivotReversal", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("PivotReversal", got);
    }
    [Fact]
    public void Golden_PlusDi()
    {
        using var ind = new Wickra.PlusDi(14);
        Assert.Equal("PLUS_DI", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("PlusDi", got);
    }
    [Fact]
    public void Golden_PlusDm()
    {
        using var ind = new Wickra.PlusDm(14);
        Assert.Equal("PLUS_DM", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("PlusDm", got);
    }
    [Fact]
    public void Golden_Pmo()
    {
        using var ind = new Wickra.Pmo(3, 7);
        Assert.Equal("PMO", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Pmo", got);
    }
    [Fact]
    public void Golden_PointAndFigureBars()
    {
        using var ind = new Wickra.PointAndFigureBars(2.0, 3);
        Assert.Equal("PointAndFigureBars", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenBars(ind.Update(r[3], r[3], r[3], r[3], 1.0, 0)));
        }
        Compare("PointAndFigureBars", got);
    }
    [Fact]
    public void Golden_PolarizedFractalEfficiency()
    {
        using var ind = new Wickra.PolarizedFractalEfficiency(10, 5);
        Assert.Equal("PolarizedFractalEfficiency", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("PolarizedFractalEfficiency", got);
    }
    [Fact]
    public void Golden_Ppo()
    {
        using var ind = new Wickra.Ppo(3, 7);
        Assert.Equal("PPO", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Ppo", got);
    }
    [Fact]
    public void Golden_PpoHistogram()
    {
        using var ind = new Wickra.PpoHistogram(3, 7, 14);
        Assert.Equal("PpoHistogram", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("PpoHistogram", got);
    }
    [Fact]
    public void Golden_ProfileShape()
    {
        using var ind = new Wickra.ProfileShape(3, 7);
        Assert.Equal("ProfileShape", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("ProfileShape", got);
    }
    [Fact]
    public void Golden_ProfitFactor()
    {
        using var ind = new Wickra.ProfitFactor(14);
        Assert.Equal("ProfitFactor", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("ProfitFactor", got);
    }
    [Fact]
    public void Golden_ProjectionBands()
    {
        using var ind = new Wickra.ProjectionBands(14);
        Assert.Equal("ProjectionBands", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 3));
        }
        Compare("ProjectionBands", got);
    }
    [Fact]
    public void Golden_ProjectionOscillator()
    {
        using var ind = new Wickra.ProjectionOscillator(14);
        Assert.Equal("ProjectionOscillator", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("ProjectionOscillator", got);
    }
    [Fact]
    public void Golden_Psar()
    {
        using var ind = new Wickra.Psar(0.02, 0.02, 0.2);
        Assert.Equal("PSAR", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Psar", got);
    }
    [Fact]
    public void Golden_Pvi()
    {
        using var ind = new Wickra.Pvi();
        Assert.Equal("PVI", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Pvi", got);
    }
    [Fact]
    public void Golden_Qqe()
    {
        using var ind = new Wickra.Qqe(3, 7, 2.0);
        Assert.Equal("QQE", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[3]), 2));
        }
        Compare("Qqe", got);
    }
    [Fact]
    public void Golden_Qstick()
    {
        using var ind = new Wickra.Qstick(14);
        Assert.Equal("Qstick", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Qstick", got);
    }
    [Fact]
    public void Golden_QuartileBands()
    {
        using var ind = new Wickra.QuartileBands(14);
        Assert.Equal("QuartileBands", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[3]), 3));
        }
        Compare("QuartileBands", got);
    }
    [Fact]
    public void Golden_QuotedSpread()
    {
        using var ind = new Wickra.QuotedSpread();
        Assert.Equal("QuotedSpread", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var (bp, bs, ap, asz) = ObLists(r);
            got.Add(new[] { ind.Update(bp, bs, ap, asz) });
        }
        Compare("QuotedSpread", got);
    }
    [Fact]
    public void Golden_RSquared()
    {
        using var ind = new Wickra.RSquared(14);
        Assert.Equal("RSquared", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("RSquared", got);
    }
    [Fact]
    public void Golden_RangeBars()
    {
        using var ind = new Wickra.RangeBars(2.0);
        Assert.Equal("RangeBars", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenBars(ind.Update(r[3], r[3], r[3], r[3], 1.0, 0)));
        }
        Compare("RangeBars", got);
    }
    [Fact]
    public void Golden_RealizedSpread()
    {
        using var ind = new Wickra.RealizedSpread(20);
        Assert.Equal("RealizedSpread", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[4], r[3] >= r[0], i, (r[1] + r[2]) / 2) });
        }
        Compare("RealizedSpread", got);
    }
    [Fact]
    public void Golden_RealizedVolatility()
    {
        using var ind = new Wickra.RealizedVolatility(14);
        Assert.Equal("RealizedVolatility", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("RealizedVolatility", got);
    }
    [Fact]
    public void Golden_RecoveryFactor()
    {
        using var ind = new Wickra.RecoveryFactor();
        Assert.Equal("RecoveryFactor", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("RecoveryFactor", got);
    }
    [Fact]
    public void Golden_RectangleRange()
    {
        using var ind = new Wickra.RectangleRange();
        Assert.Equal("RectangleRange", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("RectangleRange", got);
    }
    [Fact]
    public void Golden_Reflex()
    {
        using var ind = new Wickra.Reflex(14);
        Assert.Equal("Reflex", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Reflex", got);
    }
    [Fact]
    public void Golden_RegimeLabel()
    {
        using var ind = new Wickra.RegimeLabel(3, 7);
        Assert.Equal("RegimeLabel", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("RegimeLabel", got);
    }
    [Fact]
    public void Golden_RelativeStrengthAB()
    {
        using var ind = new Wickra.RelativeStrengthAB(14, 14);
        Assert.Equal("RelativeStrengthAB", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[3], r[0]), 3));
        }
        Compare("RelativeStrengthAB", got);
    }
    [Fact]
    public void Golden_RenkoBars()
    {
        using var ind = new Wickra.RenkoBars(2.0);
        Assert.Equal("RenkoBars", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenBars(ind.Update(r[3], r[3], r[3], r[3], 1.0, 0)));
        }
        Compare("RenkoBars", got);
    }
    [Fact]
    public void Golden_RenkoTrailingStop()
    {
        using var ind = new Wickra.RenkoTrailingStop(2.0);
        Assert.Equal("RenkoTrailingStop", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("RenkoTrailingStop", got);
    }
    [Fact]
    public void Golden_RickshawMan()
    {
        using var ind = new Wickra.RickshawMan();
        Assert.Equal("RickshawMan", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("RickshawMan", got);
    }
    [Fact]
    public void Golden_RisingThreeMethods()
    {
        using var ind = new Wickra.RisingThreeMethods();
        Assert.Equal("RisingThreeMethods", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("RisingThreeMethods", got);
    }
    [Fact]
    public void Golden_Rmi()
    {
        using var ind = new Wickra.Rmi(3, 7);
        Assert.Equal("RMI", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Rmi", got);
    }
    [Fact]
    public void Golden_Roc()
    {
        using var ind = new Wickra.Roc(14);
        Assert.Equal("ROC", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Roc", got);
    }
    [Fact]
    public void Golden_Rocp()
    {
        using var ind = new Wickra.Rocp(14);
        Assert.Equal("ROCP", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Rocp", got);
    }
    [Fact]
    public void Golden_Rocr()
    {
        using var ind = new Wickra.Rocr(14);
        Assert.Equal("ROCR", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Rocr", got);
    }
    [Fact]
    public void Golden_Rocr100()
    {
        using var ind = new Wickra.Rocr100(14);
        Assert.Equal("ROCR100", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Rocr100", got);
    }
    [Fact]
    public void Golden_RogersSatchellVolatility()
    {
        using var ind = new Wickra.RogersSatchellVolatility(20, 252);
        Assert.Equal("RogersSatchellVolatility", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("RogersSatchellVolatility", got);
    }
    [Fact]
    public void Golden_RollMeasure()
    {
        using var ind = new Wickra.RollMeasure(20);
        Assert.Equal("RollMeasure", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[4], r[3] >= r[0], i) });
        }
        Compare("RollMeasure", got);
    }
    [Fact]
    public void Golden_RollingCorrelation()
    {
        using var ind = new Wickra.RollingCorrelation(14);
        Assert.Equal("RollingCorrelation", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[0]) });
        }
        Compare("RollingCorrelation", got);
    }
    [Fact]
    public void Golden_RollingCovariance()
    {
        using var ind = new Wickra.RollingCovariance(14);
        Assert.Equal("RollingCovariance", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[0]) });
        }
        Compare("RollingCovariance", got);
    }
    [Fact]
    public void Golden_RollingIqr()
    {
        using var ind = new Wickra.RollingIqr(14);
        Assert.Equal("RollingIqr", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("RollingIqr", got);
    }
    [Fact]
    public void Golden_RollingMinMaxScaler()
    {
        using var ind = new Wickra.RollingMinMaxScaler(14);
        Assert.Equal("RollingMinMaxScaler", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("RollingMinMaxScaler", got);
    }
    [Fact]
    public void Golden_RollingPercentileRank()
    {
        using var ind = new Wickra.RollingPercentileRank(14);
        Assert.Equal("RollingPercentileRank", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("RollingPercentileRank", got);
    }
    [Fact]
    public void Golden_RollingQuantile()
    {
        using var ind = new Wickra.RollingQuantile(20, 0.5);
        Assert.Equal("RollingQuantile", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("RollingQuantile", got);
    }
    [Fact]
    public void Golden_RollingVwap()
    {
        using var ind = new Wickra.RollingVwap(14);
        Assert.Equal("RollingVWAP", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("RollingVwap", got);
    }
    [Fact]
    public void Golden_RoofingFilter()
    {
        using var ind = new Wickra.RoofingFilter(3, 7);
        Assert.Equal("RoofingFilter", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("RoofingFilter", got);
    }
    [Fact]
    public void Golden_Rsi()
    {
        using var ind = new Wickra.Rsi(14);
        Assert.Equal("RSI", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Rsi", got);
    }
    [Fact]
    public void Golden_Rsx()
    {
        using var ind = new Wickra.Rsx(14);
        Assert.Equal("RSX", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Rsx", got);
    }
    [Fact]
    public void Golden_RunBars()
    {
        using var ind = new Wickra.RunBars(3);
        Assert.Equal("RunBars", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenBars(ind.Update(r[0], r[1], r[2], r[3], 1.0, 0)));
        }
        Compare("RunBars", got);
    }
    [Fact]
    public void Golden_Rvi()
    {
        using var ind = new Wickra.Rvi(14);
        Assert.Equal("RVI", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Rvi", got);
    }
    [Fact]
    public void Golden_RviVolatility()
    {
        using var ind = new Wickra.RviVolatility(14);
        Assert.Equal("RVIVolatility", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("RviVolatility", got);
    }
    [Fact]
    public void Golden_Rwi()
    {
        using var ind = new Wickra.Rwi(14);
        Assert.Equal("RWI", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("Rwi", got);
    }
    [Fact]
    public void Golden_SampleEntropy()
    {
        using var ind = new Wickra.SampleEntropy(20, 2, 0.2);
        Assert.Equal("SampleEntropy", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("SampleEntropy", got);
    }
    [Fact]
    public void Golden_SarExt()
    {
        using var ind = new Wickra.SarExt(2.0, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5);
        Assert.Equal("SAREXT", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("SarExt", got);
    }
    [Fact]
    public void Golden_SeasonalZScore()
    {
        using var ind = new Wickra.SeasonalZScore(14);
        Assert.Equal("SeasonalZScore", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("SeasonalZScore", got);
    }
    [Fact]
    public void Golden_SeparatingLines()
    {
        using var ind = new Wickra.SeparatingLines();
        Assert.Equal("SeparatingLines", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("SeparatingLines", got);
    }
    [Fact]
    public void Golden_SessionHighLow()
    {
        using var ind = new Wickra.SessionHighLow(14);
        Assert.Equal("SessionHighLow", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("SessionHighLow", got);
    }
    [Fact]
    public void Golden_SessionRange()
    {
        using var ind = new Wickra.SessionRange(14);
        Assert.Equal("SessionRange", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 3));
        }
        Compare("SessionRange", got);
    }
    [Fact]
    public void Golden_SessionVwap()
    {
        using var ind = new Wickra.SessionVwap(14);
        Assert.Equal("SessionVwap", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("SessionVwap", got);
    }
    [Fact]
    public void Golden_ShannonEntropy()
    {
        using var ind = new Wickra.ShannonEntropy(3, 7);
        Assert.Equal("ShannonEntropy", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("ShannonEntropy", got);
    }
    [Fact]
    public void Golden_Shark()
    {
        using var ind = new Wickra.Shark();
        Assert.Equal("Shark", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Shark", got);
    }
    [Fact]
    public void Golden_SharpeRatio()
    {
        using var ind = new Wickra.SharpeRatio(14, 2.0);
        Assert.Equal("SharpeRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("SharpeRatio", got);
    }
    [Fact]
    public void Golden_ShootingStar()
    {
        using var ind = new Wickra.ShootingStar();
        Assert.Equal("ShootingStar", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("ShootingStar", got);
    }
    [Fact]
    public void Golden_ShortLine()
    {
        using var ind = new Wickra.ShortLine();
        Assert.Equal("ShortLine", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("ShortLine", got);
    }
    [Fact]
    public void Golden_SignedVolume()
    {
        using var ind = new Wickra.SignedVolume();
        Assert.Equal("SignedVolume", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[4], r[3] >= r[0], i) });
        }
        Compare("SignedVolume", got);
    }
    [Fact]
    public void Golden_SineWave()
    {
        using var ind = new Wickra.SineWave();
        Assert.Equal("SineWave", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("SineWave", got);
    }
    [Fact]
    public void Golden_SineWeightedMa()
    {
        using var ind = new Wickra.SineWeightedMa(14);
        Assert.Equal("SWMA", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("SineWeightedMa", got);
    }
    [Fact]
    public void Golden_SinglePrints()
    {
        using var ind = new Wickra.SinglePrints(3, 7);
        Assert.Equal("SinglePrints", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("SinglePrints", got);
    }
    [Fact]
    public void Golden_Skewness()
    {
        using var ind = new Wickra.Skewness(14);
        Assert.Equal("Skewness", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Skewness", got);
    }
    [Fact]
    public void Golden_Sma()
    {
        using var ind = new Wickra.Sma(14);
        Assert.Equal("SMA", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Sma", got);
    }
    [Fact]
    public void Golden_Smi()
    {
        using var ind = new Wickra.Smi(3, 7, 14);
        Assert.Equal("SMI", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Smi", got);
    }
    [Fact]
    public void Golden_Smma()
    {
        using var ind = new Wickra.Smma(14);
        Assert.Equal("SMMA", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Smma", got);
    }
    [Fact]
    public void Golden_SmoothedHeikinAshi()
    {
        using var ind = new Wickra.SmoothedHeikinAshi(14);
        Assert.Equal("SmoothedHeikinAshi", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 4));
        }
        Compare("SmoothedHeikinAshi", got);
    }
    [Fact]
    public void Golden_SortinoRatio()
    {
        using var ind = new Wickra.SortinoRatio(14, 2.0);
        Assert.Equal("SortinoRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("SortinoRatio", got);
    }
    [Fact]
    public void Golden_SpearmanCorrelation()
    {
        using var ind = new Wickra.SpearmanCorrelation(14);
        Assert.Equal("SpearmanCorrelation", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[0]) });
        }
        Compare("SpearmanCorrelation", got);
    }
    [Fact]
    public void Golden_SpinningTop()
    {
        using var ind = new Wickra.SpinningTop();
        Assert.Equal("SpinningTop", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("SpinningTop", got);
    }
    [Fact]
    public void Golden_SpreadAr1Coefficient()
    {
        using var ind = new Wickra.SpreadAr1Coefficient(14);
        Assert.Equal("SpreadAr1Coefficient", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[0]) });
        }
        Compare("SpreadAr1Coefficient", got);
    }
    [Fact]
    public void Golden_SpreadBollingerBands()
    {
        using var ind = new Wickra.SpreadBollingerBands(14, 2.0);
        Assert.Equal("SpreadBollingerBands", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[3], r[0]), 4));
        }
        Compare("SpreadBollingerBands", got);
    }
    [Fact]
    public void Golden_SpreadHurst()
    {
        using var ind = new Wickra.SpreadHurst(14);
        Assert.Equal("SpreadHurst", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[0]) });
        }
        Compare("SpreadHurst", got);
    }
    [Fact]
    public void Golden_StalledPattern()
    {
        using var ind = new Wickra.StalledPattern();
        Assert.Equal("StalledPattern", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("StalledPattern", got);
    }
    [Fact]
    public void Golden_StandardError()
    {
        using var ind = new Wickra.StandardError(14);
        Assert.Equal("StandardError", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("StandardError", got);
    }
    [Fact]
    public void Golden_StandardErrorBands()
    {
        using var ind = new Wickra.StandardErrorBands(14, 2.0);
        Assert.Equal("StandardErrorBands", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[3]), 3));
        }
        Compare("StandardErrorBands", got);
    }
    [Fact]
    public void Golden_StarcBands()
    {
        using var ind = new Wickra.StarcBands(3, 7, 2.0);
        Assert.Equal("StarcBands", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 3));
        }
        Compare("StarcBands", got);
    }
    [Fact]
    public void Golden_Stc()
    {
        using var ind = new Wickra.Stc(10, 23, 10, 0.5);
        Assert.Equal("STC", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Stc", got);
    }
    [Fact]
    public void Golden_StdDev()
    {
        using var ind = new Wickra.StdDev(14);
        Assert.Equal("StdDev", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("StdDev", got);
    }
    [Fact]
    public void Golden_StepTrailingStop()
    {
        using var ind = new Wickra.StepTrailingStop(2.0);
        Assert.Equal("StepTrailingStop", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("StepTrailingStop", got);
    }
    [Fact]
    public void Golden_SterlingRatio()
    {
        using var ind = new Wickra.SterlingRatio(14);
        Assert.Equal("SterlingRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("SterlingRatio", got);
    }
    [Fact]
    public void Golden_StickSandwich()
    {
        using var ind = new Wickra.StickSandwich();
        Assert.Equal("StickSandwich", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("StickSandwich", got);
    }
    [Fact]
    public void Golden_StochRsi()
    {
        using var ind = new Wickra.StochRsi(3, 7);
        Assert.Equal("StochRSI", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("StochRsi", got);
    }
    [Fact]
    public void Golden_Stochastic()
    {
        using var ind = new Wickra.Stochastic(3, 7);
        Assert.Equal("Stochastic", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("Stochastic", got);
    }
    [Fact]
    public void Golden_StochasticCci()
    {
        using var ind = new Wickra.StochasticCci(14);
        Assert.Equal("StochasticCCI", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("StochasticCci", got);
    }
    [Fact]
    public void Golden_SuperSmoother()
    {
        using var ind = new Wickra.SuperSmoother(14);
        Assert.Equal("SuperSmoother", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("SuperSmoother", got);
    }
    [Fact]
    public void Golden_SuperTrend()
    {
        using var ind = new Wickra.SuperTrend(14, 2.0);
        Assert.Equal("SuperTrend", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("SuperTrend", got);
    }
    [Fact]
    public void Golden_T3()
    {
        using var ind = new Wickra.T3(5, 0.7);
        Assert.Equal("T3", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("T3", got);
    }
    [Fact]
    public void Golden_TailRatio()
    {
        using var ind = new Wickra.TailRatio(14);
        Assert.Equal("TailRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("TailRatio", got);
    }
    [Fact]
    public void Golden_TakerBuySellRatio()
    {
        using var ind = new Wickra.TakerBuySellRatio();
        Assert.Equal("TakerBuySellRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var d = DerivFields(r);
            got.Add(new[] { ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], i) });
        }
        Compare("TakerBuySellRatio", got);
    }
    [Fact]
    public void Golden_Takuri()
    {
        using var ind = new Wickra.Takuri();
        Assert.Equal("Takuri", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Takuri", got);
    }
    [Fact]
    public void Golden_TasukiGap()
    {
        using var ind = new Wickra.TasukiGap();
        Assert.Equal("TasukiGap", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TasukiGap", got);
    }
    [Fact]
    public void Golden_TdCamouflage()
    {
        using var ind = new Wickra.TdCamouflage();
        Assert.Equal("TDCamouflage", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TdCamouflage", got);
    }
    [Fact]
    public void Golden_TdClop()
    {
        using var ind = new Wickra.TdClop();
        Assert.Equal("TDClop", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TdClop", got);
    }
    [Fact]
    public void Golden_TdClopwin()
    {
        using var ind = new Wickra.TdClopwin();
        Assert.Equal("TDClopwin", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TdClopwin", got);
    }
    [Fact]
    public void Golden_TdCombo()
    {
        using var ind = new Wickra.TdCombo(3, 7, 14, 28);
        Assert.Equal("TDCombo", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TdCombo", got);
    }
    [Fact]
    public void Golden_TdCountdown()
    {
        using var ind = new Wickra.TdCountdown(3, 7, 14, 28);
        Assert.Equal("TDCountdown", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TdCountdown", got);
    }
    [Fact]
    public void Golden_TdDWave()
    {
        using var ind = new Wickra.TdDWave(2);
        Assert.Equal("TDDWave", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TdDWave", got);
    }
    [Fact]
    public void Golden_TdDeMarker()
    {
        using var ind = new Wickra.TdDeMarker(14);
        Assert.Equal("TDDeMarker", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TdDeMarker", got);
    }
    [Fact]
    public void Golden_TdDifferential()
    {
        using var ind = new Wickra.TdDifferential();
        Assert.Equal("TDDifferential", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TdDifferential", got);
    }
    [Fact]
    public void Golden_TdLines()
    {
        using var ind = new Wickra.TdLines(3, 7);
        Assert.Equal("TDLines", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("TdLines", got);
    }
    [Fact]
    public void Golden_TdMovingAverage()
    {
        using var ind = new Wickra.TdMovingAverage(3, 7);
        Assert.Equal("TDMovingAverage", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("TdMovingAverage", got);
    }
    [Fact]
    public void Golden_TdOpen()
    {
        using var ind = new Wickra.TdOpen();
        Assert.Equal("TDOpen", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TdOpen", got);
    }
    [Fact]
    public void Golden_TdPressure()
    {
        using var ind = new Wickra.TdPressure(14);
        Assert.Equal("TDPressure", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TdPressure", got);
    }
    [Fact]
    public void Golden_TdPropulsion()
    {
        using var ind = new Wickra.TdPropulsion();
        Assert.Equal("TDPropulsion", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TdPropulsion", got);
    }
    [Fact]
    public void Golden_TdRangeProjection()
    {
        using var ind = new Wickra.TdRangeProjection();
        Assert.Equal("TDRangeProjection", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("TdRangeProjection", got);
    }
    [Fact]
    public void Golden_TdRei()
    {
        using var ind = new Wickra.TdRei(14);
        Assert.Equal("TDREI", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TdRei", got);
    }
    [Fact]
    public void Golden_TdRiskLevel()
    {
        using var ind = new Wickra.TdRiskLevel(3, 7);
        Assert.Equal("TDRiskLevel", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("TdRiskLevel", got);
    }
    [Fact]
    public void Golden_TdSequential()
    {
        using var ind = new Wickra.TdSequential(3, 7, 14, 28);
        Assert.Equal("TDSequential", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 3));
        }
        Compare("TdSequential", got);
    }
    [Fact]
    public void Golden_TdSetup()
    {
        using var ind = new Wickra.TdSetup(3, 7);
        Assert.Equal("TDSetup", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TdSetup", got);
    }
    [Fact]
    public void Golden_TdTrap()
    {
        using var ind = new Wickra.TdTrap();
        Assert.Equal("TDTrap", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TdTrap", got);
    }
    [Fact]
    public void Golden_Tema()
    {
        using var ind = new Wickra.Tema(14);
        Assert.Equal("TEMA", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Tema", got);
    }
    [Fact]
    public void Golden_TermStructureBasis()
    {
        using var ind = new Wickra.TermStructureBasis();
        Assert.Equal("TermStructureBasis", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var d = DerivFields(r);
            got.Add(new[] { ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], i) });
        }
        Compare("TermStructureBasis", got);
    }
    [Fact]
    public void Golden_ThreeDrives()
    {
        using var ind = new Wickra.ThreeDrives();
        Assert.Equal("ThreeDrives", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("ThreeDrives", got);
    }
    [Fact]
    public void Golden_ThreeInside()
    {
        using var ind = new Wickra.ThreeInside();
        Assert.Equal("ThreeInside", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("ThreeInside", got);
    }
    [Fact]
    public void Golden_ThreeLineBreak()
    {
        using var ind = new Wickra.ThreeLineBreak(14);
        Assert.Equal("ThreeLineBreak", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("ThreeLineBreak", got);
    }
    [Fact]
    public void Golden_ThreeLineBreakBars()
    {
        using var ind = new Wickra.ThreeLineBreakBars(3);
        Assert.Equal("ThreeLineBreakBars", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenBars(ind.Update(r[3], r[3], r[3], r[3], 1.0, 0)));
        }
        Compare("ThreeLineBreakBars", got);
    }
    [Fact]
    public void Golden_ThreeLineStrike()
    {
        using var ind = new Wickra.ThreeLineStrike();
        Assert.Equal("ThreeLineStrike", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("ThreeLineStrike", got);
    }
    [Fact]
    public void Golden_ThreeOutside()
    {
        using var ind = new Wickra.ThreeOutside();
        Assert.Equal("ThreeOutside", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("ThreeOutside", got);
    }
    [Fact]
    public void Golden_ThreeSoldiersOrCrows()
    {
        using var ind = new Wickra.ThreeSoldiersOrCrows();
        Assert.Equal("ThreeSoldiersOrCrows", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("ThreeSoldiersOrCrows", got);
    }
    [Fact]
    public void Golden_ThreeStarsInSouth()
    {
        using var ind = new Wickra.ThreeStarsInSouth();
        Assert.Equal("ThreeStarsInSouth", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("ThreeStarsInSouth", got);
    }
    [Fact]
    public void Golden_Thrusting()
    {
        using var ind = new Wickra.Thrusting();
        Assert.Equal("Thrusting", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Thrusting", got);
    }
    [Fact]
    public void Golden_TickBars()
    {
        using var ind = new Wickra.TickBars(2);
        Assert.Equal("TickBars", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenBars(ind.Update(r[0], r[1], r[2], r[3], r[4], 0)));
        }
        Compare("TickBars", got);
    }
    [Fact]
    public void Golden_TickIndex()
    {
        using var ind = new Wickra.TickIndex();
        Assert.Equal("TickIndex", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var (ch, vo, nh, nl, am, ob) = CrossLists(r);
            got.Add(new[] { ind.Update(ch, vo, nh, nl, am, ob, i) });
        }
        Compare("TickIndex", got);
    }
    [Fact]
    public void Golden_Tii()
    {
        using var ind = new Wickra.Tii(3, 7);
        Assert.Equal("TII", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Tii", got);
    }
    [Fact]
    public void Golden_TimeBasedStop()
    {
        using var ind = new Wickra.TimeBasedStop(14);
        Assert.Equal("TimeBasedStop", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TimeBasedStop", got);
    }
    [Fact]
    public void Golden_TimeOfDayReturnProfile()
    {
        using var ind = new Wickra.TimeOfDayReturnProfile(24, 0);
        Assert.Equal("TimeOfDayReturnProfile", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var bins = ind.Update(r[0], r[1], r[2], r[3], r[4], i);
            got.Add(bins ?? NanRow(24));
        }
        Compare("TimeOfDayReturnProfile", got);
    }
    [Fact]
    public void Golden_TowerTopBottom()
    {
        using var ind = new Wickra.TowerTopBottom();
        Assert.Equal("TowerTopBottom", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TowerTopBottom", got);
    }
    [Fact]
    public void Golden_TpoProfile()
    {
        using var ind = new Wickra.TpoProfile(30, 50);
        Assert.Equal("TpoProfile", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 52));
        }
        Compare("TpoProfile", got);
    }
    [Fact]
    public void Golden_TradeImbalance()
    {
        using var ind = new Wickra.TradeImbalance(20);
        Assert.Equal("TradeImbalance", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[4], r[3] >= r[0], i) });
        }
        Compare("TradeImbalance", got);
    }
    [Fact]
    public void Golden_TradeSignAutocorrelation()
    {
        using var ind = new Wickra.TradeSignAutocorrelation(20);
        Assert.Equal("TradeSignAutocorrelation", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[4], r[3] >= r[0], i) });
        }
        Compare("TradeSignAutocorrelation", got);
    }
    [Fact]
    public void Golden_TradeVolumeIndex()
    {
        using var ind = new Wickra.TradeVolumeIndex(2.0);
        Assert.Equal("TradeVolumeIndex", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TradeVolumeIndex", got);
    }
    [Fact]
    public void Golden_TrendLabel()
    {
        using var ind = new Wickra.TrendLabel(14);
        Assert.Equal("TrendLabel", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("TrendLabel", got);
    }
    [Fact]
    public void Golden_TrendStrengthIndex()
    {
        using var ind = new Wickra.TrendStrengthIndex(14);
        Assert.Equal("TrendStrengthIndex", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("TrendStrengthIndex", got);
    }
    [Fact]
    public void Golden_Trendflex()
    {
        using var ind = new Wickra.Trendflex(14);
        Assert.Equal("Trendflex", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Trendflex", got);
    }
    [Fact]
    public void Golden_TreynorRatio()
    {
        using var ind = new Wickra.TreynorRatio(14, 2.0);
        Assert.Equal("TreynorRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[0]) });
        }
        Compare("TreynorRatio", got);
    }
    [Fact]
    public void Golden_Triangle()
    {
        using var ind = new Wickra.Triangle();
        Assert.Equal("Triangle", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Triangle", got);
    }
    [Fact]
    public void Golden_Trima()
    {
        using var ind = new Wickra.Trima(14);
        Assert.Equal("TRIMA", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Trima", got);
    }
    [Fact]
    public void Golden_Trin()
    {
        using var ind = new Wickra.Trin();
        Assert.Equal("Trin", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var (ch, vo, nh, nl, am, ob) = CrossLists(r);
            got.Add(new[] { ind.Update(ch, vo, nh, nl, am, ob, i) });
        }
        Compare("Trin", got);
    }
    [Fact]
    public void Golden_TripleTopBottom()
    {
        using var ind = new Wickra.TripleTopBottom();
        Assert.Equal("TripleTopBottom", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TripleTopBottom", got);
    }
    [Fact]
    public void Golden_Tristar()
    {
        using var ind = new Wickra.Tristar();
        Assert.Equal("Tristar", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Tristar", got);
    }
    [Fact]
    public void Golden_Trix()
    {
        using var ind = new Wickra.Trix(14);
        Assert.Equal("TRIX", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Trix", got);
    }
    [Fact]
    public void Golden_TrueRange()
    {
        using var ind = new Wickra.TrueRange();
        Assert.Equal("TrueRange", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TrueRange", got);
    }
    [Fact]
    public void Golden_Tsf()
    {
        using var ind = new Wickra.Tsf(14);
        Assert.Equal("TSF", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Tsf", got);
    }
    [Fact]
    public void Golden_TsfOscillator()
    {
        using var ind = new Wickra.TsfOscillator(14);
        Assert.Equal("TsfOscillator", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("TsfOscillator", got);
    }
    [Fact]
    public void Golden_Tsi()
    {
        using var ind = new Wickra.Tsi(3, 7);
        Assert.Equal("TSI", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Tsi", got);
    }
    [Fact]
    public void Golden_Tsv()
    {
        using var ind = new Wickra.Tsv(14);
        Assert.Equal("TSV", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Tsv", got);
    }
    [Fact]
    public void Golden_TtmSqueeze()
    {
        using var ind = new Wickra.TtmSqueeze(14, 2.0, 0.5);
        Assert.Equal("TtmSqueeze", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("TtmSqueeze", got);
    }
    [Fact]
    public void Golden_TtmTrend()
    {
        using var ind = new Wickra.TtmTrend(14);
        Assert.Equal("TtmTrend", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TtmTrend", got);
    }
    [Fact]
    public void Golden_TurnOfMonth()
    {
        using var ind = new Wickra.TurnOfMonth(3u, 3u, 0);
        Assert.Equal("TurnOfMonth", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TurnOfMonth", got);
    }
    [Fact]
    public void Golden_Tweezer()
    {
        using var ind = new Wickra.Tweezer();
        Assert.Equal("Tweezer", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Tweezer", got);
    }
    [Fact]
    public void Golden_TwiggsMoneyFlow()
    {
        using var ind = new Wickra.TwiggsMoneyFlow(14);
        Assert.Equal("TwiggsMoneyFlow", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TwiggsMoneyFlow", got);
    }
    [Fact]
    public void Golden_TwoCrows()
    {
        using var ind = new Wickra.TwoCrows();
        Assert.Equal("TwoCrows", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TwoCrows", got);
    }
    [Fact]
    public void Golden_TypicalPrice()
    {
        using var ind = new Wickra.TypicalPrice();
        Assert.Equal("TypicalPrice", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("TypicalPrice", got);
    }
    [Fact]
    public void Golden_UlcerIndex()
    {
        using var ind = new Wickra.UlcerIndex(14);
        Assert.Equal("UlcerIndex", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("UlcerIndex", got);
    }
    [Fact]
    public void Golden_UltimateOscillator()
    {
        using var ind = new Wickra.UltimateOscillator(3, 7, 14);
        Assert.Equal("UltimateOscillator", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("UltimateOscillator", got);
    }
    [Fact]
    public void Golden_UniqueThreeRiver()
    {
        using var ind = new Wickra.UniqueThreeRiver();
        Assert.Equal("UniqueThreeRiver", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("UniqueThreeRiver", got);
    }
    [Fact]
    public void Golden_UniversalOscillator()
    {
        using var ind = new Wickra.UniversalOscillator(14);
        Assert.Equal("UniversalOscillator", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("UniversalOscillator", got);
    }
    [Fact]
    public void Golden_UpDownVolumeRatio()
    {
        using var ind = new Wickra.UpDownVolumeRatio();
        Assert.Equal("UpDownVolumeRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var (ch, vo, nh, nl, am, ob) = CrossLists(r);
            got.Add(new[] { ind.Update(ch, vo, nh, nl, am, ob, i) });
        }
        Compare("UpDownVolumeRatio", got);
    }
    [Fact]
    public void Golden_UpsideGapThreeMethods()
    {
        using var ind = new Wickra.UpsideGapThreeMethods();
        Assert.Equal("UpsideGapThreeMethods", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("UpsideGapThreeMethods", got);
    }
    [Fact]
    public void Golden_UpsideGapTwoCrows()
    {
        using var ind = new Wickra.UpsideGapTwoCrows();
        Assert.Equal("UpsideGapTwoCrows", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("UpsideGapTwoCrows", got);
    }
    [Fact]
    public void Golden_UpsidePotentialRatio()
    {
        using var ind = new Wickra.UpsidePotentialRatio(14, 2.0);
        Assert.Equal("UpsidePotentialRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("UpsidePotentialRatio", got);
    }
    [Fact]
    public void Golden_ValueArea()
    {
        using var ind = new Wickra.ValueArea(20, 50, 0.7);
        Assert.Equal("ValueArea", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 3));
        }
        Compare("ValueArea", got);
    }
    [Fact]
    public void Golden_ValueAtRisk()
    {
        using var ind = new Wickra.ValueAtRisk(20, 0.95);
        Assert.Equal("ValueAtRisk", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("ValueAtRisk", got);
    }
    [Fact]
    public void Golden_Variance()
    {
        using var ind = new Wickra.Variance(14);
        Assert.Equal("Variance", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Variance", got);
    }
    [Fact]
    public void Golden_VarianceRatio()
    {
        using var ind = new Wickra.VarianceRatio(60, 2);
        Assert.Equal("VarianceRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[0]) });
        }
        Compare("VarianceRatio", got);
    }
    [Fact]
    public void Golden_VerticalHorizontalFilter()
    {
        using var ind = new Wickra.VerticalHorizontalFilter(14);
        Assert.Equal("VerticalHorizontalFilter", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("VerticalHorizontalFilter", got);
    }
    [Fact]
    public void Golden_Vidya()
    {
        using var ind = new Wickra.Vidya(3, 7);
        Assert.Equal("VIDYA", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Vidya", got);
    }
    [Fact]
    public void Golden_VolatilityCone()
    {
        using var ind = new Wickra.VolatilityCone(3, 7);
        Assert.Equal("VolatilityCone", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 5));
        }
        Compare("VolatilityCone", got);
    }
    [Fact]
    public void Golden_VolatilityOfVolatility()
    {
        using var ind = new Wickra.VolatilityOfVolatility(3, 7);
        Assert.Equal("VolatilityOfVolatility", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("VolatilityOfVolatility", got);
    }
    [Fact]
    public void Golden_VolatilityRatio()
    {
        using var ind = new Wickra.VolatilityRatio(14);
        Assert.Equal("VolatilityRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("VolatilityRatio", got);
    }
    [Fact]
    public void Golden_VoltyStop()
    {
        using var ind = new Wickra.VoltyStop(14, 2.0);
        Assert.Equal("VoltyStop", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("VoltyStop", got);
    }
    [Fact]
    public void Golden_VolumeBars()
    {
        using var ind = new Wickra.VolumeBars(500.0);
        Assert.Equal("VolumeBars", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenBars(ind.Update(r[0], r[1], r[2], r[3], r[4], 0)));
        }
        Compare("VolumeBars", got);
    }
    [Fact]
    public void Golden_VolumeByTimeProfile()
    {
        using var ind = new Wickra.VolumeByTimeProfile(24, 0);
        Assert.Equal("VolumeByTimeProfile", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            var bins = ind.Update(r[0], r[1], r[2], r[3], r[4], i);
            got.Add(bins ?? NanRow(24));
        }
        Compare("VolumeByTimeProfile", got);
    }
    [Fact]
    public void Golden_VolumeOscillator()
    {
        using var ind = new Wickra.VolumeOscillator(3, 7);
        Assert.Equal("VolumeOscillator", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("VolumeOscillator", got);
    }
    [Fact]
    public void Golden_VolumePriceTrend()
    {
        using var ind = new Wickra.VolumePriceTrend();
        Assert.Equal("VPT", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("VolumePriceTrend", got);
    }
    [Fact]
    public void Golden_VolumeProfile()
    {
        using var ind = new Wickra.VolumeProfile(20, 50);
        Assert.Equal("VolumeProfile", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 52));
        }
        Compare("VolumeProfile", got);
    }
    [Fact]
    public void Golden_VolumeRsi()
    {
        using var ind = new Wickra.VolumeRsi(14);
        Assert.Equal("VolumeRsi", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("VolumeRsi", got);
    }
    [Fact]
    public void Golden_VolumeWeightedMacd()
    {
        using var ind = new Wickra.VolumeWeightedMacd(3, 7, 14);
        Assert.Equal("VolumeWeightedMacd", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 3));
        }
        Compare("VolumeWeightedMacd", got);
    }
    [Fact]
    public void Golden_VolumeWeightedSr()
    {
        using var ind = new Wickra.VolumeWeightedSr(14);
        Assert.Equal("VolumeWeightedSr", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("VolumeWeightedSr", got);
    }
    [Fact]
    public void Golden_Vortex()
    {
        using var ind = new Wickra.Vortex(14);
        Assert.Equal("Vortex", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("Vortex", got);
    }
    [Fact]
    public void Golden_Vpin()
    {
        using var ind = new Wickra.Vpin(5000.0, 10);
        Assert.Equal("Vpin", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3], r[4], r[3] >= r[0], i) });
        }
        Compare("Vpin", got);
    }
    [Fact]
    public void Golden_Vwap()
    {
        using var ind = new Wickra.Vwap();
        Assert.Equal("VWAP", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Vwap", got);
    }
    [Fact]
    public void Golden_VwapStdDevBands()
    {
        using var ind = new Wickra.VwapStdDevBands(2.0);
        Assert.Equal("VwapStdDevBands", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 4));
        }
        Compare("VwapStdDevBands", got);
    }
    [Fact]
    public void Golden_Vwma()
    {
        using var ind = new Wickra.Vwma(14);
        Assert.Equal("VWMA", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Vwma", got);
    }
    [Fact]
    public void Golden_Vzo()
    {
        using var ind = new Wickra.Vzo(14);
        Assert.Equal("VZO", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Vzo", got);
    }
    [Fact]
    public void Golden_Wad()
    {
        using var ind = new Wickra.Wad();
        Assert.Equal("Wad", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Wad", got);
    }
    [Fact]
    public void Golden_WavePm()
    {
        using var ind = new Wickra.WavePm(3, 7);
        Assert.Equal("WavePm", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("WavePm", got);
    }
    [Fact]
    public void Golden_WaveTrend()
    {
        using var ind = new Wickra.WaveTrend(3, 7, 14);
        Assert.Equal("WaveTrend", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("WaveTrend", got);
    }
    [Fact]
    public void Golden_Wedge()
    {
        using var ind = new Wickra.Wedge();
        Assert.Equal("Wedge", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("Wedge", got);
    }
    [Fact]
    public void Golden_WeightedClose()
    {
        using var ind = new Wickra.WeightedClose();
        Assert.Equal("WeightedClose", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("WeightedClose", got);
    }
    [Fact]
    public void Golden_WickRatio()
    {
        using var ind = new Wickra.WickRatio();
        Assert.Equal("WickRatio", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("WickRatio", got);
    }
    [Fact]
    public void Golden_WilliamsFractals()
    {
        using var ind = new Wickra.WilliamsFractals();
        Assert.Equal("WilliamsFractals", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("WilliamsFractals", got);
    }
    [Fact]
    public void Golden_WilliamsR()
    {
        using var ind = new Wickra.WilliamsR(14);
        Assert.Equal("WilliamsR", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("WilliamsR", got);
    }
    [Fact]
    public void Golden_WinRate()
    {
        using var ind = new Wickra.WinRate(14);
        Assert.Equal("WinRate", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("WinRate", got);
    }
    [Fact]
    public void Golden_Wma()
    {
        using var ind = new Wickra.Wma(14);
        Assert.Equal("WMA", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Wma", got);
    }
    [Fact]
    public void Golden_WoodiePivots()
    {
        using var ind = new Wickra.WoodiePivots();
        Assert.Equal("WoodiePivots", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 5));
        }
        Compare("WoodiePivots", got);
    }
    [Fact]
    public void Golden_YangZhangVolatility()
    {
        using var ind = new Wickra.YangZhangVolatility(20, 252);
        Assert.Equal("YangZhangVolatility", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("YangZhangVolatility", got);
    }
    [Fact]
    public void Golden_YoyoExit()
    {
        using var ind = new Wickra.YoyoExit(14, 2.0);
        Assert.Equal("YoyoExit", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });
        }
        Compare("YoyoExit", got);
    }
    [Fact]
    public void Golden_ZScore()
    {
        using var ind = new Wickra.ZScore(14);
        Assert.Equal("ZScore", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("ZScore", got);
    }
    [Fact]
    public void Golden_ZeroLagMacd()
    {
        using var ind = new Wickra.ZeroLagMacd(3, 7, 14);
        Assert.Equal("ZeroLagMACD", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[3]), 3));
        }
        Compare("ZeroLagMacd", got);
    }
    [Fact]
    public void Golden_ZigZag()
    {
        using var ind = new Wickra.ZigZag(0.02);
        Assert.Equal("ZigZag", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), 2));
        }
        Compare("ZigZag", got);
    }
    [Fact]
    public void Golden_Zlema()
    {
        using var ind = new Wickra.Zlema(14);
        Assert.Equal("ZLEMA", ind.Name());
        var got = new List<double[]>();
        for (var i = 0; i < Rows.Length; i++)
        {
            var r = Rows[i];
            got.Add(new[] { ind.Update(r[3]) });
        }
        Compare("Zlema", got);
    }
}
