mirror of
https://github.com/mihakralj/QuanTAlib.git
synced 2026-08-24 13:38:05 +00:00
docs: remove C# Implementation Considerations sections, clean up temp scripts, reorganize test files
- 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
This commit is contained in:
Miha Kralj
@@ -0,0 +1,346 @@
|
||||
using Xunit;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public class JerkTests
|
||||
{
|
||||
[Fact]
|
||||
public void Properties_Accessible()
|
||||
{
|
||||
var jerk = new Jerk();
|
||||
Assert.Equal(0, jerk.Last.Value);
|
||||
Assert.False(jerk.IsHot);
|
||||
Assert.Contains("Jerk", jerk.Name, StringComparison.Ordinal);
|
||||
Assert.Equal(4, jerk.WarmupPeriod);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calc_IsNew_False_UpdatesValue()
|
||||
{
|
||||
var jerk = new Jerk();
|
||||
jerk.Update(new TValue(DateTime.UtcNow, 10));
|
||||
jerk.Update(new TValue(DateTime.UtcNow, 20));
|
||||
jerk.Update(new TValue(DateTime.UtcNow, 30));
|
||||
jerk.Update(new TValue(DateTime.UtcNow, 40));
|
||||
|
||||
double valueBefore = jerk.Last.Value;
|
||||
|
||||
// Update with isNew=false should change the result
|
||||
jerk.Update(new TValue(DateTime.UtcNow, 100), isNew: false);
|
||||
double valueAfter = jerk.Last.Value;
|
||||
|
||||
Assert.NotEqual(valueBefore, valueAfter);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void NaN_Input_UsesLastValidValue()
|
||||
{
|
||||
var jerk = new Jerk();
|
||||
jerk.Update(new TValue(DateTime.UtcNow, 10));
|
||||
jerk.Update(new TValue(DateTime.UtcNow, 20));
|
||||
jerk.Update(new TValue(DateTime.UtcNow, 30));
|
||||
jerk.Update(new TValue(DateTime.UtcNow, 40));
|
||||
|
||||
var result = jerk.Update(new TValue(DateTime.UtcNow, double.NaN));
|
||||
|
||||
Assert.True(double.IsFinite(result.Value));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Infinity_Input_UsesLastValidValue()
|
||||
{
|
||||
var jerk = new Jerk();
|
||||
jerk.Update(new TValue(DateTime.UtcNow, 10));
|
||||
jerk.Update(new TValue(DateTime.UtcNow, 20));
|
||||
jerk.Update(new TValue(DateTime.UtcNow, 30));
|
||||
jerk.Update(new TValue(DateTime.UtcNow, 40));
|
||||
|
||||
var resultPosInf = jerk.Update(new TValue(DateTime.UtcNow, double.PositiveInfinity));
|
||||
Assert.True(double.IsFinite(resultPosInf.Value));
|
||||
|
||||
var resultNegInf = jerk.Update(new TValue(DateTime.UtcNow, double.NegativeInfinity));
|
||||
Assert.True(double.IsFinite(resultNegInf.Value));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IterativeCorrections_RestoreToOriginalState()
|
||||
{
|
||||
var jerk = new Jerk();
|
||||
var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.1, seed: 42);
|
||||
|
||||
// Feed 10 new values
|
||||
TValue tenthInput = default;
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
var bar = gbm.Next(isNew: true);
|
||||
tenthInput = new TValue(bar.Time, bar.Close);
|
||||
jerk.Update(tenthInput, isNew: true);
|
||||
}
|
||||
|
||||
// Remember state after 10 values
|
||||
double stateAfterTen = jerk.Last.Value;
|
||||
|
||||
// Generate 9 corrections with isNew=false (different values)
|
||||
for (int i = 0; i < 9; i++)
|
||||
{
|
||||
var bar = gbm.Next(isNew: false);
|
||||
jerk.Update(new TValue(bar.Time, bar.Close), isNew: false);
|
||||
}
|
||||
|
||||
// Feed the remembered 10th input again with isNew=false
|
||||
TValue finalResult = jerk.Update(tenthInput, isNew: false);
|
||||
|
||||
// State should match the original state after 10 values
|
||||
Assert.Equal(stateAfterTen, finalResult.Value, 1e-9);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SpanBatch_ValidatesInput()
|
||||
{
|
||||
double[] source = [1, 2, 3, 4, 5];
|
||||
double[] wrongSizeOutput = new double[3];
|
||||
|
||||
// Output must be same length as source
|
||||
Assert.Throws<ArgumentException>(() =>
|
||||
Jerk.Batch(source.AsSpan(), wrongSizeOutput.AsSpan()));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AllModes_ProduceSameResult()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 123);
|
||||
var bars = gbm.Fetch(1000, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
var series = bars.Close;
|
||||
|
||||
// 1. Batch Mode (static span)
|
||||
var tValues = series.Values.ToArray();
|
||||
var batchOutput = new double[tValues.Length];
|
||||
Jerk.Batch(tValues, batchOutput);
|
||||
double expected = batchOutput[^1];
|
||||
|
||||
// 2. Streaming Mode
|
||||
var streamingInd = new Jerk();
|
||||
for (int i = 0; i < series.Count; i++)
|
||||
{
|
||||
streamingInd.Update(series[i]);
|
||||
}
|
||||
double streamingResult = streamingInd.Last.Value;
|
||||
|
||||
// 3. TSeries Batch Mode
|
||||
var batchSeriesResult = Jerk.Batch(series);
|
||||
double tseriesResult = batchSeriesResult.Last.Value;
|
||||
|
||||
Assert.Equal(expected, streamingResult, precision: 9);
|
||||
Assert.Equal(expected, tseriesResult, precision: 9);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calculation_KnownValues()
|
||||
{
|
||||
// jerk[i] = source[i] - 3*source[i-1] + 3*source[i-2] - source[i-3]
|
||||
// Data: 10, 20, 35, 40, 42, 50
|
||||
// jerk[0] = 0 (insufficient history)
|
||||
// jerk[1] = 0 (insufficient history)
|
||||
// jerk[2] = 0 (insufficient history)
|
||||
// jerk[3] = 40 - 3*35 + 3*20 - 10 = 40 - 105 + 60 - 10 = -15
|
||||
// jerk[4] = 42 - 3*40 + 3*35 - 20 = 42 - 120 + 105 - 20 = 7
|
||||
// jerk[5] = 50 - 3*42 + 3*40 - 35 = 50 - 126 + 120 - 35 = 9
|
||||
|
||||
double[] data = [10, 20, 35, 40, 42, 50];
|
||||
double[] expected = [0, 0, 0, -15, 7, 9];
|
||||
|
||||
var jerk = new Jerk();
|
||||
for (int i = 0; i < data.Length; i++)
|
||||
{
|
||||
var result = jerk.Update(new TValue(DateTime.UtcNow, data[i]));
|
||||
Assert.Equal(expected[i], result.Value, precision: 9);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IsHot_BecomesTrueAfterWarmup()
|
||||
{
|
||||
var jerk = new Jerk();
|
||||
|
||||
Assert.False(jerk.IsHot);
|
||||
jerk.Update(new TValue(DateTime.UtcNow, 10));
|
||||
Assert.False(jerk.IsHot);
|
||||
jerk.Update(new TValue(DateTime.UtcNow, 20));
|
||||
Assert.False(jerk.IsHot);
|
||||
jerk.Update(new TValue(DateTime.UtcNow, 30));
|
||||
Assert.False(jerk.IsHot);
|
||||
jerk.Update(new TValue(DateTime.UtcNow, 40));
|
||||
Assert.True(jerk.IsHot);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Reset_ClearsState()
|
||||
{
|
||||
var jerk = new Jerk();
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
jerk.Update(new TValue(DateTime.UtcNow, i));
|
||||
}
|
||||
Assert.True(jerk.IsHot);
|
||||
|
||||
jerk.Reset();
|
||||
Assert.False(jerk.IsHot);
|
||||
Assert.Equal(0, jerk.Last.Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_Matches_Iterative()
|
||||
{
|
||||
int count = 1000;
|
||||
var data = new double[count];
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 123);
|
||||
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
data[i] = gbm.Next().Close;
|
||||
}
|
||||
|
||||
// Iterative
|
||||
var jerk = new Jerk();
|
||||
var iterativeResults = new double[count];
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
jerk.Update(new TValue(DateTime.UtcNow, data[i]));
|
||||
iterativeResults[i] = jerk.Last.Value;
|
||||
}
|
||||
|
||||
// Batch
|
||||
var batchResults = new double[count];
|
||||
Jerk.Batch(data, batchResults);
|
||||
|
||||
// Compare
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
Assert.Equal(iterativeResults[i], batchResults[i], precision: 9);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_TSeries_Matches_Iterative()
|
||||
{
|
||||
int count = 1000;
|
||||
var data = new TSeries();
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 123);
|
||||
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
var bar = gbm.Next();
|
||||
data.Add(new TValue(bar.Time, bar.Close));
|
||||
}
|
||||
|
||||
// Iterative
|
||||
var jerk = new Jerk();
|
||||
var iterativeResults = new double[count];
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
jerk.Update(data[i]);
|
||||
iterativeResults[i] = jerk.Last.Value;
|
||||
}
|
||||
|
||||
// TSeries Batch
|
||||
var jerkBatch = new Jerk();
|
||||
var batchSeries = jerkBatch.Update(data);
|
||||
|
||||
// Compare
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
Assert.Equal(iterativeResults[i], batchSeries[i].Value, precision: 9);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EventSubscription_Works()
|
||||
{
|
||||
var source = new TSeries();
|
||||
var jerk = new Jerk(source);
|
||||
|
||||
source.Add(new TValue(DateTime.UtcNow, 10));
|
||||
source.Add(new TValue(DateTime.UtcNow, 20));
|
||||
source.Add(new TValue(DateTime.UtcNow, 35));
|
||||
source.Add(new TValue(DateTime.UtcNow, 40));
|
||||
|
||||
Assert.True(jerk.IsHot);
|
||||
// jerk = 40 - 3*35 + 3*20 - 10 = 40 - 105 + 60 - 10 = -15
|
||||
Assert.Equal(-15, jerk.Last.Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void DerivativeChain_MatchesDirectCalculation()
|
||||
{
|
||||
// Jerk should equal Accel of Slope
|
||||
// Also: Jerk[i] = Accel[i] - Accel[i-1]
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 456);
|
||||
var bars = gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
var series = bars.Close;
|
||||
|
||||
// Direct Jerk calculation
|
||||
var jerk = new Jerk();
|
||||
var jerkResults = new double[series.Count];
|
||||
for (int i = 0; i < series.Count; i++)
|
||||
{
|
||||
jerk.Update(series[i]);
|
||||
jerkResults[i] = jerk.Last.Value;
|
||||
}
|
||||
|
||||
// Chain: Slope -> Accel (should match Jerk after accounting for warmup)
|
||||
var slope = new Slope();
|
||||
var accel = new Accel();
|
||||
var chainResults = new double[series.Count];
|
||||
for (int i = 0; i < series.Count; i++)
|
||||
{
|
||||
var slopeVal = slope.Update(series[i]);
|
||||
var accelOfSlope = accel.Update(slopeVal);
|
||||
chainResults[i] = accelOfSlope.Value;
|
||||
}
|
||||
|
||||
// Compare from index 3 onwards (when both have sufficient warmup)
|
||||
for (int i = 3; i < series.Count; i++)
|
||||
{
|
||||
Assert.Equal(jerkResults[i], chainResults[i], precision: 9);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_AllNonFinite_FallsBackToZero()
|
||||
{
|
||||
double[] source = [double.NaN, double.PositiveInfinity, double.NegativeInfinity, double.NaN, double.NaN];
|
||||
double[] output = new double[source.Length];
|
||||
|
||||
Jerk.Batch(source.AsSpan(), output.AsSpan());
|
||||
|
||||
Assert.Equal(0.0, output[0], 12);
|
||||
Assert.Equal(0.0, output[1], 12);
|
||||
Assert.Equal(0.0, output[2], 12);
|
||||
Assert.Equal(0.0, output[3], 12);
|
||||
Assert.Equal(0.0, output[4], 12);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calculate_ReturnsConfiguredIndicatorAndMatchingResults()
|
||||
{
|
||||
var source = new TSeries();
|
||||
var now = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 30; i++)
|
||||
{
|
||||
source.Add(now.AddSeconds(i), 100 + i * 0.5);
|
||||
}
|
||||
|
||||
var (results, indicator) = Jerk.Calculate(source);
|
||||
var batch = Jerk.Batch(source);
|
||||
|
||||
Assert.NotNull(indicator);
|
||||
Assert.Equal(4, indicator.WarmupPeriod);
|
||||
Assert.Equal(results.Count, batch.Count);
|
||||
|
||||
for (int i = 0; i < results.Count; i++)
|
||||
{
|
||||
Assert.Equal(batch[i].Value, results[i].Value, 10);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,165 @@
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// Validation tests for Jerk using synthetic data with known mathematical results.
|
||||
/// </summary>
|
||||
public class JerkValidationTests
|
||||
{
|
||||
[Fact]
|
||||
public void CubicSequence_ProducesConstantJerk()
|
||||
{
|
||||
// Cubic sequence: 0, 1, 8, 27, 64, 125 (x^3)
|
||||
// First diff (slope): 1, 7, 19, 37, 61
|
||||
// Second diff (accel): 6, 12, 18, 24
|
||||
// Third diff (jerk): 6, 6, 6 (constant for cubic)
|
||||
double[] data = [0, 1, 8, 27, 64, 125];
|
||||
double[] expected = [0, 0, 0, 6, 6, 6]; // First three are warmup (0), rest are 6
|
||||
|
||||
var jerk = new Jerk();
|
||||
for (int i = 0; i < data.Length; i++)
|
||||
{
|
||||
var result = jerk.Update(new TValue(DateTime.UtcNow, data[i]));
|
||||
Assert.Equal(expected[i], result.Value, precision: 9);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void QuadraticSequence_ProducesZeroJerk()
|
||||
{
|
||||
// Quadratic sequence: 0, 1, 4, 9, 16, 25 (x^2)
|
||||
// Accel = 2 (constant), so Jerk = 0
|
||||
double[] data = [0, 1, 4, 9, 16, 25];
|
||||
double[] expected = [0, 0, 0, 0, 0, 0];
|
||||
|
||||
var jerk = new Jerk();
|
||||
for (int i = 0; i < data.Length; i++)
|
||||
{
|
||||
var result = jerk.Update(new TValue(DateTime.UtcNow, data[i]));
|
||||
Assert.Equal(expected[i], result.Value, precision: 9);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void LinearSequence_ProducesZeroJerk()
|
||||
{
|
||||
// Linear sequence: 0, 2, 4, 6, 8, 10 (slope = 2, accel = 0, jerk = 0)
|
||||
double[] data = [0, 2, 4, 6, 8, 10];
|
||||
double[] expected = [0, 0, 0, 0, 0, 0];
|
||||
|
||||
var jerk = new Jerk();
|
||||
for (int i = 0; i < data.Length; i++)
|
||||
{
|
||||
var result = jerk.Update(new TValue(DateTime.UtcNow, data[i]));
|
||||
Assert.Equal(expected[i], result.Value, precision: 9);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ConstantSequence_ProducesZeroJerk()
|
||||
{
|
||||
// Constant sequence: 5, 5, 5, 5, 5 (all derivatives = 0)
|
||||
double[] data = [5, 5, 5, 5, 5];
|
||||
double[] expected = [0, 0, 0, 0, 0];
|
||||
|
||||
var jerk = new Jerk();
|
||||
for (int i = 0; i < data.Length; i++)
|
||||
{
|
||||
var result = jerk.Update(new TValue(DateTime.UtcNow, data[i]));
|
||||
Assert.Equal(expected[i], result.Value, precision: 9);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void QuarticSequence_ProducesLinearJerk()
|
||||
{
|
||||
// Quartic sequence: 0, 1, 16, 81, 256, 625 (x^4)
|
||||
// First diff: 1, 15, 65, 175, 369
|
||||
// Second diff: 14, 50, 110, 194
|
||||
// Third diff (jerk): 36, 60, 84 (linear, step of 24)
|
||||
double[] data = [0, 1, 16, 81, 256, 625];
|
||||
double[] expected = [0, 0, 0, 36, 60, 84];
|
||||
|
||||
var jerk = new Jerk();
|
||||
for (int i = 0; i < data.Length; i++)
|
||||
{
|
||||
var result = jerk.Update(new TValue(DateTime.UtcNow, data[i]));
|
||||
Assert.Equal(expected[i], result.Value, precision: 9);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void NegativeCubic_ProducesNegativeJerk()
|
||||
{
|
||||
// Negative cubic: -x³ → 0, -1, -8, -27, -64
|
||||
// Jerk = -6 (constant)
|
||||
double[] data = [0, -1, -8, -27, -64];
|
||||
double[] expected = [0, 0, 0, -6, -6];
|
||||
|
||||
var jerk = new Jerk();
|
||||
for (int i = 0; i < data.Length; i++)
|
||||
{
|
||||
var result = jerk.Update(new TValue(DateTime.UtcNow, data[i]));
|
||||
Assert.Equal(expected[i], result.Value, precision: 9);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AlternatingSequence_ProducesAlternatingJerk()
|
||||
{
|
||||
// Alternating: 0, 10, 0, 10, 0, 10
|
||||
// Slope: 10, -10, 10, -10, 10
|
||||
// Accel: -20, 20, -20, 20
|
||||
// Jerk: 40, -40, 40
|
||||
double[] data = [0, 10, 0, 10, 0, 10];
|
||||
double[] expected = [0, 0, 0, 40, -40, 40];
|
||||
|
||||
var jerk = new Jerk();
|
||||
for (int i = 0; i < data.Length; i++)
|
||||
{
|
||||
var result = jerk.Update(new TValue(DateTime.UtcNow, data[i]));
|
||||
Assert.Equal(expected[i], result.Value, precision: 9);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BatchCalculation_MatchesSyntheticData()
|
||||
{
|
||||
double[] data = [0, 1, 8, 27, 64, 125];
|
||||
double[] expected = [0, 0, 0, 6, 6, 6];
|
||||
double[] output = new double[data.Length];
|
||||
|
||||
Jerk.Batch(data, output);
|
||||
|
||||
for (int i = 0; i < data.Length; i++)
|
||||
{
|
||||
Assert.Equal(expected[i], output[i], precision: 9);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void LargeCubicSequence_ProducesConstantJerk()
|
||||
{
|
||||
// Generate 1000 points: f(n) = n³ with coefficient 1/6 → jerk = 1
|
||||
// f(n) = n³/6, f'(n) = n²/2, f''(n) = n, f'''(n) = 1
|
||||
// Discrete: jerk = 1 (after warmup)
|
||||
// Note: Large cubic values accumulate floating-point error, use precision: 8
|
||||
int count = 1000;
|
||||
double[] data = new double[count];
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
data[i] = (double)(i * i * i) / 6.0;
|
||||
}
|
||||
|
||||
var jerk = new Jerk();
|
||||
// Skip warmup period (first 3 bars)
|
||||
_ = jerk.Update(new TValue(DateTime.UtcNow, data[0]));
|
||||
_ = jerk.Update(new TValue(DateTime.UtcNow, data[1]));
|
||||
_ = jerk.Update(new TValue(DateTime.UtcNow, data[2]));
|
||||
|
||||
for (int i = 3; i < count; i++)
|
||||
{
|
||||
jerk.Update(new TValue(DateTime.UtcNow, data[i]));
|
||||
Assert.Equal(1.0, jerk.Last.Value, precision: 6);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user