mirror of
https://github.com/mihakralj/QuanTAlib.git
synced 2026-08-04 04:07:42 +00:00
Miha Kralj
060649192f
- Remove 'C# Implementation Considerations' sections from 34 indicator .md files - Delete 29 temp PowerShell scripts (_fix_mojibake.ps1, _hex_scan.ps1, etc.) - Move test files into tests/ subdirectories for consistent project structure - Add trader-focused bullet points to indicator documentation
680 lines
21 KiB
C#
680 lines
21 KiB
C#
using Xunit;
|
|
|
|
namespace QuanTAlib.Tests;
|
|
|
|
public sealed class KdjTests
|
|
{
|
|
// ── A) Constructor validation ──────────────────────────────────────
|
|
|
|
[Fact]
|
|
public void Constructor_ValidParameters()
|
|
{
|
|
var kdj = new Kdj(length: 9, signal: 3);
|
|
|
|
Assert.NotNull(kdj);
|
|
Assert.Equal("Kdj(9,3)", kdj.Name);
|
|
Assert.Equal(11, kdj.WarmupPeriod);
|
|
Assert.False(kdj.IsHot);
|
|
}
|
|
|
|
[Fact]
|
|
public void Constructor_InvalidLength_Throws()
|
|
{
|
|
var ex = Assert.Throws<ArgumentException>(() => new Kdj(length: 0, signal: 3));
|
|
Assert.Equal("length", ex.ParamName);
|
|
}
|
|
|
|
[Fact]
|
|
public void Constructor_NegativeLength_Throws()
|
|
{
|
|
var ex = Assert.Throws<ArgumentException>(() => new Kdj(length: -5, signal: 3));
|
|
Assert.Equal("length", ex.ParamName);
|
|
}
|
|
|
|
[Fact]
|
|
public void Constructor_InvalidSignal_Throws()
|
|
{
|
|
var ex = Assert.Throws<ArgumentException>(() => new Kdj(length: 9, signal: 0));
|
|
Assert.Equal("signal", ex.ParamName);
|
|
}
|
|
|
|
[Fact]
|
|
public void Constructor_NegativeSignal_Throws()
|
|
{
|
|
var ex = Assert.Throws<ArgumentException>(() => new Kdj(length: 9, signal: -1));
|
|
Assert.Equal("signal", ex.ParamName);
|
|
}
|
|
|
|
// ── B) Basic calculation ───────────────────────────────────────────
|
|
|
|
[Fact]
|
|
public void Update_ReturnsTValue()
|
|
{
|
|
var kdj = new Kdj(length: 3, signal: 2);
|
|
DateTime time = DateTime.UtcNow;
|
|
|
|
var result = kdj.Update(new TBar(time, 100, 110, 90, 105, 1000));
|
|
|
|
Assert.IsType<TValue>(result);
|
|
}
|
|
|
|
[Fact]
|
|
public void Last_K_D_Accessible()
|
|
{
|
|
var kdj = new Kdj(length: 3, signal: 2);
|
|
DateTime time = DateTime.UtcNow;
|
|
|
|
kdj.Update(new TBar(time, 100, 110, 90, 105, 1000));
|
|
|
|
Assert.True(double.IsFinite(kdj.Last.Value));
|
|
Assert.True(double.IsFinite(kdj.K.Value));
|
|
Assert.True(double.IsFinite(kdj.D.Value));
|
|
}
|
|
|
|
[Fact]
|
|
public void Name_ContainsKdj()
|
|
{
|
|
var kdj = new Kdj(length: 14, signal: 5);
|
|
Assert.Contains("Kdj", kdj.Name, StringComparison.Ordinal);
|
|
Assert.Contains("14", kdj.Name, StringComparison.Ordinal);
|
|
Assert.Contains("5", kdj.Name, StringComparison.Ordinal);
|
|
}
|
|
|
|
[Fact]
|
|
public void ConstantPrice_KDConvergeToFifty()
|
|
{
|
|
var kdj = new Kdj(length: 3, signal: 2);
|
|
DateTime time = DateTime.UtcNow;
|
|
|
|
// With constant OHLC, range = 0, RSV = 50
|
|
// Need enough iterations for exponential warmup compensator to converge
|
|
for (int i = 0; i < 100; i++)
|
|
{
|
|
kdj.Update(new TBar(time.AddSeconds(i), 100, 100, 100, 100, 1000));
|
|
}
|
|
|
|
Assert.Equal(50.0, kdj.K.Value, 1e-3);
|
|
Assert.Equal(50.0, kdj.D.Value, 1e-3);
|
|
// J = 3*50 - 2*50 = 50
|
|
Assert.Equal(50.0, kdj.Last.Value, 1e-3);
|
|
}
|
|
|
|
[Fact]
|
|
public void CloseAtHigh_KConvergesToHundred()
|
|
{
|
|
var kdj = new Kdj(length: 3, signal: 2);
|
|
DateTime time = DateTime.UtcNow;
|
|
|
|
// Close always at the high of the range => RSV = 100
|
|
for (int i = 0; i < 50; i++)
|
|
{
|
|
kdj.Update(new TBar(time.AddSeconds(i), 100, 110, 90, 110, 1000));
|
|
}
|
|
|
|
Assert.True(kdj.K.Value > 99.0);
|
|
Assert.True(kdj.D.Value > 99.0);
|
|
}
|
|
|
|
[Fact]
|
|
public void CloseAtLow_KConvergesToZero()
|
|
{
|
|
var kdj = new Kdj(length: 3, signal: 2);
|
|
DateTime time = DateTime.UtcNow;
|
|
|
|
// Close always at the low of the range => RSV = 0
|
|
for (int i = 0; i < 50; i++)
|
|
{
|
|
kdj.Update(new TBar(time.AddSeconds(i), 100, 110, 90, 90, 1000));
|
|
}
|
|
|
|
Assert.True(kdj.K.Value < 1.0);
|
|
Assert.True(kdj.D.Value < 1.0);
|
|
}
|
|
|
|
// ── C) State + bar correction ──────────────────────────────────────
|
|
|
|
[Fact]
|
|
public void IsNew_True_AdvancesState()
|
|
{
|
|
var kdj = new Kdj(length: 3, signal: 2);
|
|
DateTime time = DateTime.UtcNow;
|
|
|
|
kdj.Update(new TBar(time, 100, 110, 90, 105, 1000), isNew: true);
|
|
double k1 = kdj.K.Value;
|
|
|
|
kdj.Update(new TBar(time.AddSeconds(1), 101, 115, 95, 112, 1000), isNew: true);
|
|
double k2 = kdj.K.Value;
|
|
|
|
Assert.NotEqual(k1, k2);
|
|
}
|
|
|
|
[Fact]
|
|
public void IsNew_False_RewritesCurrentBar()
|
|
{
|
|
var kdj = new Kdj(length: 3, signal: 2);
|
|
DateTime time = DateTime.UtcNow;
|
|
|
|
kdj.Update(new TBar(time, 100, 110, 90, 105, 1000), isNew: true);
|
|
kdj.Update(new TBar(time.AddSeconds(1), 101, 111, 91, 106, 1000), isNew: true);
|
|
kdj.Update(new TBar(time.AddSeconds(2), 102, 112, 92, 107, 1000), isNew: true);
|
|
|
|
double kBefore = kdj.K.Value;
|
|
double dBefore = kdj.D.Value;
|
|
|
|
// Correct current bar with different close
|
|
kdj.Update(new TBar(time.AddSeconds(2), 102, 120, 85, 115, 1000), isNew: false);
|
|
|
|
double kAfter = kdj.K.Value;
|
|
double dAfter = kdj.D.Value;
|
|
|
|
Assert.NotEqual(kBefore, kAfter);
|
|
Assert.NotEqual(dBefore, dAfter);
|
|
}
|
|
|
|
[Fact]
|
|
public void IterativeCorrections_RestoreState()
|
|
{
|
|
var kdj = new Kdj(length: 5, signal: 3);
|
|
var gbm = new GBM(startPrice: 100, mu: 0.01, sigma: 0.1, seed: 42);
|
|
|
|
TBar remembered = default;
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
remembered = gbm.Next(isNew: true);
|
|
kdj.Update(remembered, isNew: true);
|
|
}
|
|
|
|
double snapK = kdj.K.Value;
|
|
double snapD = kdj.D.Value;
|
|
double snapJ = kdj.Last.Value;
|
|
|
|
// Several corrections
|
|
for (int i = 0; i < 5; i++)
|
|
{
|
|
var corrected = gbm.Next(isNew: false);
|
|
kdj.Update(corrected, isNew: false);
|
|
}
|
|
|
|
// Restore original bar
|
|
kdj.Update(remembered, isNew: false);
|
|
|
|
Assert.Equal(snapK, kdj.K.Value, 1e-10);
|
|
Assert.Equal(snapD, kdj.D.Value, 1e-10);
|
|
Assert.Equal(snapJ, kdj.Last.Value, 1e-10);
|
|
}
|
|
|
|
[Fact]
|
|
public void Reset_ClearsState()
|
|
{
|
|
var kdj = new Kdj(length: 5, signal: 3);
|
|
var gbm = new GBM(startPrice: 100, mu: 0.01, sigma: 0.1, seed: 7);
|
|
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
kdj.Update(gbm.Next(isNew: true), isNew: true);
|
|
}
|
|
|
|
Assert.True(kdj.IsHot);
|
|
|
|
kdj.Reset();
|
|
|
|
Assert.False(kdj.IsHot);
|
|
Assert.Equal(0.0, kdj.Last.Value);
|
|
Assert.Equal(0.0, kdj.K.Value);
|
|
Assert.Equal(0.0, kdj.D.Value);
|
|
}
|
|
|
|
// ── D) Warmup / convergence ────────────────────────────────────────
|
|
|
|
[Fact]
|
|
public void IsHot_FlipsAfterLengthBars()
|
|
{
|
|
var kdj = new Kdj(length: 5, signal: 3);
|
|
DateTime time = DateTime.UtcNow;
|
|
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
kdj.Update(new TBar(time.AddSeconds(i), 100 + i, 101 + i, 99 + i, 100 + i, 1000));
|
|
Assert.False(kdj.IsHot);
|
|
}
|
|
|
|
kdj.Update(new TBar(time.AddSeconds(4), 104, 105, 103, 104, 1000));
|
|
Assert.True(kdj.IsHot);
|
|
}
|
|
|
|
[Fact]
|
|
public void WarmupPeriod_EqualsLengthPlusSignalMinusOne()
|
|
{
|
|
var kdj = new Kdj(length: 9, signal: 3);
|
|
Assert.Equal(11, kdj.WarmupPeriod);
|
|
|
|
var kdj2 = new Kdj(length: 14, signal: 5);
|
|
Assert.Equal(18, kdj2.WarmupPeriod);
|
|
}
|
|
|
|
// ── E) Robustness (NaN / Infinity) ─────────────────────────────────
|
|
|
|
[Fact]
|
|
public void NaN_HighUsesLastValid()
|
|
{
|
|
var kdj = new Kdj(length: 3, signal: 2);
|
|
DateTime time = DateTime.UtcNow;
|
|
|
|
kdj.Update(new TBar(time, 100, 110, 90, 105, 1000));
|
|
kdj.Update(new TBar(time.AddSeconds(1), 101, 111, 91, 106, 1000));
|
|
var result = kdj.Update(new TBar(time.AddSeconds(2), 102, double.NaN, 92, 107, 1000));
|
|
|
|
Assert.True(double.IsFinite(result.Value));
|
|
Assert.True(double.IsFinite(kdj.K.Value));
|
|
Assert.True(double.IsFinite(kdj.D.Value));
|
|
}
|
|
|
|
[Fact]
|
|
public void NaN_LowUsesLastValid()
|
|
{
|
|
var kdj = new Kdj(length: 3, signal: 2);
|
|
DateTime time = DateTime.UtcNow;
|
|
|
|
kdj.Update(new TBar(time, 100, 110, 90, 105, 1000));
|
|
kdj.Update(new TBar(time.AddSeconds(1), 101, 111, 91, 106, 1000));
|
|
var result = kdj.Update(new TBar(time.AddSeconds(2), 102, 112, double.NaN, 107, 1000));
|
|
|
|
Assert.True(double.IsFinite(result.Value));
|
|
}
|
|
|
|
[Fact]
|
|
public void NaN_CloseUsesLastValid()
|
|
{
|
|
var kdj = new Kdj(length: 3, signal: 2);
|
|
DateTime time = DateTime.UtcNow;
|
|
|
|
kdj.Update(new TBar(time, 100, 110, 90, 105, 1000));
|
|
kdj.Update(new TBar(time.AddSeconds(1), 101, 111, 91, 106, 1000));
|
|
var result = kdj.Update(new TBar(time.AddSeconds(2), 102, 112, 92, double.NaN, 1000));
|
|
|
|
Assert.True(double.IsFinite(result.Value));
|
|
}
|
|
|
|
[Fact]
|
|
public void Infinity_HandledGracefully()
|
|
{
|
|
var kdj = new Kdj(length: 3, signal: 2);
|
|
DateTime time = DateTime.UtcNow;
|
|
|
|
kdj.Update(new TBar(time, 100, 110, 90, 105, 1000));
|
|
kdj.Update(new TBar(time.AddSeconds(1), 101, 111, 91, 106, 1000));
|
|
var result = kdj.Update(new TBar(time.AddSeconds(2), 102, double.PositiveInfinity, 92, 107, 1000));
|
|
|
|
Assert.True(double.IsFinite(result.Value));
|
|
}
|
|
|
|
[Fact]
|
|
public void BatchNaN_Safe()
|
|
{
|
|
var kdj = new Kdj(length: 3, signal: 2);
|
|
DateTime time = DateTime.UtcNow;
|
|
|
|
// All NaN inputs at the start
|
|
var result = kdj.Update(new TBar(time, double.NaN, double.NaN, double.NaN, double.NaN, 1000));
|
|
Assert.True(double.IsNaN(result.Value));
|
|
|
|
// Then valid data
|
|
result = kdj.Update(new TBar(time.AddSeconds(1), 100, 110, 90, 105, 1000));
|
|
Assert.True(double.IsFinite(result.Value));
|
|
}
|
|
|
|
// ── F) Consistency (4 API modes) ───────────────────────────────────
|
|
|
|
[Fact]
|
|
public void AllFourModes_ProduceConsistentResults()
|
|
{
|
|
const int length = 9;
|
|
const int signal = 3;
|
|
int barCount = 50;
|
|
|
|
var gbm = new GBM(startPrice: 100, mu: 0.01, sigma: 0.1, seed: 123);
|
|
var bars = new TBarSeries();
|
|
for (int i = 0; i < barCount; i++)
|
|
{
|
|
bars.Add(gbm.Next(isNew: true));
|
|
}
|
|
|
|
// Mode 1: Streaming
|
|
var streamKdj = new Kdj(length, signal);
|
|
for (int i = 0; i < barCount; i++)
|
|
{
|
|
streamKdj.Update(bars[i], isNew: true);
|
|
}
|
|
double streamK = streamKdj.K.Value;
|
|
double streamD = streamKdj.D.Value;
|
|
double streamJ = streamKdj.Last.Value;
|
|
|
|
// Mode 2: Batch via instance Update(TBarSeries)
|
|
var batchKdj = new Kdj(length, signal);
|
|
var (bK, bD, bJ) = batchKdj.Update(bars);
|
|
double batchK = bK.Values[^1];
|
|
double batchD = bD.Values[^1];
|
|
double batchJ = bJ.Values[^1];
|
|
|
|
// Mode 3: Static Batch
|
|
var (sK, sD, sJ) = Kdj.Batch(bars, length, signal);
|
|
double staticK = sK.Values[^1];
|
|
double staticD = sD.Values[^1];
|
|
double staticJ = sJ.Values[^1];
|
|
|
|
// Mode 4: Static Calculate
|
|
var ((cK, cD, cJ), _) = Kdj.Calculate(bars, length, signal);
|
|
double calcK = cK.Values[^1];
|
|
double calcD = cD.Values[^1];
|
|
double calcJ = cJ.Values[^1];
|
|
|
|
// All modes must produce same results
|
|
Assert.Equal(streamK, batchK, 1e-10);
|
|
Assert.Equal(streamD, batchD, 1e-10);
|
|
Assert.Equal(streamJ, batchJ, 1e-10);
|
|
|
|
Assert.Equal(streamK, staticK, 1e-10);
|
|
Assert.Equal(streamD, staticD, 1e-10);
|
|
Assert.Equal(streamJ, staticJ, 1e-10);
|
|
|
|
Assert.Equal(streamK, calcK, 1e-10);
|
|
Assert.Equal(streamD, calcD, 1e-10);
|
|
Assert.Equal(streamJ, calcJ, 1e-10);
|
|
}
|
|
|
|
// ── G) Span API tests ──────────────────────────────────────────────
|
|
|
|
[Fact]
|
|
public void Batch_Span_InvalidLength_Throws()
|
|
{
|
|
double[] high = [1, 2, 3];
|
|
double[] low = [0.5, 1.5, 2.5];
|
|
double[] close = [0.8, 1.8, 2.8];
|
|
double[] kOut = new double[3];
|
|
double[] dOut = new double[3];
|
|
double[] jOut = new double[3];
|
|
|
|
var ex = Assert.Throws<ArgumentException>(() =>
|
|
Kdj.Batch(high, low, close, kOut, dOut, jOut, 0, 3));
|
|
Assert.Equal("length", ex.ParamName);
|
|
}
|
|
|
|
[Fact]
|
|
public void Batch_Span_InvalidSignal_Throws()
|
|
{
|
|
double[] high = [1, 2, 3];
|
|
double[] low = [0.5, 1.5, 2.5];
|
|
double[] close = [0.8, 1.8, 2.8];
|
|
double[] kOut = new double[3];
|
|
double[] dOut = new double[3];
|
|
double[] jOut = new double[3];
|
|
|
|
var ex = Assert.Throws<ArgumentException>(() =>
|
|
Kdj.Batch(high, low, close, kOut, dOut, jOut, 3, 0));
|
|
Assert.Equal("signal", ex.ParamName);
|
|
}
|
|
|
|
[Fact]
|
|
public void Batch_Span_MismatchedInputs_Throws()
|
|
{
|
|
double[] high = [1, 2, 3];
|
|
double[] low = [0.5, 1.5];
|
|
double[] close = [0.8, 1.8, 2.8];
|
|
double[] kOut = new double[3];
|
|
double[] dOut = new double[3];
|
|
double[] jOut = new double[3];
|
|
|
|
var ex = Assert.Throws<ArgumentException>(() =>
|
|
Kdj.Batch(high, low, close, kOut, dOut, jOut, 3, 3));
|
|
Assert.Equal("high", ex.ParamName);
|
|
}
|
|
|
|
[Fact]
|
|
public void Batch_Span_ShortKOutput_Throws()
|
|
{
|
|
double[] high = [1, 2, 3];
|
|
double[] low = [0.5, 1.5, 2.5];
|
|
double[] close = [0.8, 1.8, 2.8];
|
|
double[] kOut = new double[2]; // too short
|
|
double[] dOut = new double[3];
|
|
double[] jOut = new double[3];
|
|
|
|
var ex = Assert.Throws<ArgumentException>(() =>
|
|
Kdj.Batch(high, low, close, kOut, dOut, jOut, 3, 3));
|
|
Assert.Equal("kOut", ex.ParamName);
|
|
}
|
|
|
|
[Fact]
|
|
public void Batch_Span_ShortDOutput_Throws()
|
|
{
|
|
double[] high = [1, 2, 3];
|
|
double[] low = [0.5, 1.5, 2.5];
|
|
double[] close = [0.8, 1.8, 2.8];
|
|
double[] kOut = new double[3];
|
|
double[] dOut = new double[2]; // too short
|
|
double[] jOut = new double[3];
|
|
|
|
var ex = Assert.Throws<ArgumentException>(() =>
|
|
Kdj.Batch(high, low, close, kOut, dOut, jOut, 3, 3));
|
|
Assert.Equal("dOut", ex.ParamName);
|
|
}
|
|
|
|
[Fact]
|
|
public void Batch_Span_ShortJOutput_Throws()
|
|
{
|
|
double[] high = [1, 2, 3];
|
|
double[] low = [0.5, 1.5, 2.5];
|
|
double[] close = [0.8, 1.8, 2.8];
|
|
double[] kOut = new double[3];
|
|
double[] dOut = new double[3];
|
|
double[] jOut = new double[2]; // too short
|
|
|
|
var ex = Assert.Throws<ArgumentException>(() =>
|
|
Kdj.Batch(high, low, close, kOut, dOut, jOut, 3, 3));
|
|
Assert.Equal("jOut", ex.ParamName);
|
|
}
|
|
|
|
[Fact]
|
|
public void Batch_Span_MatchesStreaming()
|
|
{
|
|
int barCount = 30;
|
|
var gbm = new GBM(startPrice: 100, mu: 0.01, sigma: 0.1, seed: 77);
|
|
var bars = new TBarSeries();
|
|
for (int i = 0; i < barCount; i++)
|
|
{
|
|
bars.Add(gbm.Next(isNew: true));
|
|
}
|
|
|
|
// Streaming
|
|
var kdj = new Kdj(length: 5, signal: 3);
|
|
for (int i = 0; i < barCount; i++)
|
|
{
|
|
kdj.Update(bars[i], isNew: true);
|
|
}
|
|
|
|
// Span
|
|
double[] kOut = new double[barCount];
|
|
double[] dOut = new double[barCount];
|
|
double[] jOut = new double[barCount];
|
|
Kdj.Batch(bars.HighValues, bars.LowValues, bars.CloseValues,
|
|
kOut, dOut, jOut, 5, 3);
|
|
|
|
Assert.Equal(kdj.K.Value, kOut[^1], 1e-10);
|
|
Assert.Equal(kdj.D.Value, dOut[^1], 1e-10);
|
|
Assert.Equal(kdj.Last.Value, jOut[^1], 1e-10);
|
|
}
|
|
|
|
[Fact]
|
|
public void Batch_Span_LargeData_NoStackOverflow()
|
|
{
|
|
int barCount = 1000;
|
|
double[] high = new double[barCount];
|
|
double[] low = new double[barCount];
|
|
double[] close = new double[barCount];
|
|
double[] kOut = new double[barCount];
|
|
double[] dOut = new double[barCount];
|
|
double[] jOut = new double[barCount];
|
|
|
|
for (int i = 0; i < barCount; i++)
|
|
{
|
|
high[i] = 100.0 + i * 0.1;
|
|
low[i] = 99.0 + i * 0.1;
|
|
close[i] = 99.5 + i * 0.1;
|
|
}
|
|
|
|
// Should not throw StackOverflowException (uses ArrayPool for > 256)
|
|
Kdj.Batch(high, low, close, kOut, dOut, jOut, 14, 3);
|
|
|
|
Assert.True(double.IsFinite(kOut[^1]));
|
|
Assert.True(double.IsFinite(dOut[^1]));
|
|
Assert.True(double.IsFinite(jOut[^1]));
|
|
}
|
|
|
|
// ── H) Chainability ────────────────────────────────────────────────
|
|
|
|
[Fact]
|
|
public void Pub_EventFires()
|
|
{
|
|
var kdj = new Kdj(length: 3, signal: 2);
|
|
int fired = 0;
|
|
kdj.Pub += (object? _, in TValueEventArgs _) => fired++;
|
|
|
|
DateTime time = DateTime.UtcNow;
|
|
kdj.Update(new TBar(time, 100, 110, 90, 105, 1000));
|
|
kdj.Update(new TBar(time.AddSeconds(1), 101, 111, 91, 106, 1000));
|
|
|
|
Assert.Equal(2, fired);
|
|
}
|
|
|
|
[Fact]
|
|
public void EventBasedChaining_Works()
|
|
{
|
|
var bars = new TBarSeries();
|
|
var kdj = new Kdj(bars, length: 5, signal: 3);
|
|
|
|
int fired = 0;
|
|
kdj.Pub += (object? _, in TValueEventArgs _) => fired++;
|
|
|
|
DateTime time = DateTime.UtcNow;
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
bars.Add(new TBar(time.AddSeconds(i), 100 + i, 110 + i, 90 + i, 105 + i, 1000));
|
|
}
|
|
|
|
Assert.Equal(10, fired);
|
|
Assert.True(kdj.IsHot);
|
|
}
|
|
|
|
// ── Additional: J line properties ──────────────────────────────────
|
|
|
|
[Fact]
|
|
public void J_CanExceedHundred()
|
|
{
|
|
// J = 3K - 2D. When K > D significantly, J > 100
|
|
var kdj = new Kdj(length: 3, signal: 3);
|
|
DateTime time = DateTime.UtcNow;
|
|
|
|
// Sharp upward move should make K > D, and J can exceed 100
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
kdj.Update(new TBar(time.AddSeconds(i), 100, 105, 95, 100, 1000));
|
|
}
|
|
// Now sharp move up
|
|
for (int i = 3; i < 8; i++)
|
|
{
|
|
kdj.Update(new TBar(time.AddSeconds(i), 100 + (i - 2) * 5, 110 + (i - 2) * 5, 95 + (i - 2) * 5, 110 + (i - 2) * 5, 1000));
|
|
}
|
|
|
|
// J should be able to exceed 100 (it's unbounded)
|
|
// This is a property test - we just verify J is computed as 3K-2D
|
|
double expectedJ = 3.0 * kdj.K.Value - 2.0 * kdj.D.Value;
|
|
Assert.Equal(expectedJ, kdj.Last.Value, 1e-10);
|
|
}
|
|
|
|
[Fact]
|
|
public void J_CanGoNegative()
|
|
{
|
|
// J = 3K - 2D. When D > K significantly, J < 0
|
|
var kdj = new Kdj(length: 3, signal: 3);
|
|
DateTime time = DateTime.UtcNow;
|
|
|
|
// Start high
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
kdj.Update(new TBar(time.AddSeconds(i), 200, 210, 190, 210, 1000));
|
|
}
|
|
// Sharp move down
|
|
for (int i = 3; i < 8; i++)
|
|
{
|
|
kdj.Update(new TBar(time.AddSeconds(i), 200 - (i - 2) * 5, 210 - (i - 2) * 5, 190 - (i - 2) * 5, 190 - (i - 2) * 5, 1000));
|
|
}
|
|
|
|
double expectedJ = 3.0 * kdj.K.Value - 2.0 * kdj.D.Value;
|
|
Assert.Equal(expectedJ, kdj.Last.Value, 1e-10);
|
|
}
|
|
|
|
[Fact]
|
|
public void K_D_ClampedBetween0And100()
|
|
{
|
|
var kdj = new Kdj(length: 5, signal: 3);
|
|
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.3, seed: 99);
|
|
|
|
for (int i = 0; i < 100; i++)
|
|
{
|
|
kdj.Update(gbm.Next(isNew: true), isNew: true);
|
|
|
|
Assert.True(kdj.K.Value >= 0.0 && kdj.K.Value <= 100.0,
|
|
$"K={kdj.K.Value} out of [0,100] at bar {i}");
|
|
Assert.True(kdj.D.Value >= 0.0 && kdj.D.Value <= 100.0,
|
|
$"D={kdj.D.Value} out of [0,100] at bar {i}");
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void Prime_SetsCorrectState()
|
|
{
|
|
var gbm = new GBM(startPrice: 100, mu: 0.01, sigma: 0.1, seed: 55);
|
|
var bars = new TBarSeries();
|
|
for (int i = 0; i < 20; i++)
|
|
{
|
|
bars.Add(gbm.Next(isNew: true));
|
|
}
|
|
|
|
// Prime from TBarSeries
|
|
var kdj1 = new Kdj(length: 5, signal: 3);
|
|
kdj1.Prime(bars);
|
|
|
|
// Manual streaming
|
|
var kdj2 = new Kdj(length: 5, signal: 3);
|
|
for (int i = 0; i < 20; i++)
|
|
{
|
|
kdj2.Update(bars[i], isNew: true);
|
|
}
|
|
|
|
Assert.Equal(kdj2.K.Value, kdj1.K.Value, 1e-10);
|
|
Assert.Equal(kdj2.D.Value, kdj1.D.Value, 1e-10);
|
|
Assert.Equal(kdj2.Last.Value, kdj1.Last.Value, 1e-10);
|
|
}
|
|
|
|
[Fact]
|
|
public void Batch_EmptySource_ReturnsEmpty()
|
|
{
|
|
var bars = new TBarSeries();
|
|
var (k, d, j) = Kdj.Batch(bars, 9, 3);
|
|
|
|
Assert.Empty(k);
|
|
Assert.Empty(d);
|
|
Assert.Empty(j);
|
|
}
|
|
|
|
[Fact]
|
|
public void Batch_NullSource_ReturnsEmpty()
|
|
{
|
|
var (k, d, j) = Kdj.Batch(null!, 9, 3);
|
|
|
|
Assert.Empty(k);
|
|
Assert.Empty(d);
|
|
Assert.Empty(j);
|
|
}
|
|
}
|