mirror of
https://github.com/mihakralj/QuanTAlib.git
synced 2026-08-18 10:38:05 +00:00
Add TRAMA implementation and comprehensive tests
- Implemented the TRAMA (Trend Regularity Adaptive Moving Average) class with adaptive EMA logic. - Added unit tests for TRAMA functionality, including constructor validation, basic calculations, state management, and robustness checks. - Created validation tests to ensure consistency across different modes of operation (streaming, batch, and static calculations). - Enhanced documentation for TRAMA, including performance profiles and quality metrics. - Updated workspace configuration by removing unnecessary folder references.
This commit is contained in:
Miha Kralj
@@ -22,10 +22,12 @@ Oscillators fluctuate above and below a centerline or within bounded ranges. Use
|
||||
| [KRI](kri/Kri.md) | Kairi Relative Index | Percentage deviation of price from SMA. Overbought/oversold. |
|
||||
| [PGO](pgo/Pgo.md) | Pretty Good Oscillator | Distance from SMA normalized by ATR. Units: ATR multiples. |
|
||||
| [PSL](psl/Psl.md) | Psychological Line | Ratio of up periods to total periods. Crowd sentiment gauge. |
|
||||
| [REFLEX](reflex/Reflex.md) | Ehlers Reflex | Ehlers zero-centered reversal oscillator using super smoother with normalized sum-of-differences. |
|
||||
| [SMI](smi/Smi.md) | Stochastic Momentum Index | Distance from range midpoint. More sensitive than classic Stochastic. |
|
||||
| [STOCH](stoch/Stoch.md) | Stochastic Oscillator | Close position within N-period high-low range. Classic overbought/oversold. |
|
||||
| [STOCHF](stochf/Stochf.md) | Stochastic Fast | Unsmoothed Stochastic. Faster but noisier. |
|
||||
| [STOCHRSI](stochrsi/Stochrsi.md) | Stochastic RSI | Stochastic applied to RSI. More sensitive than either alone. |
|
||||
| [TRENDFLEX](trendflex/Trendflex.md) | Ehlers Trendflex | Ehlers zero-lag trend oscillator using super smoother with sum-of-differences normalization. |
|
||||
| [TRIX](trix/Trix.md) | Triple Exponential Average | ROC of triple EMA. Filters noise through three smoothings. |
|
||||
| [TTM_WAVE](ttm_wave/TtmWave.md) | TTM Wave | Fibonacci-period MACD composite (Waves A/B/C). John Carter. |
|
||||
| [ULTOSC](ultosc/Ultosc.md) | Ultimate Oscillator | Multi-timeframe oscillator. Combines 7, 14, 28 period buying pressure. |
|
||||
|
||||
@@ -0,0 +1,100 @@
|
||||
# BBI: Bulls Bears Index
|
||||
|
||||
> "Average four moving averages of doubling periods and you get a single line that votes on whether bulls or bears own the tape. It is a committee of trends, each watching a different time horizon, forced to agree on one number."
|
||||
|
||||
BBI (Bulls Bears Index) computes the arithmetic mean of four Simple Moving Averages with geometrically spaced periods (3, 6, 12, 24 by default). The result is a price-overlay line that captures trend consensus across ultra-short, short, medium, and long timeframes simultaneously. Price above BBI signals bullish dominance; price below BBI signals bearish control. The crossover point marks the regime boundary between long and short markets.
|
||||
|
||||
## Historical Context
|
||||
|
||||
BBI originated in the Chinese stock market technical analysis community, where it became a standard indicator on domestic trading platforms and textbooks. The Chinese name (多空指标, duō kōng zhǐbiāo, literally "long-short indicator") reflects its primary purpose: determining whether the market is in a bullish ("long") or bearish ("short") regime.
|
||||
|
||||
The specific period set (3, 6, 12, 24) follows a doubling progression that spans from intraday noise (3 bars) to nearly a full trading month (24 bars on a daily chart). This geometric spacing ensures each SMA captures a distinct frequency band of price behavior. The equal-weight average ($1/4$ each) treats all four timeframes as equally important, which is a deliberate design choice: no single timeframe dominates the composite signal.
|
||||
|
||||
BBI is functionally equivalent to a single weighted moving average with a composite kernel. The kernel is the sum of four rectangular windows of lengths 3, 6, 12, and 24, normalized by 4. This means each price bar contributes to the output based on how many of the four SMA windows it falls within: the most recent 3 bars are counted by all four SMAs (effective weight $4/4$), bars 4-6 by three SMAs ($3/4$), bars 7-12 by two ($2/4$), and bars 13-24 by one ($1/4$). The result is a stepped triangular-like kernel that naturally emphasizes recent prices without requiring explicit weight parameters.
|
||||
|
||||
## Architecture & Physics
|
||||
|
||||
### 1. Four Independent SMA Buffers
|
||||
|
||||
Four circular buffers of sizes $N_1, N_2, N_3, N_4$ maintain running sums for O(1) per-bar SMA updates:
|
||||
|
||||
$$
|
||||
\text{SMA}_k[t] = \frac{1}{N_k} \sum_{i=0}^{N_k - 1} x_{t-i}, \quad k = 1, 2, 3, 4
|
||||
$$
|
||||
|
||||
### 2. Composite Average
|
||||
|
||||
$$
|
||||
\text{BBI}[t] = \frac{\text{SMA}_1[t] + \text{SMA}_2[t] + \text{SMA}_3[t] + \text{SMA}_4[t]}{4}
|
||||
$$
|
||||
|
||||
### 3. Warmup Behavior
|
||||
|
||||
Each SMA produces valid output from bar 1 using available data (partial window). The composite BBI is valid from bar 1, with full-window accuracy achieved once all four SMAs have filled: $\text{WarmupPeriod} = \max(N_1, N_2, N_3, N_4) = 24$ bars with default parameters.
|
||||
|
||||
## Mathematical Foundation
|
||||
|
||||
**Individual SMAs with running sums:**
|
||||
|
||||
$$
|
||||
S_k[t] = S_k[t-1] - x_{t-N_k} + x_t
|
||||
$$
|
||||
|
||||
$$
|
||||
\text{SMA}_k[t] = \frac{S_k[t]}{N_k}
|
||||
$$
|
||||
|
||||
**Composite output:**
|
||||
|
||||
$$
|
||||
\text{BBI}[t] = \frac{1}{4} \sum_{k=1}^{4} \text{SMA}_k[t]
|
||||
$$
|
||||
|
||||
**Equivalent single-pass kernel:** Substituting the SMA definitions:
|
||||
|
||||
$$
|
||||
\text{BBI}[t] = \frac{1}{4} \sum_{k=1}^{4} \frac{1}{N_k} \sum_{i=0}^{N_k - 1} x_{t-i} = \sum_{i=0}^{N_4 - 1} w_i \cdot x_{t-i}
|
||||
$$
|
||||
|
||||
where the effective weight for lag $i$ is:
|
||||
|
||||
$$
|
||||
w_i = \frac{1}{4} \sum_{k=1}^{4} \frac{\mathbf{1}_{[i < N_k]}}{N_k}
|
||||
$$
|
||||
|
||||
For default periods $(3, 6, 12, 24)$:
|
||||
|
||||
| Lag range | Contributing SMAs | Weight |
|
||||
| :--- | :---: | :---: |
|
||||
| $0 \leq i < 3$ | All 4 | $\frac{1}{4}\left(\frac{1}{3} + \frac{1}{6} + \frac{1}{12} + \frac{1}{24}\right) \approx 0.1528$ |
|
||||
| $3 \leq i < 6$ | SMA2, SMA3, SMA4 | $\frac{1}{4}\left(\frac{1}{6} + \frac{1}{12} + \frac{1}{24}\right) \approx 0.0694$ |
|
||||
| $6 \leq i < 12$ | SMA3, SMA4 | $\frac{1}{4}\left(\frac{1}{12} + \frac{1}{24}\right) \approx 0.0313$ |
|
||||
| $12 \leq i < 24$ | SMA4 only | $\frac{1}{4} \cdot \frac{1}{24} \approx 0.0104$ |
|
||||
|
||||
**Group delay:** The weighted centroid of the composite kernel determines the effective lag:
|
||||
|
||||
$$
|
||||
\bar{d} = \frac{1}{4} \sum_{k=1}^{4} \frac{N_k - 1}{2} = \frac{1}{4} \cdot \frac{(3-1) + (6-1) + (12-1) + (24-1)}{2} = \frac{42}{8} = 5.25 \text{ bars}
|
||||
$$
|
||||
|
||||
**Default parameters:** `p1 = 3`, `p2 = 6`, `p3 = 12`, `p4 = 24`, `minPeriod = 1`.
|
||||
|
||||
**Pseudo-code (streaming):**
|
||||
|
||||
```
|
||||
// Four circular buffers with running sums
|
||||
for k = 1 to 4:
|
||||
sum[k] -= buf[k][head[k]]
|
||||
sum[k] += src
|
||||
buf[k][head[k]] = src
|
||||
head[k] = (head[k] + 1) % period[k]
|
||||
sma[k] = sum[k] / min(count, period[k])
|
||||
|
||||
return (sma[1] + sma[2] + sma[3] + sma[4]) / 4
|
||||
```
|
||||
|
||||
## Resources
|
||||
|
||||
- TradingView. "BBI - Bull and Bear Index." Community Scripts. (Standard implementation reference.)
|
||||
- Chinese Securities Association. Technical analysis indicator specifications. (Origin of 3/6/12/24 period convention.)
|
||||
- Binance Square. "BBI Indicator Usage Tutorial." (Modern application to cryptocurrency markets.)
|
||||
@@ -0,0 +1,103 @@
|
||||
# REFLEX: Ehlers Reflex Indicator
|
||||
|
||||
> "John Ehlers measured how much a filtered price deviates from its own linear extrapolation. The result is a zero-lag oscillator that catches reversals before they happen, because the deviation is largest precisely when the trend is bending."
|
||||
|
||||
REFLEX is a zero-lag oscillator that measures the reversal tendency of price by comparing a Super-Smoother-filtered price against a linear extrapolation from $N$ bars ago. The filter computes the slope of the filtered series over the lookback window, projects a straight line, and sums the deviations of the actual filtered values from this projected line. The sum is normalized by an exponential RMS estimate to produce values in roughly $\pm \sigma$ scale. Values above 0 indicate uptrend, below 0 indicate downtrend; crossovers signal potential reversals.
|
||||
|
||||
## Historical Context
|
||||
|
||||
John F. Ehlers published REFLEX in "Reflex: A New Zero-Lag Indicator" (*Technical Analysis of Stocks & Commodities*, February 2020). Ehlers' motivation was to create a cycle-based oscillator that responds to trend reversals with zero lag, unlike traditional oscillators (RSI, stochastic) that inherently lag price due to their smoothing components.
|
||||
|
||||
The core idea is that linear extrapolation of a smoothed series will overshoot (undershoot) when the trend is decelerating (accelerating). By measuring the sum of these overshoots, REFLEX detects curvature changes — exactly the inflection points where trends reverse. This is mathematically similar to measuring the second derivative (acceleration), but the linear-extrapolation approach is more numerically stable and naturally adapts to the trend's own slope.
|
||||
|
||||
The 2-pole Super Smoother pre-filter (at half the specified period) removes high-frequency noise before the reflex computation, preventing false signals from bar-to-bar price noise. The exponential RMS normalization ensures the output has consistent scale regardless of the instrument's volatility.
|
||||
|
||||
## Architecture & Physics
|
||||
|
||||
### 1. Super Smoother Pre-Filter
|
||||
|
||||
A 2-pole IIR low-pass filter with cutoff at half the specified period:
|
||||
|
||||
$$
|
||||
\text{Filt} = c_1 \cdot \frac{x_t + x_{t-1}}{2} + c_2 \cdot \text{Filt}_{t-1} + c_3 \cdot \text{Filt}_{t-2}
|
||||
$$
|
||||
|
||||
where $a_1 = e^{-\sqrt{2}\pi / (N/2)}$, $c_2 = 2a_1\cos(\sqrt{2}\pi/(N/2))$, $c_3 = -a_1^2$, $c_1 = 1-c_2-c_3$.
|
||||
|
||||
### 2. Linear Extrapolation Slope
|
||||
|
||||
$$
|
||||
\text{slope} = \frac{\text{Filt}_{t-N} - \text{Filt}_t}{N}
|
||||
$$
|
||||
|
||||
### 3. Deviation Summation
|
||||
|
||||
$$
|
||||
\text{Sum} = \frac{1}{N}\sum_{i=1}^{N}\left[(\text{Filt}_t + i \cdot \text{slope}) - \text{Filt}_{t-i}\right]
|
||||
$$
|
||||
|
||||
### 4. Exponential RMS Normalization
|
||||
|
||||
$$
|
||||
\text{MS} = 0.04 \cdot \text{Sum}^2 + 0.96 \cdot \text{MS}_{t-1}
|
||||
$$
|
||||
|
||||
$$
|
||||
\text{REFLEX} = \frac{\text{Sum}}{\sqrt{\text{MS}}}
|
||||
$$
|
||||
|
||||
## Mathematical Foundation
|
||||
|
||||
**Super Smoother coefficients (half-period cutoff):**
|
||||
|
||||
$$
|
||||
a_1 = e^{-\sqrt{2}\pi / (N/2)}, \quad c_2 = 2a_1\cos\!\left(\frac{\sqrt{2}\pi}{N/2}\right), \quad c_3 = -a_1^2, \quad c_1 = 1-c_2-c_3
|
||||
$$
|
||||
|
||||
**Deviation from linear trend:**
|
||||
|
||||
$$
|
||||
D_i = (\text{Filt}_t + i \cdot \text{slope}) - \text{Filt}_{t-i}, \quad i = 1, \ldots, N
|
||||
$$
|
||||
|
||||
**Mean deviation:**
|
||||
|
||||
$$
|
||||
\text{Sum} = \frac{1}{N}\sum_{i=1}^{N} D_i
|
||||
$$
|
||||
|
||||
**Interpretation:**
|
||||
|
||||
- $\text{Sum} > 0$: filtered price is above its linear extrapolation (upward curvature, potential uptrend)
|
||||
- $\text{Sum} < 0$: filtered price is below its linear extrapolation (downward curvature, potential downtrend)
|
||||
- Zero crossings signal inflection points (trend reversals)
|
||||
|
||||
**Default parameters:** `period = 20`, `minPeriod = 2`. Output is an oscillator (not overlay).
|
||||
|
||||
**Pseudo-code (streaming):**
|
||||
|
||||
```
|
||||
// Super Smoother (2-pole IIR)
|
||||
filt = c1*(price + price[1])/2 + c2*filt[1] + c3*filt[2]
|
||||
|
||||
// Store in circular buffer
|
||||
buf[head] = filt
|
||||
|
||||
// Slope from N-bar-ago to current
|
||||
slope = (filt_lag_N - filt) / N
|
||||
|
||||
// Sum deviations from linear extrapolation
|
||||
sum = 0
|
||||
for i = 1 to N:
|
||||
sum += (filt + i*slope) - filt[i]
|
||||
sum /= N
|
||||
|
||||
// Normalize by exponential RMS
|
||||
ms = 0.04 * sum² + 0.96 * ms[1]
|
||||
return ms > 0 ? sum / sqrt(ms) : 0
|
||||
```
|
||||
|
||||
## Resources
|
||||
|
||||
- Ehlers, J.F. (2020). "Reflex: A New Zero-Lag Indicator." *Technical Analysis of Stocks & Commodities*, February 2020.
|
||||
- Ehlers, J.F. (2013). *Cycle Analytics for Traders*. Wiley. Chapter 3: Super Smoothers.
|
||||
@@ -0,0 +1,90 @@
|
||||
// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0
|
||||
// https://mozilla.org/MPL/2.0/
|
||||
// © QuanTAlib
|
||||
|
||||
//@version=6
|
||||
indicator("Ehlers Reflex Indicator (REFLEX)", "REFLEX", overlay = false)
|
||||
|
||||
//@function Ehlers Reflex — a zero-lag oscillator that measures the reflex (reversal
|
||||
// tendency) of price by comparing the SSF-filtered price against a linear
|
||||
// extrapolation from N bars ago. Applies a 2-pole Super Smoother pre-filter
|
||||
// at half the specified period, then computes slope = (Filt[N] - Filt) / N,
|
||||
// sums deviations of the extrapolated line from actual filtered values over
|
||||
// the window, and normalizes by exponential RMS. Values above 0 suggest
|
||||
// uptrend, below 0 suggest downtrend; crossovers signal reversals.
|
||||
//@param source Series to analyze
|
||||
//@param period Lookback window / assumed cycle period (>= 2)
|
||||
//@returns Reflex oscillator value (normalized, roughly ±σ scale)
|
||||
//@reference Ehlers, J.F. (2020). "Reflex: A New Zero-Lag Indicator."
|
||||
// Technical Analysis of Stocks & Commodities, Feb 2020.
|
||||
//@optimized O(period) per bar for the summation loop; SSF is O(1) IIR
|
||||
export reflex(series float source, simple int period) =>
|
||||
if period < 2
|
||||
runtime.error("Period must be at least 2")
|
||||
|
||||
float price = nz(source)
|
||||
|
||||
// --- 2-Pole Super Smoother Filter (half-period cutoff) ---
|
||||
float half_period = period * 0.5
|
||||
float a1 = math.exp(-1.414 * math.pi / half_period)
|
||||
float b1 = 2.0 * a1 * math.cos(1.414 * math.pi / half_period)
|
||||
float c2 = b1
|
||||
float c3 = -(a1 * a1)
|
||||
float c1 = 1.0 - c2 - c3
|
||||
|
||||
var float filt = 0.0
|
||||
var float filt1 = 0.0
|
||||
var float filt2 = 0.0
|
||||
float src1 = nz(source[1])
|
||||
filt2 := filt1
|
||||
filt1 := filt
|
||||
filt := c1 * (price + src1) * 0.5 + c2 * filt1 + c3 * filt2
|
||||
|
||||
// --- Circular buffer to store filtered values for lookback ---
|
||||
var array<float> buf = array.new_float(period + 1, 0.0)
|
||||
var int head = 0
|
||||
array.set(buf, head, filt)
|
||||
|
||||
int count = math.min(bar_index + 1, period)
|
||||
|
||||
// --- Slope: (Filt[Length] - Filt) / Length ---
|
||||
int lag_idx = (head - period + period + 1) % (period + 1)
|
||||
float filt_lag = array.get(buf, lag_idx)
|
||||
float slope = (filt_lag - filt) / period
|
||||
|
||||
// --- Sum the differences ---
|
||||
// Sum = Σ(i=1..Length) [(Filt + i*Slope) - Filt[i]] / Length
|
||||
float the_sum = 0.0
|
||||
if count >= period
|
||||
for i = 1 to period
|
||||
int idx = (head - i + period + 1) % (period + 1)
|
||||
float filt_i = array.get(buf, idx)
|
||||
the_sum += (filt + float(i) * slope) - filt_i
|
||||
the_sum /= period
|
||||
|
||||
// --- Advance head ---
|
||||
head := (head + 1) % (period + 1)
|
||||
|
||||
// --- Normalize in terms of Standard Deviations ---
|
||||
// MS = 0.04 * Sum² + 0.96 * MS[1] (exponential RMS)
|
||||
var float ms = 0.0
|
||||
ms := 0.04 * the_sum * the_sum + 0.96 * ms
|
||||
|
||||
float result = 0.0
|
||||
if ms > 0.0
|
||||
result := the_sum / math.sqrt(ms)
|
||||
|
||||
result
|
||||
|
||||
// ── Inputs ──
|
||||
int p_period = input.int(20, "Period", minval = 2)
|
||||
float p_src = input.source(close, "Source")
|
||||
|
||||
// ── Calculation ──
|
||||
float out = reflex(p_src, p_period)
|
||||
|
||||
// ── Plot ──
|
||||
plot(out, "REFLEX", color.yellow, 2)
|
||||
hline(0, "Zero", color.gray)
|
||||
hline(1.0, "+1σ", color.new(color.red, 60))
|
||||
hline(-1.0, "-1σ", color.new(color.green, 60))
|
||||
@@ -0,0 +1,155 @@
|
||||
using TradingPlatform.BusinessLayer;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public class TrendflexIndicatorTests
|
||||
{
|
||||
[Fact]
|
||||
public void TrendflexIndicator_Constructor_SetsDefaults()
|
||||
{
|
||||
var indicator = new TrendflexIndicator();
|
||||
|
||||
Assert.Equal(20, indicator.Period);
|
||||
Assert.Equal(SourceType.Close, indicator.Source);
|
||||
Assert.True(indicator.ShowColdValues);
|
||||
Assert.Equal("TRENDFLEX - Ehlers Trendflex Indicator", indicator.Name);
|
||||
Assert.True(indicator.SeparateWindow);
|
||||
Assert.True(indicator.OnBackGround);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TrendflexIndicator_MinHistoryDepths_EqualsZero()
|
||||
{
|
||||
var indicator = new TrendflexIndicator();
|
||||
|
||||
Assert.Equal(0, TrendflexIndicator.MinHistoryDepths);
|
||||
Assert.Equal(0, ((IWatchlistIndicator)indicator).MinHistoryDepths);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TrendflexIndicator_ShortName_IncludesPeriodAndSource()
|
||||
{
|
||||
var indicator = new TrendflexIndicator { Period = 30 };
|
||||
|
||||
Assert.Contains("TRENDFLEX", indicator.ShortName, StringComparison.Ordinal);
|
||||
Assert.Contains("30", indicator.ShortName, StringComparison.Ordinal);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TrendflexIndicator_SourceCodeLink_IsValid()
|
||||
{
|
||||
var indicator = new TrendflexIndicator();
|
||||
|
||||
Assert.Contains("github.com", indicator.SourceCodeLink, StringComparison.Ordinal);
|
||||
Assert.Contains("Trendflex.Quantower.cs", indicator.SourceCodeLink, StringComparison.Ordinal);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TrendflexIndicator_Initialize_CreatesInternalIndicator()
|
||||
{
|
||||
var indicator = new TrendflexIndicator { Period = 20 };
|
||||
|
||||
indicator.Initialize();
|
||||
|
||||
// After init, one line series should exist (Trendflex is single output)
|
||||
Assert.Single(indicator.LinesSeries);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TrendflexIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
|
||||
{
|
||||
var indicator = new TrendflexIndicator { Period = 3 };
|
||||
indicator.Initialize();
|
||||
|
||||
var now = DateTime.UtcNow;
|
||||
indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
|
||||
|
||||
var args = new UpdateArgs(UpdateReason.HistoricalBar);
|
||||
indicator.ProcessUpdate(args);
|
||||
|
||||
Assert.Equal(1, indicator.LinesSeries[0].Count);
|
||||
Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TrendflexIndicator_ProcessUpdate_NewBar_ComputesValue()
|
||||
{
|
||||
var indicator = new TrendflexIndicator { Period = 3 };
|
||||
indicator.Initialize();
|
||||
|
||||
var now = DateTime.UtcNow;
|
||||
indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
|
||||
indicator.HistoricalData.AddBar(now.AddMinutes(1), 102, 108, 100, 106);
|
||||
|
||||
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
|
||||
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
|
||||
|
||||
Assert.Equal(2, indicator.LinesSeries[0].Count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TrendflexIndicator_InternalIndicator_HandlesBarCorrection()
|
||||
{
|
||||
// Test the underlying Trendflex with isNew=false (bar correction)
|
||||
var ma = new Trendflex(3);
|
||||
|
||||
var now = DateTime.UtcNow;
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
ma.Update(new TValue(now.AddMinutes(i).Ticks, 100 + i), isNew: true);
|
||||
}
|
||||
|
||||
double beforeCorrection = ma.Last.Value;
|
||||
|
||||
// Correct last bar with a very different value
|
||||
ma.Update(new TValue(now.AddMinutes(9).Ticks, 200), isNew: false);
|
||||
double afterCorrection = ma.Last.Value;
|
||||
|
||||
Assert.NotEqual(beforeCorrection, afterCorrection);
|
||||
Assert.True(double.IsFinite(afterCorrection));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TrendflexIndicator_DifferentSourceTypes()
|
||||
{
|
||||
foreach (SourceType sourceType in new[] { SourceType.Close, SourceType.Open, SourceType.High, SourceType.Low })
|
||||
{
|
||||
var indicator = new TrendflexIndicator();
|
||||
indicator.Source = sourceType;
|
||||
Assert.Equal(sourceType, indicator.Source);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TrendflexIndicator_MultipleHistoricalBars()
|
||||
{
|
||||
var indicator = new TrendflexIndicator { Period = 5 };
|
||||
indicator.Initialize();
|
||||
|
||||
var now = DateTime.UtcNow;
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
indicator.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 105 + i, 95 + i, 102 + i);
|
||||
indicator.ProcessUpdate(new UpdateArgs(i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar));
|
||||
}
|
||||
|
||||
Assert.Equal(20, indicator.LinesSeries[0].Count);
|
||||
|
||||
// All values should be finite
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(i)));
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TrendflexIndicator_PeriodChange_UpdatesConfig()
|
||||
{
|
||||
var indicator = new TrendflexIndicator();
|
||||
indicator.Period = 25;
|
||||
Assert.Equal(25, indicator.Period);
|
||||
|
||||
indicator.Period = 50;
|
||||
Assert.Equal(50, indicator.Period);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
using System.Drawing;
|
||||
using System.Runtime.CompilerServices;
|
||||
using TradingPlatform.BusinessLayer;
|
||||
|
||||
namespace QuanTAlib;
|
||||
|
||||
[SkipLocalsInit]
|
||||
public sealed class TrendflexIndicator : Indicator, IWatchlistIndicator
|
||||
{
|
||||
[InputParameter("Period", sortIndex: 1, 1, 1000, 1, 0)]
|
||||
public int Period { get; set; } = 20;
|
||||
|
||||
[IndicatorExtensions.DataSourceInput]
|
||||
public SourceType Source { get; set; } = SourceType.Close;
|
||||
|
||||
[InputParameter("Show cold values", sortIndex: 21)]
|
||||
public bool ShowColdValues { get; set; } = true;
|
||||
|
||||
private Trendflex _ma = null!;
|
||||
private readonly LineSeries _series;
|
||||
private string _sourceName = null!;
|
||||
private Func<IHistoryItem, double> _priceSelector = null!;
|
||||
|
||||
public static int MinHistoryDepths => 0;
|
||||
int IWatchlistIndicator.MinHistoryDepths => MinHistoryDepths;
|
||||
|
||||
public override string ShortName => $"TRENDFLEX {Period}:{_sourceName}";
|
||||
public override string SourceCodeLink => "https://github.com/mihakralj/QuanTAlib/blob/main/lib/oscillators/trendflex/Trendflex.Quantower.cs";
|
||||
|
||||
public TrendflexIndicator()
|
||||
{
|
||||
OnBackGround = true;
|
||||
SeparateWindow = true;
|
||||
_sourceName = Source.ToString();
|
||||
Name = "TRENDFLEX - Ehlers Trendflex Indicator";
|
||||
Description = "Measures trend slope via Super Smoother pre-filter with O(1) cumulative slope and RMS normalization";
|
||||
_series = new LineSeries(name: $"TRENDFLEX {Period}", color: Color.Yellow, width: 2, style: LineStyle.Solid);
|
||||
AddLineSeries(_series);
|
||||
}
|
||||
|
||||
protected override void OnInit()
|
||||
{
|
||||
_ma = new Trendflex(Period);
|
||||
_sourceName = Source.ToString();
|
||||
_priceSelector = Source.GetPriceSelector();
|
||||
base.OnInit();
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
protected override void OnUpdate(UpdateArgs args)
|
||||
{
|
||||
var item = HistoricalData[Count - 1, SeekOriginHistory.Begin];
|
||||
TValue result = _ma.Update(new TValue(item.TimeLeft.Ticks, _priceSelector(item)), isNew: args.IsNewBar());
|
||||
_series.SetValue(result.Value, _ma.IsHot, ShowColdValues);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,422 @@
|
||||
namespace QuanTAlib;
|
||||
|
||||
public class TrendflexTests
|
||||
{
|
||||
private const int DefaultPeriod = 20;
|
||||
private const double Tolerance = 1e-12;
|
||||
|
||||
private static TSeries MakeSeries(int count = 500)
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.5, seed: 42);
|
||||
var bars = gbm.Fetch(count, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
return bars.Close;
|
||||
}
|
||||
|
||||
// ========== A) Constructor Validation ==========
|
||||
|
||||
[Fact]
|
||||
public void Constructor_ZeroPeriod_ThrowsArgumentOutOfRangeException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentOutOfRangeException>(() => new Trendflex(0));
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_NegativePeriod_ThrowsArgumentOutOfRangeException()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentOutOfRangeException>(() => new Trendflex(-5));
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_ValidPeriod_SetsNameAndWarmup()
|
||||
{
|
||||
var indicator = new Trendflex(20);
|
||||
Assert.Equal("Trendflex(20)", indicator.Name);
|
||||
Assert.Equal(20, indicator.WarmupPeriod);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_PeriodOne_IsValid()
|
||||
{
|
||||
var indicator = new Trendflex(1);
|
||||
Assert.Equal("Trendflex(1)", indicator.Name);
|
||||
Assert.Equal(1, indicator.WarmupPeriod);
|
||||
}
|
||||
|
||||
// ========== B) Basic Calculation ==========
|
||||
|
||||
[Fact]
|
||||
public void Update_ReturnsTValue_WithValidProperties()
|
||||
{
|
||||
var indicator = new Trendflex(DefaultPeriod);
|
||||
var input = new TValue(DateTime.UtcNow, 100.0);
|
||||
TValue result = indicator.Update(input);
|
||||
|
||||
Assert.Equal(input.Time, result.Time);
|
||||
Assert.True(double.IsFinite(result.Value));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_AfterWarmup_IsHotBecomesTrue()
|
||||
{
|
||||
var indicator = new Trendflex(DefaultPeriod);
|
||||
Assert.False(indicator.IsHot);
|
||||
|
||||
for (int i = 0; i < 500; i++)
|
||||
{
|
||||
indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i * 0.1));
|
||||
}
|
||||
|
||||
Assert.True(indicator.IsHot);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Update_LastProperty_MatchesReturnValue()
|
||||
{
|
||||
var indicator = new Trendflex(DefaultPeriod);
|
||||
var input = new TValue(DateTime.UtcNow, 42.0);
|
||||
TValue result = indicator.Update(input);
|
||||
|
||||
Assert.Equal(result.Value, indicator.Last.Value, Tolerance);
|
||||
}
|
||||
|
||||
// ========== C) State + Bar Correction ==========
|
||||
|
||||
[Fact]
|
||||
public void IsNew_True_AdvancesState()
|
||||
{
|
||||
var indicator = new Trendflex(DefaultPeriod);
|
||||
var input1 = new TValue(DateTime.UtcNow, 100.0);
|
||||
var input2 = new TValue(DateTime.UtcNow.AddSeconds(1), 105.0);
|
||||
|
||||
TValue r1 = indicator.Update(input1, isNew: true);
|
||||
TValue r2 = indicator.Update(input2, isNew: true);
|
||||
|
||||
Assert.NotEqual(r1.Value, r2.Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IsNew_False_RewritesCurrentBar()
|
||||
{
|
||||
var indicator = new Trendflex(DefaultPeriod);
|
||||
|
||||
for (int i = 0; i < 50; i++)
|
||||
{
|
||||
indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i));
|
||||
}
|
||||
|
||||
indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(50), 200.0), isNew: true);
|
||||
double afterNew = indicator.Last.Value;
|
||||
|
||||
indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(50), 150.0), isNew: false);
|
||||
double afterCorrection = indicator.Last.Value;
|
||||
|
||||
Assert.NotEqual(afterNew, afterCorrection);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IterativeCorrections_RestoreState()
|
||||
{
|
||||
var indicator = new Trendflex(DefaultPeriod);
|
||||
TSeries data = MakeSeries();
|
||||
|
||||
for (int i = 0; i < 50; i++)
|
||||
{
|
||||
indicator.Update(data[i], isNew: true);
|
||||
}
|
||||
|
||||
indicator.Update(data[50], isNew: true);
|
||||
|
||||
for (int j = 0; j < 5; j++)
|
||||
{
|
||||
indicator.Update(data[50], isNew: false);
|
||||
}
|
||||
|
||||
double afterCorrections = indicator.Last.Value;
|
||||
|
||||
var fresh = new Trendflex(DefaultPeriod);
|
||||
for (int i = 0; i <= 50; i++)
|
||||
{
|
||||
fresh.Update(data[i], isNew: true);
|
||||
}
|
||||
|
||||
Assert.Equal(fresh.Last.Value, afterCorrections, Tolerance);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Reset_ClearsState()
|
||||
{
|
||||
var indicator = new Trendflex(DefaultPeriod);
|
||||
|
||||
for (int i = 0; i < 50; i++)
|
||||
{
|
||||
indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i));
|
||||
}
|
||||
|
||||
Assert.True(indicator.IsHot);
|
||||
|
||||
indicator.Reset();
|
||||
|
||||
Assert.False(indicator.IsHot);
|
||||
Assert.Equal(default, indicator.Last);
|
||||
}
|
||||
|
||||
// ========== D) Warmup/Convergence ==========
|
||||
|
||||
[Fact]
|
||||
public void IsHot_FlipsAtCorrectTime()
|
||||
{
|
||||
var indicator = new Trendflex(10);
|
||||
int hotAt = -1;
|
||||
|
||||
for (int i = 0; i < 200; i++)
|
||||
{
|
||||
indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0));
|
||||
if (indicator.IsHot && hotAt < 0)
|
||||
{
|
||||
hotAt = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
Assert.InRange(hotAt, 1, 200);
|
||||
}
|
||||
|
||||
// ========== E) Robustness ==========
|
||||
|
||||
[Fact]
|
||||
public void NaN_Input_UsesLastValidValue()
|
||||
{
|
||||
var indicator = new Trendflex(DefaultPeriod);
|
||||
|
||||
for (int i = 0; i < 30; i++)
|
||||
{
|
||||
indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0));
|
||||
}
|
||||
|
||||
TValue nanResult = indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(30), double.NaN));
|
||||
|
||||
Assert.True(double.IsFinite(nanResult.Value));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Infinity_Input_UsesLastValidValue()
|
||||
{
|
||||
var indicator = new Trendflex(DefaultPeriod);
|
||||
|
||||
for (int i = 0; i < 30; i++)
|
||||
{
|
||||
indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0));
|
||||
}
|
||||
|
||||
TValue infResult = indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(30), double.PositiveInfinity));
|
||||
Assert.True(double.IsFinite(infResult.Value));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BatchNaN_DoesNotPropagate()
|
||||
{
|
||||
int period = 10;
|
||||
double[] source = new double[100];
|
||||
double[] output = new double[100];
|
||||
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
source[i] = 100.0 + i * 0.5;
|
||||
}
|
||||
|
||||
source[50] = double.NaN;
|
||||
source[51] = double.NaN;
|
||||
|
||||
Trendflex.Batch(source, output, period);
|
||||
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
Assert.True(double.IsFinite(output[i]), $"Output[{i}] is not finite");
|
||||
}
|
||||
}
|
||||
|
||||
// ========== F) Consistency (4 API modes) ==========
|
||||
|
||||
[Fact]
|
||||
public void AllModes_ProduceSameResult()
|
||||
{
|
||||
int period = 10;
|
||||
TSeries data = MakeSeries();
|
||||
|
||||
// 1. Batch (TSeries)
|
||||
TSeries batchResults = Trendflex.Batch(data, period);
|
||||
double expected = batchResults.Last.Value;
|
||||
|
||||
// 2. Span batch
|
||||
var tValues = data.Values.ToArray();
|
||||
var spanOutput = new double[tValues.Length];
|
||||
Trendflex.Batch(new ReadOnlySpan<double>(tValues), spanOutput, period);
|
||||
double spanResult = spanOutput[^1];
|
||||
|
||||
// 3. Streaming
|
||||
var streaming = new Trendflex(period);
|
||||
for (int i = 0; i < data.Count; i++)
|
||||
{
|
||||
streaming.Update(data[i]);
|
||||
}
|
||||
double streamingResult = streaming.Last.Value;
|
||||
|
||||
// 4. Eventing
|
||||
var pubSource = new TSeries();
|
||||
var eventBased = new Trendflex(pubSource, period);
|
||||
for (int i = 0; i < data.Count; i++)
|
||||
{
|
||||
pubSource.Add(data[i]);
|
||||
}
|
||||
double eventingResult = eventBased.Last.Value;
|
||||
|
||||
Assert.Equal(expected, spanResult, precision: 9);
|
||||
Assert.Equal(expected, streamingResult, precision: 9);
|
||||
Assert.Equal(expected, eventingResult, precision: 9);
|
||||
}
|
||||
|
||||
// ========== G) Span API Tests ==========
|
||||
|
||||
[Fact]
|
||||
public void SpanBatch_MismatchedLengths_ThrowsArgumentException()
|
||||
{
|
||||
double[] source = new double[10];
|
||||
double[] output = new double[5];
|
||||
|
||||
var ex = Assert.Throws<ArgumentException>(() => Trendflex.Batch(source, output, 5));
|
||||
Assert.Equal("output", ex.ParamName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SpanBatch_ZeroPeriod_ThrowsArgumentOutOfRangeException()
|
||||
{
|
||||
double[] source = new double[10];
|
||||
double[] output = new double[10];
|
||||
|
||||
Assert.Throws<ArgumentOutOfRangeException>(() => Trendflex.Batch(source, output, 0));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SpanBatch_EmptyInput_ProducesEmptyOutput()
|
||||
{
|
||||
double[] source = Array.Empty<double>();
|
||||
double[] output = Array.Empty<double>();
|
||||
var ex = Record.Exception(() => Trendflex.Batch(source, output, 10));
|
||||
Assert.Null(ex);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SpanBatch_LargeData_DoesNotStackOverflow()
|
||||
{
|
||||
int size = 5000;
|
||||
double[] source = new double[size];
|
||||
double[] output = new double[size];
|
||||
|
||||
for (int i = 0; i < size; i++)
|
||||
{
|
||||
source[i] = 100.0 + i * 0.1;
|
||||
}
|
||||
|
||||
Trendflex.Batch(source, output, 20);
|
||||
|
||||
Assert.True(double.IsFinite(output[size - 1]));
|
||||
}
|
||||
|
||||
// ========== H) Chainability ==========
|
||||
|
||||
[Fact]
|
||||
public void Pub_EventFires_OnUpdate()
|
||||
{
|
||||
var indicator = new Trendflex(DefaultPeriod);
|
||||
int eventCount = 0;
|
||||
|
||||
indicator.Pub += (object? sender, in TValueEventArgs args) => eventCount++;
|
||||
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i));
|
||||
}
|
||||
|
||||
Assert.Equal(10, eventCount);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EventBased_Chaining_Works()
|
||||
{
|
||||
var source = new TSeries();
|
||||
var indicator = new Trendflex(source, 5);
|
||||
|
||||
source.Add(new TValue(DateTime.UtcNow, 100));
|
||||
source.Add(new TValue(DateTime.UtcNow, 110));
|
||||
source.Add(new TValue(DateTime.UtcNow, 120));
|
||||
|
||||
Assert.True(double.IsFinite(indicator.Last.Value));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calculate_ReturnsHotIndicator()
|
||||
{
|
||||
TSeries data = MakeSeries();
|
||||
(TSeries results, Trendflex indicator) = Trendflex.Calculate(data, DefaultPeriod);
|
||||
|
||||
Assert.Equal(data.Count, results.Count);
|
||||
Assert.True(indicator.IsHot);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void StaticCalculate_MatchesInstance()
|
||||
{
|
||||
const int period = 10;
|
||||
int count = 100;
|
||||
var source = new TSeries();
|
||||
var indicator = new Trendflex(period);
|
||||
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
source.Add(new TValue(DateTime.UtcNow.AddMinutes(i), i));
|
||||
indicator.Update(source.Last);
|
||||
}
|
||||
|
||||
var staticResult = Trendflex.Batch(source, period);
|
||||
|
||||
Assert.Equal(source.Count, staticResult.Count);
|
||||
Assert.Equal(indicator.Last.Value, staticResult.Last.Value, 8);
|
||||
}
|
||||
|
||||
// ========== Trendflex-specific: Oscillator centered around zero ==========
|
||||
|
||||
[Fact]
|
||||
public void ConstantInput_OutputConvergesToZero()
|
||||
{
|
||||
var indicator = new Trendflex(10);
|
||||
double lastResult = double.NaN;
|
||||
|
||||
for (int i = 0; i < 200; i++)
|
||||
{
|
||||
TValue r = indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0));
|
||||
lastResult = r.Value;
|
||||
}
|
||||
|
||||
// Constant input → zero slope → zero output
|
||||
Assert.Equal(0.0, lastResult, 1e-10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TrendingInput_ProducesPositiveValues()
|
||||
{
|
||||
var indicator = new Trendflex(10);
|
||||
double lastResult = 0;
|
||||
|
||||
// Strong uptrend
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
TValue r = indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), 100.0 + i * 2.0));
|
||||
lastResult = r.Value;
|
||||
}
|
||||
|
||||
// Uptrend should produce positive Trendflex
|
||||
Assert.True(lastResult > 0, $"Expected positive for uptrend, got {lastResult}");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,188 @@
|
||||
using Xunit;
|
||||
using Xunit.Abstractions;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public sealed class TrendflexValidationTests : IDisposable
|
||||
{
|
||||
private readonly ITestOutputHelper _output;
|
||||
private readonly ValidationTestData _testData;
|
||||
private const int DefaultPeriod = 20;
|
||||
|
||||
public TrendflexValidationTests(ITestOutputHelper output)
|
||||
{
|
||||
_output = output;
|
||||
_testData = new ValidationTestData(5000);
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
_testData.Dispose();
|
||||
}
|
||||
|
||||
private void Dispose(bool disposing)
|
||||
{
|
||||
if (disposing)
|
||||
{
|
||||
_testData.Dispose();
|
||||
}
|
||||
}
|
||||
|
||||
// ========== Self-consistency Validation ==========
|
||||
|
||||
[Fact]
|
||||
public void Trendflex_BatchStreaming_Match()
|
||||
{
|
||||
// Streaming
|
||||
var streaming = new Trendflex(DefaultPeriod);
|
||||
var streamResults = new List<double>(_testData.Data.Count);
|
||||
for (int i = 0; i < _testData.Data.Count; i++)
|
||||
{
|
||||
TValue r = streaming.Update(_testData.Data[i], isNew: true);
|
||||
streamResults.Add(r.Value);
|
||||
}
|
||||
|
||||
// Batch
|
||||
TSeries batchResults = Trendflex.Batch(_testData.Data, DefaultPeriod);
|
||||
|
||||
int mismatchCount = 0;
|
||||
double maxDiff = 0;
|
||||
for (int i = 0; i < streamResults.Count; i++)
|
||||
{
|
||||
double diff = Math.Abs(streamResults[i] - batchResults[i].Value);
|
||||
if (diff > 1e-10)
|
||||
{
|
||||
mismatchCount++;
|
||||
maxDiff = Math.Max(maxDiff, diff);
|
||||
}
|
||||
}
|
||||
|
||||
_output.WriteLine($"Trendflex({DefaultPeriod}) Batch vs Streaming: {mismatchCount} mismatches, max diff = {maxDiff:E3}");
|
||||
Assert.Equal(0, mismatchCount);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Trendflex_SpanBatch_MatchesStreaming()
|
||||
{
|
||||
// Streaming
|
||||
var streaming = new Trendflex(DefaultPeriod);
|
||||
var streamResults = new List<double>(_testData.Data.Count);
|
||||
for (int i = 0; i < _testData.Data.Count; i++)
|
||||
{
|
||||
TValue r = streaming.Update(_testData.Data[i], isNew: true);
|
||||
streamResults.Add(r.Value);
|
||||
}
|
||||
|
||||
// Span batch
|
||||
double[] output = new double[_testData.Data.Count];
|
||||
Trendflex.Batch(_testData.Data.Values, output, DefaultPeriod);
|
||||
|
||||
int mismatchCount = 0;
|
||||
double maxDiff = 0;
|
||||
for (int i = 0; i < streamResults.Count; i++)
|
||||
{
|
||||
double diff = Math.Abs(streamResults[i] - output[i]);
|
||||
if (diff > 1e-10)
|
||||
{
|
||||
mismatchCount++;
|
||||
maxDiff = Math.Max(maxDiff, diff);
|
||||
}
|
||||
}
|
||||
|
||||
_output.WriteLine($"Trendflex({DefaultPeriod}) Span vs Streaming: {mismatchCount} mismatches, max diff = {maxDiff:E3}");
|
||||
Assert.Equal(0, mismatchCount);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Trendflex_DifferentPeriods_ProduceDifferentResults()
|
||||
{
|
||||
TSeries result10 = Trendflex.Batch(_testData.Data, 10);
|
||||
TSeries result20 = Trendflex.Batch(_testData.Data, 20);
|
||||
|
||||
int lastIdx = _testData.Data.Count - 1;
|
||||
_output.WriteLine($"Trendflex(10) last = {result10[lastIdx].Value:F6}");
|
||||
_output.WriteLine($"Trendflex(20) last = {result20[lastIdx].Value:F6}");
|
||||
|
||||
Assert.NotEqual(result10[lastIdx].Value, result20[lastIdx].Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Trendflex_ConstantInput_ConvergesToZero()
|
||||
{
|
||||
var indicator = new Trendflex(10);
|
||||
double constantVal = 100.0;
|
||||
|
||||
double lastResult = double.NaN;
|
||||
for (int i = 0; i < 1000; i++)
|
||||
{
|
||||
TValue r = indicator.Update(new TValue(DateTime.UtcNow.AddSeconds(i), constantVal));
|
||||
lastResult = r.Value;
|
||||
}
|
||||
|
||||
_output.WriteLine($"Trendflex(10) constant input result after 1000 bars: {lastResult:E6}");
|
||||
// Constant input → zero slope → zero output
|
||||
Assert.True(Math.Abs(lastResult) < 1e-6, $"Expected near-zero for constant input, got {lastResult}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Trendflex_Calculate_ReturnsHotIndicator()
|
||||
{
|
||||
(TSeries results, Trendflex indicator) = Trendflex.Calculate(_testData.Data, DefaultPeriod);
|
||||
|
||||
Assert.Equal(_testData.Data.Count, results.Count);
|
||||
Assert.True(indicator.IsHot);
|
||||
|
||||
// Verify the indicator can continue streaming
|
||||
TValue next = indicator.Update(new TValue(DateTime.UtcNow, 100.0), isNew: true);
|
||||
Assert.True(double.IsFinite(next.Value));
|
||||
|
||||
_output.WriteLine($"Trendflex({DefaultPeriod}) Calculate: {results.Count} bars, last = {results[results.Count - 1].Value:F6}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Trendflex_BarCorrection_ProducesConsistentResults()
|
||||
{
|
||||
// Build reference: 100 bars then bar 101
|
||||
var reference = new Trendflex(DefaultPeriod);
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
reference.Update(_testData.Data[i], isNew: true);
|
||||
}
|
||||
reference.Update(new TValue(DateTime.UtcNow, 50.0), isNew: true);
|
||||
double referenceVal = reference.Last.Value;
|
||||
|
||||
// Build test: 100 bars, wrong bar 101, then correct bar 101
|
||||
var test = new Trendflex(DefaultPeriod);
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
test.Update(_testData.Data[i], isNew: true);
|
||||
}
|
||||
test.Update(new TValue(DateTime.UtcNow, 999.0), isNew: true); // wrong
|
||||
test.Update(new TValue(DateTime.UtcNow, 50.0), isNew: false); // correct
|
||||
double testVal = test.Last.Value;
|
||||
|
||||
_output.WriteLine($"Reference: {referenceVal:F10}, Corrected: {testVal:F10}");
|
||||
Assert.Equal(referenceVal, testVal, 1e-10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Trendflex_SubsetValidation_StableBehavior()
|
||||
{
|
||||
// Verify that smaller subsets produce stable, finite results
|
||||
using var subset = _testData.CreateSubset(200);
|
||||
|
||||
TSeries results = Trendflex.Batch(subset.Data, DefaultPeriod);
|
||||
|
||||
int nanCount = 0;
|
||||
for (int i = 0; i < results.Count; i++)
|
||||
{
|
||||
if (!double.IsFinite(results[i].Value))
|
||||
{
|
||||
nanCount++;
|
||||
}
|
||||
}
|
||||
|
||||
_output.WriteLine($"Trendflex({DefaultPeriod}) on 200-bar subset: {nanCount} non-finite values");
|
||||
Assert.Equal(0, nanCount);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,349 @@
|
||||
using System.Buffers;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace QuanTAlib;
|
||||
|
||||
/// <summary>
|
||||
/// TRENDFLEX: Ehlers Trendflex Indicator
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Measures the slope of the Super Smoother output over a lookback window,
|
||||
/// normalized by its own RMS for a zero-centered, unit-scale oscillator.
|
||||
/// John F. Ehlers (2013) — combines a 2-pole Butterworth low-pass (Super Smoother)
|
||||
/// with O(1) cumulative slope via circular buffer and exponential RMS normalization.
|
||||
///
|
||||
/// Calculation:
|
||||
/// <c>SSF[n] = c1 * (src + src[1]) * 0.5 + c2 * SSF[1] + c3 * SSF[2]</c>
|
||||
/// <c>Slope = (n * SSF - Σ SSF[i]) / period</c>
|
||||
/// <c>MS = 0.04 * Slope² + 0.96 * MS[1]</c>
|
||||
/// <c>Trendflex = Slope / √MS</c>
|
||||
/// </remarks>
|
||||
/// <seealso href="Trendflex.md">Detailed documentation</seealso>
|
||||
/// <seealso href="trendflex.pine">Reference Pine Script implementation</seealso>
|
||||
[SkipLocalsInit]
|
||||
public sealed class Trendflex : AbstractBase
|
||||
{
|
||||
[StructLayout(LayoutKind.Auto)]
|
||||
private record struct State(
|
||||
double Filt, double Filt1,
|
||||
double Src1, double Ms,
|
||||
int Count, double LastValid)
|
||||
{
|
||||
public static State New() => new()
|
||||
{
|
||||
Filt = 0,
|
||||
Filt1 = 0,
|
||||
Src1 = 0,
|
||||
Ms = 0,
|
||||
Count = 0,
|
||||
LastValid = 0
|
||||
};
|
||||
}
|
||||
|
||||
private readonly int _period;
|
||||
private readonly double _c1;
|
||||
private readonly double _c2;
|
||||
private readonly double _c3;
|
||||
|
||||
private State _s = State.New();
|
||||
private State _ps = State.New();
|
||||
private readonly RingBuffer _buf;
|
||||
|
||||
private const double RMS_ALPHA = 0.04;
|
||||
private const double RMS_DECAY = 0.96;
|
||||
private const int StackallocThreshold = 1024;
|
||||
|
||||
/// <summary>
|
||||
/// Creates Trendflex with specified period.
|
||||
/// </summary>
|
||||
/// <param name="period">Lookback period for trend measurement (must be > 0)</param>
|
||||
public Trendflex(int period)
|
||||
{
|
||||
ArgumentOutOfRangeException.ThrowIfNegativeOrZero(period);
|
||||
|
||||
_period = period;
|
||||
|
||||
// Super Smoother (2-pole Butterworth) coefficients
|
||||
double halfPeriod = period * 0.5;
|
||||
double a1 = Math.Exp(-1.414 * Math.PI / halfPeriod);
|
||||
double b1 = 2.0 * a1 * Math.Cos(1.414 * Math.PI / halfPeriod);
|
||||
_c2 = b1;
|
||||
_c3 = -(a1 * a1);
|
||||
_c1 = 1.0 - _c2 - _c3;
|
||||
|
||||
_buf = new RingBuffer(period);
|
||||
|
||||
Name = $"Trendflex({period})";
|
||||
WarmupPeriod = period;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Creates Trendflex with specified source and period.
|
||||
/// Subscribes to source.Pub event.
|
||||
/// </summary>
|
||||
public Trendflex(ITValuePublisher source, int period) : this(period)
|
||||
{
|
||||
source.Pub += Handle;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Creates Trendflex with a TSeries source, primes from history, then subscribes.
|
||||
/// </summary>
|
||||
public Trendflex(TSeries source, int period) : this(period)
|
||||
{
|
||||
Prime(source.Values);
|
||||
if (source.Count > 0)
|
||||
{
|
||||
Last = new TValue(source.LastTime, Last.Value);
|
||||
}
|
||||
source.Pub += Handle;
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
public override bool IsHot => _s.Count >= _period;
|
||||
|
||||
/// <inheritdoc/>
|
||||
public override void Prime(ReadOnlySpan<double> source, TimeSpan? step = null)
|
||||
{
|
||||
if (source.Length == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
_s = State.New();
|
||||
_ps = State.New();
|
||||
_buf.Clear();
|
||||
|
||||
int len = source.Length;
|
||||
double[]? rented = len > StackallocThreshold ? ArrayPool<double>.Shared.Rent(len) : null;
|
||||
Span<double> temp = rented != null ? rented.AsSpan(0, len) : stackalloc double[len];
|
||||
|
||||
try
|
||||
{
|
||||
CalculateCore(source, temp, _period, _c1, _c2, _c3, ref _s, _buf);
|
||||
|
||||
Last = new TValue(DateTime.MinValue, temp[len - 1]);
|
||||
_ps = _s;
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (rented != null)
|
||||
{
|
||||
ArrayPool<double>.Shared.Return(rented);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
private void Handle(object? sender, in TValueEventArgs e) => Update(e.Value, e.IsNew);
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
private static double GetValidValue(double input, ref State s)
|
||||
{
|
||||
if (double.IsFinite(input))
|
||||
{
|
||||
s.LastValid = input;
|
||||
return input;
|
||||
}
|
||||
return s.LastValid;
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
|
||||
public override TValue Update(TValue input, bool isNew = true)
|
||||
{
|
||||
if (isNew)
|
||||
{
|
||||
_ps = _s;
|
||||
_buf.Snapshot();
|
||||
}
|
||||
else
|
||||
{
|
||||
_s = _ps;
|
||||
_buf.Restore();
|
||||
}
|
||||
|
||||
double val = GetValidValue(input.Value, ref _s);
|
||||
double result = Compute(val, _period, _c1, _c2, _c3, ref _s, _buf);
|
||||
|
||||
Last = new TValue(input.Time, result);
|
||||
PubEvent(Last, isNew);
|
||||
return Last;
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
[MethodImpl(MethodImplOptions.AggressiveOptimization)]
|
||||
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);
|
||||
|
||||
CalculateCore(source.Values, vSpan, _period, _c1, _c2, _c3, ref _s, _buf);
|
||||
|
||||
source.Times.CopyTo(tSpan);
|
||||
|
||||
_ps = _s;
|
||||
Last = new TValue(tSpan[len - 1], vSpan[len - 1]);
|
||||
|
||||
return new TSeries(t, v);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Core streaming computation: SSF + slope via RingBuffer + RMS normalization.
|
||||
/// O(1) per bar.
|
||||
/// </summary>
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
|
||||
private static double Compute(double input, int period, double c1, double c2, double c3,
|
||||
ref State s, RingBuffer buf)
|
||||
{
|
||||
s.Count++;
|
||||
|
||||
// --- Super Smoother filter ---
|
||||
double filt;
|
||||
if (s.Count <= 2)
|
||||
{
|
||||
filt = input;
|
||||
}
|
||||
else
|
||||
{
|
||||
filt = Math.FusedMultiplyAdd(c1, (input + s.Src1) * 0.5,
|
||||
Math.FusedMultiplyAdd(c2, s.Filt, c3 * s.Filt1));
|
||||
}
|
||||
|
||||
s.Filt1 = s.Filt;
|
||||
s.Filt = filt;
|
||||
s.Src1 = input;
|
||||
|
||||
// --- O(1) cumulative slope ---
|
||||
// Always use Add (not UpdateNewest) because Snapshot/Restore already handles rollback
|
||||
buf.Add(filt);
|
||||
int n = Math.Min(s.Count, period);
|
||||
double slopeSum = n > 0 ? (n * filt - buf.Sum) / period : 0.0;
|
||||
|
||||
// --- RMS normalization ---
|
||||
s.Ms = Math.FusedMultiplyAdd(RMS_ALPHA, slopeSum * slopeSum, RMS_DECAY * s.Ms);
|
||||
|
||||
return s.Ms > 0 ? slopeSum / Math.Sqrt(s.Ms) : 0.0;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Core batch calculation.
|
||||
/// </summary>
|
||||
[MethodImpl(MethodImplOptions.AggressiveOptimization)]
|
||||
private static void CalculateCore(ReadOnlySpan<double> source, Span<double> output,
|
||||
int period, double c1, double c2, double c3, ref State s, RingBuffer buf)
|
||||
{
|
||||
int len = source.Length;
|
||||
|
||||
for (int i = 0; i < len; i++)
|
||||
{
|
||||
double val = source[i];
|
||||
if (double.IsFinite(val))
|
||||
{
|
||||
s.LastValid = val;
|
||||
}
|
||||
else
|
||||
{
|
||||
val = s.LastValid;
|
||||
}
|
||||
|
||||
s.Count++;
|
||||
|
||||
// Super Smoother
|
||||
double filt;
|
||||
if (s.Count <= 2)
|
||||
{
|
||||
filt = val;
|
||||
}
|
||||
else
|
||||
{
|
||||
filt = Math.FusedMultiplyAdd(c1, (val + s.Src1) * 0.5,
|
||||
Math.FusedMultiplyAdd(c2, s.Filt, c3 * s.Filt1));
|
||||
}
|
||||
|
||||
s.Filt1 = s.Filt;
|
||||
s.Filt = filt;
|
||||
s.Src1 = val;
|
||||
|
||||
// Slope
|
||||
buf.Add(filt);
|
||||
int n = Math.Min(s.Count, period);
|
||||
double slopeSum = n > 0 ? (n * filt - buf.Sum) / period : 0.0;
|
||||
|
||||
// RMS
|
||||
s.Ms = Math.FusedMultiplyAdd(RMS_ALPHA, slopeSum * slopeSum, RMS_DECAY * s.Ms);
|
||||
|
||||
output[i] = s.Ms > 0 ? slopeSum / Math.Sqrt(s.Ms) : 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Batch calculation returning a TSeries.
|
||||
/// </summary>
|
||||
public static TSeries Batch(TSeries source, int period)
|
||||
{
|
||||
var indicator = new Trendflex(period);
|
||||
return indicator.Update(source);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Batch calculation writing to a pre-allocated output span. Zero-allocation hot path.
|
||||
/// </summary>
|
||||
public static void Batch(ReadOnlySpan<double> source, Span<double> output, int period)
|
||||
{
|
||||
if (source.Length != output.Length)
|
||||
{
|
||||
throw new ArgumentException("Source and output must have the same length", nameof(output));
|
||||
}
|
||||
ArgumentOutOfRangeException.ThrowIfNegativeOrZero(period);
|
||||
|
||||
if (source.Length == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Compute SSF coefficients
|
||||
double halfPeriod = period * 0.5;
|
||||
double a1 = Math.Exp(-1.414 * Math.PI / halfPeriod);
|
||||
double b1 = 2.0 * a1 * Math.Cos(1.414 * Math.PI / halfPeriod);
|
||||
double c2 = b1;
|
||||
double c3 = -(a1 * a1);
|
||||
double c1 = 1.0 - c2 - c3;
|
||||
|
||||
var state = State.New();
|
||||
var buf = new RingBuffer(period);
|
||||
|
||||
CalculateCore(source, output, period, c1, c2, c3, ref state, buf);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Creates a hot indicator from historical data, ready for streaming.
|
||||
/// </summary>
|
||||
public static (TSeries Results, Trendflex Indicator) Calculate(TSeries source, int period)
|
||||
{
|
||||
var indicator = new Trendflex(period);
|
||||
TSeries results = indicator.Update(source);
|
||||
return (results, indicator);
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
public override void Reset()
|
||||
{
|
||||
_s = State.New();
|
||||
_ps = _s;
|
||||
_buf.Clear();
|
||||
Last = default;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,138 @@
|
||||
# TRENDFLEX: Ehlers Trendflex Indicator
|
||||
|
||||
> "The trend is your friend until it bends." — Ed Seykota, but Ehlers actually measures the bending.
|
||||
|
||||
## Introduction
|
||||
|
||||
The Trendflex indicator combines a 2-pole Butterworth low-pass pre-filter (Super Smoother) with an O(1) cumulative slope measurement and exponential RMS normalization to produce a zero-centered oscillator that quantifies trend strength. Unlike conventional slope or momentum indicators that suffer from noise amplification or lag, Trendflex pre-smooths via the Super Smoother, computes the least-squares slope of the filtered signal over a lookback window in constant time, then normalizes by a running RMS estimate. The result: a bounded oscillator where values above zero indicate uptrend, below zero indicate downtrend, and magnitude reflects trend conviction.
|
||||
|
||||
## Historical Context
|
||||
|
||||
John F. Ehlers introduced the Trendflex indicator in his 2013 work on cycle and trend measurement for traders. The indicator addresses a fundamental problem: how do you separate trend from cycle without introducing excessive lag or noise? Ehlers' insight was to cascade two well-understood DSP components: a Super Smoother (2-pole Butterworth) that removes high-frequency noise without the phase distortion of moving averages, followed by a slope estimator that measures the linear regression slope of the filtered signal.
|
||||
|
||||
The original Pine Script implementation uses an O(N) summation loop per bar. QuanTAlib's implementation replaces this with a RingBuffer-based running sum, reducing the per-bar cost to O(1) while producing bit-identical results. This is a pure algorithmic optimization with no mathematical approximation.
|
||||
|
||||
No other major library (TA-Lib, Skender, Tulip, Ooples) implements Trendflex. QuanTAlib's implementation serves as a reference.
|
||||
|
||||
## Architecture and Physics
|
||||
|
||||
### 1. Super Smoother Pre-Filter (2-Pole Butterworth)
|
||||
|
||||
The Super Smoother acts as a low-pass filter with cutoff at the half-period:
|
||||
|
||||
$$a_1 = e^{-\sqrt{2}\pi / P_{half}}, \quad b_1 = 2 a_1 \cos\!\left(\frac{\sqrt{2}\pi}{P_{half}}\right)$$
|
||||
|
||||
$$c_2 = b_1, \quad c_3 = -a_1^2, \quad c_1 = 1 - c_2 - c_3$$
|
||||
|
||||
The filter update is:
|
||||
|
||||
$$\text{Filt}_n = c_1 \cdot \frac{x_n + x_{n-1}}{2} + c_2 \cdot \text{Filt}_{n-1} + c_3 \cdot \text{Filt}_{n-2}$$
|
||||
|
||||
where $P_{half} = \text{period} \times 0.5$.
|
||||
|
||||
### 2. O(1) Cumulative Slope via Running Sum
|
||||
|
||||
The slope over the lookback window is computed from the identity:
|
||||
|
||||
$$\text{Slope} = \frac{N \cdot \text{Filt}_n - \sum_{i=0}^{N-1} \text{Filt}_{n-i}}{\text{period}}$$
|
||||
|
||||
The summation $\sum \text{Filt}_{n-i}$ is maintained as a running sum in a circular buffer (RingBuffer). Each bar adds the new filtered value and removes the oldest, keeping the operation O(1) regardless of period length.
|
||||
|
||||
### 3. Exponential RMS Normalization
|
||||
|
||||
To produce a unit-scale oscillator, the slope is divided by its own running RMS:
|
||||
|
||||
$$\text{MS}_n = 0.04 \cdot \text{Slope}_n^2 + 0.96 \cdot \text{MS}_{n-1}$$
|
||||
|
||||
$$\text{Trendflex}_n = \frac{\text{Slope}_n}{\sqrt{\text{MS}_n}}$$
|
||||
|
||||
The 0.04/0.96 exponential weighting corresponds to approximately a 25-bar half-life for the mean-square estimate, providing smooth normalization without requiring a lookback buffer.
|
||||
|
||||
## Mathematical Foundation
|
||||
|
||||
### Z-Domain Transfer Function
|
||||
|
||||
The Super Smoother transfer function:
|
||||
|
||||
$$H_{SSF}(z) = \frac{c_1 \cdot \frac{1 + z^{-1}}{2}}{1 - c_2 z^{-1} - c_3 z^{-2}}$$
|
||||
|
||||
The slope estimator computes a differenced cumulative sum, effectively applying a comb filter:
|
||||
|
||||
$$H_{slope}(z) = \frac{N - \sum_{k=0}^{N-1} z^{-k}}{\text{period}}$$
|
||||
|
||||
The RMS normalization is a nonlinear operation with no closed-form transfer function, but its exponential smoothing has characteristic time constant $\tau = 1/0.04 = 25$ bars.
|
||||
|
||||
### FMA Usage
|
||||
|
||||
Both the Super Smoother and RMS normalization use `Math.FusedMultiplyAdd` for the `a*b + c` patterns:
|
||||
|
||||
```csharp
|
||||
filt = Math.FusedMultiplyAdd(c1, (input + src1) * 0.5,
|
||||
Math.FusedMultiplyAdd(c2, filt, c3 * filt1));
|
||||
|
||||
ms = Math.FusedMultiplyAdd(RMS_ALPHA, slopeSum * slopeSum, RMS_DECAY * ms);
|
||||
```
|
||||
|
||||
## Performance Profile
|
||||
|
||||
### Operation Count (Streaming Mode, Scalar)
|
||||
|
||||
| Operation | Count | Notes |
|
||||
|-----------|-------|-------|
|
||||
| FMA (SSF filter) | 2 | Nested `FusedMultiplyAdd` for IIR |
|
||||
| Multiply (SSF input avg) | 1 | `(input + src1) * 0.5` |
|
||||
| RingBuffer Add | 1 | O(1) circular write + sum update |
|
||||
| Multiply + Subtract (slope) | 2 | `n * filt - sum` then `/ period` |
|
||||
| FMA (RMS update) | 1 | `0.04 * slope^2 + 0.96 * ms` |
|
||||
| Sqrt | 1 | `Math.Sqrt(ms)` |
|
||||
| Division (normalize) | 1 | `slope / sqrt(ms)` |
|
||||
| **Total hot path** | **~9 ops** | O(1) per bar |
|
||||
|
||||
### Batch Mode
|
||||
|
||||
The batch path uses `CalculateCore` which inlines the same logic without RingBuffer snapshot/restore overhead. Since the SSF is inherently serial (IIR dependency), SIMD parallelization is not applicable. The FMA chain provides excellent instruction-level pipelining.
|
||||
|
||||
### Quality Metrics
|
||||
|
||||
| Metric | Score | Notes |
|
||||
|--------|-------|-------|
|
||||
| Trend Detection | 9/10 | Strong trend/no-trend discrimination |
|
||||
| Noise Rejection | 8/10 | SSF pre-filter removes HF noise |
|
||||
| Lag | 6/10 | SSF introduces some phase delay |
|
||||
| Responsiveness | 7/10 | Good for trend changes |
|
||||
| Computational Cost | 9/10 | O(1), ~9 ops per bar |
|
||||
| Memory Efficiency | 8/10 | RingBuffer(period) + ~64 bytes state |
|
||||
|
||||
## Validation
|
||||
|
||||
| Library | Status | Notes |
|
||||
|---------|--------|-------|
|
||||
| TA-Lib | N/A | Not implemented |
|
||||
| Skender | N/A | Not implemented |
|
||||
| Tulip | N/A | Not implemented |
|
||||
| Ooples | N/A | Not implemented |
|
||||
| PineScript | Reference | `trendflex.pine` validated self-consistency |
|
||||
|
||||
Self-consistency validation: Streaming, Batch (TSeries), and Span Batch modes produce identical results to machine precision ($< 10^{-10}$).
|
||||
|
||||
## Common Pitfalls
|
||||
|
||||
1. **Not an overlay.** Trendflex is an oscillator centered around zero. Plot in a separate window, not overlaid on price.
|
||||
|
||||
2. **Period interpretation.** The `period` parameter controls both the SSF cutoff (via half-period) and the slope lookback window. Larger periods produce smoother output but increase lag. Typical range: 10-40.
|
||||
|
||||
3. **RMS normalization startup.** The exponential mean-square estimate needs approximately 25 bars (1/0.04) to stabilize. During warmup, the normalization may produce values with higher variance. `IsHot` fires at `count >= period`.
|
||||
|
||||
4. **Constant input produces zero.** By design, constant input produces zero slope and zero output. This is correct behavior, not a bug.
|
||||
|
||||
5. **Sensitivity to period < 3.** Very small periods cause the SSF coefficients to become extreme, potentially producing oscillatory artifacts. Use period >= 3 for stable results.
|
||||
|
||||
6. **Bar correction cost.** The RingBuffer snapshot/restore mechanism for `isNew=false` is O(period) due to the buffer copy. For very large periods (>1000), this may be noticeable in tight correction loops.
|
||||
|
||||
7. **Not bounded to [-1, 1].** Despite RMS normalization, Trendflex output is not strictly bounded. Strong trend initiations can produce values > 1 or < -1 before the RMS estimate catches up. Treat as a relative measure, not a percentage.
|
||||
|
||||
## References
|
||||
|
||||
- Ehlers, J. F. (2013). "Trendflex and Reflex." *Cycle Analytics for Traders*. Wiley.
|
||||
- Ehlers, J. F. (2004). *Cybernetic Analysis for Stocks and Futures*. Wiley.
|
||||
- Ehlers, J. F. (2001). *Rocket Science for Traders*. Wiley.
|
||||
@@ -0,0 +1,69 @@
|
||||
// The MIT License (MIT)
|
||||
// © mihakralj
|
||||
//@version=6
|
||||
// Indicator algorithm (C) 2013 John F. Ehlers
|
||||
indicator(" Ehlers Trendflex Indicator (TRENDFLEX)", "TRENDFLEX", overlay=false)
|
||||
|
||||
//@function Calculates Ehlers Trendflex using SuperSmoother pre-filtering and cumulative slope with RMS normalization
|
||||
//@param source Series to calculate Trendflex from
|
||||
//@param period Lookback period for trend measurement (>= 1)
|
||||
//@returns Normalized Trendflex value centered around zero
|
||||
//@optimized Uses O(1) running sum for cumulative slope instead of O(N) loop, with RMS normalization
|
||||
trendflex(series float source, simple int period) =>
|
||||
if period <= 0
|
||||
runtime.error("Period must be positive")
|
||||
|
||||
float src = nz(source)
|
||||
|
||||
// SuperSmoother (2-pole Butterworth lowpass) coefficients
|
||||
float halfPeriod = period * 0.5
|
||||
float a1 = math.exp(-1.414 * math.pi / halfPeriod)
|
||||
float b1 = 2.0 * a1 * math.cos(1.414 * math.pi / halfPeriod)
|
||||
float c2 = b1
|
||||
float c3 = -(a1 * a1)
|
||||
float c1 = 1.0 - c2 - c3
|
||||
|
||||
// SuperSmoother filter state
|
||||
var float filt = 0.0
|
||||
var float filt1 = 0.0
|
||||
float new_filt = bar_index < 2 ? src : c1 * (src + nz(src[1])) * 0.5 + c2 * filt + c3 * filt1
|
||||
filt1 := filt
|
||||
filt := new_filt
|
||||
|
||||
// O(1) cumulative slope via circular buffer and running sum
|
||||
// Sum = Σ(Filt - Filt[i]) for i=1..N = N × Filt - Σ(Filt[i])
|
||||
var array<float> buf = array.new_float(period, 0.0)
|
||||
var int head = 0
|
||||
var float running_sum = 0.0
|
||||
var int count = 0
|
||||
|
||||
int n = math.min(count, period)
|
||||
float slope_sum = n > 0 ? (n * new_filt - running_sum) / period : 0.0
|
||||
|
||||
float oldest = array.get(buf, head)
|
||||
running_sum -= oldest
|
||||
running_sum += new_filt
|
||||
array.set(buf, head, new_filt)
|
||||
head := (head + 1) % period
|
||||
if count < period
|
||||
count += 1
|
||||
|
||||
// RMS normalization via exponential mean-square
|
||||
var float ms = 0.0
|
||||
ms := 0.04 * slope_sum * slope_sum + 0.96 * ms
|
||||
|
||||
float result = ms > 0 ? slope_sum / math.sqrt(ms) : 0.0
|
||||
na(source) ? na : result
|
||||
|
||||
// ---------- Main loop ----------
|
||||
|
||||
// Inputs
|
||||
i_period = input.int(20, "Period", minval=1, tooltip="Lookback period for trend measurement")
|
||||
i_source = input.source(close, "Source")
|
||||
|
||||
// Calculation
|
||||
trendflex_value = trendflex(i_source, i_period)
|
||||
|
||||
// Plot
|
||||
plot(trendflex_value, "TRENDFLEX", color=color.yellow, linewidth=2)
|
||||
hline(0, "Zero", color=color.gray, linestyle=hline.style_dotted)
|
||||
Reference in New Issue
Block a user