gavindiaz/QuanTAlib
1
0
Fork 0
mirror of https://github.com/mihakralj/QuanTAlib.git synced 2026-08-24 13:38:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor MAMA and HTIT implementation for improved accuracy and performance

Browse Source
This commit is contained in:
Miha Kralj
2025-12-24 20:50:58 -08:00
parent 8917575994
commit 9ba89812cd
27 changed files with 1030 additions and 547 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/trends/htit/Htit.Tests.cs
+1 -1
View File
@@ -97,7 +97,7 @@ public class HtitTests
htit.Reset();
Assert.Equal(0, htit.Last.Value);
Assert.True(double.IsNaN(htit.Last.Value));
Assert.False(htit.IsHot);
}
lib/trends/htit/Htit.cs
+259 -286
View File
@@ -2,7 +2,6 @@ using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using QuanTAlib;
namespace QuanTAlib;
@@ -19,13 +18,21 @@ namespace QuanTAlib;
[SkipLocalsInit]
public sealed class Htit : AbstractBase
{
public override bool IsHot => _state.Index >= WarmupPeriod;
private record struct State(
double I2, double Q2, double Re, double Im,
double Period, double SmoothPeriod,
double LastValidPrice, int Index
);
private State _state;
private State _p_state;
private readonly RingBuffer _priceBuffer;
private readonly RingBuffer _smoothBuffer;
private readonly RingBuffer _detrenderBuffer;
private readonly RingBuffer _i1Buffer;
private readonly RingBuffer _q1Buffer;
private readonly RingBuffer _periodBuffer;
private readonly RingBuffer _smoothPeriodBuffer;
private readonly RingBuffer _itBuffer;
// High-precision constants
@@ -33,25 +40,23 @@ public sealed class Htit : AbstractBase
private const double c2 = 15.0 / 26.0; // ~0.57692308
private const double adjSlope = 3.0 / 40.0; // 0.075
private const double adjIntercept = 27.0 / 50.0; // 0.54
private record struct State(double I2, double Q2, double Re, double Im, double LastValidValue);
private State _state;
private State _p_state;
public override bool IsHot => _priceBuffer.Count >= WarmupPeriod;
private const double TwoPi = 2.0 * Math.PI;
private const double MinDeltaRadians = Math.PI / 180.0; // 1 degree in radians
public Htit()
{
Name = "Htit";
WarmupPeriod = 12; // Based on logic: _priceBuffer.Count >= 12
_priceBuffer = new RingBuffer(50);
_smoothBuffer = new RingBuffer(7);
_detrenderBuffer = new RingBuffer(7);
_i1Buffer = new RingBuffer(7);
_q1Buffer = new RingBuffer(7);
_periodBuffer = new RingBuffer(2);
_smoothPeriodBuffer = new RingBuffer(2);
_itBuffer = new RingBuffer(4);
WarmupPeriod = 12;
// Initialize buffers with size 8 (power of 2) for consistency with Calculate optimization
// except priceBuffer which needs to be larger for IT calculation
_priceBuffer = new RingBuffer(64); // Needs to hold enough history for IT calculation (up to 50 bars)
_smoothBuffer = new RingBuffer(8);
_detrenderBuffer = new RingBuffer(8);
_i1Buffer = new RingBuffer(8);
_q1Buffer = new RingBuffer(8);
_itBuffer = new RingBuffer(8);
Init();
}
@@ -62,197 +67,129 @@ public sealed class Htit : AbstractBase
private void Init()
{
Reset();
}
public override void Reset()
{
_state = default;
_p_state = default;
_priceBuffer.Clear();
_smoothBuffer.Clear();
_detrenderBuffer.Clear();
_i1Buffer.Clear();
_q1Buffer.Clear();
_periodBuffer.Clear();
_smoothPeriodBuffer.Clear();
_itBuffer.Clear();
_state = default;
_p_state = default;
Last = default;
Last = new TValue(DateTime.MinValue, double.NaN);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override TValue Update(TValue input, bool isNew = true)
private double Step(double price, bool isNew)
{
ManageState(isNew);
double price = ValidateInput(input.Value);
UpdateBuffer(_priceBuffer, price, isNew);
if (isNew)
{
_p_state = _state;
_state.Index++;
}
else
{
_state = _p_state;
}
if (_priceBuffer.Count < 7)
return ProcessWarmup(input, price, isNew);
if (!double.IsFinite(price))
{
price = _state.LastValidPrice;
}
else
{
_state.LastValidPrice = price;
}
_priceBuffer.Add(price, isNew);
// Need enough data for smooth calculation (4 bars) + detrender (7 bars total lag)
if (_state.Index < 7)
{
_smoothBuffer.Add(price, isNew);
_detrenderBuffer.Add(0, isNew);
_i1Buffer.Add(0, isNew);
_q1Buffer.Add(0, isNew);
_itBuffer.Add(price, isNew);
return price;
}
// 1. Smooth Price
double smooth = (4 * _priceBuffer[^1] + 3 * _priceBuffer[^2] + 2 * _priceBuffer[^3] + _priceBuffer[^4]) / 10.0;
UpdateBuffer(_smoothBuffer, smooth, isNew);
// smooth = (4*Price + 3*Price[1] + 2*Price[2] + Price[3]) / 10
double smooth = (4.0 * _priceBuffer[^1] + 3.0 * _priceBuffer[^2] + 2.0 * _priceBuffer[^3] + _priceBuffer[^4]) * 0.1;
_smoothBuffer.Add(smooth, isNew);
// 2. Detrender
double prevPeriod = _periodBuffer[isNew ? ^1 : ^2];
// In streaming, we use previous period from state
double prevPeriod = _p_state.Period;
double adj = (adjSlope * prevPeriod) + adjIntercept;
double detrender = (c1 * _smoothBuffer[^1] + c2 * _smoothBuffer[^3] - c2 * _smoothBuffer[^5] - c1 * _smoothBuffer[^7]) * adj;
UpdateBuffer(_detrenderBuffer, detrender, isNew);
_detrenderBuffer.Add(detrender, isNew);
// 3. In-Phase and Quadrature
double q1 = (c1 * _detrenderBuffer[^1] + c2 * _detrenderBuffer[^3] - c2 * _detrenderBuffer[^5] - c1 * _detrenderBuffer[^7]) * adj;
double i1 = _detrenderBuffer[^4];
UpdateBuffer(_q1Buffer, q1, isNew);
UpdateBuffer(_i1Buffer, i1, isNew);
_q1Buffer.Add(q1, isNew);
_i1Buffer.Add(i1, isNew);
// 4. Advance phases by 90 degrees
double jI = (c1 * _i1Buffer[^1] + c2 * _i1Buffer[^3] - c2 * _i1Buffer[^5] - c1 * _i1Buffer[^7]) * adj;
double jQ = (c1 * _q1Buffer[^1] + c2 * _q1Buffer[^3] - c2 * _q1Buffer[^5] - c1 * _q1Buffer[^7]) * adj;
// 5. Phasor addition & 6. Homodyne Discriminator
ProcessPhasorAndHomodyne(i1, q1, jI, jQ);
// 7. Calculate Period
double period = CalculatePeriod(prevPeriod);
UpdateBuffer(_periodBuffer, period, isNew);
// Smooth dominant cycle period
double prevSmoothPeriod = _smoothPeriodBuffer[isNew ? ^1 : ^2];
double smoothPeriod = (0.33 * period) + (0.67 * prevSmoothPeriod);
UpdateBuffer(_smoothPeriodBuffer, smoothPeriod, isNew);
// 8. Instantaneous Trend
double it = CalculateInstantaneousTrend(smoothPeriod, price);
UpdateBuffer(_itBuffer, it, isNew);
// 9. Final Trendline
double trendline = _priceBuffer.Count >= 12
? (4 * _itBuffer[^1] + 3 * _itBuffer[^2] + 2 * _itBuffer[^3] + _itBuffer[^4]) / 10.0
: price;
Last = new TValue(input.Time, trendline);
PubEvent(Last);
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);
Calculate(source.Values, vSpan);
source.Times.CopyTo(tSpan);
// Restore state by replaying last 50 bars
Init();
int startIndex = Math.Max(0, len - 50);
for (int i = startIndex; 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);
}
public override void Prime(ReadOnlySpan<double> source)
{
foreach (var value in source)
{
Update(new TValue(DateTime.MinValue, value));
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void ManageState(bool isNew)
{
if (isNew) _p_state = _state;
else _state = _p_state;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private double ValidateInput(double value)
{
double price = double.IsFinite(value) ? value : _state.LastValidValue;
_state.LastValidValue = price;
return price;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static void UpdateBuffer(RingBuffer buffer, double val, bool isNew)
{
if (isNew) buffer.Add(val);
else buffer.UpdateNewest(val);
}
private TValue ProcessWarmup(TValue input, double price, bool isNew)
{
UpdateBuffer(_smoothBuffer, price, isNew);
UpdateBuffer(_detrenderBuffer, 0, isNew);
UpdateBuffer(_i1Buffer, 0, isNew);
UpdateBuffer(_q1Buffer, 0, isNew);
UpdateBuffer(_periodBuffer, 0, isNew);
UpdateBuffer(_smoothPeriodBuffer, 0, isNew);
UpdateBuffer(_itBuffer, price, isNew);
Last = new TValue(input.Time, price);
PubEvent(Last);
return Last;
}
private void ProcessPhasorAndHomodyne(double i1, double q1, double jI, double jQ)
{
// 5. Phasor addition
double i2_raw = i1 - jQ;
double q2_raw = q1 + jI;
double i2_val = i1 - jQ;
double q2_val = q1 + jI;
// Smoothing
_state.I2 = (0.2 * i2_raw) + (0.8 * _p_state.I2);
_state.Q2 = (0.2 * q2_raw) + (0.8 * _p_state.Q2);
// Smooth i2, q2
_state.I2 = 0.2 * i2_val + 0.8 * _p_state.I2;
_state.Q2 = 0.2 * q2_val + 0.8 * _p_state.Q2;
// 6. Homodyne Discriminator
double re_raw = (_state.I2 * _p_state.I2) + (_state.Q2 * _p_state.Q2);
double im_raw = (_state.I2 * _p_state.Q2) - (_state.Q2 * _p_state.I2);
double re_val = (_state.I2 * _p_state.I2) + (_state.Q2 * _p_state.Q2);
double im_val = (_state.I2 * _p_state.Q2) - (_state.Q2 * _p_state.I2);
// Smoothing
_state.Re = (0.2 * re_raw) + (0.8 * _p_state.Re);
_state.Im = (0.2 * im_raw) + (0.8 * _p_state.Im);
}
// Smooth re, im
_state.Re = 0.2 * re_val + 0.8 * _p_state.Re;
_state.Im = 0.2 * im_val + 0.8 * _p_state.Im;
private double CalculatePeriod(double prevPeriod)
{
double period = 0;
if (Math.Abs(_state.Im) > 1e-9 && Math.Abs(_state.Re) > 1e-9)
{
period = 2 * Math.PI / Math.Atan(_state.Im / _state.Re);
}
// 7. Calculate Period
double angle = Math.Atan2(_state.Im, _state.Re);
double period = Math.Abs(angle) > MinDeltaRadians
? TwoPi / Math.Abs(angle)
: _p_state.Period;
// Adjust period to thresholds
if (prevPeriod > 0)
{
if (period > 1.5 * prevPeriod) period = 1.5 * prevPeriod;
if (period < 0.67 * prevPeriod) period = 0.67 * prevPeriod;
double cap = 1.5 * prevPeriod;
double floor = 0.67 * prevPeriod;
if (period > cap) period = cap;
if (period < floor) period = floor;
}
if (period < 6) period = 6;
if (period > 50) period = 50;
// Smooth the period
return (0.2 * period) + (0.8 * prevPeriod);
}
_state.Period = 0.2 * period + 0.8 * prevPeriod;
_state.SmoothPeriod = 0.33 * _state.Period + 0.67 * _p_state.SmoothPeriod;
private double CalculateInstantaneousTrend(double smoothPeriod, double price)
{
int dcPeriods = (int)(double.IsNaN(smoothPeriod) ? 0 : smoothPeriod + 0.5);
// 8. Instantaneous Trend
int dcPeriods = (int)(double.IsNaN(_state.SmoothPeriod) ? 0 : _state.SmoothPeriod + 0.5);
double sumPr = 0;
int count = 0;
// Sum price over dcPeriods
for (int d = 0; d < dcPeriods; d++)
{
// Check if we have enough history
if (d < _priceBuffer.Count)
{
sumPr += _priceBuffer[^(d + 1)];
@@ -260,7 +197,52 @@ public sealed class Htit : AbstractBase
}
}
return count > 0 ? sumPr / count : price;
double it = count > 0 ? sumPr / count : price;
_itBuffer.Add(it, isNew);
// 9. Final Trendline
// Need at least 12 bars total (Index > 11) to have valid IT history for smoothing
if (_state.Index >= 12)
{
return (4.0 * _itBuffer[^1] + 3.0 * _itBuffer[^2] + 2.0 * _itBuffer[^3] + _itBuffer[^4]) * 0.1;
}
return price;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override TValue Update(TValue input, bool isNew = true)
{
double val = Step(input.Value, isNew);
Last = new TValue(input.Time, val);
PubEvent(Last);
return Last;
}
public override TSeries Update(TSeries source)
{
if (source.Count == 0) return new TSeries([], []);
int len = source.Count;
var v = new List<double>(len);
var t = new List<long>(len);
for (int i = 0; i < len; i++)
{
var result = Update(new TValue(source.Times[i], source.Values[i]));
t.Add(result.Time);
v.Add(result.Value);
}
return new TSeries(t, v);
}
public override void Prime(ReadOnlySpan<double> source)
{
foreach (var value in source)
{
Step(value, true);
}
}
public static TSeries Batch(TSeries source)
@@ -275,181 +257,172 @@ public sealed class Htit : AbstractBase
if (source.Length != output.Length)
throw new ArgumentException("Source and output must have the same length");
int len = source.Length;
if (len == 0) return;
if (source.Length == 0) return;
// Buffers
Span<double> priceBuffer = stackalloc double[50];
Span<double> smoothBuffer = stackalloc double[7];
Span<double> detrenderBuffer = stackalloc double[7];
Span<double> i1Buffer = stackalloc double[7];
Span<double> q1Buffer = stackalloc double[7];
Span<double> periodBuffer = stackalloc double[2];
Span<double> smoothPeriodBuffer = stackalloc double[2];
Span<double> itBuffer = stackalloc double[4];
// Stack allocate buffers
// priceBuffer needs to be larger for IT calculation (up to 50 bars)
// Using 64 (power of 2) for efficient masking
Span<double> priceBuffer = stackalloc double[64];
Span<double> smoothBuffer = stackalloc double[8];
Span<double> detrenderBuffer = stackalloc double[8];
Span<double> i1Buffer = stackalloc double[8];
Span<double> q1Buffer = stackalloc double[8];
Span<double> itBuffer = stackalloc double[8];
int pIdx = 0, sIdx = 0, dIdx = 0, i1Idx = 0, q1Idx = 0, pdIdx = 0, sdIdx = 0, itIdx = 0;
int pCount = 0;
int pIdx = 0; // Index for priceBuffer (mask 63)
int sIdx = 0; // Index for other buffers (mask 7)
int count = 0;
// State variables
double i2 = 0, q2 = 0, re = 0, im = 0;
double period = 0, smoothPeriod = 0;
double lastValidPrice = 0;
// Previous state variables
double p_i2 = 0, p_q2 = 0, p_re = 0, p_im = 0;
double lastValid = 0;
double p_period = 0, p_smoothPeriod = 0;
for (int i = 0; i < len; i++)
const int Mask63 = 63;
const int Mask7 = 7;
for (int i = 0; i < source.Length; i++)
{
double price = source[i];
if (double.IsFinite(price)) lastValid = price; else price = lastValid;
// Add to price buffer
priceBuffer[pIdx] = price;
pCount++;
if (pCount < 7)
if (!double.IsFinite(price))
{
smoothBuffer[sIdx] = price;
detrenderBuffer[dIdx] = 0;
i1Buffer[i1Idx] = 0;
q1Buffer[q1Idx] = 0;
periodBuffer[pdIdx] = 0;
smoothPeriodBuffer[sdIdx] = 0;
itBuffer[itIdx] = price;
output[i] = price;
price = count > 0 ? lastValidPrice : 0.0;
}
else
{
lastValidPrice = price;
}
// Update circular buffer indices
pIdx = (pIdx + 1) & Mask63;
sIdx = (sIdx + 1) & Mask7;
count++;
priceBuffer[pIdx] = price;
if (count > 6)
{
// 1. Smooth Price
double p0 = priceBuffer[pIdx];
double p1 = priceBuffer[(pIdx - 1 + 50) % 50];
double p2 = priceBuffer[(pIdx - 2 + 50) % 50];
double p3 = priceBuffer[(pIdx - 3 + 50) % 50];
double smooth = (4 * p0 + 3 * p1 + 2 * p2 + p3) / 10.0;
double smooth = (4.0 * priceBuffer[pIdx] +
3.0 * priceBuffer[(pIdx - 1) & Mask63] +
2.0 * priceBuffer[(pIdx - 2) & Mask63] +
priceBuffer[(pIdx - 3) & Mask63]) * 0.1;
smoothBuffer[sIdx] = smooth;
// 2. Detrender
double prevPeriod = periodBuffer[(pdIdx - 1 + 2) % 2];
double adj = (adjSlope * prevPeriod) + adjIntercept;
double s0 = smoothBuffer[sIdx];
double s2 = smoothBuffer[(sIdx - 2 + 7) % 7];
double s4 = smoothBuffer[(sIdx - 4 + 7) % 7];
double s6 = smoothBuffer[(sIdx - 6 + 7) % 7];
double detrender = (c1 * s0 + c2 * s2 - c2 * s4 - c1 * s6) * adj;
detrenderBuffer[dIdx] = detrender;
double adj = (adjSlope * p_period) + adjIntercept;
double detrender = (c1 * smoothBuffer[sIdx] +
c2 * smoothBuffer[(sIdx - 2) & Mask7] -
c2 * smoothBuffer[(sIdx - 4) & Mask7] -
c1 * smoothBuffer[(sIdx - 6) & Mask7]) * adj;
detrenderBuffer[sIdx] = detrender;
// 3. In-Phase and Quadrature
double d0 = detrenderBuffer[dIdx];
double d2 = detrenderBuffer[(dIdx - 2 + 7) % 7];
double d4 = detrenderBuffer[(dIdx - 4 + 7) % 7];
double d6 = detrenderBuffer[(dIdx - 6 + 7) % 7];
double q1 = (c1 * detrender +
c2 * detrenderBuffer[(sIdx - 2) & Mask7] -
c2 * detrenderBuffer[(sIdx - 4) & Mask7] -
c1 * detrenderBuffer[(sIdx - 6) & Mask7]) * adj;
q1Buffer[sIdx] = q1;
double q1 = (c1 * d0 + c2 * d2 - c2 * d4 - c1 * d6) * adj;
double i1 = detrenderBuffer[(dIdx - 3 + 7) % 7];
q1Buffer[q1Idx] = q1;
i1Buffer[i1Idx] = i1;
double i1 = detrenderBuffer[(sIdx - 3) & Mask7];
i1Buffer[sIdx] = i1;
// 4. Advance phases
double i1_0 = i1Buffer[i1Idx];
double i1_2 = i1Buffer[(i1Idx - 2 + 7) % 7];
double i1_4 = i1Buffer[(i1Idx - 4 + 7) % 7];
double i1_6 = i1Buffer[(i1Idx - 6 + 7) % 7];
double jI = (c1 * i1_0 + c2 * i1_2 - c2 * i1_4 - c1 * i1_6) * adj;
double jI = (c1 * i1 +
c2 * i1Buffer[(sIdx - 2) & Mask7] -
c2 * i1Buffer[(sIdx - 4) & Mask7] -
c1 * i1Buffer[(sIdx - 6) & Mask7]) * adj;
double q1_0 = q1Buffer[q1Idx];
double q1_2 = q1Buffer[(q1Idx - 2 + 7) % 7];
double q1_4 = q1Buffer[(q1Idx - 4 + 7) % 7];
double q1_6 = q1Buffer[(q1Idx - 6 + 7) % 7];
double jQ = (c1 * q1_0 + c2 * q1_2 - c2 * q1_4 - c1 * q1_6) * adj;
double jQ = (c1 * q1 +
c2 * q1Buffer[(sIdx - 2) & Mask7] -
c2 * q1Buffer[(sIdx - 4) & Mask7] -
c1 * q1Buffer[(sIdx - 6) & Mask7]) * adj;
// 5. Phasor addition
double i2_raw = i1 - jQ;
double q2_raw = q1 + jI;
double i2_val = i1 - jQ;
double q2_val = q1 + jI;
i2 = (0.2 * i2_raw) + (0.8 * p_i2);
q2 = (0.2 * q2_raw) + (0.8 * p_q2);
i2 = 0.2 * i2_val + 0.8 * p_i2;
q2 = 0.2 * q2_val + 0.8 * p_q2;
// 6. Homodyne Discriminator
double re_raw = (i2 * p_i2) + (q2 * p_q2);
double im_raw = (i2 * p_q2) - (q2 * p_i2);
double re_val = (i2 * p_i2) + (q2 * p_q2);
double im_val = (i2 * p_q2) - (q2 * p_i2);
re = (0.2 * re_raw) + (0.8 * p_re);
im = (0.2 * im_raw) + (0.8 * p_im);
re = 0.2 * re_val + 0.8 * p_re;
im = 0.2 * im_val + 0.8 * p_im;
// 7. Calculate Period
double period = 0;
if (Math.Abs(im) > 1e-9 && Math.Abs(re) > 1e-9)
double angle = Math.Atan2(im, re);
double newPeriod = Math.Abs(angle) > MinDeltaRadians
? TwoPi / Math.Abs(angle)
: p_period;
if (p_period > 0)
{
period = 2 * Math.PI / Math.Atan(im / re);
double cap = 1.5 * p_period;
double floor = 0.67 * p_period;
if (newPeriod > cap) newPeriod = cap;
if (newPeriod < floor) newPeriod = floor;
}
if (newPeriod < 6) newPeriod = 6;
if (newPeriod > 50) newPeriod = 50;
if (prevPeriod > 0)
{
if (period > 1.5 * prevPeriod) period = 1.5 * prevPeriod;
if (period < 0.67 * prevPeriod) period = 0.67 * prevPeriod;
}
if (period < 6) period = 6;
if (period > 50) period = 50;
period = (0.2 * period) + (0.8 * prevPeriod);
periodBuffer[pdIdx] = period;
double prevSmoothPeriod = smoothPeriodBuffer[(sdIdx - 1 + 2) % 2];
double smoothPeriod = (0.33 * period) + (0.67 * prevSmoothPeriod);
smoothPeriodBuffer[sdIdx] = smoothPeriod;
period = 0.2 * newPeriod + 0.8 * p_period;
smoothPeriod = 0.33 * period + 0.67 * p_smoothPeriod;
// 8. Instantaneous Trend
int dcPeriods = (int)(double.IsNaN(smoothPeriod) ? 0 : smoothPeriod + 0.5);
int dcPeriods = (int)(smoothPeriod + 0.5);
double sumPr = 0;
int count = 0;
int prCount = 0;
for (int d = 0; d < dcPeriods; d++)
{
if (d < pCount)
if (d < count)
{
sumPr += priceBuffer[(pIdx - d + 50) % 50];
count++;
sumPr += priceBuffer[(pIdx - d) & Mask63];
prCount++;
}
}
double it = count > 0 ? sumPr / count : price;
itBuffer[itIdx] = it;
double it = prCount > 0 ? sumPr / prCount : price;
itBuffer[sIdx] = it;
// 9. Final Trendline
if (pCount >= 12)
{
double it0 = itBuffer[itIdx];
double it1 = itBuffer[(itIdx - 1 + 4) % 4];
double it2 = itBuffer[(itIdx - 2 + 4) % 4];
double it3 = itBuffer[(itIdx - 3 + 4) % 4];
output[i] = (4 * it0 + 3 * it1 + 2 * it2 + it3) / 10.0;
}
else
{
output[i] = price;
}
output[i] = count >= 12
? (4.0 * itBuffer[sIdx] +
3.0 * itBuffer[(sIdx - 1) & Mask7] +
2.0 * itBuffer[(sIdx - 2) & Mask7] +
itBuffer[(sIdx - 3) & Mask7]) * 0.1
: price;
// Update state
// Update previous state
p_i2 = i2;
p_q2 = q2;
p_re = re;
p_im = im;
p_period = period;
p_smoothPeriod = smoothPeriod;
}
else
{
// Initialization
smoothBuffer[sIdx] = price;
detrenderBuffer[sIdx] = 0;
i1Buffer[sIdx] = 0;
q1Buffer[sIdx] = 0;
itBuffer[sIdx] = price;
output[i] = price;
// Reset state variables
p_i2 = 0; p_q2 = 0; p_re = 0; p_im = 0;
p_period = 0; p_smoothPeriod = 0;
}
// Advance indices
pIdx = (pIdx + 1) % 50;
sIdx = (sIdx + 1) % 7;
dIdx = (dIdx + 1) % 7;
i1Idx = (i1Idx + 1) % 7;
q1Idx = (q1Idx + 1) % 7;
pdIdx = (pdIdx + 1) % 2;
sdIdx = (sdIdx + 1) % 2;
itIdx = (itIdx + 1) % 4;
}
}
public override void Reset()
{
Init();
}
}
lib/trends/htit/Htit.md
+68 -35
View File
@@ -8,33 +8,32 @@ HTIT (Hilbert Transform Instantaneous Trend) is a trend-following indicator that
John Ehlers, a pioneer in applying DSP to trading, introduced this in his book *Rocket Science for Traders*. He recognized that markets have cyclic components (noise) and trend components. By identifying the cycle, you can mathematically subtract it to reveal the pure trend.
Most trend indicators (SMA, EMA) are low-pass filters: they let low frequencies (trend) pass and block high frequencies (noise). The problem is that "noise" in markets isn't random white noise; it's often cyclic. A fixed-period SMA might filter out a 10-day cycle perfectly but amplify a 20-day cycle. HTIT solves this by measuring the cycle first, then tuning the filter to kill exactly that frequency.
## Architecture & Physics
This is a complex, multi-stage signal processing pipeline:
This is a complex, multi-stage signal processing pipeline. It's not just a formula; it's a machine.
1. **Smooth**: 4-bar WMA to remove high-frequency noise.
1. **Smooth**: 4-bar WMA to remove high-frequency noise (Nyquist limit).
2. **Detrend**: High-pass filter to remove the DC component (trend) temporarily to isolate the cycle.
3. **Hilbert Transform**: Compute In-Phase (I) and Quadrature (Q) components.
4. **Period Measurement**: Use the phase rate of change (Homodyne Discriminator) to measure the dominant cycle period.
5. **Trend Extraction**: Average the price over the measured dominant cycle period to cancel out the cycle.
6. **Post-Smoothing**: 4-bar WMA on the extracted trend for final polish.
The "physics" here is cancellation. If you average a sine wave over exactly one period, the result is zero. If you average Price (Trend + Cycle) over exactly one cycle period, the Cycle cancels out, leaving only the Trend.
## Mathematical Foundation
The core idea is that if you average a sine wave over exactly one period, the result is 0.
$$ \text{Trend}_t = \frac{1}{\text{DC}} \sum_{i=0}^{\text{DC}-1} P_{t-i} $$
Where $\text{DC}$ is the measured Dominant Cycle period.
### 1. Pre-Smoothing
A 4-tap FIR filter removes high-frequency noise (Nyquist limit) to prevent aliasing before the Hilbert Transform.
A 4-tap FIR filter removes high-frequency noise to prevent aliasing before the Hilbert Transform.
$$ \text{Smooth}_t = \frac{4 P_t + 3 P_{t-1} + 2 P_{t-2} + P_{t-3}}{10} $$
### 2. Hilbert Transform & Detrending
The signal is detrended and split into In-Phase ($I$) and Quadrature ($Q$) components using a 7-tap Hilbert Transform. The coefficients are optimized for market cycles (10-40 bars) to minimize passband ripple.
The signal is detrended and split into In-Phase ($I$) and Quadrature ($Q$) components using a 7-tap Hilbert Transform. The coefficients are optimized for market cycles (10-40 bars).
$$ \text{Adj} = 0.075 \cdot \text{Period}_{t-1} + 0.54 $$
@@ -46,46 +45,80 @@ $$ I_t = D_{t-3} $$
### 3. Homodyne Discriminator
The phase rate of change is calculated using the complex conjugate product of the current and previous phasors.
The phase rate of change is calculated using the complex conjugate product of the current and previous phasors. This is the "Homodyne Discriminator" - a fancy radio term for "measuring frequency by comparing a signal to a delayed version of itself."
$$ \Delta \text{Phase} = \arctan\left(\frac{I_t Q_{t-1} - Q_t I_{t-1}}{I_t I_{t-1} + Q_t Q_{t-1}}\right) $$
$$ \text{Re}_t = (I2_t \cdot I2_{t-1}) + (Q2_t \cdot Q2_{t-1}) $$
$$ \text{Period}_t = \frac{2\pi}{\Delta \text{Phase}} $$
$$ \text{Im}_t = (I2_t \cdot Q2_{t-1}) - (Q2_t \cdot I2_{t-1}) $$
The period is derived from the phase angle of this complex product:
$$ \text{Period}_t = \frac{2\pi}{\arctan\left(\frac{\text{Im}_t}{\text{Re}_t}\right)} $$
The period is constrained to [6, 50] bars and smoothed.
### 4. Instantaneous Trend
The trend is extracted by averaging the price over the measured dominant cycle period.
The trend is extracted by averaging the price over the measured dominant cycle period. This is the magic step.
$$ \text{Trend}_t = \frac{1}{\text{Period}_t} \sum_{i=0}^{\text{Period}_t-1} P_{t-i} $$
$$ \text{IT}_t = \frac{1}{\text{DC}} \sum_{i=0}^{\text{DC}-1} P_{t-i} $$
Where $\text{DC}$ is the integer part of the smoothed dominant cycle period.
### 5. Final Output
The Instantaneous Trend is smoothed again using the same 4-bar WMA to remove any residual stepping artifacts from the integer period changes.
$$ \text{HTIT}_t = \frac{4 \text{IT}_t + 3 \text{IT}_{t-1} + 2 \text{IT}_{t-2} + \text{IT}_{t-3}}{10} $$
## Mathematical Precision & Implementation Philosophy
Like our MAMA implementation, QuanTAlib's HTIT prioritizes mathematical correctness over blind porting.
| Aspect | Other Libraries | QuanTAlib | Rationale |
| :----------------------- | :----------------- | :---------------------- | :-------------------------------------------- |
| **Hilbert Coefficients** | `0.0962`, `0.5769` | `5.0/52.0`, `15.0/26.0` | Exact fractions avoid rounding accumulation |
| **Adjustment Slope** | `0.075` | `3.0/40.0` | Preserves rational arithmetic precision |
| **Adjustment Intercept** | `0.54` | `27.0/50.0` | Ditto |
| **Arctangent Function** | `atan(y/x)` | `atan2(y, x)` | Proper quadrant handling, no division by zero |
| **Period Calculation** | `360/atan(...)` | `2π/atan2(...)` | Mathematically correct radians |
We use `atan2` for robust phase calculation and maintain full double precision throughout the pipeline.
## Performance Profile
This is an $O(1)$ algorithm, but the constant factor is large due to the many steps.
HTIT is computationally heavier than a simple MA but lighter than MAMA. The main cost is the loop for the Instantaneous Trend calculation, which sums up to 50 past prices.
| Metric | Score | Notes |
| :--- | :--- | :--- |
| **Throughput** | [N] ns/bar | Heavy floating-point math per bar |
| **Allocations** | 0 | Stack-based calculations only |
| **Complexity** | O(1) | Pipeline depth is fixed |
| **Accuracy** | 9/10 | Extracts trend by removing cycle |
| **Timeliness** | 7/10 | Adapts, but has some lag |
| **Overshoot** | 8/10 | Generally good, stable trendline |
| **Smoothness** | 9/10 | Very smooth trendline |
| Metric | Score | Notes |
| :-------------- | :---------- | :----------------------------------------------------------- |
| **Throughput** | ~120 ns/bar | Variable cost due to dynamic loop length |
| **Allocations** | 0 | Stack-based circular buffers |
| **Complexity** | O(N) | Depends on cycle period (max 50 iterations) |
| **Accuracy** | 9/10 | Extracts trend by removing cycle |
| **Timeliness** | 7/10 | Adapts, but has inherent lag from the cycle period averaging |
| **Overshoot** | 8/10 | Generally good, stable trendline |
| **Smoothness** | 9/10 | Very smooth trendline due to double WMA |
## Validation
Validated against Ehlers' original EasyLanguage code and Python ports.
Validated against TA-Lib, Skender, and Ooples.
| Library | Status | Notes |
| :--- | :--- | :--- |
| **QuanTAlib** | ✅ | Validated. |
| **TA-Lib** | ✅ | Matches `HtTrendline` exactly |
| **Skender** | ⚠️ | Matches `GetHtTrendline` (~0.32% diff) |
| **Ooples** | ⚠️ | Matches `CalculateEhlersInstantaneousTrendlineV1` (~0.25% diff) |
| Library | Status | Notes |
| :------------ | :----------- | :--------------------------------------------------------------- |
| **QuanTAlib** | ✅ Reference | Mathematically correct implementation. |
| **TA-Lib** | ✅ | Matches `HtTrendline` exactly (1e-9 precision). |
| **Skender** | ⚠️ | Matches `GetHtTrendline` (~0.32% diff). |
| **Ooples** | ⚠️ | Matches `CalculateEhlersInstantaneousTrendlineV1` (~0.25% diff). |
The differences with Skender and Ooples arise from:
1. **Initialization**: How the first few bars are handled.
2. **Precision**: Hardcoded decimals vs exact fractions.
3. **Period Constraints**: How strictly the [6, 50] bounds are enforced during intermediate steps.
| **Tulip** | N/A | Not implemented. |
### Common Pitfalls
1. **Warmup**: This indicator needs significant warmup (at least 12 bars, ideally 50+) for the feedback loops (period smoothing) to stabilize.
2. **Lag**: While it adapts, the trendline still lags because it's essentially a dynamic SMA. The advantage is that the period is optimal for the current market condition.
1. **Warmup**: This indicator needs significant warmup (at least 12 bars, ideally 50+) for the feedback loops (period smoothing) to stabilize. Don't trust the first 50 bars.
2. **Lag**: While it adapts, the trendline still lags because it's essentially a dynamic SMA. The advantage is that the period is optimal for the current market condition, not that it has zero lag.
3. **Complexity**: Debugging this is a nightmare. Trust the math.
4. **Ranging Markets**: In a pure range, the "trend" should be flat. HTIT handles this well because the cycle cancellation works best when the cycle is clear.