mirror of
https://github.com/mihakralj/QuanTAlib.git
synced 2026-08-23 13:08:04 +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,406 @@
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public class RsquaredTests
|
||||
{
|
||||
private readonly GBM _gbm;
|
||||
private const int Period = 10;
|
||||
|
||||
public RsquaredTests()
|
||||
{
|
||||
_gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 42);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_ValidatesInput()
|
||||
{
|
||||
Assert.Throws<ArgumentException>(() => new Rsquared(0));
|
||||
Assert.Throws<ArgumentException>(() => new Rsquared(-1));
|
||||
|
||||
var r2 = new Rsquared(10);
|
||||
Assert.NotNull(r2);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calc_ReturnsValue()
|
||||
{
|
||||
var r2 = new Rsquared(Period);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
var result = r2.Update(new TValue(time, 100), new TValue(time, 95));
|
||||
|
||||
Assert.True(result.Value <= 1.0);
|
||||
Assert.Equal(result.Value, r2.Last.Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Properties_Accessible()
|
||||
{
|
||||
var r2 = new Rsquared(Period);
|
||||
|
||||
Assert.Equal(0, r2.Last.Value);
|
||||
Assert.False(r2.IsHot);
|
||||
Assert.Contains("R²", r2.Name, StringComparison.Ordinal);
|
||||
|
||||
r2.Update(new TValue(DateTime.UtcNow, 100), new TValue(DateTime.UtcNow, 95));
|
||||
Assert.NotEqual(0, r2.Last.Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calc_IsNew_AcceptsParameter()
|
||||
{
|
||||
var r2 = new Rsquared(Period);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
r2.Update(new TValue(time, 100), new TValue(time, 95), isNew: true);
|
||||
double value1 = r2.Last.Value;
|
||||
|
||||
r2.Update(new TValue(time.AddSeconds(1), 102), new TValue(time.AddSeconds(1), 98), isNew: true);
|
||||
double value2 = r2.Last.Value;
|
||||
|
||||
Assert.NotEqual(value1, value2);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calc_IsNew_False_UpdatesValue()
|
||||
{
|
||||
var r2 = new Rsquared(Period);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
r2.Update(new TValue(time, 100), new TValue(time, 95));
|
||||
r2.Update(new TValue(time.AddSeconds(1), 105), new TValue(time.AddSeconds(1), 100), isNew: true);
|
||||
double beforeUpdate = r2.Last.Value;
|
||||
|
||||
r2.Update(new TValue(time.AddSeconds(1), 110), new TValue(time.AddSeconds(1), 100), isNew: false);
|
||||
double afterUpdate = r2.Last.Value;
|
||||
|
||||
Assert.NotEqual(beforeUpdate, afterUpdate);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Reset_ClearsState()
|
||||
{
|
||||
var r2 = new Rsquared(Period);
|
||||
|
||||
r2.Update(new TValue(DateTime.UtcNow, 100), new TValue(DateTime.UtcNow, 95));
|
||||
r2.Update(new TValue(DateTime.UtcNow, 105), new TValue(DateTime.UtcNow, 100));
|
||||
|
||||
r2.Reset();
|
||||
|
||||
Assert.Equal(0, r2.Last.Value);
|
||||
Assert.False(r2.IsHot);
|
||||
|
||||
r2.Update(new TValue(DateTime.UtcNow, 50), new TValue(DateTime.UtcNow, 48));
|
||||
Assert.NotEqual(0, r2.Last.Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IsHot_BecomesTrueWhenBufferFull()
|
||||
{
|
||||
var r2 = new Rsquared(5);
|
||||
|
||||
Assert.False(r2.IsHot);
|
||||
|
||||
for (int i = 1; i <= 4; i++)
|
||||
{
|
||||
r2.Update(new TValue(DateTime.UtcNow, 100 + i), new TValue(DateTime.UtcNow, 100));
|
||||
Assert.False(r2.IsHot);
|
||||
}
|
||||
|
||||
r2.Update(new TValue(DateTime.UtcNow, 106), new TValue(DateTime.UtcNow, 101));
|
||||
Assert.True(r2.IsHot);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void NaN_Input_UsesLastValidValue()
|
||||
{
|
||||
var r2 = new Rsquared(Period);
|
||||
|
||||
r2.Update(new TValue(DateTime.UtcNow, 100), new TValue(DateTime.UtcNow, 95));
|
||||
r2.Update(new TValue(DateTime.UtcNow, 105), new TValue(DateTime.UtcNow, 100));
|
||||
|
||||
var resultAfterNaN = r2.Update(new TValue(DateTime.UtcNow, double.NaN), new TValue(DateTime.UtcNow, 102));
|
||||
|
||||
Assert.True(double.IsFinite(resultAfterNaN.Value));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Infinity_Input_UsesLastValidValue()
|
||||
{
|
||||
var r2 = new Rsquared(Period);
|
||||
|
||||
r2.Update(new TValue(DateTime.UtcNow, 100), new TValue(DateTime.UtcNow, 95));
|
||||
r2.Update(new TValue(DateTime.UtcNow, 105), new TValue(DateTime.UtcNow, 100));
|
||||
|
||||
var resultAfterPosInf = r2.Update(new TValue(DateTime.UtcNow, double.PositiveInfinity), new TValue(DateTime.UtcNow, 102));
|
||||
Assert.True(double.IsFinite(resultAfterPosInf.Value));
|
||||
|
||||
var resultAfterNegInf = r2.Update(new TValue(DateTime.UtcNow, 108), new TValue(DateTime.UtcNow, double.NegativeInfinity));
|
||||
Assert.True(double.IsFinite(resultAfterNegInf.Value));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PerfectPrediction_ReturnsOne()
|
||||
{
|
||||
var r2 = new Rsquared(Period);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
// Different actual values but perfect predictions
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
double val = 100 + i * 2;
|
||||
r2.Update(new TValue(time.AddSeconds(i), val), new TValue(time.AddSeconds(i), val));
|
||||
}
|
||||
|
||||
Assert.Equal(1.0, r2.Last.Value, 1e-10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void R2EqualsOneMinusRse()
|
||||
{
|
||||
// R² = 1 - RSE relationship
|
||||
var r2 = new Rsquared(10);
|
||||
var rse = new Rse(10);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
// Generate data with some error
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
double actual = 100 + i * 2;
|
||||
double predicted = actual + (i % 3 - 1) * 2;
|
||||
r2.Update(new TValue(time.AddSeconds(i), actual), new TValue(time.AddSeconds(i), predicted));
|
||||
rse.Update(new TValue(time.AddSeconds(i), actual), new TValue(time.AddSeconds(i), predicted));
|
||||
}
|
||||
|
||||
double r2Value = r2.Last.Value;
|
||||
double rseValue = rse.Last.Value;
|
||||
|
||||
// R² = 1 - RSE
|
||||
Assert.Equal(r2Value, 1.0 - rseValue, 1e-10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void MeanPredictor_ReturnsApproximatelyZero()
|
||||
{
|
||||
// When prediction = mean of actuals, R² ≈ 0
|
||||
var r2 = new Rsquared(5);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
double[] values = { 100, 104, 96, 108, 92, 110, 90, 105, 95, 100 };
|
||||
|
||||
// Use running mean as predictor
|
||||
double runningSum = 0;
|
||||
for (int i = 0; i < values.Length; i++)
|
||||
{
|
||||
runningSum += values[i];
|
||||
double mean = runningSum / (i + 1);
|
||||
r2.Update(new TValue(time.AddSeconds(i), values[i]), new TValue(time.AddSeconds(i), mean));
|
||||
}
|
||||
|
||||
// R² should be close to 0 when predicting the mean
|
||||
Assert.True(r2.Last.Value > -0.5 && r2.Last.Value < 0.5,
|
||||
$"Expected R² ≈ 0, got {r2.Last.Value}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GoodPredictions_HighR2()
|
||||
{
|
||||
var r2 = new Rsquared(10);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
// Linear trend with small random noise in predictions
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
double actual = 100 + i * 2;
|
||||
double predicted = actual + (i % 2 == 0 ? 0.5 : -0.5); // Small systematic error
|
||||
r2.Update(new TValue(time.AddSeconds(i), actual), new TValue(time.AddSeconds(i), predicted));
|
||||
}
|
||||
|
||||
// Good predictions should have high R²
|
||||
Assert.True(r2.Last.Value > 0.9, $"Expected R² > 0.9 for good predictions, got {r2.Last.Value}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void NegativeR2_WorseThanMean()
|
||||
{
|
||||
var r2 = new Rsquared(10);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
// Predictions that are anti-correlated with actuals
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
double actual = 100 + (i % 2 == 0 ? 10 : -10);
|
||||
double predicted = 100 + (i % 2 == 0 ? -10 : 10); // Opposite direction
|
||||
r2.Update(new TValue(time.AddSeconds(i), actual), new TValue(time.AddSeconds(i), predicted));
|
||||
}
|
||||
|
||||
// Anti-correlated predictions should have negative R²
|
||||
Assert.True(r2.Last.Value < 0, $"Expected R² < 0 for anti-correlated predictions, got {r2.Last.Value}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void FlatLine_ReturnsOne()
|
||||
{
|
||||
var r2 = new Rsquared(Period);
|
||||
|
||||
// Flat actual values means TSS = 0
|
||||
// Should return 1.0 (default when TSS is zero)
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
r2.Update(new TValue(DateTime.UtcNow, 100), new TValue(DateTime.UtcNow, 95));
|
||||
}
|
||||
|
||||
// When all actual values are the same, TSS = 0, returns 1.0
|
||||
Assert.Equal(1.0, r2.Last.Value, 1e-10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void R2_RangeUpperBoundIsOne()
|
||||
{
|
||||
var r2 = new Rsquared(Period);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
double actual = 100 + Math.Sin(i * 0.1) * 20;
|
||||
double predicted = actual + (i % 5 - 2); // Small systematic error
|
||||
r2.Update(new TValue(time.AddSeconds(i), actual), new TValue(time.AddSeconds(i), predicted));
|
||||
|
||||
// R² should never exceed 1
|
||||
Assert.True(r2.Last.Value <= 1.0 + 1e-10,
|
||||
$"R² = {r2.Last.Value} exceeded 1.0 at iteration {i}");
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BatchCalc_MatchesIterativeCalc()
|
||||
{
|
||||
var r2Iterative = new Rsquared(Period);
|
||||
var bars = _gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
var actual = bars.Close;
|
||||
var predicted = new TSeries();
|
||||
foreach (var item in actual)
|
||||
{
|
||||
predicted.Add(item.Time, item.Value * 0.98);
|
||||
}
|
||||
|
||||
var iterativeResults = new List<double>();
|
||||
for (int i = 0; i < actual.Count; i++)
|
||||
{
|
||||
iterativeResults.Add(r2Iterative.Update(actual[i], predicted[i]).Value);
|
||||
}
|
||||
|
||||
var batchResults = Rsquared.Batch(actual, predicted, Period);
|
||||
|
||||
Assert.Equal(iterativeResults.Count, batchResults.Count);
|
||||
for (int i = 0; i < iterativeResults.Count; i++)
|
||||
{
|
||||
Assert.Equal(iterativeResults[i], batchResults[i].Value, 1e-9);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SpanBatch_ValidatesInput()
|
||||
{
|
||||
double[] actual = [1, 2, 3, 4, 5];
|
||||
double[] predicted = [1, 2, 3, 4, 5];
|
||||
double[] output = new double[5];
|
||||
double[] wrongSizeOutput = new double[3];
|
||||
|
||||
Assert.Throws<ArgumentException>(() =>
|
||||
Rsquared.Batch(actual.AsSpan(), predicted.AsSpan(), output.AsSpan(), 0));
|
||||
Assert.Throws<ArgumentException>(() =>
|
||||
Rsquared.Batch(actual.AsSpan(), predicted.AsSpan(), output.AsSpan(), -1));
|
||||
Assert.Throws<ArgumentException>(() =>
|
||||
Rsquared.Batch(actual.AsSpan(), predicted.AsSpan(), wrongSizeOutput.AsSpan(), 3));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SpanBatch_MatchesTSeriesBatch()
|
||||
{
|
||||
var bars = _gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
|
||||
var actualSeries = bars.Close;
|
||||
var predictedSeries = new TSeries();
|
||||
foreach (var item in actualSeries)
|
||||
{
|
||||
predictedSeries.Add(item.Time, item.Value * 0.98);
|
||||
}
|
||||
|
||||
double[] actualArr = actualSeries.Values.ToArray();
|
||||
double[] predictedArr = predictedSeries.Values.ToArray();
|
||||
double[] output = new double[100];
|
||||
|
||||
var tseriesResult = Rsquared.Batch(actualSeries, predictedSeries, Period);
|
||||
Rsquared.Batch(actualArr.AsSpan(), predictedArr.AsSpan(), output.AsSpan(), Period);
|
||||
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
Assert.Equal(tseriesResult[i].Value, output[i], 1e-10);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AllModes_ProduceSameResult()
|
||||
{
|
||||
var bars = _gbm.Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
var actualSeries = bars.Close;
|
||||
var predictedSeries = new TSeries();
|
||||
foreach (var item in actualSeries)
|
||||
{
|
||||
predictedSeries.Add(item.Time, item.Value * 0.98);
|
||||
}
|
||||
|
||||
// 1. Batch Mode (static method)
|
||||
var batchSeries = Rsquared.Batch(actualSeries, predictedSeries, Period);
|
||||
double expected = batchSeries.Last.Value;
|
||||
|
||||
// 2. Span Mode
|
||||
double[] actualArr = actualSeries.Values.ToArray();
|
||||
double[] predictedArr = predictedSeries.Values.ToArray();
|
||||
double[] spanOutput = new double[actualArr.Length];
|
||||
Rsquared.Batch(actualArr.AsSpan(), predictedArr.AsSpan(), spanOutput.AsSpan(), Period);
|
||||
double spanResult = spanOutput[^1];
|
||||
|
||||
// 3. Streaming Mode
|
||||
var streamingInd = new Rsquared(Period);
|
||||
for (int i = 0; i < actualSeries.Count; i++)
|
||||
{
|
||||
streamingInd.Update(actualSeries[i], predictedSeries[i]);
|
||||
}
|
||||
double streamingResult = streamingInd.Last.Value;
|
||||
|
||||
Assert.Equal(expected, spanResult, precision: 9);
|
||||
Assert.Equal(expected, streamingResult, precision: 9);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void DoubleOverload_Works()
|
||||
{
|
||||
var r2 = new Rsquared(Period);
|
||||
|
||||
var result = r2.Update(100.0, 95.0);
|
||||
|
||||
Assert.True(result.Value <= 1.0);
|
||||
Assert.Equal(result.Value, r2.Last.Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SingleInputUpdate_Throws()
|
||||
{
|
||||
var r2 = new Rsquared(Period);
|
||||
|
||||
Assert.Throws<NotSupportedException>(() =>
|
||||
r2.Update(new TValue(DateTime.UtcNow, 100)));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SingleInputTSeriesUpdate_Throws()
|
||||
{
|
||||
var r2 = new Rsquared(Period);
|
||||
var series = new TSeries();
|
||||
series.Add(DateTime.UtcNow, 100);
|
||||
|
||||
Assert.Throws<NotSupportedException>(() => r2.Update(series));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,223 @@
|
||||
using QuanTAlib.Tests;
|
||||
using Skender.Stock.Indicators;
|
||||
|
||||
namespace QuanTAlib.Validation;
|
||||
|
||||
/// <summary>
|
||||
/// Validation tests for R² (Coefficient of Determination).
|
||||
///
|
||||
/// Note: QuanTAlib's Rsquared uses a streaming-optimized incremental formula where
|
||||
/// TSS is accumulated using the running mean at each point in time. This differs
|
||||
/// from the textbook formula where TSS uses the final window mean for all values.
|
||||
/// These tests verify internal consistency between Streaming and Batch modes,
|
||||
/// and validate known mathematical properties of R².
|
||||
/// </summary>
|
||||
public sealed class RsquaredValidationTests : IDisposable
|
||||
{
|
||||
private readonly ValidationTestData _data = new();
|
||||
|
||||
public void Dispose() => _data.Dispose();
|
||||
|
||||
[Fact]
|
||||
public void Rsquared_Streaming_Matches_Batch()
|
||||
{
|
||||
// Verify streaming and batch produce identical results
|
||||
int[] periods = { 5, 10, 20, 50, 100 };
|
||||
|
||||
var quotes = _data.SkenderQuotes.ToList();
|
||||
double[] actual = quotes.Select(q => (double)q.Close).ToArray();
|
||||
double[] predicted = quotes.Select(q => (double)q.Open).ToArray();
|
||||
|
||||
foreach (int period in periods)
|
||||
{
|
||||
var rsq = new Rsquared(period);
|
||||
double[] batchOutput = new double[actual.Length];
|
||||
Rsquared.Batch(actual, predicted, batchOutput, period);
|
||||
|
||||
for (int i = 0; i < actual.Length; i++)
|
||||
{
|
||||
var streamingVal = rsq.Update(
|
||||
new TValue(quotes[i].Date, actual[i]),
|
||||
new TValue(quotes[i].Date, predicted[i]));
|
||||
|
||||
Assert.Equal(batchOutput[i], streamingVal.Value, 1e-9);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Rsquared_PerfectPrediction_ReturnsOne()
|
||||
{
|
||||
var rsq = new Rsquared(5);
|
||||
|
||||
// Perfect prediction: predicted = actual → RSS = 0 → R² = 1
|
||||
double[] values = { 10, 20, 30, 40, 50 };
|
||||
|
||||
for (int i = 0; i < values.Length; i++)
|
||||
{
|
||||
rsq.Update(values[i], values[i]);
|
||||
}
|
||||
|
||||
Assert.Equal(1.0, rsq.Last.Value, 1e-9);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Rsquared_ConstantInput_ReturnsOne()
|
||||
{
|
||||
// When actual is constant, TSS = 0, so R² = 1 (by convention)
|
||||
var rsq = new Rsquared(5);
|
||||
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
rsq.Update(100.0, 100.0 + i); // Actual is constant
|
||||
}
|
||||
|
||||
// With constant actual and varying predicted, TSS ≈ 0, R² should be 1 (or close)
|
||||
Assert.True(rsq.Last.Value >= 0.99 || rsq.Last.Value <= 1.01);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Rsquared_Range_IsValid()
|
||||
{
|
||||
// R² can be negative (predictions worse than mean), but bounded at 1
|
||||
var rsq = new Rsquared(20);
|
||||
|
||||
var quotes = _data.SkenderQuotes.ToList();
|
||||
|
||||
for (int i = 0; i < quotes.Count; i++)
|
||||
{
|
||||
var val = rsq.Update((double)quotes[i].Close, (double)quotes[i].Open);
|
||||
|
||||
// R² ≤ 1 always
|
||||
Assert.True(val.Value <= 1.0 + 1e-9, $"R² should be ≤ 1, got {val.Value}");
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Rsquared_GoodPredictions_PositiveValue()
|
||||
{
|
||||
// When predictions track actual closely, R² should be positive and close to 1
|
||||
var rsq = new Rsquared(10);
|
||||
|
||||
// Use EMA of close as predicted (should track close well)
|
||||
var quotes = _data.SkenderQuotes.ToList();
|
||||
var ema = new Ema(5);
|
||||
|
||||
for (int i = 0; i < quotes.Count; i++)
|
||||
{
|
||||
double actual = (double)quotes[i].Close;
|
||||
double predicted = ema.Update(new TValue(quotes[i].Date, actual)).Value;
|
||||
rsq.Update(actual, predicted);
|
||||
}
|
||||
|
||||
// EMA should be a reasonable predictor, R² should be positive after warmup
|
||||
Assert.True(rsq.Last.Value > 0, $"R² with EMA predictions should be positive, got {rsq.Last.Value}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Rsquared_ReversePredictions_NegativeValue()
|
||||
{
|
||||
// When predictions are systematically wrong, R² can be negative
|
||||
var rsq = new Rsquared(10);
|
||||
|
||||
var quotes = _data.SkenderQuotes.Take(200).ToList();
|
||||
|
||||
for (int i = 0; i < quotes.Count; i++)
|
||||
{
|
||||
double actual = (double)quotes[i].Close;
|
||||
// Use inverse predictions (when close goes up, predict down)
|
||||
double predicted = 200 - actual; // Systematically wrong direction
|
||||
rsq.Update(actual, predicted);
|
||||
}
|
||||
|
||||
// With inverse predictions, R² should be significantly negative
|
||||
Assert.True(rsq.Last.Value < 0.5, $"R² with inverse predictions should be low, got {rsq.Last.Value}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Rsquared_Batch_ValidatesInputLengths()
|
||||
{
|
||||
double[] actual = { 1, 2, 3 };
|
||||
double[] predicted = { 1, 2 }; // Wrong length
|
||||
double[] output = new double[3];
|
||||
|
||||
Assert.Throws<ArgumentException>(() => Rsquared.Batch(actual, predicted, output, 2));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Rsquared_Batch_ValidatesPeriod()
|
||||
{
|
||||
double[] actual = { 1, 2, 3 };
|
||||
double[] predicted = { 1, 2, 3 };
|
||||
double[] output = new double[3];
|
||||
|
||||
Assert.Throws<ArgumentException>(() => Rsquared.Batch(actual, predicted, output, 0));
|
||||
Assert.Throws<ArgumentException>(() => Rsquared.Batch(actual, predicted, output, -1));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Structural validation against Skender <c>GetSlope().RSquared</c>.
|
||||
/// Skender R² measures goodness-of-fit of linear regression on price data.
|
||||
/// QuanTAlib Rsquared compares actual vs predicted values (different concept).
|
||||
/// Both must produce finite output bounded ≤ 1.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void Validate_Skender_RSquared_Structural()
|
||||
{
|
||||
const int period = 20;
|
||||
|
||||
// Skender R² from linear regression slope
|
||||
var sResult = _data.SkenderQuotes.GetSlope(period).ToList();
|
||||
|
||||
int finiteCount = sResult.Count(r => r.RSquared is not null && double.IsFinite(r.RSquared.Value));
|
||||
Assert.True(finiteCount > 100, $"Skender should produce >100 finite R² values, got {finiteCount}");
|
||||
|
||||
// All Skender R² values should be in [0, 1] for linear regression
|
||||
foreach (var r in sResult.Where(r => r.RSquared is not null))
|
||||
{
|
||||
Assert.True(r.RSquared!.Value >= -0.01 && r.RSquared.Value <= 1.01,
|
||||
$"Skender R² = {r.RSquared.Value} out of expected [0, 1] range");
|
||||
}
|
||||
|
||||
// QuanTAlib R² (using close as actual, EMA as predicted — same as existing test)
|
||||
var rsq = new Rsquared(period);
|
||||
var ema = new Ema(5);
|
||||
var quotes = _data.SkenderQuotes.ToList();
|
||||
|
||||
for (int i = 0; i < quotes.Count; i++)
|
||||
{
|
||||
double actual = (double)quotes[i].Close;
|
||||
double predicted = ema.Update(new TValue(quotes[i].Date, actual)).Value;
|
||||
rsq.Update(actual, predicted);
|
||||
}
|
||||
|
||||
Assert.True(double.IsFinite(rsq.Last.Value), "QuanTAlib R² last must be finite");
|
||||
Assert.True(rsq.Last.Value <= 1.0 + 1e-9, $"QuanTAlib R² should be ≤ 1, got {rsq.Last.Value}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Rsquared_Correction_Recomputes()
|
||||
{
|
||||
var ind = new Rsquared(20);
|
||||
|
||||
// Build state well past warmup
|
||||
for (int i = 0; i < 50; i++)
|
||||
{
|
||||
ind.Update(100.0 + (i * 0.5), 98.0 + (i * 0.5));
|
||||
}
|
||||
|
||||
// Anchor bar
|
||||
const double anchorActual = 125.0;
|
||||
const double anchorPredicted = 123.0;
|
||||
ind.Update(anchorActual, anchorPredicted, isNew: true);
|
||||
double anchorResult = ind.Last.Value;
|
||||
|
||||
// R² is scale-invariant: change only predicted (not ×10 both) to break R²
|
||||
ind.Update(anchorActual, 10.0, isNew: false);
|
||||
Assert.NotEqual(anchorResult, ind.Last.Value);
|
||||
|
||||
// Correction back to original — must exactly restore original result
|
||||
ind.Update(anchorActual, anchorPredicted, isNew: false);
|
||||
Assert.Equal(anchorResult, ind.Last.Value, 1e-9);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user