mirror of
https://github.com/mihakralj/QuanTAlib.git
synced 2026-08-25 13:58:04 +00:00
Add Standardize class for Z-Score normalization and update project files
- Implemented the Standardize class for calculating Z-Score normalization over a specified lookback period. - Updated NDepend badge SVG files to reflect new metrics. - Modified NDepend project files to reference the updated solution file name. - Removed outdated documentation files related to indicator proposals and channel documentation remediation. - Updated workspace configuration to point to the new solution file.
This commit is contained in:
Miha Kralj
@@ -0,0 +1,52 @@
|
||||
using TradingPlatform.BusinessLayer;
|
||||
using Xunit;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public class RocpIndicatorTests
|
||||
{
|
||||
[Fact]
|
||||
public void Constructor_InitializesDefaults()
|
||||
{
|
||||
var indicator = new RocpIndicator();
|
||||
Assert.Equal(9, indicator.Period);
|
||||
Assert.Equal(SourceType.Close, indicator.Source);
|
||||
Assert.True(indicator.ShowColdValues);
|
||||
Assert.Equal("ROCP - Rate of Change Percentage", indicator.Name);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ShortName_ReflectsPeriod()
|
||||
{
|
||||
var indicator = new RocpIndicator { Period = 14 };
|
||||
Assert.Equal("ROCP(14)", indicator.ShortName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void MinHistoryDepths_IsPeriodPlusOne()
|
||||
{
|
||||
var indicator = new RocpIndicator { Period = 9 };
|
||||
Assert.Equal(10, indicator.MinHistoryDepths);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Period_CanBeSet()
|
||||
{
|
||||
var indicator = new RocpIndicator { Period = 20 };
|
||||
Assert.Equal(20, indicator.Period);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Source_CanBeSet()
|
||||
{
|
||||
var indicator = new RocpIndicator { Source = SourceType.Open };
|
||||
Assert.Equal(SourceType.Open, indicator.Source);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ShowColdValues_CanBeSet()
|
||||
{
|
||||
var indicator = new RocpIndicator { ShowColdValues = false };
|
||||
Assert.False(indicator.ShowColdValues);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,85 @@
|
||||
using System.Drawing;
|
||||
using TradingPlatform.BusinessLayer;
|
||||
using static QuanTAlib.IndicatorExtensions;
|
||||
|
||||
namespace QuanTAlib;
|
||||
|
||||
/// <summary>
|
||||
/// ROCP (Rate of Change Percentage) Quantower indicator.
|
||||
/// Calculates percentage price change over a lookback period.
|
||||
/// Formula: 100 × (current - past) / past
|
||||
/// </summary>
|
||||
public class RocpIndicator : Indicator, IWatchlistIndicator
|
||||
{
|
||||
[InputParameter("Period", 0, 1, 999, 1, 0)]
|
||||
public int Period { get; set; } = 9;
|
||||
|
||||
[DataSourceInput]
|
||||
public SourceType Source { get; set; } = SourceType.Close;
|
||||
|
||||
[InputParameter("Show Cold Values", sortIndex: 100)]
|
||||
public bool ShowColdValues { get; set; } = true;
|
||||
|
||||
private Rocp? _rocp;
|
||||
private Func<IHistoryItem, double>? _selector;
|
||||
|
||||
public int MinHistoryDepths => Period + 1;
|
||||
public override string ShortName => $"ROCP({Period})";
|
||||
|
||||
public RocpIndicator()
|
||||
{
|
||||
Name = "ROCP - Rate of Change Percentage";
|
||||
Description = "Calculates percentage price change: 100 × (current - past) / past";
|
||||
SeparateWindow = true;
|
||||
OnBackGround = false;
|
||||
}
|
||||
|
||||
protected override void OnInit()
|
||||
{
|
||||
_rocp = new Rocp(Period);
|
||||
_selector = Source.GetPriceSelector();
|
||||
|
||||
AddLineSeries(new LineSeries("ROCP", IndicatorExtensions.Momentum, 2, LineStyle.Histogramm));
|
||||
AddLineSeries(new LineSeries("Zero", Color.Gray, 1, LineStyle.Dot));
|
||||
}
|
||||
|
||||
protected override void OnUpdate(UpdateArgs args)
|
||||
{
|
||||
if (_rocp == null || _selector == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var item = HistoricalData[0, SeekOriginHistory.End];
|
||||
double value = _selector(item);
|
||||
bool isNew = args.IsNewBar();
|
||||
|
||||
TValue input = new(item.TimeLeft, value);
|
||||
_rocp.Update(input, isNew);
|
||||
|
||||
bool isHot = _rocp.IsHot;
|
||||
|
||||
LinesSeries[0].SetValue(_rocp.Last.Value, isHot, ShowColdValues);
|
||||
LinesSeries[1].SetValue(0);
|
||||
|
||||
if (isHot || ShowColdValues)
|
||||
{
|
||||
double rocp = _rocp.Last.Value;
|
||||
Color color;
|
||||
if (rocp > 0)
|
||||
{
|
||||
color = Color.Green;
|
||||
}
|
||||
else if (rocp < 0)
|
||||
{
|
||||
color = Color.Red;
|
||||
}
|
||||
else
|
||||
{
|
||||
color = Color.Gray;
|
||||
}
|
||||
|
||||
LinesSeries[0].SetMarker(0, new IndicatorLineMarker(color));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,480 @@
|
||||
using Xunit;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public class RocpTests
|
||||
{
|
||||
private readonly TSeries _gbm;
|
||||
private const int TestPeriod = 9;
|
||||
private const int DataPoints = 100;
|
||||
|
||||
public RocpTests()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.0, sigma: 0.5, seed: 42);
|
||||
var bars = gbm.Fetch(DataPoints, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
_gbm = bars.Close;
|
||||
}
|
||||
|
||||
#region Constructor Tests
|
||||
|
||||
[Fact]
|
||||
public void Constructor_WithValidPeriod_SetsProperties()
|
||||
{
|
||||
var rocp = new Rocp(TestPeriod);
|
||||
Assert.Equal($"Rocp({TestPeriod})", rocp.Name);
|
||||
Assert.Equal(TestPeriod + 1, rocp.WarmupPeriod);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_WithZeroPeriod_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Rocp(0));
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_WithNegativePeriod_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Rocp(-1));
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_WithSource_SubscribesToEvents()
|
||||
{
|
||||
var source = new TSeries(DataPoints);
|
||||
var rocp = new Rocp(source, TestPeriod);
|
||||
Assert.NotNull(rocp);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Basic Calculation Tests
|
||||
|
||||
[Fact]
|
||||
public void Update_ReturnsCorrectValue()
|
||||
{
|
||||
var rocp = new Rocp(TestPeriod);
|
||||
var tv = rocp.Update(new TValue(DateTime.UtcNow, 100.0));
|
||||
Assert.Equal(0.0, tv.Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_FirstValues_ReturnsZero()
|
||||
{
|
||||
var rocp = new Rocp(TestPeriod);
|
||||
for (int i = 0; i < TestPeriod; i++)
|
||||
{
|
||||
var tv = rocp.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i));
|
||||
Assert.Equal(0.0, tv.Value);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_AfterWarmup_ReturnsPercentage()
|
||||
{
|
||||
var rocp = new Rocp(2); // period=2
|
||||
var values = new double[] { 100, 102, 105, 103, 110 };
|
||||
|
||||
for (int i = 0; i < values.Length; i++)
|
||||
{
|
||||
var tv = rocp.Update(new TValue(DateTime.UtcNow.AddSeconds(i), values[i]), true);
|
||||
|
||||
if (i < 2)
|
||||
{
|
||||
Assert.Equal(0.0, tv.Value); // warmup period
|
||||
}
|
||||
else
|
||||
{
|
||||
// percentage: 100 * (current - past) / past
|
||||
double expected = 100.0 * (values[i] - values[i - 2]) / values[i - 2];
|
||||
Assert.Equal(expected, tv.Value, 10);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Last_IsAccessible()
|
||||
{
|
||||
var rocp = new Rocp(TestPeriod);
|
||||
rocp.Update(new TValue(DateTime.UtcNow, 100.0));
|
||||
Assert.Equal(0.0, rocp.Last.Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IsHot_ReturnsFalseDuringWarmup()
|
||||
{
|
||||
var rocp = new Rocp(TestPeriod);
|
||||
for (int i = 0; i < TestPeriod; i++)
|
||||
{
|
||||
rocp.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i));
|
||||
Assert.False(rocp.IsHot);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IsHot_ReturnsTrueAfterWarmup()
|
||||
{
|
||||
var rocp = new Rocp(TestPeriod);
|
||||
for (int i = 0; i <= TestPeriod; i++)
|
||||
{
|
||||
rocp.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i));
|
||||
}
|
||||
Assert.True(rocp.IsHot);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Name_IsAccessible()
|
||||
{
|
||||
var rocp = new Rocp(TestPeriod);
|
||||
Assert.Equal($"Rocp({TestPeriod})", rocp.Name);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region State Management Tests
|
||||
|
||||
[Fact]
|
||||
public void Update_WithIsNewTrue_AdvancesState()
|
||||
{
|
||||
var rocp = new Rocp(TestPeriod);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocp.Update(new TValue(time, 100.0), true);
|
||||
rocp.Update(new TValue(time.AddSeconds(1), 105.0), true);
|
||||
rocp.Update(new TValue(time.AddSeconds(2), 110.0), true);
|
||||
|
||||
Assert.NotEqual(default, rocp.Last);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_WithIsNewFalse_UpdatesCurrentState()
|
||||
{
|
||||
var rocp = new Rocp(2);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
// Warmup
|
||||
rocp.Update(new TValue(time, 100.0), true);
|
||||
rocp.Update(new TValue(time.AddSeconds(1), 102.0), true);
|
||||
var first = rocp.Update(new TValue(time.AddSeconds(2), 105.0), true);
|
||||
|
||||
// Update same bar with different value
|
||||
var corrected = rocp.Update(new TValue(time.AddSeconds(2), 110.0), false);
|
||||
|
||||
Assert.NotEqual(first.Value, corrected.Value);
|
||||
// first: 100 * (105-100)/100 = 5%
|
||||
// corrected: 100 * (110-100)/100 = 10%
|
||||
Assert.Equal(5.0, first.Value, 10);
|
||||
Assert.Equal(10.0, corrected.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_IterativeCorrections_RestoresPreviousState()
|
||||
{
|
||||
var rocp = new Rocp(2);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocp.Update(new TValue(time, 100.0), true);
|
||||
rocp.Update(new TValue(time.AddSeconds(1), 102.0), true);
|
||||
var baseline = rocp.Update(new TValue(time.AddSeconds(2), 105.0), true);
|
||||
|
||||
rocp.Update(new TValue(time.AddSeconds(2), 110.0), false);
|
||||
rocp.Update(new TValue(time.AddSeconds(2), 115.0), false);
|
||||
var restored = rocp.Update(new TValue(time.AddSeconds(2), 105.0), false);
|
||||
|
||||
Assert.Equal(baseline.Value, restored.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Reset_ClearsStateAndLastValidTracking()
|
||||
{
|
||||
var rocp = new Rocp(TestPeriod);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i <= TestPeriod; i++)
|
||||
{
|
||||
rocp.Update(new TValue(time.AddSeconds(i), 100.0 + i));
|
||||
}
|
||||
|
||||
rocp.Reset();
|
||||
|
||||
Assert.Equal(default, rocp.Last);
|
||||
Assert.False(rocp.IsHot);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Robustness Tests
|
||||
|
||||
[Fact]
|
||||
public void Update_WithNaN_UsesLastValidValue()
|
||||
{
|
||||
var rocp = new Rocp(2);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocp.Update(new TValue(time, 100.0), true);
|
||||
rocp.Update(new TValue(time.AddSeconds(1), 102.0), true);
|
||||
_ = rocp.Update(new TValue(time.AddSeconds(2), 105.0), true);
|
||||
var afterNaN = rocp.Update(new TValue(time.AddSeconds(3), double.NaN), true);
|
||||
|
||||
// NaN uses last valid (105), so: 100 * (105-102)/102 ≈ 2.94%
|
||||
Assert.True(double.IsFinite(afterNaN.Value));
|
||||
Assert.Equal(100.0 * (105.0 - 102.0) / 102.0, afterNaN.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_WithInfinity_UsesLastValidValue()
|
||||
{
|
||||
var rocp = new Rocp(2);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocp.Update(new TValue(time, 100.0), true);
|
||||
rocp.Update(new TValue(time.AddSeconds(1), 102.0), true);
|
||||
rocp.Update(new TValue(time.AddSeconds(2), 105.0), true);
|
||||
var afterInf = rocp.Update(new TValue(time.AddSeconds(3), double.PositiveInfinity), true);
|
||||
|
||||
Assert.True(double.IsFinite(afterInf.Value));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_BatchNaN_HandlesSafely()
|
||||
{
|
||||
var rocp = new Rocp(TestPeriod);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
var value = i % 3 == 0 ? double.NaN : 100.0 + i;
|
||||
var tv = rocp.Update(new TValue(time.AddSeconds(i), value), true);
|
||||
Assert.True(double.IsFinite(tv.Value));
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_WithZeroPastValue_ReturnsZero()
|
||||
{
|
||||
var rocp = new Rocp(2);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocp.Update(new TValue(time, 0.0), true);
|
||||
rocp.Update(new TValue(time.AddSeconds(1), 50.0), true);
|
||||
var result = rocp.Update(new TValue(time.AddSeconds(2), 100.0), true);
|
||||
|
||||
// Division by zero: returns 0.0 as safe default
|
||||
Assert.Equal(0.0, result.Value);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Consistency Tests (All 4 modes must match)
|
||||
|
||||
[Fact]
|
||||
public void AllModes_ProduceSameResults()
|
||||
{
|
||||
// Mode 1: Batch via TSeries
|
||||
var batchResult = Rocp.Calculate(_gbm, TestPeriod);
|
||||
|
||||
// Mode 2: Streaming
|
||||
var streamingRocp = new Rocp(TestPeriod);
|
||||
var streamingResult = new TSeries(DataPoints);
|
||||
for (int i = 0; i < _gbm.Count; i++)
|
||||
{
|
||||
var tv = streamingRocp.Update(new TValue(_gbm[i].Time, _gbm[i].Value), true);
|
||||
streamingResult.Add(tv, true);
|
||||
}
|
||||
|
||||
// Mode 3: Span-based
|
||||
Span<double> spanOutput = stackalloc double[DataPoints];
|
||||
Rocp.Calculate(_gbm.Values, spanOutput, TestPeriod);
|
||||
|
||||
// Mode 4: Event-driven
|
||||
var eventRocp = new Rocp(TestPeriod);
|
||||
var eventResult = new TSeries(DataPoints);
|
||||
eventRocp.Pub += (object? _, in TValueEventArgs e) => eventResult.Add(e.Value, e.IsNew);
|
||||
for (int i = 0; i < _gbm.Count; i++)
|
||||
{
|
||||
eventRocp.Update(new TValue(_gbm[i].Time, _gbm[i].Value), true);
|
||||
}
|
||||
|
||||
int compareCount = Math.Min(100, DataPoints);
|
||||
for (int i = DataPoints - compareCount; i < DataPoints; i++)
|
||||
{
|
||||
Assert.Equal(batchResult[i].Value, streamingResult[i].Value, 10);
|
||||
Assert.Equal(batchResult[i].Value, spanOutput[i], 10);
|
||||
Assert.Equal(batchResult[i].Value, eventResult[i].Value, 10);
|
||||
}
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Span API Tests
|
||||
|
||||
[Fact]
|
||||
public void Calculate_Span_ValidatesEmptySource()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() =>
|
||||
{
|
||||
ReadOnlySpan<double> empty = [];
|
||||
Span<double> output = stackalloc double[1];
|
||||
Rocp.Calculate(empty, output, TestPeriod);
|
||||
});
|
||||
Assert.Equal("source", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calculate_Span_ValidatesOutputLength()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() =>
|
||||
{
|
||||
ReadOnlySpan<double> source = stackalloc double[] { 1, 2, 3, 4, 5 };
|
||||
Span<double> output = stackalloc double[3];
|
||||
Rocp.Calculate(source, output, TestPeriod);
|
||||
});
|
||||
Assert.Equal("output", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calculate_Span_ValidatesPeriod()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() =>
|
||||
{
|
||||
ReadOnlySpan<double> source = stackalloc double[] { 1, 2, 3, 4, 5 };
|
||||
Span<double> output = stackalloc double[5];
|
||||
Rocp.Calculate(source, output, 0);
|
||||
});
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calculate_Span_MatchesTSeries()
|
||||
{
|
||||
var batchResult = Rocp.Calculate(_gbm, TestPeriod);
|
||||
|
||||
Span<double> spanOutput = stackalloc double[DataPoints];
|
||||
Rocp.Calculate(_gbm.Values, spanOutput, TestPeriod);
|
||||
|
||||
for (int i = 0; i < DataPoints; i++)
|
||||
{
|
||||
Assert.Equal(batchResult[i].Value, spanOutput[i], 10);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calculate_Span_LargeData_NoStackOverflow()
|
||||
{
|
||||
int largeSize = 10000;
|
||||
double[] source = new double[largeSize];
|
||||
double[] output = new double[largeSize];
|
||||
|
||||
for (int i = 0; i < largeSize; i++)
|
||||
{
|
||||
source[i] = 100.0 + i * 0.1;
|
||||
}
|
||||
|
||||
Rocp.Calculate(source, output, TestPeriod);
|
||||
Assert.Equal(largeSize, output.Length);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Chainability Tests
|
||||
|
||||
[Fact]
|
||||
public void Pub_FiresOnUpdate()
|
||||
{
|
||||
var rocp = new Rocp(TestPeriod);
|
||||
bool eventFired = false;
|
||||
|
||||
rocp.Pub += (object? _, in TValueEventArgs e) => eventFired = true;
|
||||
rocp.Update(new TValue(DateTime.UtcNow, 100.0));
|
||||
|
||||
Assert.True(eventFired);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EventBasedChaining_Works()
|
||||
{
|
||||
var source = new TSeries(10);
|
||||
var rocp = new Rocp(source, 2);
|
||||
var results = new List<double>();
|
||||
|
||||
rocp.Pub += (object? _, in TValueEventArgs e) => results.Add(e.Value.Value);
|
||||
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
source.Add(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i), true);
|
||||
}
|
||||
|
||||
Assert.Equal(10, results.Count);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Mathematical Properties Tests
|
||||
|
||||
[Fact]
|
||||
public void Update_TenPercentIncrease_ReturnsTen()
|
||||
{
|
||||
var rocp = new Rocp(1);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocp.Update(new TValue(time, 100.0), true);
|
||||
var result = rocp.Update(new TValue(time.AddSeconds(1), 110.0), true);
|
||||
|
||||
// 100 * (110 - 100) / 100 = 10%
|
||||
Assert.Equal(10.0, result.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_TenPercentDecrease_ReturnsNegativeTen()
|
||||
{
|
||||
var rocp = new Rocp(1);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocp.Update(new TValue(time, 100.0), true);
|
||||
var result = rocp.Update(new TValue(time.AddSeconds(1), 90.0), true);
|
||||
|
||||
// 100 * (90 - 100) / 100 = -10%
|
||||
Assert.Equal(-10.0, result.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_PriceDoubled_Returns100()
|
||||
{
|
||||
var rocp = new Rocp(1);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocp.Update(new TValue(time, 50.0), true);
|
||||
var result = rocp.Update(new TValue(time.AddSeconds(1), 100.0), true);
|
||||
|
||||
// 100 * (100 - 50) / 50 = 100%
|
||||
Assert.Equal(100.0, result.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_PriceHalved_ReturnsNegative50()
|
||||
{
|
||||
var rocp = new Rocp(1);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocp.Update(new TValue(time, 100.0), true);
|
||||
var result = rocp.Update(new TValue(time.AddSeconds(1), 50.0), true);
|
||||
|
||||
// 100 * (50 - 100) / 100 = -50%
|
||||
Assert.Equal(-50.0, result.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_NoChange_ReturnsZero()
|
||||
{
|
||||
var rocp = new Rocp(1);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocp.Update(new TValue(time, 100.0), true);
|
||||
var result = rocp.Update(new TValue(time.AddSeconds(1), 100.0), true);
|
||||
|
||||
Assert.Equal(0.0, result.Value, 10);
|
||||
}
|
||||
|
||||
#endregion
|
||||
}
|
||||
@@ -0,0 +1,214 @@
|
||||
using Xunit;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public class RocpValidationTests
|
||||
{
|
||||
#region Mathematical Validation
|
||||
|
||||
[Fact]
|
||||
public void Rocp_ManualCalculation_MatchesExpected()
|
||||
{
|
||||
var rocp = new Rocp(3);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
var values = new double[] { 100, 105, 110, 115, 120, 125 };
|
||||
|
||||
for (int i = 0; i < values.Length; i++)
|
||||
{
|
||||
var result = rocp.Update(new TValue(time.AddSeconds(i), values[i]), true);
|
||||
|
||||
if (i >= 3)
|
||||
{
|
||||
double expected = 100.0 * (values[i] - values[i - 3]) / values[i - 3];
|
||||
Assert.Equal(expected, result.Value, 10);
|
||||
}
|
||||
else
|
||||
{
|
||||
Assert.Equal(0.0, result.Value, 10);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Rocp_FivePercentIncrease_ReturnsFive()
|
||||
{
|
||||
var rocp = new Rocp(1);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocp.Update(new TValue(time, 100.0), true);
|
||||
var result = rocp.Update(new TValue(time.AddSeconds(1), 105.0), true);
|
||||
|
||||
Assert.Equal(5.0, result.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Rocp_FivePercentDecrease_ReturnsNegativeFive()
|
||||
{
|
||||
var rocp = new Rocp(1);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocp.Update(new TValue(time, 100.0), true);
|
||||
var result = rocp.Update(new TValue(time.AddSeconds(1), 95.0), true);
|
||||
|
||||
Assert.Equal(-5.0, result.Value, 10);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Relationship to ROCR and ROC
|
||||
|
||||
[Fact]
|
||||
public void Rocp_RelationshipToRocr_IsCorrect()
|
||||
{
|
||||
// ROCP = (ROCR - 1) * 100
|
||||
var rocp = new Rocp(2);
|
||||
var rocr = new Rocr(2);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
var values = new double[] { 100, 105, 110, 120, 115 };
|
||||
|
||||
for (int i = 0; i < values.Length; i++)
|
||||
{
|
||||
rocp.Update(new TValue(time.AddSeconds(i), values[i]), true);
|
||||
rocr.Update(new TValue(time.AddSeconds(i), values[i]), true);
|
||||
}
|
||||
|
||||
// ROCP = (ROCR - 1) * 100
|
||||
double expectedFromRocr = (rocr.Last.Value - 1.0) * 100.0;
|
||||
Assert.Equal(expectedFromRocr, rocp.Last.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Rocp_RelationshipToRoc_IsCorrect()
|
||||
{
|
||||
// ROCP = 100 * ROC / past
|
||||
var rocp = new Rocp(2);
|
||||
var roc = new Roc(2);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
var values = new double[] { 100, 105, 110, 120, 115 };
|
||||
|
||||
for (int i = 0; i < values.Length; i++)
|
||||
{
|
||||
rocp.Update(new TValue(time.AddSeconds(i), values[i]), true);
|
||||
roc.Update(new TValue(time.AddSeconds(i), values[i]), true);
|
||||
}
|
||||
|
||||
// ROCP = 100 * ROC / past
|
||||
// For last value: past = values[2] = 110
|
||||
double expectedFromRoc = 100.0 * roc.Last.Value / values[2];
|
||||
Assert.Equal(expectedFromRoc, rocp.Last.Value, 10);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Edge Cases
|
||||
|
||||
[Fact]
|
||||
public void Rocp_SmallValues_MaintainsPrecision()
|
||||
{
|
||||
var rocp = new Rocp(1);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocp.Update(new TValue(time, 0.0001), true);
|
||||
var result = rocp.Update(new TValue(time.AddSeconds(1), 0.00015), true);
|
||||
|
||||
// 100 * (0.00015 - 0.0001) / 0.0001 = 50%
|
||||
Assert.Equal(50.0, result.Value, 5);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Rocp_LargeValues_MaintainsPrecision()
|
||||
{
|
||||
var rocp = new Rocp(1);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocp.Update(new TValue(time, 1_000_000), true);
|
||||
var result = rocp.Update(new TValue(time.AddSeconds(1), 1_100_000), true);
|
||||
|
||||
// 100 * (1_100_000 - 1_000_000) / 1_000_000 = 10%
|
||||
Assert.Equal(10.0, result.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Rocp_NegativeValues_HandlesCorrectly()
|
||||
{
|
||||
var rocp = new Rocp(1);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocp.Update(new TValue(time, -100.0), true);
|
||||
var result = rocp.Update(new TValue(time.AddSeconds(1), -50.0), true);
|
||||
|
||||
// 100 * (-50 - (-100)) / (-100) = 100 * 50 / -100 = -50%
|
||||
Assert.Equal(-50.0, result.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Rocp_MixedSigns_HandlesCorrectly()
|
||||
{
|
||||
var rocp = new Rocp(1);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocp.Update(new TValue(time, -100.0), true);
|
||||
var result = rocp.Update(new TValue(time.AddSeconds(1), 100.0), true);
|
||||
|
||||
// 100 * (100 - (-100)) / (-100) = 100 * 200 / -100 = -200%
|
||||
Assert.Equal(-200.0, result.Value, 10);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Batch vs Streaming Consistency
|
||||
|
||||
[Fact]
|
||||
public void Batch_MatchesStreaming_IdenticalResults()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.0, sigma: 0.5, seed: 42);
|
||||
var bars = gbm.Fetch(50, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
var source = bars.Close;
|
||||
|
||||
// Streaming
|
||||
var streamingRocp = new Rocp(5);
|
||||
var streamingResults = new List<double>();
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
var tv = streamingRocp.Update(new TValue(source[i].Time, source[i].Value), true);
|
||||
streamingResults.Add(tv.Value);
|
||||
}
|
||||
|
||||
// Batch
|
||||
var batchResult = Rocp.Calculate(source, 5);
|
||||
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
Assert.Equal(batchResult[i].Value, streamingResults[i], 10);
|
||||
}
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region TA-Lib Compatibility Notes
|
||||
|
||||
[Fact]
|
||||
public void Rocp_TaLibCompatibility_Conversion()
|
||||
{
|
||||
// TA-Lib ROCP returns decimal (0.05 for 5%)
|
||||
// QuanTAlib ROCP returns percentage (5.0 for 5%)
|
||||
// Conversion: TaLibRocp = QuanTAlibRocp / 100
|
||||
|
||||
var rocp = new Rocp(1);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocp.Update(new TValue(time, 100.0), true);
|
||||
var result = rocp.Update(new TValue(time.AddSeconds(1), 105.0), true);
|
||||
|
||||
double quantalibRocp = result.Value; // 5.0
|
||||
double talibEquivalent = quantalibRocp / 100.0; // 0.05
|
||||
|
||||
Assert.Equal(5.0, quantalibRocp, 10);
|
||||
Assert.Equal(0.05, talibEquivalent, 10);
|
||||
}
|
||||
|
||||
#endregion
|
||||
}
|
||||
@@ -0,0 +1,179 @@
|
||||
using System.Runtime.CompilerServices;
|
||||
|
||||
namespace QuanTAlib;
|
||||
|
||||
/// <summary>
|
||||
/// ROCP: Rate of Change Percentage
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Percentage price momentum: percentage change between current and N-period-ago value.
|
||||
/// Returns percentage values (e.g., 5.0 = 5% increase, -3.0 = 3% decrease).
|
||||
/// See ROC for absolute change, ROCR for ratio.
|
||||
///
|
||||
/// Calculation: <c>ROCP = 100 × (Price - Price[N]) / Price[N]</c>.
|
||||
/// </remarks>
|
||||
/// <seealso href="Rocp.md">Detailed documentation</seealso>
|
||||
[SkipLocalsInit]
|
||||
public sealed class Rocp : AbstractBase
|
||||
{
|
||||
private readonly int _period;
|
||||
private readonly RingBuffer _buffer;
|
||||
private record struct State(double LastValid);
|
||||
private State _state, _p_state;
|
||||
private ITValuePublisher? _source;
|
||||
private bool _disposed;
|
||||
|
||||
public override bool IsHot => _buffer.Count > _period;
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new Rate of Change Percentage indicator with specified lookback period.
|
||||
/// </summary>
|
||||
/// <param name="period">Lookback period (must be >= 1)</param>
|
||||
public Rocp(int period = 9)
|
||||
{
|
||||
if (period < 1)
|
||||
{
|
||||
throw new ArgumentException("Period must be >= 1", nameof(period));
|
||||
}
|
||||
|
||||
_period = period;
|
||||
_buffer = new RingBuffer(period + 1);
|
||||
Name = $"Rocp({period})";
|
||||
WarmupPeriod = period + 1;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new Rate of Change Percentage indicator with source for event-based chaining.
|
||||
/// </summary>
|
||||
/// <param name="source">Source indicator for chaining</param>
|
||||
/// <param name="period">Lookback period</param>
|
||||
public Rocp(ITValuePublisher source, int period = 9) : this(period)
|
||||
{
|
||||
_source = source;
|
||||
_source.Pub += HandleUpdate;
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
private void HandleUpdate(object? sender, in TValueEventArgs e) => Update(e.Value, e.IsNew);
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
public override TValue Update(TValue input, bool isNew = true)
|
||||
{
|
||||
if (isNew)
|
||||
{
|
||||
_p_state = _state;
|
||||
}
|
||||
else
|
||||
{
|
||||
_state = _p_state;
|
||||
}
|
||||
|
||||
double value = double.IsFinite(input.Value) ? input.Value : _state.LastValid;
|
||||
_state = new State(value);
|
||||
|
||||
_buffer.Add(value, isNew);
|
||||
|
||||
double result;
|
||||
if (_buffer.Count <= _period)
|
||||
{
|
||||
result = 0.0; // Default percentage during warmup
|
||||
}
|
||||
else
|
||||
{
|
||||
double past = _buffer[0];
|
||||
result = past != 0 ? 100.0 * (value - past) / past : 0.0; // Avoid division by zero
|
||||
}
|
||||
|
||||
Last = new TValue(input.Time, result);
|
||||
PubEvent(Last, isNew);
|
||||
return Last;
|
||||
}
|
||||
|
||||
public override TSeries Update(TSeries source)
|
||||
{
|
||||
var result = new TSeries(source.Count);
|
||||
ReadOnlySpan<double> values = source.Values;
|
||||
ReadOnlySpan<long> times = source.Times;
|
||||
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
var tv = Update(new TValue(new DateTime(times[i], DateTimeKind.Utc), values[i]), true);
|
||||
result.Add(tv, true);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public override void Prime(ReadOnlySpan<double> source, TimeSpan? step = null)
|
||||
{
|
||||
TimeSpan interval = step ?? TimeSpan.FromSeconds(1);
|
||||
DateTime time = DateTime.UtcNow - (interval * source.Length);
|
||||
|
||||
for (int i = 0; i < source.Length; i++)
|
||||
{
|
||||
Update(new TValue(time, source[i]), true);
|
||||
time += interval;
|
||||
}
|
||||
}
|
||||
|
||||
public static TSeries Calculate(TSeries source, int period = 9)
|
||||
{
|
||||
var indicator = new Rocp(period);
|
||||
return indicator.Update(source);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Calculates rate of change percentage over a span of values.
|
||||
/// </summary>
|
||||
public static void Calculate(ReadOnlySpan<double> source, Span<double> output, int period = 9)
|
||||
{
|
||||
if (source.Length == 0)
|
||||
{
|
||||
throw new ArgumentException("Source cannot be empty", nameof(source));
|
||||
}
|
||||
|
||||
if (output.Length < source.Length)
|
||||
{
|
||||
throw new ArgumentException("Output length must be >= source length", nameof(output));
|
||||
}
|
||||
|
||||
if (period < 1)
|
||||
{
|
||||
throw new ArgumentException("Period must be >= 1", nameof(period));
|
||||
}
|
||||
|
||||
for (int i = 0; i < source.Length; i++)
|
||||
{
|
||||
if (i < period)
|
||||
{
|
||||
output[i] = 0.0; // Default percentage during warmup
|
||||
}
|
||||
else
|
||||
{
|
||||
double past = source[i - period];
|
||||
output[i] = past != 0 ? 100.0 * (source[i] - past) / past : 0.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public override void Reset()
|
||||
{
|
||||
_buffer.Clear();
|
||||
_state = default;
|
||||
_p_state = default;
|
||||
Last = default;
|
||||
}
|
||||
|
||||
protected override void Dispose(bool disposing)
|
||||
{
|
||||
if (!_disposed)
|
||||
{
|
||||
if (disposing && _source != null)
|
||||
{
|
||||
_source.Pub -= HandleUpdate;
|
||||
_source = null;
|
||||
}
|
||||
_disposed = true;
|
||||
}
|
||||
base.Dispose(disposing);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,122 @@
|
||||
# ROCP: Rate of Change Percentage
|
||||
|
||||
> "The percentage form of momentum: by what percent has price changed? The most intuitive momentum measure."
|
||||
|
||||
ROCP (Rate of Change Percentage) calculates the percentage change between the current value and the value N periods ago. This is the most commonly used form of rate of change, expressing change in percentage terms that are directly interpretable (e.g., 5.0 = 5% increase).
|
||||
|
||||
## Historical Context
|
||||
|
||||
ROCP is the standard way of expressing price momentum in percentage terms. It's widely used in technical analysis because percentage changes are comparable across different instruments regardless of their price levels.
|
||||
|
||||
The terminology varies by platform:
|
||||
- **TA-Lib**: Uses `ROCP` for percentage change / 100 (decimal form)
|
||||
- **TradingView/PineScript**: Often uses `change` for this calculation
|
||||
- **QuanTAlib**: Uses `ROCP` for percentage (5.0 = 5%), `CHANGE` for decimal (0.05 = 5%)
|
||||
|
||||
## Architecture & Physics
|
||||
|
||||
### 1. Ring Buffer Storage
|
||||
|
||||
The indicator maintains a sliding window of `period + 1` values:
|
||||
|
||||
$$
|
||||
\text{buffer} = [v_{t-n}, v_{t-n+1}, ..., v_{t-1}, v_t]
|
||||
$$
|
||||
|
||||
where $n$ is the lookback period.
|
||||
|
||||
### 2. Percentage Calculation
|
||||
|
||||
$$
|
||||
\text{ROCP}_t = 100 \times \frac{v_t - v_{t-n}}{v_{t-n}}
|
||||
$$
|
||||
|
||||
where:
|
||||
- $v_t$ = current value
|
||||
- $v_{t-n}$ = value from $n$ periods ago
|
||||
- Result is in percentage units (5.0 = 5%)
|
||||
|
||||
## Mathematical Foundation
|
||||
|
||||
### Core Formula
|
||||
|
||||
$$
|
||||
\text{ROCP}_t = 100 \times \frac{P_t - P_{t-n}}{P_{t-n}}
|
||||
$$
|
||||
|
||||
### Relationship to Other Rate of Change Variants
|
||||
|
||||
| Indicator | Formula | Output |
|
||||
|-----------|---------|--------|
|
||||
| **ROC** | $P_t - P_{t-n}$ | Absolute (price units) |
|
||||
| **ROCP** | $\frac{P_t - P_{t-n}}{P_{t-n}} \times 100$ | Percentage (%) |
|
||||
| **ROCR** | $\frac{P_t}{P_{t-n}}$ | Ratio (dimensionless) |
|
||||
| **CHANGE** | $\frac{P_t - P_{t-n}}{P_{t-n}}$ | Decimal (0.10 = 10%) |
|
||||
|
||||
### Conversions
|
||||
|
||||
$$
|
||||
\text{ROCP} = \text{CHANGE} \times 100
|
||||
$$
|
||||
|
||||
$$
|
||||
\text{ROCP} = (\text{ROCR} - 1) \times 100
|
||||
$$
|
||||
|
||||
$$
|
||||
\text{CHANGE} = \text{ROCP} / 100
|
||||
$$
|
||||
|
||||
## Performance Profile
|
||||
|
||||
### Operation Count (Streaming Mode)
|
||||
|
||||
| Operation | Count | Notes |
|
||||
| :--- | :---: | :--- |
|
||||
| SUB | 1 | current - past |
|
||||
| DIV | 1 | change / past |
|
||||
| MUL | 1 | × 100 |
|
||||
| Buffer add | 1 | O(1) ring buffer |
|
||||
| **Total** | **~4 ops** | Very lightweight |
|
||||
|
||||
### Quality Metrics
|
||||
|
||||
| Metric | Score | Notes |
|
||||
| :--- | :---: | :--- |
|
||||
| **Accuracy** | 10/10 | Exact arithmetic |
|
||||
| **Timeliness** | 10/10 | Zero lag |
|
||||
| **Smoothness** | 3/10 | Reflects raw volatility |
|
||||
| **Simplicity** | 10/10 | Basic arithmetic |
|
||||
|
||||
## Interpretation
|
||||
|
||||
* **ROCP = 0.0**: No change from N periods ago
|
||||
* **ROCP > 0**: Price increased (e.g., 5.0 = 5% increase)
|
||||
* **ROCP < 0**: Price decreased (e.g., -3.0 = 3% decrease)
|
||||
* **ROCP = 100**: Price doubled
|
||||
* **ROCP = -50**: Price halved
|
||||
|
||||
## Validation
|
||||
|
||||
| Library | Status | Notes |
|
||||
| :--- | :---: | :--- |
|
||||
| **TA-Lib** | ✅ | Note: TA-Lib ROCP returns decimal (0.05), multiply by 100 |
|
||||
| **TradingView** | ✅ | Matches PineScript calculation |
|
||||
|
||||
## Common Pitfalls
|
||||
|
||||
1. **Scale**: ROCP returns percentage values directly. A return of 5.0 means 5%, not 0.05.
|
||||
|
||||
2. **Division by zero**: If the historical price is zero, ROCP returns 0.0 as a safe default.
|
||||
|
||||
3. **TA-Lib difference**: TA-Lib's ROCP returns decimal form (0.05 for 5%), while this implementation returns percentage form (5.0).
|
||||
|
||||
4. **Compounding**: Unlike ROCR, ROCP values cannot be directly multiplied for multi-period changes.
|
||||
|
||||
5. **Warmup period**: The first `period` values return 0.0.
|
||||
|
||||
## References
|
||||
|
||||
- Pring, M. J. (2014). "Technical Analysis Explained." McGraw-Hill.
|
||||
- Murphy, J. J. (1999). "Technical Analysis of the Financial Markets."
|
||||
- TA-Lib Documentation: ROCP function
|
||||
@@ -0,0 +1,52 @@
|
||||
using TradingPlatform.BusinessLayer;
|
||||
using Xunit;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public class RocrIndicatorTests
|
||||
{
|
||||
[Fact]
|
||||
public void Constructor_InitializesDefaults()
|
||||
{
|
||||
var indicator = new RocrIndicator();
|
||||
Assert.Equal(9, indicator.Period);
|
||||
Assert.Equal(SourceType.Close, indicator.Source);
|
||||
Assert.True(indicator.ShowColdValues);
|
||||
Assert.Equal("ROCR - Rate of Change Ratio", indicator.Name);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ShortName_ReflectsPeriod()
|
||||
{
|
||||
var indicator = new RocrIndicator { Period = 14 };
|
||||
Assert.Equal("ROCR(14)", indicator.ShortName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void MinHistoryDepths_IsPeriodPlusOne()
|
||||
{
|
||||
var indicator = new RocrIndicator { Period = 9 };
|
||||
Assert.Equal(10, indicator.MinHistoryDepths);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Period_CanBeSet()
|
||||
{
|
||||
var indicator = new RocrIndicator { Period = 20 };
|
||||
Assert.Equal(20, indicator.Period);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Source_CanBeSet()
|
||||
{
|
||||
var indicator = new RocrIndicator { Source = SourceType.Open };
|
||||
Assert.Equal(SourceType.Open, indicator.Source);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ShowColdValues_CanBeSet()
|
||||
{
|
||||
var indicator = new RocrIndicator { ShowColdValues = false };
|
||||
Assert.False(indicator.ShowColdValues);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,85 @@
|
||||
using System.Drawing;
|
||||
using TradingPlatform.BusinessLayer;
|
||||
using static QuanTAlib.IndicatorExtensions;
|
||||
|
||||
namespace QuanTAlib;
|
||||
|
||||
/// <summary>
|
||||
/// ROCR (Rate of Change Ratio) Quantower indicator.
|
||||
/// Calculates price ratio over a lookback period.
|
||||
/// Formula: current / past (ratio around 1.0)
|
||||
/// </summary>
|
||||
public class RocrIndicator : Indicator, IWatchlistIndicator
|
||||
{
|
||||
[InputParameter("Period", 0, 1, 999, 1, 0)]
|
||||
public int Period { get; set; } = 9;
|
||||
|
||||
[DataSourceInput]
|
||||
public SourceType Source { get; set; } = SourceType.Close;
|
||||
|
||||
[InputParameter("Show Cold Values", sortIndex: 100)]
|
||||
public bool ShowColdValues { get; set; } = true;
|
||||
|
||||
private Rocr? _rocr;
|
||||
private Func<IHistoryItem, double>? _selector;
|
||||
|
||||
public int MinHistoryDepths => Period + 1;
|
||||
public override string ShortName => $"ROCR({Period})";
|
||||
|
||||
public RocrIndicator()
|
||||
{
|
||||
Name = "ROCR - Rate of Change Ratio";
|
||||
Description = "Calculates price ratio: current / past (ratio around 1.0)";
|
||||
SeparateWindow = true;
|
||||
OnBackGround = false;
|
||||
}
|
||||
|
||||
protected override void OnInit()
|
||||
{
|
||||
_rocr = new Rocr(Period);
|
||||
_selector = Source.GetPriceSelector();
|
||||
|
||||
AddLineSeries(new LineSeries("ROCR", IndicatorExtensions.Momentum, 2, LineStyle.Solid));
|
||||
AddLineSeries(new LineSeries("One", Color.Gray, 1, LineStyle.Dot));
|
||||
}
|
||||
|
||||
protected override void OnUpdate(UpdateArgs args)
|
||||
{
|
||||
if (_rocr == null || _selector == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var item = HistoricalData[0, SeekOriginHistory.End];
|
||||
double value = _selector(item);
|
||||
bool isNew = args.IsNewBar();
|
||||
|
||||
TValue input = new(item.TimeLeft, value);
|
||||
_rocr.Update(input, isNew);
|
||||
|
||||
bool isHot = _rocr.IsHot;
|
||||
|
||||
LinesSeries[0].SetValue(_rocr.Last.Value, isHot, ShowColdValues);
|
||||
LinesSeries[1].SetValue(1.0);
|
||||
|
||||
if (isHot || ShowColdValues)
|
||||
{
|
||||
double rocr = _rocr.Last.Value;
|
||||
Color color;
|
||||
if (rocr > 1.0)
|
||||
{
|
||||
color = Color.Green;
|
||||
}
|
||||
else if (rocr < 1.0)
|
||||
{
|
||||
color = Color.Red;
|
||||
}
|
||||
else
|
||||
{
|
||||
color = Color.Gray;
|
||||
}
|
||||
|
||||
LinesSeries[0].SetMarker(0, new IndicatorLineMarker(color));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,479 @@
|
||||
using Xunit;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public class RocrTests
|
||||
{
|
||||
private readonly TSeries _gbm;
|
||||
private const int TestPeriod = 9;
|
||||
private const int DataPoints = 100;
|
||||
|
||||
public RocrTests()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.0, sigma: 0.5, seed: 42);
|
||||
var bars = gbm.Fetch(DataPoints, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
_gbm = bars.Close;
|
||||
}
|
||||
|
||||
#region Constructor Tests
|
||||
|
||||
[Fact]
|
||||
public void Constructor_WithValidPeriod_SetsProperties()
|
||||
{
|
||||
var rocr = new Rocr(TestPeriod);
|
||||
Assert.Equal($"Rocr({TestPeriod})", rocr.Name);
|
||||
Assert.Equal(TestPeriod + 1, rocr.WarmupPeriod);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_WithZeroPeriod_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Rocr(0));
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_WithNegativePeriod_ThrowsArgumentException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() => new Rocr(-1));
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_WithSource_SubscribesToEvents()
|
||||
{
|
||||
var source = new TSeries(DataPoints);
|
||||
var rocr = new Rocr(source, TestPeriod);
|
||||
Assert.NotNull(rocr);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Basic Calculation Tests
|
||||
|
||||
[Fact]
|
||||
public void Update_ReturnsCorrectValue()
|
||||
{
|
||||
var rocr = new Rocr(TestPeriod);
|
||||
var tv = rocr.Update(new TValue(DateTime.UtcNow, 100.0));
|
||||
Assert.Equal(1.0, tv.Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_FirstValues_ReturnsOne()
|
||||
{
|
||||
var rocr = new Rocr(TestPeriod);
|
||||
for (int i = 0; i < TestPeriod; i++)
|
||||
{
|
||||
var tv = rocr.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i));
|
||||
Assert.Equal(1.0, tv.Value);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_AfterWarmup_ReturnsRatio()
|
||||
{
|
||||
var rocr = new Rocr(2); // period=2
|
||||
var values = new double[] { 100, 102, 105, 103, 110 };
|
||||
|
||||
for (int i = 0; i < values.Length; i++)
|
||||
{
|
||||
var tv = rocr.Update(new TValue(DateTime.UtcNow.AddSeconds(i), values[i]), true);
|
||||
|
||||
if (i < 2)
|
||||
{
|
||||
Assert.Equal(1.0, tv.Value); // warmup period
|
||||
}
|
||||
else
|
||||
{
|
||||
// ratio: current / past
|
||||
double expected = values[i] / values[i - 2];
|
||||
Assert.Equal(expected, tv.Value, 10);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Last_IsAccessible()
|
||||
{
|
||||
var rocr = new Rocr(TestPeriod);
|
||||
rocr.Update(new TValue(DateTime.UtcNow, 100.0));
|
||||
Assert.Equal(1.0, rocr.Last.Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IsHot_ReturnsFalseDuringWarmup()
|
||||
{
|
||||
var rocr = new Rocr(TestPeriod);
|
||||
for (int i = 0; i < TestPeriod; i++)
|
||||
{
|
||||
rocr.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i));
|
||||
Assert.False(rocr.IsHot);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IsHot_ReturnsTrueAfterWarmup()
|
||||
{
|
||||
var rocr = new Rocr(TestPeriod);
|
||||
for (int i = 0; i <= TestPeriod; i++)
|
||||
{
|
||||
rocr.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i));
|
||||
}
|
||||
Assert.True(rocr.IsHot);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Name_IsAccessible()
|
||||
{
|
||||
var rocr = new Rocr(TestPeriod);
|
||||
Assert.Equal($"Rocr({TestPeriod})", rocr.Name);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region State Management Tests
|
||||
|
||||
[Fact]
|
||||
public void Update_WithIsNewTrue_AdvancesState()
|
||||
{
|
||||
var rocr = new Rocr(TestPeriod);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocr.Update(new TValue(time, 100.0), true);
|
||||
rocr.Update(new TValue(time.AddSeconds(1), 105.0), true);
|
||||
rocr.Update(new TValue(time.AddSeconds(2), 110.0), true);
|
||||
|
||||
// state should advance after each true
|
||||
Assert.NotEqual(default, rocr.Last);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_WithIsNewFalse_UpdatesCurrentState()
|
||||
{
|
||||
var rocr = new Rocr(2);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
// Warmup
|
||||
rocr.Update(new TValue(time, 100.0), true);
|
||||
rocr.Update(new TValue(time.AddSeconds(1), 102.0), true);
|
||||
var first = rocr.Update(new TValue(time.AddSeconds(2), 105.0), true);
|
||||
|
||||
// Update same bar with different value
|
||||
var corrected = rocr.Update(new TValue(time.AddSeconds(2), 108.0), false);
|
||||
|
||||
Assert.NotEqual(first.Value, corrected.Value);
|
||||
// first: 105 / 100 = 1.05
|
||||
// corrected: 108 / 100 = 1.08
|
||||
Assert.Equal(1.05, first.Value, 10);
|
||||
Assert.Equal(1.08, corrected.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_IterativeCorrections_RestoresPreviousState()
|
||||
{
|
||||
var rocr = new Rocr(2);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
// Initial values
|
||||
rocr.Update(new TValue(time, 100.0), true);
|
||||
rocr.Update(new TValue(time.AddSeconds(1), 102.0), true);
|
||||
var baseline = rocr.Update(new TValue(time.AddSeconds(2), 105.0), true);
|
||||
|
||||
// Make several corrections
|
||||
rocr.Update(new TValue(time.AddSeconds(2), 108.0), false);
|
||||
rocr.Update(new TValue(time.AddSeconds(2), 110.0), false);
|
||||
var restored = rocr.Update(new TValue(time.AddSeconds(2), 105.0), false);
|
||||
|
||||
// Should match original value
|
||||
Assert.Equal(baseline.Value, restored.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Reset_ClearsStateAndLastValidTracking()
|
||||
{
|
||||
var rocr = new Rocr(TestPeriod);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i <= TestPeriod; i++)
|
||||
{
|
||||
rocr.Update(new TValue(time.AddSeconds(i), 100.0 + i));
|
||||
}
|
||||
|
||||
rocr.Reset();
|
||||
|
||||
Assert.Equal(default, rocr.Last);
|
||||
Assert.False(rocr.IsHot);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Robustness Tests
|
||||
|
||||
[Fact]
|
||||
public void Update_WithNaN_UsesLastValidValue()
|
||||
{
|
||||
var rocr = new Rocr(2);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocr.Update(new TValue(time, 100.0), true);
|
||||
rocr.Update(new TValue(time.AddSeconds(1), 102.0), true);
|
||||
_ = rocr.Update(new TValue(time.AddSeconds(2), 105.0), true);
|
||||
var afterNaN = rocr.Update(new TValue(time.AddSeconds(3), double.NaN), true);
|
||||
|
||||
// NaN should use last valid (105), so ratio is 105 / 102 = 1.0294...
|
||||
Assert.True(double.IsFinite(afterNaN.Value));
|
||||
Assert.Equal(105.0 / 102.0, afterNaN.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_WithInfinity_UsesLastValidValue()
|
||||
{
|
||||
var rocr = new Rocr(2);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocr.Update(new TValue(time, 100.0), true);
|
||||
rocr.Update(new TValue(time.AddSeconds(1), 102.0), true);
|
||||
rocr.Update(new TValue(time.AddSeconds(2), 105.0), true);
|
||||
var afterInf = rocr.Update(new TValue(time.AddSeconds(3), double.PositiveInfinity), true);
|
||||
|
||||
Assert.True(double.IsFinite(afterInf.Value));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_BatchNaN_HandlesSafely()
|
||||
{
|
||||
var rocr = new Rocr(TestPeriod);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
// Insert several NaN values
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
var value = i % 3 == 0 ? double.NaN : 100.0 + i;
|
||||
var tv = rocr.Update(new TValue(time.AddSeconds(i), value), true);
|
||||
Assert.True(double.IsFinite(tv.Value));
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_WithZeroPastValue_ReturnsOne()
|
||||
{
|
||||
var rocr = new Rocr(2);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocr.Update(new TValue(time, 0.0), true); // Value of 0
|
||||
rocr.Update(new TValue(time.AddSeconds(1), 50.0), true);
|
||||
var result = rocr.Update(new TValue(time.AddSeconds(2), 100.0), true);
|
||||
|
||||
// Division by zero: 100 / 0 should return 1.0 as safe default
|
||||
Assert.Equal(1.0, result.Value);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Consistency Tests (All 4 modes must match)
|
||||
|
||||
[Fact]
|
||||
public void AllModes_ProduceSameResults()
|
||||
{
|
||||
// Mode 1: Batch via TSeries
|
||||
var batchResult = Rocr.Calculate(_gbm, TestPeriod);
|
||||
|
||||
// Mode 2: Streaming
|
||||
var streamingRocr = new Rocr(TestPeriod);
|
||||
var streamingResult = new TSeries(DataPoints);
|
||||
for (int i = 0; i < _gbm.Count; i++)
|
||||
{
|
||||
var tv = streamingRocr.Update(new TValue(_gbm[i].Time, _gbm[i].Value), true);
|
||||
streamingResult.Add(tv, true);
|
||||
}
|
||||
|
||||
// Mode 3: Span-based
|
||||
Span<double> spanOutput = stackalloc double[DataPoints];
|
||||
Rocr.Calculate(_gbm.Values, spanOutput, TestPeriod);
|
||||
|
||||
// Mode 4: Event-driven
|
||||
var eventRocr = new Rocr(TestPeriod);
|
||||
var eventResult = new TSeries(DataPoints);
|
||||
eventRocr.Pub += (object? _, in TValueEventArgs e) => eventResult.Add(e.Value, e.IsNew);
|
||||
for (int i = 0; i < _gbm.Count; i++)
|
||||
{
|
||||
eventRocr.Update(new TValue(_gbm[i].Time, _gbm[i].Value), true);
|
||||
}
|
||||
|
||||
// Compare last 100 values (or all if fewer)
|
||||
int compareCount = Math.Min(100, DataPoints);
|
||||
for (int i = DataPoints - compareCount; i < DataPoints; i++)
|
||||
{
|
||||
Assert.Equal(batchResult[i].Value, streamingResult[i].Value, 10);
|
||||
Assert.Equal(batchResult[i].Value, spanOutput[i], 10);
|
||||
Assert.Equal(batchResult[i].Value, eventResult[i].Value, 10);
|
||||
}
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Span API Tests
|
||||
|
||||
[Fact]
|
||||
public void Calculate_Span_ValidatesEmptySource()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() =>
|
||||
{
|
||||
ReadOnlySpan<double> empty = [];
|
||||
Span<double> output = stackalloc double[1];
|
||||
Rocr.Calculate(empty, output, TestPeriod);
|
||||
});
|
||||
Assert.Equal("source", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calculate_Span_ValidatesOutputLength()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() =>
|
||||
{
|
||||
ReadOnlySpan<double> source = stackalloc double[] { 1, 2, 3, 4, 5 };
|
||||
Span<double> output = stackalloc double[3]; // too short
|
||||
Rocr.Calculate(source, output, TestPeriod);
|
||||
});
|
||||
Assert.Equal("output", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calculate_Span_ValidatesPeriod()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentException>(() =>
|
||||
{
|
||||
ReadOnlySpan<double> source = stackalloc double[] { 1, 2, 3, 4, 5 };
|
||||
Span<double> output = stackalloc double[5];
|
||||
Rocr.Calculate(source, output, 0);
|
||||
});
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calculate_Span_MatchesTSeries()
|
||||
{
|
||||
var batchResult = Rocr.Calculate(_gbm, TestPeriod);
|
||||
|
||||
Span<double> spanOutput = stackalloc double[DataPoints];
|
||||
Rocr.Calculate(_gbm.Values, spanOutput, TestPeriod);
|
||||
|
||||
for (int i = 0; i < DataPoints; i++)
|
||||
{
|
||||
Assert.Equal(batchResult[i].Value, spanOutput[i], 10);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calculate_Span_HandlesZeroDivision()
|
||||
{
|
||||
double[] source = [0, 100, 102, 103, 104];
|
||||
Span<double> output = stackalloc double[5];
|
||||
|
||||
// Should not throw
|
||||
Rocr.Calculate(source, output, 2);
|
||||
|
||||
// First element after warmup divides by 0
|
||||
Assert.Equal(1.0, output[2]); // 102 / 0 = 1.0 (safe default)
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calculate_Span_LargeData_NoStackOverflow()
|
||||
{
|
||||
int largeSize = 10000;
|
||||
double[] source = new double[largeSize];
|
||||
double[] output = new double[largeSize];
|
||||
|
||||
for (int i = 0; i < largeSize; i++)
|
||||
{
|
||||
source[i] = 100.0 + i * 0.1;
|
||||
}
|
||||
|
||||
// Should not throw
|
||||
Rocr.Calculate(source, output, TestPeriod);
|
||||
|
||||
Assert.Equal(largeSize, output.Length);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Chainability Tests
|
||||
|
||||
[Fact]
|
||||
public void Pub_FiresOnUpdate()
|
||||
{
|
||||
var rocr = new Rocr(TestPeriod);
|
||||
bool eventFired = false;
|
||||
|
||||
rocr.Pub += (object? _, in TValueEventArgs e) => eventFired = true;
|
||||
rocr.Update(new TValue(DateTime.UtcNow, 100.0));
|
||||
|
||||
Assert.True(eventFired);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EventBasedChaining_Works()
|
||||
{
|
||||
var source = new TSeries(10);
|
||||
var rocr = new Rocr(source, 2);
|
||||
var results = new List<double>();
|
||||
|
||||
rocr.Pub += (object? _, in TValueEventArgs e) => results.Add(e.Value.Value);
|
||||
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
source.Add(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i), true);
|
||||
}
|
||||
|
||||
Assert.Equal(10, results.Count);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Mathematical Properties Tests
|
||||
|
||||
[Fact]
|
||||
public void Update_PriceDoubled_ReturnsTwo()
|
||||
{
|
||||
var rocr = new Rocr(2);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocr.Update(new TValue(time, 50.0), true);
|
||||
rocr.Update(new TValue(time.AddSeconds(1), 60.0), true);
|
||||
var result = rocr.Update(new TValue(time.AddSeconds(2), 100.0), true);
|
||||
|
||||
// 100 / 50 = 2.0
|
||||
Assert.Equal(2.0, result.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_PriceHalved_ReturnsPointFive()
|
||||
{
|
||||
var rocr = new Rocr(2);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocr.Update(new TValue(time, 100.0), true);
|
||||
rocr.Update(new TValue(time.AddSeconds(1), 80.0), true);
|
||||
var result = rocr.Update(new TValue(time.AddSeconds(2), 50.0), true);
|
||||
|
||||
// 50 / 100 = 0.5
|
||||
Assert.Equal(0.5, result.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_NoChange_ReturnsOne()
|
||||
{
|
||||
var rocr = new Rocr(2);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocr.Update(new TValue(time, 100.0), true);
|
||||
rocr.Update(new TValue(time.AddSeconds(1), 105.0), true);
|
||||
var result = rocr.Update(new TValue(time.AddSeconds(2), 100.0), true);
|
||||
|
||||
// 100 / 100 = 1.0
|
||||
Assert.Equal(1.0, result.Value, 10);
|
||||
}
|
||||
|
||||
#endregion
|
||||
}
|
||||
@@ -0,0 +1,240 @@
|
||||
using Xunit;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public class RocrValidationTests
|
||||
{
|
||||
private const double Epsilon = 1e-10;
|
||||
|
||||
#region Mathematical Validation
|
||||
|
||||
[Fact]
|
||||
public void Rocr_ManualCalculation_MatchesExpected()
|
||||
{
|
||||
// Manual test: ROCR = current / past
|
||||
var rocr = new Rocr(3);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
var values = new double[] { 100, 105, 110, 115, 120, 125 };
|
||||
|
||||
for (int i = 0; i < values.Length; i++)
|
||||
{
|
||||
var result = rocr.Update(new TValue(time.AddSeconds(i), values[i]), true);
|
||||
|
||||
if (i >= 3)
|
||||
{
|
||||
// After warmup, should return ratio
|
||||
double expected = values[i] / values[i - 3];
|
||||
Assert.Equal(expected, result.Value, 10);
|
||||
}
|
||||
else
|
||||
{
|
||||
// During warmup, should return 1.0
|
||||
Assert.Equal(1.0, result.Value, 10);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Rocr_TenPercentIncrease_Returns1Point1()
|
||||
{
|
||||
var rocr = new Rocr(1); // 1-period lookback
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocr.Update(new TValue(time, 100.0), true);
|
||||
var result = rocr.Update(new TValue(time.AddSeconds(1), 110.0), true);
|
||||
|
||||
// 110 / 100 = 1.10
|
||||
Assert.Equal(1.10, result.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Rocr_TenPercentDecrease_Returns0Point9()
|
||||
{
|
||||
var rocr = new Rocr(1);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocr.Update(new TValue(time, 100.0), true);
|
||||
var result = rocr.Update(new TValue(time.AddSeconds(1), 90.0), true);
|
||||
|
||||
// 90 / 100 = 0.90
|
||||
Assert.Equal(0.90, result.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Rocr_ConversionToRocp_IsCorrect()
|
||||
{
|
||||
// ROCP = (ROCR - 1) * 100
|
||||
var rocr = new Rocr(1);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocr.Update(new TValue(time, 100.0), true);
|
||||
var result = rocr.Update(new TValue(time.AddSeconds(1), 115.0), true);
|
||||
|
||||
double rocp = (result.Value - 1.0) * 100.0;
|
||||
// 115/100 = 1.15, ROCP = (1.15 - 1) * 100 = 15%
|
||||
Assert.Equal(15.0, rocp, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Rocr_ConversionFromChange_IsCorrect()
|
||||
{
|
||||
// CHANGE = (current - past) / past = ROCR - 1
|
||||
var rocr = new Rocr(1);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocr.Update(new TValue(time, 100.0), true);
|
||||
var result = rocr.Update(new TValue(time.AddSeconds(1), 125.0), true);
|
||||
|
||||
double change = result.Value - 1.0;
|
||||
// 125/100 = 1.25, CHANGE = 0.25 = 25% increase
|
||||
Assert.Equal(0.25, change, 10);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Relationship to ROC
|
||||
|
||||
[Fact]
|
||||
public void Rocr_RelationshipToRoc_IsCorrect()
|
||||
{
|
||||
// ROC = current - past
|
||||
// ROCR = current / past
|
||||
// If we know ROC and past, we can verify: ROCR = (ROC + past) / past = 1 + ROC/past
|
||||
|
||||
var rocr = new Rocr(2);
|
||||
var roc = new Roc(2);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
var values = new double[] { 100, 105, 110, 120, 115 };
|
||||
|
||||
for (int i = 0; i < values.Length; i++)
|
||||
{
|
||||
rocr.Update(new TValue(time.AddSeconds(i), values[i]), true);
|
||||
roc.Update(new TValue(time.AddSeconds(i), values[i]), true);
|
||||
}
|
||||
|
||||
// For last value: ROCR = current/past, ROC = current - past
|
||||
// past = values[3] = 110, current = values[4] = 115
|
||||
// ROCR = 115/110, ROC = 115 - 110 = 5
|
||||
// Relationship: ROCR = (past + ROC) / past = 1 + ROC/past
|
||||
double expectedRelationship = 1.0 + roc.Last.Value / values[2];
|
||||
Assert.Equal(expectedRelationship, rocr.Last.Value, 10);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Compounding Property
|
||||
|
||||
[Fact]
|
||||
public void Rocr_Compounding_MultiplyForTotalChange()
|
||||
{
|
||||
// ROCR values can be multiplied to get total change
|
||||
var rocr = new Rocr(1);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
var values = new double[] { 100, 110, 121, 133.1 }; // ~10% increase each period
|
||||
double compound = 1.0;
|
||||
|
||||
for (int i = 0; i < values.Length; i++)
|
||||
{
|
||||
var result = rocr.Update(new TValue(time.AddSeconds(i), values[i]), true);
|
||||
if (i > 0)
|
||||
{
|
||||
compound *= result.Value;
|
||||
}
|
||||
}
|
||||
|
||||
// Total change from 100 to 133.1 = 1.331
|
||||
double expectedTotal = values[^1] / values[0];
|
||||
Assert.Equal(expectedTotal, compound, 5);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Edge Cases
|
||||
|
||||
[Fact]
|
||||
public void Rocr_SmallValues_MaintainsPrecision()
|
||||
{
|
||||
var rocr = new Rocr(1);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocr.Update(new TValue(time, 0.0001), true);
|
||||
var result = rocr.Update(new TValue(time.AddSeconds(1), 0.00015), true);
|
||||
|
||||
// 0.00015 / 0.0001 = 1.5
|
||||
Assert.Equal(1.5, result.Value, 5);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Rocr_LargeValues_MaintainsPrecision()
|
||||
{
|
||||
var rocr = new Rocr(1);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocr.Update(new TValue(time, 1_000_000), true);
|
||||
var result = rocr.Update(new TValue(time.AddSeconds(1), 1_100_000), true);
|
||||
|
||||
// 1_100_000 / 1_000_000 = 1.1
|
||||
Assert.Equal(1.1, result.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Rocr_NegativeValues_HandlesCorrectly()
|
||||
{
|
||||
// Negative values can occur in spreads, basis, etc.
|
||||
var rocr = new Rocr(1);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocr.Update(new TValue(time, -100.0), true);
|
||||
var result = rocr.Update(new TValue(time.AddSeconds(1), -50.0), true);
|
||||
|
||||
// -50 / -100 = 0.5
|
||||
Assert.Equal(0.5, result.Value, 10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Rocr_MixedSigns_HandlesCorrectly()
|
||||
{
|
||||
var rocr = new Rocr(1);
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
rocr.Update(new TValue(time, -100.0), true);
|
||||
var result = rocr.Update(new TValue(time.AddSeconds(1), 100.0), true);
|
||||
|
||||
// 100 / -100 = -1.0
|
||||
Assert.Equal(-1.0, result.Value, 10);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Batch vs Streaming Consistency
|
||||
|
||||
[Fact]
|
||||
public void Batch_MatchesStreaming_IdenticalResults()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.0, sigma: 0.5, seed: 42);
|
||||
var bars = gbm.Fetch(50, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
var source = bars.Close;
|
||||
|
||||
// Streaming
|
||||
var streamingRocr = new Rocr(5);
|
||||
var streamingResults = new List<double>();
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
var tv = streamingRocr.Update(new TValue(source[i].Time, source[i].Value), true);
|
||||
streamingResults.Add(tv.Value);
|
||||
}
|
||||
|
||||
// Batch
|
||||
var batchResult = Rocr.Calculate(source, 5);
|
||||
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
Assert.Equal(batchResult[i].Value, streamingResults[i], 10);
|
||||
}
|
||||
}
|
||||
|
||||
#endregion
|
||||
}
|
||||
@@ -0,0 +1,179 @@
|
||||
using System.Runtime.CompilerServices;
|
||||
|
||||
namespace QuanTAlib;
|
||||
|
||||
/// <summary>
|
||||
/// ROCR: Rate of Change Ratio
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Price ratio momentum: ratio between current and N-period-ago value.
|
||||
/// Returns 1.0 for no change, greater than 1 for increase, less than 1 for decrease.
|
||||
/// See ROC for absolute change, ROCP for percentage.
|
||||
///
|
||||
/// Calculation: <c>ROCR = Price / Price[N]</c>.
|
||||
/// </remarks>
|
||||
/// <seealso href="Rocr.md">Detailed documentation</seealso>
|
||||
[SkipLocalsInit]
|
||||
public sealed class Rocr : AbstractBase
|
||||
{
|
||||
private readonly int _period;
|
||||
private readonly RingBuffer _buffer;
|
||||
private record struct State(double LastValid);
|
||||
private State _state, _p_state;
|
||||
private ITValuePublisher? _source;
|
||||
private bool _disposed;
|
||||
|
||||
public override bool IsHot => _buffer.Count > _period;
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new Rate of Change Ratio indicator with specified lookback period.
|
||||
/// </summary>
|
||||
/// <param name="period">Lookback period (must be >= 1)</param>
|
||||
public Rocr(int period = 9)
|
||||
{
|
||||
if (period < 1)
|
||||
{
|
||||
throw new ArgumentException("Period must be >= 1", nameof(period));
|
||||
}
|
||||
|
||||
_period = period;
|
||||
_buffer = new RingBuffer(period + 1);
|
||||
Name = $"Rocr({period})";
|
||||
WarmupPeriod = period + 1;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new Rate of Change Ratio indicator with source for event-based chaining.
|
||||
/// </summary>
|
||||
/// <param name="source">Source indicator for chaining</param>
|
||||
/// <param name="period">Lookback period</param>
|
||||
public Rocr(ITValuePublisher source, int period = 9) : this(period)
|
||||
{
|
||||
_source = source;
|
||||
_source.Pub += HandleUpdate;
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
private void HandleUpdate(object? sender, in TValueEventArgs e) => Update(e.Value, e.IsNew);
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
public override TValue Update(TValue input, bool isNew = true)
|
||||
{
|
||||
if (isNew)
|
||||
{
|
||||
_p_state = _state;
|
||||
}
|
||||
else
|
||||
{
|
||||
_state = _p_state;
|
||||
}
|
||||
|
||||
double value = double.IsFinite(input.Value) ? input.Value : _state.LastValid;
|
||||
_state = new State(value);
|
||||
|
||||
_buffer.Add(value, isNew);
|
||||
|
||||
double result;
|
||||
if (_buffer.Count <= _period)
|
||||
{
|
||||
result = 1.0; // Default ratio during warmup
|
||||
}
|
||||
else
|
||||
{
|
||||
double past = _buffer[0];
|
||||
result = past != 0 ? value / past : 1.0; // Avoid division by zero
|
||||
}
|
||||
|
||||
Last = new TValue(input.Time, result);
|
||||
PubEvent(Last, isNew);
|
||||
return Last;
|
||||
}
|
||||
|
||||
public override TSeries Update(TSeries source)
|
||||
{
|
||||
var result = new TSeries(source.Count);
|
||||
ReadOnlySpan<double> values = source.Values;
|
||||
ReadOnlySpan<long> times = source.Times;
|
||||
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
var tv = Update(new TValue(new DateTime(times[i], DateTimeKind.Utc), values[i]), true);
|
||||
result.Add(tv, true);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public override void Prime(ReadOnlySpan<double> source, TimeSpan? step = null)
|
||||
{
|
||||
TimeSpan interval = step ?? TimeSpan.FromSeconds(1);
|
||||
DateTime time = DateTime.UtcNow - (interval * source.Length);
|
||||
|
||||
for (int i = 0; i < source.Length; i++)
|
||||
{
|
||||
Update(new TValue(time, source[i]), true);
|
||||
time += interval;
|
||||
}
|
||||
}
|
||||
|
||||
public static TSeries Calculate(TSeries source, int period = 9)
|
||||
{
|
||||
var indicator = new Rocr(period);
|
||||
return indicator.Update(source);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Calculates rate of change ratio over a span of values.
|
||||
/// </summary>
|
||||
public static void Calculate(ReadOnlySpan<double> source, Span<double> output, int period = 9)
|
||||
{
|
||||
if (source.Length == 0)
|
||||
{
|
||||
throw new ArgumentException("Source cannot be empty", nameof(source));
|
||||
}
|
||||
|
||||
if (output.Length < source.Length)
|
||||
{
|
||||
throw new ArgumentException("Output length must be >= source length", nameof(output));
|
||||
}
|
||||
|
||||
if (period < 1)
|
||||
{
|
||||
throw new ArgumentException("Period must be >= 1", nameof(period));
|
||||
}
|
||||
|
||||
for (int i = 0; i < source.Length; i++)
|
||||
{
|
||||
if (i < period)
|
||||
{
|
||||
output[i] = 1.0; // Default ratio during warmup
|
||||
}
|
||||
else
|
||||
{
|
||||
double past = source[i - period];
|
||||
output[i] = past != 0 ? source[i] / past : 1.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public override void Reset()
|
||||
{
|
||||
_buffer.Clear();
|
||||
_state = default;
|
||||
_p_state = default;
|
||||
Last = default;
|
||||
}
|
||||
|
||||
protected override void Dispose(bool disposing)
|
||||
{
|
||||
if (!_disposed)
|
||||
{
|
||||
if (disposing && _source != null)
|
||||
{
|
||||
_source.Pub -= HandleUpdate;
|
||||
_source = null;
|
||||
}
|
||||
_disposed = true;
|
||||
}
|
||||
base.Dispose(disposing);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,146 @@
|
||||
# ROCR: Rate of Change Ratio
|
||||
|
||||
> "The ratio form of momentum: how many times larger is the current price compared to the past? A multiplier view of market movement."
|
||||
|
||||
ROCR (Rate of Change Ratio) calculates the ratio between the current value and the value N periods ago. Values hover around 1.0, with values above 1.0 indicating price increase and values below 1.0 indicating price decrease. Unlike ROC (absolute) or ROCP (percentage), ROCR provides a dimensionless multiplier that directly shows the price ratio.
|
||||
|
||||
## Historical Context
|
||||
|
||||
ROCR belongs to the family of momentum indicators that measure price change over time. The ratio form is particularly useful when comparing relative movements across instruments with different price scales. The terminology varies by platform and library:
|
||||
|
||||
- **TA-Lib**: Uses `ROCR` for ratio (price / past_price)
|
||||
- **Tulip**: Uses `ROCR` for ratio
|
||||
- **TradingView/PineScript**: Uses `source / source[n]` pattern
|
||||
- **QuanTAlib**: Uses `ROCR` for ratio, `ROC` for absolute, `ROCP` for percentage
|
||||
|
||||
## Architecture & Physics
|
||||
|
||||
### 1. Ring Buffer Storage
|
||||
|
||||
The indicator maintains a sliding window of `period + 1` values:
|
||||
|
||||
$$
|
||||
\text{buffer} = [v_{t-n}, v_{t-n+1}, ..., v_{t-1}, v_t]
|
||||
$$
|
||||
|
||||
where $n$ is the lookback period. Only the oldest and newest values are needed for calculation.
|
||||
|
||||
### 2. Ratio Calculation
|
||||
|
||||
$$
|
||||
\text{ROCR}_t = \frac{v_t}{v_{t-n}}
|
||||
$$
|
||||
|
||||
where:
|
||||
- $v_t$ = current value
|
||||
- $v_{t-n}$ = value from $n$ periods ago
|
||||
- Result is dimensionless (ratio around 1.0)
|
||||
|
||||
### 3. State Management
|
||||
|
||||
The indicator uses state rollback for bar correction:
|
||||
|
||||
```
|
||||
if isNew:
|
||||
save current state as previous
|
||||
else:
|
||||
restore previous state
|
||||
```
|
||||
|
||||
This enables real-time bar updates without corrupting historical calculations.
|
||||
|
||||
## Mathematical Foundation
|
||||
|
||||
### Core Formula
|
||||
|
||||
$$
|
||||
\text{ROCR}_t = \frac{P_t}{P_{t-n}}
|
||||
$$
|
||||
|
||||
### Relationship to Other Rate of Change Variants
|
||||
|
||||
| Indicator | Formula | Output |
|
||||
|-----------|---------|--------|
|
||||
| **ROC** | $P_t - P_{t-n}$ | Absolute (price units) |
|
||||
| **ROCP** | $\frac{P_t - P_{t-n}}{P_{t-n}} \times 100$ | Percentage (%) |
|
||||
| **ROCR** | $\frac{P_t}{P_{t-n}}$ | Ratio (dimensionless) |
|
||||
| **CHANGE** | $\frac{P_t - P_{t-n}}{P_{t-n}}$ | Decimal (0.10 = 10%) |
|
||||
|
||||
### Conversions
|
||||
|
||||
$$
|
||||
\text{ROCR} = \text{CHANGE} + 1 = \frac{P_t}{P_{t-n}}
|
||||
$$
|
||||
|
||||
$$
|
||||
\text{ROCP} = (\text{ROCR} - 1) \times 100
|
||||
$$
|
||||
|
||||
$$
|
||||
\text{CHANGE} = \text{ROCR} - 1
|
||||
$$
|
||||
|
||||
## Performance Profile
|
||||
|
||||
### Operation Count (Streaming Mode)
|
||||
|
||||
| Operation | Count | Notes |
|
||||
| :--- | :---: | :--- |
|
||||
| DIV | 1 | current / past |
|
||||
| Buffer add | 1 | O(1) ring buffer |
|
||||
| State copy | 1 | rollback support |
|
||||
| Zero check | 1 | division safety |
|
||||
| **Total** | **~4 ops** | Very lightweight |
|
||||
|
||||
### Batch Mode (Span-based)
|
||||
|
||||
The span-based calculation is a simple loop with no dependencies between iterations.
|
||||
|
||||
| Operation | Complexity | Notes |
|
||||
| :--- | :---: | :--- |
|
||||
| Per-element | O(1) | Single division |
|
||||
| Total | O(n) | Linear scan |
|
||||
| Memory | O(1) | No additional allocation |
|
||||
|
||||
### Quality Metrics
|
||||
|
||||
| Metric | Score | Notes |
|
||||
| :--- | :---: | :--- |
|
||||
| **Accuracy** | 10/10 | Exact arithmetic, no approximation |
|
||||
| **Timeliness** | 10/10 | Zero lag by definition |
|
||||
| **Smoothness** | 3/10 | No smoothing, reflects raw volatility |
|
||||
| **Simplicity** | 10/10 | Single division |
|
||||
|
||||
## Interpretation
|
||||
|
||||
* **ROCR = 1.0**: No change from N periods ago
|
||||
* **ROCR > 1.0**: Price increased (e.g., 1.05 = 5% increase)
|
||||
* **ROCR < 1.0**: Price decreased (e.g., 0.95 = 5% decrease)
|
||||
* **ROCR = 2.0**: Price doubled
|
||||
* **ROCR = 0.5**: Price halved
|
||||
|
||||
## Validation
|
||||
|
||||
| Library | Status | Notes |
|
||||
| :--- | :---: | :--- |
|
||||
| **TA-Lib** | ✅ | ROCR matches exactly |
|
||||
| **Tulip** | ✅ | Matches ratio calculation |
|
||||
| **TradingView** | ✅ | Matches PineScript division |
|
||||
|
||||
## Common Pitfalls
|
||||
|
||||
1. **Value interpretation**: ROCR returns values around 1.0, not percentages. A ROCR of 1.05 means 5% increase, not 105% increase.
|
||||
|
||||
2. **Division by zero**: If the historical price is zero, ROCR returns 1.0 as a safe default.
|
||||
|
||||
3. **Warmup period**: The first `period` values return 1.0 as there's no historical reference point.
|
||||
|
||||
4. **Scale invariance**: ROCR is comparable across instruments since it's a ratio.
|
||||
|
||||
5. **Compounding**: ROCR values can be multiplied across periods: total_change = ROCR_1 × ROCR_2 × ...
|
||||
|
||||
## References
|
||||
|
||||
- Pring, M. J. (2014). "Technical Analysis Explained." McGraw-Hill.
|
||||
- Murphy, J. J. (1999). "Technical Analysis of the Financial Markets." New York Institute of Finance.
|
||||
- TA-Lib Documentation: ROCR function
|
||||
@@ -0,0 +1,108 @@
|
||||
using TradingPlatform.BusinessLayer;
|
||||
using Xunit;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public class TsiIndicatorTests
|
||||
{
|
||||
[Fact]
|
||||
public void Indicator_DefaultConstruction()
|
||||
{
|
||||
var indicator = new TsiIndicator();
|
||||
Assert.NotNull(indicator);
|
||||
Assert.Equal("TSI - True Strength Index", indicator.Name);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Indicator_DefaultParameters()
|
||||
{
|
||||
var indicator = new TsiIndicator();
|
||||
Assert.Equal(25, indicator.LongPeriod);
|
||||
Assert.Equal(13, indicator.ShortPeriod);
|
||||
Assert.Equal(13, indicator.SignalPeriod);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Indicator_MinHistoryDepths()
|
||||
{
|
||||
// MinHistoryDepths is static
|
||||
Assert.Equal(0, TsiIndicator.MinHistoryDepths);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Indicator_CustomParameters()
|
||||
{
|
||||
var indicator = new TsiIndicator { LongPeriod = 20, ShortPeriod = 10, SignalPeriod = 7 };
|
||||
Assert.Equal(20, indicator.LongPeriod);
|
||||
Assert.Equal(10, indicator.ShortPeriod);
|
||||
Assert.Equal(7, indicator.SignalPeriod);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Indicator_UsesTsiCore()
|
||||
{
|
||||
var indicator = new TsiIndicator();
|
||||
Assert.Equal(25, indicator.LongPeriod);
|
||||
Assert.Equal(13, indicator.ShortPeriod);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Indicator_CalculatesCorrectly()
|
||||
{
|
||||
var core = new Tsi(5, 3, 3);
|
||||
|
||||
// Feed rising prices
|
||||
var prices = new double[] { 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
|
||||
111, 112, 113, 114, 115, 116, 117, 118, 119, 120 };
|
||||
|
||||
foreach (var price in prices)
|
||||
{
|
||||
core.Update(new TValue(DateTime.Now, price));
|
||||
}
|
||||
|
||||
// TSI should be positive for rising prices
|
||||
Assert.True(core.Last.Value > 0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Indicator_ShortName_ContainsParameters()
|
||||
{
|
||||
var indicator = new TsiIndicator { LongPeriod = 20, ShortPeriod = 10, SignalPeriod = 7 };
|
||||
|
||||
// ShortName is computed property, just verify it returns non-empty
|
||||
Assert.NotNull(indicator.ShortName);
|
||||
Assert.NotEmpty(indicator.ShortName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Indicator_HasSignalLine()
|
||||
{
|
||||
var core = new Tsi(5, 3, 3);
|
||||
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
core.Update(new TValue(DateTime.Now.AddMinutes(i), 100.0 + i * 0.5));
|
||||
}
|
||||
|
||||
// Signal property should return signal line value
|
||||
Assert.True(!double.IsNaN(core.Signal));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Indicator_OutputBounded()
|
||||
{
|
||||
var core = new Tsi(5, 3, 3);
|
||||
var random = new Random(42);
|
||||
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
double price = 100.0 + random.NextDouble() * 50;
|
||||
core.Update(new TValue(DateTime.Now.AddMinutes(i), price));
|
||||
|
||||
// TSI must be bounded [-100, 100]
|
||||
Assert.True(core.Last.Value >= -100.0 && core.Last.Value <= 100.0);
|
||||
// Signal must be bounded too
|
||||
Assert.True(core.Signal >= -100.0 && core.Signal <= 100.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
using System.Drawing;
|
||||
using System.Runtime.CompilerServices;
|
||||
using TradingPlatform.BusinessLayer;
|
||||
|
||||
namespace QuanTAlib;
|
||||
|
||||
[SkipLocalsInit]
|
||||
public sealed class TsiIndicator : Indicator, IWatchlistIndicator
|
||||
{
|
||||
[InputParameter("Long Period", sortIndex: 1, 1, 500, 1, 0)]
|
||||
public int LongPeriod { get; set; } = 25;
|
||||
|
||||
[InputParameter("Short Period", sortIndex: 2, 1, 100, 1, 0)]
|
||||
public int ShortPeriod { get; set; } = 13;
|
||||
|
||||
[InputParameter("Signal Period", sortIndex: 3, 1, 100, 1, 0)]
|
||||
public int SignalPeriod { get; set; } = 13;
|
||||
|
||||
[IndicatorExtensions.DataSourceInput]
|
||||
public SourceType Source { get; set; } = SourceType.Close;
|
||||
|
||||
[InputParameter("Show cold values", sortIndex: 21)]
|
||||
public bool ShowColdValues { get; set; } = true;
|
||||
|
||||
private Tsi _tsi = null!;
|
||||
private readonly LineSeries _series;
|
||||
private readonly LineSeries _signalSeries;
|
||||
private string _sourceName = null!;
|
||||
private Func<IHistoryItem, double> _priceSelector = null!;
|
||||
|
||||
public static int MinHistoryDepths => 0;
|
||||
int IWatchlistIndicator.MinHistoryDepths => MinHistoryDepths;
|
||||
|
||||
public override string ShortName => $"TSI({LongPeriod},{ShortPeriod},{SignalPeriod}):{_sourceName}";
|
||||
public override string SourceCodeLink => "https://github.com/mihakralj/QuanTAlib/blob/main/lib/momentum/tsi/Tsi.Quantower.cs";
|
||||
|
||||
public TsiIndicator()
|
||||
{
|
||||
OnBackGround = true;
|
||||
SeparateWindow = true;
|
||||
_sourceName = Source.ToString();
|
||||
Name = "TSI - True Strength Index";
|
||||
Description = "Momentum oscillator using double-smoothed EMA of price momentum";
|
||||
|
||||
_series = new LineSeries(name: "TSI", color: Color.Blue, width: 2, style: LineStyle.Solid);
|
||||
_signalSeries = new LineSeries(name: "Signal", color: Color.Red, width: 1, style: LineStyle.Solid);
|
||||
AddLineSeries(_series);
|
||||
AddLineSeries(_signalSeries);
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
protected override void OnInit()
|
||||
{
|
||||
_tsi = new Tsi(LongPeriod, ShortPeriod, SignalPeriod);
|
||||
_sourceName = Source.ToString();
|
||||
_priceSelector = Source.GetPriceSelector();
|
||||
base.OnInit();
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
protected override void OnUpdate(UpdateArgs args)
|
||||
{
|
||||
TValue result = _tsi.Update(new TValue(this.GetInputBar(args).Time, _priceSelector(HistoricalData[Count - 1, SeekOriginHistory.Begin])), args.IsNewBar());
|
||||
|
||||
_series.SetValue(result.Value, _tsi.IsHot, ShowColdValues);
|
||||
_series.SetMarker(0, Color.Transparent);
|
||||
|
||||
_signalSeries.SetValue(_tsi.Signal, _tsi.IsHot, ShowColdValues);
|
||||
_signalSeries.SetMarker(0, Color.Transparent);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,486 @@
|
||||
using Xunit;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public class TsiTests
|
||||
{
|
||||
private const double Epsilon = 1e-10;
|
||||
|
||||
// ==================== CONSTRUCTION ====================
|
||||
[Fact]
|
||||
public void Constructor_DefaultParameters()
|
||||
{
|
||||
var tsi = new Tsi();
|
||||
Assert.Equal("Tsi(25,13,13)", tsi.Name);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_CustomParameters()
|
||||
{
|
||||
var tsi = new Tsi(20, 10, 7);
|
||||
Assert.Equal("Tsi(20,10,7)", tsi.Name);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_MinimumPeriod()
|
||||
{
|
||||
var tsi = new Tsi(1, 1, 1);
|
||||
Assert.Equal("Tsi(1,1,1)", tsi.Name);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_ZeroLongPeriod_ThrowsException()
|
||||
{
|
||||
Assert.Throws<ArgumentException>(() => new Tsi(0, 13, 13));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_ZeroShortPeriod_ThrowsException()
|
||||
{
|
||||
Assert.Throws<ArgumentException>(() => new Tsi(25, 0, 13));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_ZeroSignalPeriod_ThrowsException()
|
||||
{
|
||||
Assert.Throws<ArgumentException>(() => new Tsi(25, 13, 0));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_NegativePeriods_ThrowsException()
|
||||
{
|
||||
Assert.Throws<ArgumentException>(() => new Tsi(-25, 13, 13));
|
||||
Assert.Throws<ArgumentException>(() => new Tsi(25, -13, 13));
|
||||
Assert.Throws<ArgumentException>(() => new Tsi(25, 13, -13));
|
||||
}
|
||||
|
||||
// ==================== BASIC CALCULATIONS ====================
|
||||
[Fact]
|
||||
public void Update_ConstantPrice_ZeroTsi()
|
||||
{
|
||||
var tsi = new Tsi(3, 2, 2);
|
||||
double constantPrice = 100.0;
|
||||
|
||||
// Feed constant prices
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), constantPrice));
|
||||
}
|
||||
|
||||
// TSI should be 0 when no price change
|
||||
Assert.True(Math.Abs(tsi.Last.Value) < 1.0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_RisingPrices_PositiveTsi()
|
||||
{
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
|
||||
// Feed rising prices
|
||||
for (int i = 0; i < 30; i++)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), 100.0 + i));
|
||||
}
|
||||
|
||||
// TSI should be positive (approaching +100) for consistent rising prices
|
||||
Assert.True(tsi.Last.Value > 50);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_FallingPrices_NegativeTsi()
|
||||
{
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
|
||||
// Feed falling prices
|
||||
for (int i = 0; i < 30; i++)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), 200.0 - i));
|
||||
}
|
||||
|
||||
// TSI should be negative (approaching -100) for consistent falling prices
|
||||
Assert.True(tsi.Last.Value < -50);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_BoundedOutput()
|
||||
{
|
||||
var tsi = new Tsi(3, 2, 2);
|
||||
var random = new Random(42);
|
||||
|
||||
// Feed random prices
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
double price = 100.0 + random.NextDouble() * 50 - 25;
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), price));
|
||||
|
||||
// TSI should always be between -100 and +100
|
||||
Assert.True(tsi.Last.Value >= -100.0 && tsi.Last.Value <= 100.0);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Signal_PropertyReturnsSignalLine()
|
||||
{
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), 100.0 + i * 0.5));
|
||||
}
|
||||
|
||||
// Signal should be a smoothed version of TSI
|
||||
// It should exist and be within TSI range
|
||||
Assert.True(tsi.Signal >= -100.0 && tsi.Signal <= 100.0);
|
||||
}
|
||||
|
||||
// ==================== IsHot ====================
|
||||
[Fact]
|
||||
public void IsHot_InitiallyFalse()
|
||||
{
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
Assert.False(tsi.IsHot);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IsHot_TrueAfterWarmup()
|
||||
{
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
|
||||
// Feed enough data to warm up all EMAs
|
||||
for (int i = 0; i < 50; i++)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), 100.0 + i * 0.5));
|
||||
}
|
||||
|
||||
Assert.True(tsi.IsHot);
|
||||
}
|
||||
|
||||
// ==================== STATE MANAGEMENT ====================
|
||||
[Fact]
|
||||
public void Update_BarCorrection_RestoresState()
|
||||
{
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
|
||||
// Initial values - building up momentum history
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), 100.0 + i * 0.5));
|
||||
}
|
||||
|
||||
// Update with new bar (large spike)
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(20), 180.0), isNew: true);
|
||||
var valueAfterSpike = tsi.Last.Value;
|
||||
|
||||
// Correct the bar to smaller value (isNew=false)
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(20), 105.0), isNew: false);
|
||||
var valueAfterCorrection = tsi.Last.Value;
|
||||
|
||||
// The spike value should be higher than the corrected value
|
||||
// because spike has larger positive momentum
|
||||
Assert.True(valueAfterSpike > valueAfterCorrection,
|
||||
$"Spike ({valueAfterSpike}) should be greater than corrected ({valueAfterCorrection})");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Reset_ClearsState()
|
||||
{
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), 100.0 + i));
|
||||
}
|
||||
|
||||
Assert.NotEqual(default, tsi.Last);
|
||||
Assert.True(tsi.IsHot);
|
||||
|
||||
tsi.Reset();
|
||||
|
||||
Assert.Equal(default, tsi.Last);
|
||||
Assert.False(tsi.IsHot);
|
||||
}
|
||||
|
||||
// ==================== SERIES ====================
|
||||
[Fact]
|
||||
public void Update_TSeries_ReturnsCorrectLength()
|
||||
{
|
||||
var source = new TSeries();
|
||||
for (int i = 0; i < 50; i++)
|
||||
{
|
||||
source.Add(new TValue(DateTime.Now.AddMinutes(i), 100.0 + i * 0.5));
|
||||
}
|
||||
|
||||
var result = Tsi.Batch(source);
|
||||
|
||||
Assert.Equal(source.Count, result.Count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Batch_MatchesStreamingCalculation()
|
||||
{
|
||||
var source = new TSeries();
|
||||
var random = new Random(42);
|
||||
for (int i = 0; i < 60; i++)
|
||||
{
|
||||
source.Add(new TValue(DateTime.Now.AddMinutes(i), 100.0 + random.NextDouble() * 20));
|
||||
}
|
||||
|
||||
// Batch calculation
|
||||
var batchResult = Tsi.Batch(source, 5, 3, 3);
|
||||
|
||||
// Streaming calculation
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
var streamingResult = new List<double>();
|
||||
foreach (var value in source)
|
||||
{
|
||||
streamingResult.Add(tsi.Update(value).Value);
|
||||
}
|
||||
|
||||
// Compare results
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
Assert.Equal(batchResult.Values[i], streamingResult[i], 6);
|
||||
}
|
||||
}
|
||||
|
||||
// ==================== EDGE CASES ====================
|
||||
[Fact]
|
||||
public void Update_SingleValue_ReturnsZero()
|
||||
{
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
var result = tsi.Update(new TValue(DateTime.Now, 100.0));
|
||||
|
||||
// First value has no momentum
|
||||
Assert.Equal(0, result.Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_LargePriceSwing_HandlesCorrectly()
|
||||
{
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
|
||||
// Stable prices
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), 100.0));
|
||||
}
|
||||
|
||||
// Large price swing
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(21), 200.0));
|
||||
|
||||
// Should handle without overflow/underflow
|
||||
Assert.True(!double.IsNaN(tsi.Last.Value));
|
||||
Assert.True(!double.IsInfinity(tsi.Last.Value));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_NegativePrices_HandlesCorrectly()
|
||||
{
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
|
||||
// Negative prices (like temperature or P&L)
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), -10.0 + i * 0.5));
|
||||
}
|
||||
|
||||
Assert.True(!double.IsNaN(tsi.Last.Value));
|
||||
Assert.True(tsi.Last.Value >= -100.0 && tsi.Last.Value <= 100.0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_VerySmallPriceChanges_HandlesCorrectly()
|
||||
{
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
|
||||
// Very small price changes
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), 100.0 + i * 1e-8));
|
||||
}
|
||||
|
||||
Assert.True(!double.IsNaN(tsi.Last.Value));
|
||||
}
|
||||
|
||||
// ==================== PRIME ====================
|
||||
[Fact]
|
||||
public void Prime_InitializesState()
|
||||
{
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
double[] primeData = [100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110];
|
||||
|
||||
tsi.Prime(primeData);
|
||||
|
||||
Assert.NotEqual(default, tsi.Last);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Prime_SameAsSequentialUpdates()
|
||||
{
|
||||
var tsi1 = new Tsi(5, 3, 3);
|
||||
var tsi2 = new Tsi(5, 3, 3);
|
||||
double[] data = [100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110];
|
||||
|
||||
// Prime
|
||||
tsi1.Prime(data);
|
||||
|
||||
// Sequential updates
|
||||
foreach (var value in data)
|
||||
{
|
||||
tsi2.Update(new TValue(DateTime.MinValue, value));
|
||||
}
|
||||
|
||||
Assert.Equal(tsi1.Last.Value, tsi2.Last.Value, 10);
|
||||
}
|
||||
|
||||
// ==================== CALCULATE ====================
|
||||
[Fact]
|
||||
public void Calculate_Static_MatchesBatch()
|
||||
{
|
||||
double[] source = new double[50];
|
||||
double[] output = new double[50];
|
||||
|
||||
var random = new Random(42);
|
||||
for (int i = 0; i < 50; i++)
|
||||
{
|
||||
source[i] = 100.0 + random.NextDouble() * 20;
|
||||
}
|
||||
|
||||
Tsi.Calculate(source, output, 5, 3);
|
||||
|
||||
var series = new TSeries();
|
||||
for (int i = 0; i < 50; i++)
|
||||
{
|
||||
series.Add(new TValue(DateTime.Now.AddMinutes(i), source[i]));
|
||||
}
|
||||
|
||||
var batchResult = Tsi.Batch(series, 5, 3, 3);
|
||||
|
||||
for (int i = 10; i < 50; i++)
|
||||
{
|
||||
Assert.Equal(output[i], batchResult.Values[i], 6);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calculate_LengthMismatch_ThrowsException()
|
||||
{
|
||||
double[] source = new double[10];
|
||||
double[] output = new double[5];
|
||||
|
||||
Assert.Throws<ArgumentException>(() => Tsi.Calculate(source, output));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calculate_ZeroPeriod_ThrowsException()
|
||||
{
|
||||
double[] source = new double[10];
|
||||
double[] output = new double[10];
|
||||
|
||||
Assert.Throws<ArgumentException>(() => Tsi.Calculate(source, output, 0, 3));
|
||||
Assert.Throws<ArgumentException>(() => Tsi.Calculate(source, output, 5, 0));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calculate_EmptyArrays_DoesNotThrow()
|
||||
{
|
||||
double[] source = [];
|
||||
double[] output = [];
|
||||
|
||||
var exception = Record.Exception(() => Tsi.Calculate(source, output));
|
||||
Assert.Null(exception);
|
||||
}
|
||||
|
||||
// ==================== EVENT HANDLING ====================
|
||||
[Fact]
|
||||
public void PubEvent_TriggersOnUpdate()
|
||||
{
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
TValue? receivedValue = null;
|
||||
bool isNewReceived = false;
|
||||
|
||||
tsi.Pub += (object? sender, in TValueEventArgs args) =>
|
||||
{
|
||||
receivedValue = args.Value;
|
||||
isNewReceived = args.IsNew;
|
||||
};
|
||||
|
||||
tsi.Update(new TValue(DateTime.Now, 100.0));
|
||||
|
||||
Assert.NotNull(receivedValue);
|
||||
Assert.True(isNewReceived);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PubSubscription_ReceivesUpdates()
|
||||
{
|
||||
var source = new TSeries();
|
||||
var tsi = new Tsi(source, 5, 3, 3);
|
||||
var receivedValues = new List<TValue>();
|
||||
|
||||
tsi.Pub += (object? sender, in TValueEventArgs args) => receivedValues.Add(args.Value);
|
||||
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
source.Add(new TValue(DateTime.Now.AddMinutes(i), 100.0 + i * 0.5));
|
||||
}
|
||||
|
||||
Assert.Equal(20, receivedValues.Count);
|
||||
}
|
||||
|
||||
// ==================== TYPICAL TRADING SCENARIOS ====================
|
||||
[Fact]
|
||||
public void TrendChange_ZeroCrossover()
|
||||
{
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
|
||||
// Rising prices
|
||||
for (int i = 0; i < 15; i++)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), 100.0 + i * 2));
|
||||
}
|
||||
Assert.True(tsi.Last.Value > 0);
|
||||
|
||||
// Falling prices
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(15 + i), 128.0 - i * 2));
|
||||
}
|
||||
Assert.True(tsi.Last.Value < 0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SignalLineCrossover_DetectsMomentumChange()
|
||||
{
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
var tsiValues = new List<double>();
|
||||
var signalValues = new List<double>();
|
||||
|
||||
// Rising then falling prices - clearer trend change
|
||||
for (int i = 0; i < 40; i++)
|
||||
{
|
||||
double price = i < 20
|
||||
? 100.0 + i * 2 // Rising
|
||||
: 140.0 - (i - 20) * 2; // Falling
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), price));
|
||||
tsiValues.Add(tsi.Last.Value);
|
||||
signalValues.Add(tsi.Signal);
|
||||
}
|
||||
|
||||
// When momentum reverses, TSI leads signal and crosses below
|
||||
// Or verify TSI goes from positive to negative (zero crossover)
|
||||
bool foundZeroCross = false;
|
||||
for (int i = 20; i < tsiValues.Count; i++)
|
||||
{
|
||||
if (tsiValues[i - 1] > 0 && tsiValues[i] <= 0)
|
||||
{
|
||||
foundZeroCross = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// After the trend reverses, TSI should cross zero
|
||||
Assert.True(foundZeroCross || tsiValues[^1] < tsiValues[19],
|
||||
$"TSI should decline after trend reversal: TSI at peak={tsiValues[19]:F2}, TSI at end={tsiValues[^1]:F2}");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,365 @@
|
||||
using Xunit;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public class TsiValidationTests
|
||||
{
|
||||
private const double Epsilon = 1e-6;
|
||||
|
||||
// ==================== FORMULA VALIDATION ====================
|
||||
[Fact]
|
||||
public void Formula_ConstantMomentumApproachesExtreme()
|
||||
{
|
||||
// TSI = 100 × doubleSmoothedMom / doubleSmoothedAbsMom
|
||||
// With constant positive momentum, TSI approaches +100
|
||||
var tsi = new Tsi(3, 2, 2);
|
||||
|
||||
// Strong consistent uptrend
|
||||
for (int i = 0; i < 50; i++)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), 100.0 + i * 2));
|
||||
}
|
||||
|
||||
// Should be close to +100
|
||||
Assert.True(tsi.Last.Value > 95.0, $"Expected TSI > 95, got {tsi.Last.Value}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Formula_ConstantNegativeMomentumApproachesNegativeExtreme()
|
||||
{
|
||||
var tsi = new Tsi(3, 2, 2);
|
||||
|
||||
// Strong consistent downtrend
|
||||
for (int i = 0; i < 50; i++)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), 200.0 - i * 2));
|
||||
}
|
||||
|
||||
// Should be close to -100
|
||||
Assert.True(tsi.Last.Value < -95.0, $"Expected TSI < -95, got {tsi.Last.Value}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Formula_ZeroMomentumGivesZeroTsi()
|
||||
{
|
||||
var tsi = new Tsi(3, 2, 2);
|
||||
|
||||
// No price change
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), 100.0));
|
||||
}
|
||||
|
||||
Assert.True(Math.Abs(tsi.Last.Value) < 1.0, $"Expected TSI ≈ 0, got {tsi.Last.Value}");
|
||||
}
|
||||
|
||||
// ==================== SIGNAL LINE VALIDATION ====================
|
||||
[Fact]
|
||||
public void Signal_LagsMainTsi()
|
||||
{
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
var tsiValues = new List<double>();
|
||||
var signalValues = new List<double>();
|
||||
|
||||
// Create a trend change
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
double price = i < 10 ? 100.0 + i * 2 : 120.0 - (i - 10) * 2;
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), price));
|
||||
tsiValues.Add(tsi.Last.Value);
|
||||
signalValues.Add(tsi.Signal);
|
||||
}
|
||||
|
||||
// Signal should lag TSI - when TSI turns, signal follows
|
||||
// Check that standard deviation of differences is not zero (they're different)
|
||||
var diff = tsiValues.Zip(signalValues, (t, s) => t - s).ToList();
|
||||
double avgDiff = diff.Average();
|
||||
double variance = diff.Average(d => (d - avgDiff) * (d - avgDiff));
|
||||
|
||||
Assert.True(variance > 0.001, "Signal should lag TSI, showing variance in differences");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Signal_ConvergesInSteadyTrend()
|
||||
{
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
|
||||
// Consistent uptrend
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), 100.0 + i));
|
||||
}
|
||||
|
||||
// In steady trend, TSI and Signal should converge
|
||||
double diff = Math.Abs(tsi.Last.Value - tsi.Signal);
|
||||
Assert.True(diff < 5.0, $"Expected TSI and Signal to converge, diff = {diff}");
|
||||
}
|
||||
|
||||
// ==================== WARMUP VALIDATION ====================
|
||||
[Fact]
|
||||
public void Warmup_GradualConvergence()
|
||||
{
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
var values = new List<double>();
|
||||
|
||||
// Rising prices
|
||||
for (int i = 0; i < 30; i++)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), 100.0 + i));
|
||||
values.Add(tsi.Last.Value);
|
||||
}
|
||||
|
||||
// Values should stabilize as warmup completes
|
||||
var lastFive = values.Skip(values.Count - 5).ToList();
|
||||
var firstFive = values.Skip(5).Take(5).ToList();
|
||||
|
||||
double lastRange = lastFive.Max() - lastFive.Min();
|
||||
double firstRange = firstFive.Max() - firstFive.Min();
|
||||
|
||||
// Later values should be more stable (smaller range)
|
||||
Assert.True(lastRange <= firstRange || lastRange < 5.0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Warmup_Period_MatchesExpected()
|
||||
{
|
||||
var tsi = new Tsi(25, 13, 13);
|
||||
Assert.Equal(25 + 13 + 13, tsi.WarmupPeriod);
|
||||
}
|
||||
|
||||
// ==================== EDGE CASE VALIDATION ====================
|
||||
[Fact]
|
||||
public void EdgeCase_AlternatingPrices()
|
||||
{
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
|
||||
// Alternating prices (no net trend)
|
||||
for (int i = 0; i < 30; i++)
|
||||
{
|
||||
double price = 100.0 + (i % 2 == 0 ? 5 : -5);
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), price));
|
||||
}
|
||||
|
||||
// Should oscillate around zero
|
||||
Assert.True(Math.Abs(tsi.Last.Value) < 50.0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EdgeCase_LargePriceSpike()
|
||||
{
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
|
||||
// Stable prices
|
||||
for (int i = 0; i < 15; i++)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), 100.0));
|
||||
}
|
||||
|
||||
// Large spike
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(16), 150.0));
|
||||
|
||||
Assert.True(!double.IsNaN(tsi.Last.Value));
|
||||
Assert.True(!double.IsInfinity(tsi.Last.Value));
|
||||
Assert.True(tsi.Last.Value > 0); // Should be positive after spike up
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EdgeCase_VerySmallPeriods()
|
||||
{
|
||||
var tsi = new Tsi(1, 1, 1);
|
||||
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), 100.0 + i));
|
||||
}
|
||||
|
||||
Assert.True(!double.IsNaN(tsi.Last.Value));
|
||||
Assert.True(tsi.Last.Value >= -100 && tsi.Last.Value <= 100);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EdgeCase_VeryLargePeriods()
|
||||
{
|
||||
var tsi = new Tsi(100, 50, 25);
|
||||
|
||||
for (int i = 0; i < 300; i++)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), 100.0 + i * 0.1));
|
||||
}
|
||||
|
||||
Assert.True(!double.IsNaN(tsi.Last.Value));
|
||||
Assert.True(tsi.Last.Value >= -100 && tsi.Last.Value <= 100);
|
||||
}
|
||||
|
||||
// ==================== COMPARISON VALIDATION ====================
|
||||
[Fact]
|
||||
public void Comparison_BatchVsStreaming()
|
||||
{
|
||||
var source = new TSeries();
|
||||
var random = new Random(42);
|
||||
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
source.Add(new TValue(DateTime.Now.AddMinutes(i), 100.0 + random.NextDouble() * 30));
|
||||
}
|
||||
|
||||
// Batch calculation
|
||||
var batchResult = Tsi.Batch(source, 10, 5, 5);
|
||||
|
||||
// Streaming calculation
|
||||
var tsi = new Tsi(10, 5, 5);
|
||||
var streamingResults = new List<double>();
|
||||
foreach (var value in source)
|
||||
{
|
||||
streamingResults.Add(tsi.Update(value).Value);
|
||||
}
|
||||
|
||||
// Compare (skip warmup period)
|
||||
for (int i = 30; i < source.Count; i++)
|
||||
{
|
||||
Assert.Equal(batchResult.Values[i], streamingResults[i], 5);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Comparison_DifferentParametersSameTrend()
|
||||
{
|
||||
var tsi1 = new Tsi(25, 13, 13); // Default
|
||||
var tsi2 = new Tsi(13, 7, 7); // Shorter
|
||||
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
var tval = new TValue(DateTime.Now.AddMinutes(i), 100.0 + i);
|
||||
tsi1.Update(tval);
|
||||
tsi2.Update(tval);
|
||||
}
|
||||
|
||||
// Both should be positive for uptrend
|
||||
Assert.True(tsi1.Last.Value > 0);
|
||||
Assert.True(tsi2.Last.Value > 0);
|
||||
|
||||
// Shorter period should react faster (closer to +100)
|
||||
Assert.True(tsi2.Last.Value >= tsi1.Last.Value - 10);
|
||||
}
|
||||
|
||||
// ==================== STATE VALIDATION ====================
|
||||
[Fact]
|
||||
public void State_ResetClearsAll()
|
||||
{
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), 100.0 + i));
|
||||
}
|
||||
|
||||
Assert.True(tsi.IsHot);
|
||||
Assert.NotEqual(default, tsi.Last);
|
||||
|
||||
tsi.Reset();
|
||||
|
||||
Assert.False(tsi.IsHot);
|
||||
Assert.Equal(default, tsi.Last);
|
||||
Assert.Equal(0, tsi.Signal);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void State_BarCorrectionMaintainsConsistency()
|
||||
{
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
|
||||
// Build up history with gradual price increases
|
||||
for (int i = 0; i < 15; i++)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(i), 100.0 + i));
|
||||
}
|
||||
|
||||
_ = tsi.Last.Value; // Capture stable value (unused, for state verification)
|
||||
|
||||
// Large spike - very different from trend
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(16), 250.0), isNew: true);
|
||||
var spike = tsi.Last.Value;
|
||||
|
||||
// Correct bar to much smaller value (below trend continuation)
|
||||
tsi.Update(new TValue(DateTime.Now.AddMinutes(16), 110.0), isNew: false);
|
||||
var corrected = tsi.Last.Value;
|
||||
|
||||
// Spike should have higher TSI than corrected (more positive momentum)
|
||||
Assert.True(spike > corrected,
|
||||
$"Spike ({spike:F4}) should be greater than corrected ({corrected:F4})");
|
||||
}
|
||||
|
||||
// ==================== MATHEMATICAL PROPERTIES ====================
|
||||
[Fact]
|
||||
public void Math_SymmetryWithInvertedPrices()
|
||||
{
|
||||
var tsi1 = new Tsi(5, 3, 3);
|
||||
var tsi2 = new Tsi(5, 3, 3);
|
||||
|
||||
// Feed reversed prices
|
||||
for (int i = 0; i < 30; i++)
|
||||
{
|
||||
tsi1.Update(new TValue(DateTime.Now.AddMinutes(i), 100.0 + i));
|
||||
tsi2.Update(new TValue(DateTime.Now.AddMinutes(i), 129.0 - i));
|
||||
}
|
||||
|
||||
// Should be approximately symmetric (opposite signs)
|
||||
Assert.True(Math.Abs(tsi1.Last.Value + tsi2.Last.Value) < 5.0,
|
||||
$"Expected symmetry: TSI1={tsi1.Last.Value}, TSI2={tsi2.Last.Value}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Math_RatioPreservesScale()
|
||||
{
|
||||
var tsi1 = new Tsi(5, 3, 3);
|
||||
var tsi2 = new Tsi(5, 3, 3);
|
||||
|
||||
// Same relative changes, different absolute scale
|
||||
for (int i = 0; i < 30; i++)
|
||||
{
|
||||
tsi1.Update(new TValue(DateTime.Now.AddMinutes(i), 100.0 + i));
|
||||
tsi2.Update(new TValue(DateTime.Now.AddMinutes(i), 1000.0 + i * 10));
|
||||
}
|
||||
|
||||
// TSI should be similar (same percentage changes)
|
||||
Assert.True(Math.Abs(tsi1.Last.Value - tsi2.Last.Value) < 5.0,
|
||||
$"TSI should be scale-independent: TSI1={tsi1.Last.Value}, TSI2={tsi2.Last.Value}");
|
||||
}
|
||||
|
||||
// ==================== CROSS-VALIDATION ====================
|
||||
[Fact]
|
||||
public void CrossValidation_ConsistentWithPineFormula()
|
||||
{
|
||||
// TSI = 100 × EMA(EMA(mom, long), short) / EMA(EMA(|mom|, long), short)
|
||||
var tsi = new Tsi(5, 3, 3);
|
||||
|
||||
double[] prices = [100, 102, 101, 104, 103, 106, 105, 108, 107, 110, 109, 112, 111, 114, 113, 116];
|
||||
|
||||
foreach (var price in prices)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now, price));
|
||||
}
|
||||
|
||||
// Result should be bounded and reasonable
|
||||
Assert.True(tsi.Last.Value >= -100 && tsi.Last.Value <= 100);
|
||||
// With alternating up-down pattern, should be positive overall (slight uptrend)
|
||||
Assert.True(tsi.Last.Value > 0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void CrossValidation_MatchesManualDoubleSmoothing()
|
||||
{
|
||||
var tsi = new Tsi(3, 2, 2);
|
||||
|
||||
// Simple test data
|
||||
double[] prices = [100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120];
|
||||
|
||||
foreach (var price in prices)
|
||||
{
|
||||
tsi.Update(new TValue(DateTime.Now, price));
|
||||
}
|
||||
|
||||
// Consistent +2 momentum = 100% TSI (or close to it)
|
||||
Assert.True(tsi.Last.Value > 90, $"Expected TSI > 90 for constant momentum, got {tsi.Last.Value}");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,315 @@
|
||||
// TSI: True Strength Index by William Blau
|
||||
// Momentum oscillator measuring overbought/oversold conditions.
|
||||
// Uses double-smoothed EMA of price momentum vs absolute momentum.
|
||||
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace QuanTAlib;
|
||||
|
||||
/// <summary>
|
||||
/// TSI: True Strength Index
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Momentum oscillator that uses double-smoothed exponential moving averages
|
||||
/// of price momentum to reduce noise and identify trend strength.
|
||||
/// Ranges from -100 to +100, with higher values indicating bullish momentum.
|
||||
///
|
||||
/// Calculation:
|
||||
/// <code>
|
||||
/// Momentum = Price - Price[1]
|
||||
/// TSI = 100 × EMA(EMA(Momentum, longPeriod), shortPeriod) / EMA(EMA(|Momentum|, longPeriod), shortPeriod)
|
||||
/// Signal = EMA(TSI, signalPeriod)
|
||||
/// </code>
|
||||
///
|
||||
/// Key characteristics:
|
||||
/// - Double smoothing reduces noise and false signals
|
||||
/// - Bounded oscillator: -100 to +100
|
||||
/// - Signal line crossovers generate trade signals
|
||||
/// - Zero line crossovers indicate trend changes
|
||||
/// </remarks>
|
||||
/// <seealso href="Tsi.md">Detailed documentation</seealso>
|
||||
[SkipLocalsInit]
|
||||
public sealed class Tsi : AbstractBase
|
||||
{
|
||||
private const int DefaultLongPeriod = 25;
|
||||
private const int DefaultShortPeriod = 13;
|
||||
private const int DefaultSignalPeriod = 13;
|
||||
|
||||
/// <summary>
|
||||
/// Gets the long period for first EMA smoothing.
|
||||
/// </summary>
|
||||
public int LongPeriod { get; }
|
||||
|
||||
/// <summary>
|
||||
/// Gets the short period for second EMA smoothing.
|
||||
/// </summary>
|
||||
public int ShortPeriod { get; }
|
||||
|
||||
/// <summary>
|
||||
/// Gets the signal line period.
|
||||
/// </summary>
|
||||
public int SignalPeriod { get; }
|
||||
private readonly TValuePublishedHandler _handler;
|
||||
|
||||
// Four EMAs for double smoothing
|
||||
private readonly Ema _emaMomLong; // First smoothing of momentum
|
||||
private readonly Ema _emaMomShort; // Second smoothing of momentum
|
||||
private readonly Ema _emaAbsMomLong; // First smoothing of |momentum|
|
||||
private readonly Ema _emaAbsMomShort; // Second smoothing of |momentum|
|
||||
private readonly Ema _emaSignal; // Signal line EMA
|
||||
|
||||
private double _prevValue;
|
||||
private double _p_prevValue;
|
||||
private double _lastSignal;
|
||||
private double _p_lastSignal;
|
||||
|
||||
/// <summary>
|
||||
/// Gets the signal line value.
|
||||
/// </summary>
|
||||
public double Signal => _lastSignal;
|
||||
|
||||
public override bool IsHot => _emaMomShort.IsHot && _emaAbsMomShort.IsHot && _emaSignal.IsHot;
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the TSI indicator.
|
||||
/// </summary>
|
||||
/// <param name="longPeriod">The long period for first EMA smoothing (default: 25).</param>
|
||||
/// <param name="shortPeriod">The short period for second EMA smoothing (default: 13).</param>
|
||||
/// <param name="signalPeriod">The period for signal line EMA (default: 13).</param>
|
||||
/// <exception cref="ArgumentException">Thrown when any period is less than 1.</exception>
|
||||
public Tsi(int longPeriod = DefaultLongPeriod, int shortPeriod = DefaultShortPeriod, int signalPeriod = DefaultSignalPeriod)
|
||||
{
|
||||
if (longPeriod < 1)
|
||||
{
|
||||
throw new ArgumentException("Long period must be at least 1", nameof(longPeriod));
|
||||
}
|
||||
if (shortPeriod < 1)
|
||||
{
|
||||
throw new ArgumentException("Short period must be at least 1", nameof(shortPeriod));
|
||||
}
|
||||
if (signalPeriod < 1)
|
||||
{
|
||||
throw new ArgumentException("Signal period must be at least 1", nameof(signalPeriod));
|
||||
}
|
||||
|
||||
LongPeriod = longPeriod;
|
||||
ShortPeriod = shortPeriod;
|
||||
SignalPeriod = signalPeriod;
|
||||
_handler = Handle;
|
||||
|
||||
// Initialize EMAs - use period directly for warmup
|
||||
_emaMomLong = new Ema(longPeriod);
|
||||
_emaMomShort = new Ema(shortPeriod);
|
||||
_emaAbsMomLong = new Ema(longPeriod);
|
||||
_emaAbsMomShort = new Ema(shortPeriod);
|
||||
_emaSignal = new Ema(signalPeriod);
|
||||
|
||||
_prevValue = double.NaN;
|
||||
_p_prevValue = double.NaN;
|
||||
_lastSignal = 0;
|
||||
_p_lastSignal = 0;
|
||||
|
||||
Name = $"Tsi({longPeriod},{shortPeriod},{signalPeriod})";
|
||||
WarmupPeriod = longPeriod + shortPeriod + signalPeriod;
|
||||
}
|
||||
|
||||
public Tsi(ITValuePublisher source, int longPeriod = DefaultLongPeriod, int shortPeriod = DefaultShortPeriod, int signalPeriod = DefaultSignalPeriod)
|
||||
: this(longPeriod, shortPeriod, signalPeriod)
|
||||
{
|
||||
source.Pub += _handler;
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
public override TValue Update(TValue input, bool isNew = true)
|
||||
{
|
||||
if (isNew)
|
||||
{
|
||||
_p_prevValue = _prevValue;
|
||||
_p_lastSignal = _lastSignal;
|
||||
}
|
||||
else
|
||||
{
|
||||
_prevValue = _p_prevValue;
|
||||
_lastSignal = _p_lastSignal;
|
||||
}
|
||||
|
||||
double val = input.Value;
|
||||
double mom = 0;
|
||||
double absMom = 0;
|
||||
|
||||
if (!double.IsNaN(_prevValue))
|
||||
{
|
||||
mom = val - _prevValue;
|
||||
absMom = Math.Abs(mom);
|
||||
}
|
||||
|
||||
if (isNew)
|
||||
{
|
||||
_prevValue = val;
|
||||
}
|
||||
|
||||
// Double smooth the momentum: EMA(EMA(mom, longPeriod), shortPeriod)
|
||||
double smoothedMomLong = _emaMomLong.Update(new TValue(input.Time, mom), isNew).Value;
|
||||
double doubleSmoothedMom = _emaMomShort.Update(new TValue(input.Time, smoothedMomLong), isNew).Value;
|
||||
|
||||
// Double smooth the absolute momentum: EMA(EMA(|mom|, longPeriod), shortPeriod)
|
||||
double smoothedAbsMomLong = _emaAbsMomLong.Update(new TValue(input.Time, absMom), isNew).Value;
|
||||
double doubleSmoothedAbsMom = _emaAbsMomShort.Update(new TValue(input.Time, smoothedAbsMomLong), isNew).Value;
|
||||
|
||||
// Calculate TSI: 100 × doubleSmoothedMom / doubleSmoothedAbsMom
|
||||
double tsi;
|
||||
const double epsilon = 1e-10;
|
||||
if (Math.Abs(doubleSmoothedAbsMom) < epsilon)
|
||||
{
|
||||
tsi = 0; // Avoid division by zero
|
||||
}
|
||||
else
|
||||
{
|
||||
tsi = 100.0 * doubleSmoothedMom / doubleSmoothedAbsMom;
|
||||
}
|
||||
|
||||
// Calculate signal line: EMA(TSI, signalPeriod)
|
||||
_lastSignal = _emaSignal.Update(new TValue(input.Time, tsi), isNew).Value;
|
||||
|
||||
Last = new TValue(input.Time, tsi);
|
||||
PubEvent(Last, isNew);
|
||||
return Last;
|
||||
}
|
||||
|
||||
public override TSeries Update(TSeries source)
|
||||
{
|
||||
if (source.Count == 0)
|
||||
{
|
||||
return [];
|
||||
}
|
||||
|
||||
int len = source.Count;
|
||||
var t = new List<long>(len);
|
||||
var v = new List<double>(len);
|
||||
CollectionsMarshal.SetCount(t, len);
|
||||
CollectionsMarshal.SetCount(v, len);
|
||||
|
||||
var tSpan = CollectionsMarshal.AsSpan(t);
|
||||
var vSpan = CollectionsMarshal.AsSpan(v);
|
||||
|
||||
// Batch calculate
|
||||
Calculate(source.Values, vSpan, LongPeriod, ShortPeriod);
|
||||
source.Times.CopyTo(tSpan);
|
||||
|
||||
// Restore state for streaming by replaying
|
||||
Reset();
|
||||
for (int i = 0; i < len; i++)
|
||||
{
|
||||
Update(new TValue(source.Times[i], source.Values[i]));
|
||||
}
|
||||
|
||||
Last = new TValue(tSpan[len - 1], vSpan[len - 1]);
|
||||
return new TSeries(t, v);
|
||||
}
|
||||
|
||||
private void Handle(object? sender, in TValueEventArgs args)
|
||||
{
|
||||
Update(args.Value, args.IsNew);
|
||||
}
|
||||
|
||||
public override void Prime(ReadOnlySpan<double> source, TimeSpan? step = null)
|
||||
{
|
||||
foreach (var value in source)
|
||||
{
|
||||
Update(new TValue(DateTime.MinValue, value));
|
||||
}
|
||||
}
|
||||
|
||||
public static TSeries Batch(TSeries source, int longPeriod = DefaultLongPeriod, int shortPeriod = DefaultShortPeriod, int signalPeriod = DefaultSignalPeriod)
|
||||
{
|
||||
var tsi = new Tsi(longPeriod, shortPeriod, signalPeriod);
|
||||
return tsi.Update(source);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Batch calculates TSI values (without signal line).
|
||||
/// </summary>
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
public static void Calculate(ReadOnlySpan<double> source, Span<double> output, int longPeriod = DefaultLongPeriod, int shortPeriod = DefaultShortPeriod)
|
||||
{
|
||||
if (source.Length != output.Length)
|
||||
{
|
||||
throw new ArgumentException("Source and output must have the same length", nameof(output));
|
||||
}
|
||||
if (longPeriod < 1)
|
||||
{
|
||||
throw new ArgumentException("Long period must be at least 1", nameof(longPeriod));
|
||||
}
|
||||
if (shortPeriod < 1)
|
||||
{
|
||||
throw new ArgumentException("Short period must be at least 1", nameof(shortPeriod));
|
||||
}
|
||||
|
||||
int len = source.Length;
|
||||
if (len == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Calculate momentum: source[i] - source[i-1]
|
||||
double[] mom = System.Buffers.ArrayPool<double>.Shared.Rent(len);
|
||||
double[] absMom = System.Buffers.ArrayPool<double>.Shared.Rent(len);
|
||||
double[] smoothedMom = System.Buffers.ArrayPool<double>.Shared.Rent(len);
|
||||
double[] smoothedAbsMom = System.Buffers.ArrayPool<double>.Shared.Rent(len);
|
||||
|
||||
Span<double> momSpan = mom.AsSpan(0, len);
|
||||
Span<double> absMomSpan = absMom.AsSpan(0, len);
|
||||
Span<double> smoothedMomSpan = smoothedMom.AsSpan(0, len);
|
||||
Span<double> smoothedAbsMomSpan = smoothedAbsMom.AsSpan(0, len);
|
||||
|
||||
momSpan[0] = 0;
|
||||
absMomSpan[0] = 0;
|
||||
for (int i = 1; i < len; i++)
|
||||
{
|
||||
momSpan[i] = source[i] - source[i - 1];
|
||||
absMomSpan[i] = Math.Abs(momSpan[i]);
|
||||
}
|
||||
|
||||
// Double smooth momentum: EMA(EMA(mom, longPeriod), shortPeriod)
|
||||
Ema.Batch(momSpan, smoothedMomSpan, longPeriod);
|
||||
Ema.Batch(smoothedMomSpan, smoothedMomSpan, shortPeriod); // In-place
|
||||
|
||||
// Double smooth absolute momentum: EMA(EMA(|mom|, longPeriod), shortPeriod)
|
||||
Ema.Batch(absMomSpan, smoothedAbsMomSpan, longPeriod);
|
||||
Ema.Batch(smoothedAbsMomSpan, smoothedAbsMomSpan, shortPeriod); // In-place
|
||||
|
||||
// Calculate TSI: 100 × smoothedMom / smoothedAbsMom
|
||||
const double epsilon = 1e-10;
|
||||
for (int i = 0; i < len; i++)
|
||||
{
|
||||
if (Math.Abs(smoothedAbsMomSpan[i]) < epsilon)
|
||||
{
|
||||
output[i] = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
output[i] = 100.0 * smoothedMomSpan[i] / smoothedAbsMomSpan[i];
|
||||
}
|
||||
}
|
||||
|
||||
System.Buffers.ArrayPool<double>.Shared.Return(mom);
|
||||
System.Buffers.ArrayPool<double>.Shared.Return(absMom);
|
||||
System.Buffers.ArrayPool<double>.Shared.Return(smoothedMom);
|
||||
System.Buffers.ArrayPool<double>.Shared.Return(smoothedAbsMom);
|
||||
}
|
||||
|
||||
public override void Reset()
|
||||
{
|
||||
_emaMomLong.Reset();
|
||||
_emaMomShort.Reset();
|
||||
_emaAbsMomLong.Reset();
|
||||
_emaAbsMomShort.Reset();
|
||||
_emaSignal.Reset();
|
||||
_prevValue = double.NaN;
|
||||
_p_prevValue = double.NaN;
|
||||
_lastSignal = 0;
|
||||
_p_lastSignal = 0;
|
||||
Last = default;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,123 @@
|
||||
# TSI: True Strength Index
|
||||
|
||||
The True Strength Index (TSI) is a momentum oscillator developed by William Blau that uses double-smoothed exponential moving averages of price momentum to reduce noise and identify trend strength and direction.
|
||||
|
||||
## Historical Context
|
||||
|
||||
William Blau introduced the TSI in his 1995 book "Momentum, Direction, and Divergence." The indicator was designed to provide a smoother momentum measure by applying double exponential smoothing to price changes, reducing the whipsaws common in simpler momentum indicators.
|
||||
|
||||
## Algorithm and Implementation
|
||||
|
||||
### 1. Momentum Calculation
|
||||
|
||||
```csharp
|
||||
mom = Price - Price[1]
|
||||
absMom = |mom|
|
||||
```
|
||||
|
||||
Price momentum captures the direction and magnitude of price change.
|
||||
|
||||
### 2. Double EMA Smoothing
|
||||
|
||||
```csharp
|
||||
// First smoothing with long period
|
||||
smoothedMomLong = EMA(mom, longPeriod)
|
||||
smoothedAbsMomLong = EMA(absMom, longPeriod)
|
||||
|
||||
// Second smoothing with short period
|
||||
doubleSmoothedMom = EMA(smoothedMomLong, shortPeriod)
|
||||
doubleSmoothedAbsMom = EMA(smoothedAbsMomLong, shortPeriod)
|
||||
```
|
||||
|
||||
Double smoothing reduces noise while preserving trend information.
|
||||
|
||||
### 3. TSI Calculation
|
||||
|
||||
```csharp
|
||||
TSI = 100 × doubleSmoothedMom / doubleSmoothedAbsMom
|
||||
```
|
||||
|
||||
The ratio normalizes momentum to a percentage scale.
|
||||
|
||||
### 4. Signal Line
|
||||
|
||||
```csharp
|
||||
Signal = EMA(TSI, signalPeriod)
|
||||
```
|
||||
|
||||
The signal line provides crossover signals.
|
||||
|
||||
## Mathematical Formula
|
||||
|
||||
### Core Formula
|
||||
|
||||
$$TSI = 100 \times \frac{EMA(EMA(Price_t - Price_{t-1}, long), short)}{EMA(EMA(|Price_t - Price_{t-1}|, long), short)}$$
|
||||
|
||||
### Signal Line
|
||||
|
||||
$$Signal = EMA(TSI, signalPeriod)$$
|
||||
|
||||
### Default Parameters
|
||||
|
||||
- Long Period: 25
|
||||
- Short Period: 13
|
||||
- Signal Period: 13
|
||||
|
||||
## Interpretation
|
||||
|
||||
### Range
|
||||
- TSI oscillates between -100 and +100
|
||||
- Positive values indicate bullish momentum
|
||||
- Negative values indicate bearish momentum
|
||||
|
||||
### Signals
|
||||
- **Zero Line Crossover**: TSI crossing above zero is bullish; below zero is bearish
|
||||
- **Signal Line Crossover**: TSI crossing above signal is bullish; below is bearish
|
||||
- **Divergence**: Price and TSI moving in opposite directions suggests trend reversal
|
||||
|
||||
### Overbought/Oversold
|
||||
- Commonly used levels: +25/-25 or +30/-30
|
||||
- Extreme readings suggest potential reversal
|
||||
|
||||
## Performance Characteristics
|
||||
|
||||
### Operation Count (Streaming Mode)
|
||||
|
||||
| Operation | Count |
|
||||
|-----------|-------|
|
||||
| Subtractions | 1 |
|
||||
| Absolute value | 1 |
|
||||
| EMA updates | 5 |
|
||||
| Division | 1 |
|
||||
| Multiplication | 1 |
|
||||
|
||||
### Complexity
|
||||
|
||||
- Time: O(1) per bar (streaming)
|
||||
- Space: O(1) - only EMA states maintained
|
||||
|
||||
### Warmup Period
|
||||
|
||||
warmupPeriod = longPeriod + shortPeriod + signalPeriod
|
||||
|
||||
Default: 25 + 13 + 13 = 51 bars
|
||||
|
||||
## Validation
|
||||
|
||||
Cross-validated against:
|
||||
- TradingView's ta.tsi()
|
||||
- Stock.Indicators library
|
||||
- TA-Lib implementations
|
||||
|
||||
## Common Pitfalls
|
||||
|
||||
1. **Short Warmup**: Ensure sufficient warmup period for convergence
|
||||
2. **Division by Zero**: When no price movement, denominator approaches zero
|
||||
3. **Lag Inherent**: Double smoothing introduces lag in trend identification
|
||||
4. **Parameter Sensitivity**: Results vary significantly with period choices
|
||||
|
||||
## References
|
||||
|
||||
- Blau, William. "Momentum, Direction, and Divergence." Wiley, 1995
|
||||
- Blau, William. "True Strength Index." Technical Analysis of Stocks & Commodities, 1991
|
||||
- [TradingView TSI Documentation](https://www.tradingview.com/support/solutions/43000502302-true-strength-index-tsi/)
|
||||
Reference in New Issue
Block a user