kingchenc
fd9f4c8bc6
* feat(bindings): expose name() on every indicator in Node, WASM, and Python Surface the core Indicator::name() / BarBuilder::name() accessor through the three native bindings so every indicator reports its canonical name at runtime, matching the existing reset/isReady/warmupPeriod surface. - Node (napi): name(): string on all 514 classes (regenerated index.d.ts) - WASM (wasm-bindgen): name(): string on all 514 classes - Python (pyo3): name() -> str on all classes * feat(bindings): expose name() across the C ABI and C/C++/Go/C#/Java/R Regenerate the C ABI and the four generated language bindings from the updated ScriptHelpers generators so every indicator and bar builder reports its canonical name at runtime, completing name() coverage across all 10 languages. - C ABI (bindings/c): wickra_<ind>_name() -> *const c_char for all 514, cached in a per-function OnceLock<CString> with ind.name() as the source of truth; cbindgen header regenerated and vendored into bindings/go/include. - Go: Name() string; C#: string Name(); Java: String name(); R: name() S3 generic over the wk_<ind>_name C glue (methods.R + NAMESPACE). The Java regeneration also restores two fixes that had drifted out of the generator (bool* arrays via boolSegment; uint8_t ctor args cast to byte) and C# re-emits '#nullable enable'; these are no-op vs the previous committed output apart from the new name() accessors. * test(golden): pin canonical name() across all 10 language bindings Add a cross-language name() consistency check: every indicator must report the exact core Indicator::name() (which can differ from the registered class name, e.g. ChaikinMoneyFlow -> "CMF", Donchian -> "DonchianChannels"). The 514 core names are committed as testdata/golden/names.json (keyed by Rust canonical) and asserted by each binding's golden replay, which already reconstructs the whole catalogue: - node / wasm: assert against names.json in the existing golden test - python: new test_golden_names.py over the shared node manifest - go / csharp / java / c+c++ / r: the golden-test generators load names.json and emit a name assertion per indicator (regenerated test artifacts committed) All 10 bindings return identical names by construction (each delegates to core), so this pins that contract and guards against a future binding breaking the passthrough. * docs(changelog): record name() across all 10 bindings under Unreleased * fix(r): restore bool* flag marshalling in the regenerated C glue The name() regeneration had reverted the cross-section bool fix: the R glue emitted (bool *)REAL(x) for const bool* inputs, reinterpreting 8-byte doubles as 1-byte bools so every flag read as false (PercentAboveMa, NewHighsNewLows, HighLowIndex, BullishPercentIndex returned 0 instead of the breadth value). The wk_bool_vec() helper is restored in the generator and the glue routes bool arrays through it again.
6884 lines
211 KiB
C#
6884 lines
211 KiB
C#
// <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);
|
|
}
|
|
}
|