mirror of
https://github.com/mihakralj/QuanTAlib.git
synced 2026-08-22 12:38:06 +00:00
validation and profiles
This commit is contained in:
Miha Kralj
@@ -74,6 +74,23 @@ The indicator requires $N$ bars to establish ATR and rolling extremes. With defa
|
||||
|
||||
## Performance Profile
|
||||
|
||||
### Operation Count (Streaming Mode)
|
||||
|
||||
Chandelier Exit uses rolling ATR + highest high / lowest low tracking — O(1) per bar.
|
||||
|
||||
| Operation | Count | Cost (cycles) | Subtotal |
|
||||
| :--- | :---: | :---: | :---: |
|
||||
| True range computation (3 comparisons) | 3 | 2 cy | ~6 cy |
|
||||
| EMA-smoothed ATR update (Wilder) | 1 | 3 cy | ~3 cy |
|
||||
| RingBuffer highest-high update | 1 | 4 cy | ~4 cy |
|
||||
| RingBuffer lowest-low update | 1 | 4 cy | ~4 cy |
|
||||
| Long stop = highest - mult*ATR | 1 | 2 cy | ~2 cy |
|
||||
| Short stop = lowest + mult*ATR | 1 | 2 cy | ~2 cy |
|
||||
| NaN guard + state update | 1 | 2 cy | ~2 cy |
|
||||
| **Total** | **O(1)** | — | **~23 cy** |
|
||||
|
||||
O(1) per bar. ATR uses Wilder smoothing (RMA). Highest/lowest tracked via O(1) RingBuffer max/min monotonic deque.
|
||||
|
||||
### Implementation Design
|
||||
|
||||
The implementation uses two monotonic deques for O(1) amortized rolling max/min operations (highest high, lowest low) with corresponding circular buffers. ATR is computed inline using SMA-seeded Wilder's smoothing with FMA optimization, eliminating the need for a child RMA indicator.
|
||||
|
||||
@@ -82,6 +82,21 @@ The indicator requires $p$ bars to establish ATR and rolling extremes, then $x$
|
||||
|
||||
## Performance Profile
|
||||
|
||||
### Operation Count (Streaming Mode)
|
||||
|
||||
Chande Kroll Stop chains ATR -> first stop -> second stop computations — O(1) per bar.
|
||||
|
||||
| Operation | Count | Cost (cycles) | Subtotal |
|
||||
| :--- | :---: | :---: | :---: |
|
||||
| ATR (Wilder EMA of TR) | 1 | 6 cy | ~6 cy |
|
||||
| First stop: highest/lowest(high/low - mult*ATR) | 2 | 5 cy | ~10 cy |
|
||||
| Second stop: highest/lowest of first stop | 2 | 5 cy | ~10 cy |
|
||||
| Signal select (long/short) | 1 | 2 cy | ~2 cy |
|
||||
| NaN guard + state update | 1 | 2 cy | ~2 cy |
|
||||
| **Total** | **O(1)** | — | **~30 cy** |
|
||||
|
||||
O(1) per bar. Two chained RingBuffer max/min operations (first stop period p, second stop q). No batch SIMD benefit due to sequential chaining.
|
||||
|
||||
### Implementation Design
|
||||
|
||||
The implementation uses four monotonic deques for O(1) amortized rolling max/min operations (highest high, lowest low, highest first-high-stop, lowest first-low-stop) and four corresponding circular buffers. An internal RMA instance handles ATR computation.
|
||||
|
||||
@@ -76,6 +76,21 @@ Williams Fractals is equivalent to `Swings(period=2)` where the pivot bar must e
|
||||
|
||||
## Performance Profile
|
||||
|
||||
### Operation Count (Streaming Mode)
|
||||
|
||||
Williams Fractals compare bar[i] high/low against 2 neighbors on each side — O(1) fixed 5-bar lookback.
|
||||
|
||||
| Operation | Count | Cost (cycles) | Subtotal |
|
||||
| :--- | :---: | :---: | :---: |
|
||||
| Ring buffer update (high + low) | 2 | 3 cy | ~6 cy |
|
||||
| Compare center high against 4 neighbors | 4 | 2 cy | ~8 cy |
|
||||
| Compare center low against 4 neighbors | 4 | 2 cy | ~8 cy |
|
||||
| Output fractal up/down signals | 2 | 1 cy | ~2 cy |
|
||||
| NaN guard + state update | 1 | 2 cy | ~2 cy |
|
||||
| **Total** | **O(1)** | — | **~26 cy** |
|
||||
|
||||
O(1) constant-width 5-bar window. Signal is delayed 2 bars (confirmed only when later bars are available). No warm-up needed beyond 5 bars.
|
||||
|
||||
### Implementation Design
|
||||
|
||||
The implementation uses two five-element circular buffers (highs and lows) with index arithmetic. No sorting, no searching, no auxiliary data structures. The pattern check is four comparisons per fractal direction, evaluated only when the buffer is full.
|
||||
|
||||
@@ -1,3 +1,6 @@
|
||||
|
||||
using OoplesFinance.StockIndicators;
|
||||
using OoplesFinance.StockIndicators.Models;
|
||||
// PIVOT Validation Tests - Classic Pivot Points (Floor Trader Pivots)
|
||||
// Self-consistency validation across all API modes.
|
||||
//
|
||||
@@ -257,4 +260,24 @@ public sealed class PivotValidationTests
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[Fact(Skip = "Ooples pivot indicators group by calendar day — 500×1-min bars yields ~3 daily pivots. Requires daily OHLCV input; not comparable with intraday GBM data.")]
|
||||
public void Pivot_MatchesOoples_Structural()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.15, seed: 42);
|
||||
var bars = gbm.Fetch(500, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
var ooplesData = bars.Select(b => new TickerData
|
||||
{
|
||||
Date = new DateTime(b.Time, DateTimeKind.Utc),
|
||||
Open = b.Open,
|
||||
High = b.High,
|
||||
Low = b.Low,
|
||||
Close = b.Close,
|
||||
Volume = b.Volume
|
||||
}).ToList();
|
||||
var result = new StockData(ooplesData).CalculateStandardPivotPoints();
|
||||
var values = result.OutputValues.Values.First();
|
||||
int finiteCount = values.Count(v => double.IsFinite(v));
|
||||
Assert.True(finiteCount > 100, $"Expected >100 finite values, got {finiteCount}");
|
||||
}
|
||||
}
|
||||
@@ -100,6 +100,24 @@ R2/S2 add the full range to/from PP. R3/S3 extend beyond the previous extremes b
|
||||
|
||||
## Performance Profile
|
||||
|
||||
### Operation Count (Streaming Mode)
|
||||
|
||||
Classic Pivot Points compute PP and 6 support/resistance levels from previous bar HLC — O(1).
|
||||
|
||||
| Operation | Count | Cost (cycles) | Subtotal |
|
||||
| :--- | :---: | :---: | :---: |
|
||||
| Store prev HLC | 3 | 1 cy | ~3 cy |
|
||||
| PP = (H + L + C) / 3 | 1 | 2 cy | ~2 cy |
|
||||
| R1 = 2*PP - L | 1 | 2 cy | ~2 cy |
|
||||
| S1 = 2*PP - H | 1 | 2 cy | ~2 cy |
|
||||
| R2 = PP + (H - L) | 1 | 2 cy | ~2 cy |
|
||||
| S2 = PP - (H - L) | 1 | 2 cy | ~2 cy |
|
||||
| R3/S3 extensions | 2 | 2 cy | ~4 cy |
|
||||
| NaN guard + state update | 1 | 2 cy | ~2 cy |
|
||||
| **Total** | **O(1)** | — | **~19 cy** |
|
||||
|
||||
Cheapest O(1) pivot variant — pure previous-bar arithmetic, no smoothing, no buffers beyond a 1-bar state.
|
||||
|
||||
### Implementation Design
|
||||
|
||||
Pure arithmetic with no loops, no buffers, no auxiliary data structures. Each `Update` call performs 3 divisions (via the single division in PP), 6 multiplications/additions, and 3 comparisons for NaN validation.
|
||||
|
||||
@@ -1,3 +1,6 @@
|
||||
|
||||
using OoplesFinance.StockIndicators;
|
||||
using OoplesFinance.StockIndicators.Models;
|
||||
// PIVOTCAM Validation Tests - Camarilla Pivot Points
|
||||
// Self-consistency validation across all API modes.
|
||||
//
|
||||
@@ -271,4 +274,24 @@ public sealed class PivotcamValidationTests
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[Fact(Skip = "Ooples pivot indicators group by calendar day — 500×1-min bars yields ~3 daily pivots. Requires daily OHLCV input; not comparable with intraday GBM data.")]
|
||||
public void Pivotcam_MatchesOoples_Structural()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.15, seed: 42);
|
||||
var bars = gbm.Fetch(500, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
var ooplesData = bars.Select(b => new TickerData
|
||||
{
|
||||
Date = new DateTime(b.Time, DateTimeKind.Utc),
|
||||
Open = b.Open,
|
||||
High = b.High,
|
||||
Low = b.Low,
|
||||
Close = b.Close,
|
||||
Volume = b.Volume
|
||||
}).ToList();
|
||||
var result = new StockData(ooplesData).CalculateCamarillaPivotPoints();
|
||||
var values = result.OutputValues.Values.First();
|
||||
int finiteCount = values.Count(v => double.IsFinite(v));
|
||||
Assert.True(finiteCount > 100, $"Expected >100 finite values, got {finiteCount}");
|
||||
}
|
||||
}
|
||||
@@ -111,6 +111,21 @@ All levels use `Math.FusedMultiplyAdd` for the `close + range * constant` comput
|
||||
|
||||
## Performance Profile
|
||||
|
||||
### Operation Count (Streaming Mode)
|
||||
|
||||
Camarilla Pivot uses a fixed multiplier series (1.1/12, 1.1/6, ...) applied to previous-bar range — O(1).
|
||||
|
||||
| Operation | Count | Cost (cycles) | Subtotal |
|
||||
| :--- | :---: | :---: | :---: |
|
||||
| Store prev OHLC | 4 | 1 cy | ~4 cy |
|
||||
| Range = H - L | 1 | 1 cy | ~1 cy |
|
||||
| R1..R4 via FMA (C + k*range) | 4 | 1 cy | ~4 cy |
|
||||
| S1..S4 via FMA (C - k*range) | 4 | 1 cy | ~4 cy |
|
||||
| NaN guard + state update | 1 | 2 cy | ~2 cy |
|
||||
| **Total** | **O(1)** | — | **~15 cy** |
|
||||
|
||||
O(1) pure arithmetic. Precomputed Camarilla multipliers [1.1/12, 1.1/6, 1.1/4, 1.1/2] applied via FMA(C, 1, k*range).
|
||||
|
||||
### Implementation Design
|
||||
|
||||
Pure arithmetic with no loops, no buffers, no auxiliary data structures. Each `Update` call performs 1 division (PP), 8 FMA operations, and 3 comparisons for NaN validation.
|
||||
|
||||
@@ -1,3 +1,6 @@
|
||||
|
||||
using OoplesFinance.StockIndicators;
|
||||
using OoplesFinance.StockIndicators.Models;
|
||||
// PIVOTDEM Validation Tests - DeMark Pivot Points
|
||||
// Self-consistency validation across all API modes.
|
||||
//
|
||||
@@ -238,4 +241,24 @@ public sealed class PivotdemValidationTests
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[Fact(Skip = "Ooples pivot indicators group by calendar day — 500×1-min bars yields ~3 daily pivots. Requires daily OHLCV input; not comparable with intraday GBM data.")]
|
||||
public void Pivotdem_MatchesOoples_Structural()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.15, seed: 42);
|
||||
var bars = gbm.Fetch(500, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
var ooplesData = bars.Select(b => new TickerData
|
||||
{
|
||||
Date = new DateTime(b.Time, DateTimeKind.Utc),
|
||||
Open = b.Open,
|
||||
High = b.High,
|
||||
Low = b.Low,
|
||||
Close = b.Close,
|
||||
Volume = b.Volume
|
||||
}).ToList();
|
||||
var result = new StockData(ooplesData).CalculateDemarkPivotPoints();
|
||||
var values = result.OutputValues.Values.First();
|
||||
int finiteCount = values.Count(v => double.IsFinite(v));
|
||||
Assert.True(finiteCount > 100, $"Expected >100 finite values, got {finiteCount}");
|
||||
}
|
||||
}
|
||||
@@ -96,6 +96,21 @@ This means R1 and S1 are always equidistant from PP, separated by one-quarter of
|
||||
|
||||
## Performance Profile
|
||||
|
||||
### Operation Count (Streaming Mode)
|
||||
|
||||
DeMark Pivot uses a conditional pivot formula based on whether Open == Close vs C vs O > C — O(1).
|
||||
|
||||
| Operation | Count | Cost (cycles) | Subtotal |
|
||||
| :--- | :---: | :---: | :---: |
|
||||
| Store prev OHLC | 4 | 1 cy | ~4 cy |
|
||||
| Conditional X formula (3-way branch) | 1 | 4 cy | ~4 cy |
|
||||
| PP = X / 4 | 1 | 2 cy | ~2 cy |
|
||||
| R1 = X/2 - L, S1 = X/2 - H | 2 | 2 cy | ~4 cy |
|
||||
| NaN guard + state update | 1 | 2 cy | ~2 cy |
|
||||
| **Total** | **O(1)** | — | **~16 cy** |
|
||||
|
||||
O(1) arithmetic with one 3-way conditional on price relationship. Branch predictor will learn the dominant market regime quickly.
|
||||
|
||||
### Implementation Design
|
||||
|
||||
Pure arithmetic with no loops, no buffers, no auxiliary data structures. Each `Update` call performs one conditional branch, 3 multiplications, 3 additions/subtractions, and 4 comparisons for NaN validation.
|
||||
|
||||
@@ -105,6 +105,20 @@ All R/S level computations use `Math.FusedMultiplyAdd` for the `multiplier * off
|
||||
|
||||
## Performance Profile
|
||||
|
||||
### Operation Count (Streaming Mode)
|
||||
|
||||
Extended Pivot Points adds R4/S4 levels beyond Classic — O(1) with 4 support/resistance pairs.
|
||||
|
||||
| Operation | Count | Cost (cycles) | Subtotal |
|
||||
| :--- | :---: | :---: | :---: |
|
||||
| Store prev HLC | 3 | 1 cy | ~3 cy |
|
||||
| PP = (H + L + C) / 3 | 1 | 2 cy | ~2 cy |
|
||||
| R1..R4 arithmetic + S1..S4 | 8 | 2 cy | ~16 cy |
|
||||
| NaN guard + state update | 1 | 2 cy | ~2 cy |
|
||||
| **Total** | **O(1)** | — | **~23 cy** |
|
||||
|
||||
O(1) pure arithmetic. Extended variant generates 4 pairs vs Classic 3 pairs, adding ~4 cy. All levels SIMD-parallel in batch mode.
|
||||
|
||||
### Implementation Design
|
||||
|
||||
Pure arithmetic with no loops, no buffers, no auxiliary data structures. Each `Update` call performs 1 division (PP), 1 subtraction (range), 2 subtractions (ppMinusL, hMinusPP), 2 additions (R2, S2), and 8 FMA operations (R1, S1, R3-R5, S3-S5), plus 3 comparisons for NaN validation.
|
||||
|
||||
@@ -5,6 +5,9 @@
|
||||
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
using OoplesFinance.StockIndicators;
|
||||
using OoplesFinance.StockIndicators.Models;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public sealed class PivotfibValidationTests
|
||||
@@ -245,4 +248,24 @@ public sealed class PivotfibValidationTests
|
||||
Assert.Equal(ind.R3 - ind.PP, ind.PP - ind.S3, 10);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[Fact(Skip = "Ooples pivot indicators group by calendar day — 500×1-min bars yields ~3 daily pivots. Requires daily OHLCV input; not comparable with intraday GBM data.")]
|
||||
public void Pivotfib_MatchesOoples_Structural()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.15, seed: 42);
|
||||
var bars = gbm.Fetch(500, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
var ooplesData = bars.Select(b => new TickerData
|
||||
{
|
||||
Date = new DateTime(b.Time, DateTimeKind.Utc),
|
||||
Open = b.Open,
|
||||
High = b.High,
|
||||
Low = b.Low,
|
||||
Close = b.Close,
|
||||
Volume = b.Volume
|
||||
}).ToList();
|
||||
var result = new StockData(ooplesData).CalculateFibonacciPivotPoints();
|
||||
var values = result.OutputValues.Values.First();
|
||||
int finiteCount = values.Count(v => double.IsFinite(v));
|
||||
Assert.True(finiteCount > 100, $"Expected >100 finite values, got {finiteCount}");
|
||||
}
|
||||
}
|
||||
@@ -63,6 +63,37 @@ Pivotfib.BatchAll(high, low, close, ppOut, r1Out, s1Out, r2Out, s2Out, r3Out, s3
|
||||
| **PIVOTEXT** (Extended) | Arithmetic extended | 11 | 1×–4× range |
|
||||
| **PIVOTDEM** (DeMark) | Conditional X/4 | 3 | Direction-based |
|
||||
|
||||
|
||||
## Performance Profile
|
||||
|
||||
### Operation Count (Streaming Mode)
|
||||
|
||||
PivotFib computes PP and 6 Fibonacci S/R levels from previous bar's HLC — O(1) pure arithmetic.
|
||||
|
||||
| Operation | Count | Cost (cycles) | Subtotal |
|
||||
| :--- | :---: | :---: | :---: |
|
||||
| Store prev bar HLC | 3 | 1 cy | ~3 cy |
|
||||
| PP = (H + L + C) / 3 | 1 | 2 cy | ~2 cy |
|
||||
| range = H - L | 1 | 1 cy | ~1 cy |
|
||||
| R1/S1 via FMA (0.382 * range) | 2 | 1 cy | ~2 cy |
|
||||
| R2/S2 via FMA (0.618 * range) | 2 | 1 cy | ~2 cy |
|
||||
| R3/S3 = PP +/- range | 2 | 1 cy | ~2 cy |
|
||||
| NaN guard + state update | 1 | 2 cy | ~2 cy |
|
||||
| **Total** | **O(1)** | — | **~14 cy** |
|
||||
|
||||
Pure O(1) arithmetic on previous-bar data. Fibonacci multipliers 0.382 and 0.618 are precomputed constants; FMA fuses multiply-add into a single instruction.
|
||||
|
||||
### Batch Mode (SIMD Analysis)
|
||||
|
||||
| Operation | Vectorizable? | Notes |
|
||||
| :--- | :---: | :--- |
|
||||
| PP computation | Yes | Vector<double> (H+L+C)/3 across all bars |
|
||||
| Range calculation | Yes | Vector subtract H-L |
|
||||
| Fibonacci level projection | Yes | FMA with broadcast constants 0.382, 0.618 |
|
||||
| All 7 output spans | Yes | Full SIMD pass — no data dependencies |
|
||||
|
||||
Excellent SIMD candidate — all 7 output levels are independent. BatchAll span overload processes 4 bars per AVX2 cycle. Expected 4× throughput vs scalar.
|
||||
|
||||
## Implementation Details
|
||||
- **WarmupPeriod**: 2 bars (need previous bar's HLC)
|
||||
- **Parameters**: None
|
||||
|
||||
@@ -5,6 +5,9 @@
|
||||
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
using OoplesFinance.StockIndicators;
|
||||
using OoplesFinance.StockIndicators.Models;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public sealed class PivotwoodValidationTests
|
||||
@@ -253,4 +256,24 @@ public sealed class PivotwoodValidationTests
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[Fact(Skip = "Ooples pivot indicators group by calendar day — 500×1-min bars yields ~3 daily pivots. Requires daily OHLCV input; not comparable with intraday GBM data.")]
|
||||
public void Pivotwood_MatchesOoples_Structural()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.15, seed: 42);
|
||||
var bars = gbm.Fetch(500, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
||||
var ooplesData = bars.Select(b => new TickerData
|
||||
{
|
||||
Date = new DateTime(b.Time, DateTimeKind.Utc),
|
||||
Open = b.Open,
|
||||
High = b.High,
|
||||
Low = b.Low,
|
||||
Close = b.Close,
|
||||
Volume = b.Volume
|
||||
}).ToList();
|
||||
var result = new StockData(ooplesData).CalculateWoodiePivotPoints();
|
||||
var values = result.OutputValues.Values.First();
|
||||
int finiteCount = values.Count(v => double.IsFinite(v));
|
||||
Assert.True(finiteCount > 100, $"Expected >100 finite values, got {finiteCount}");
|
||||
}
|
||||
}
|
||||
@@ -81,6 +81,38 @@ Pivotwood.BatchAll(high, low, close, ppOut, r1Out, s1Out, r2Out, s2Out, r3Out, s
|
||||
| **PIVOTEXT** (Extended) | (H+L+C)/3 | Arithmetic extended | 11 | 1x-4x range |
|
||||
| **PIVOTDEM** (DeMark) | Conditional X/4 | X/2 based | 3 | Direction-based |
|
||||
|
||||
|
||||
## Performance Profile
|
||||
|
||||
### Operation Count (Streaming Mode)
|
||||
|
||||
Pivot Woodie uses a distinctive formula weighting Close *2 in the pivot — O(1) arithmetic on previous bar.
|
||||
|
||||
| Operation | Count | Cost (cycles) | Subtotal |
|
||||
| :--- | :---: | :---: | :---: |
|
||||
| Store prev bar OHLC | 4 | 1 cy | ~4 cy |
|
||||
| PP = (H + L + 2*C) / 4 (FMA) | 1 | 1 cy | ~1 cy |
|
||||
| R1 = 2*PP - L | 1 | 2 cy | ~2 cy |
|
||||
| S1 = 2*PP - H | 1 | 2 cy | ~2 cy |
|
||||
| R2 = PP + (H - L) | 1 | 2 cy | ~2 cy |
|
||||
| S2 = PP - (H - L) | 1 | 2 cy | ~2 cy |
|
||||
| R3/S3 additional levels | 2 | 2 cy | ~4 cy |
|
||||
| NaN guard + state update | 1 | 2 cy | ~2 cy |
|
||||
| **Total** | **O(1)** | — | **~19 cy** |
|
||||
|
||||
O(1) per bar. Woodie pivot uses `(H + L + 2×Close) / 4` instead of `(H + L + C) / 3`, giving close price double weight. FMA-friendly.
|
||||
|
||||
### Batch Mode (SIMD Analysis)
|
||||
|
||||
| Operation | Vectorizable? | Notes |
|
||||
| :--- | :---: | :--- |
|
||||
| PP with FMA (2*C+H+L)/4 | Yes | Vector<double> FMA with broadcast constant |
|
||||
| R1/S1 subtraction | Yes | Vector arithmetic, no dependencies |
|
||||
| R2/S2 range-based | Yes | Vector<double> subtract and add |
|
||||
| All output spans | Yes | Full SIMD pass across all bars |
|
||||
|
||||
Full vectorization possible. All output levels computed from previous-bar constants — no streaming dependency between bars in batch mode.
|
||||
|
||||
## Implementation Details
|
||||
|
||||
- **WarmupPeriod**: 2 bars (need previous bar's HLC)
|
||||
|
||||
@@ -1,7 +1,10 @@
|
||||
// PSAR Validation Tests - Parabolic Stop And Reverse
|
||||
// Cross-validated against Skender.Stock.Indicators GetParabolicSar()
|
||||
// Cross-validated against Skender.Stock.Indicators GetParabolicSar(), TALib SAR, and OoplesFinance CalculateParabolicSAR.
|
||||
|
||||
using OoplesFinance.StockIndicators;
|
||||
using OoplesFinance.StockIndicators.Models;
|
||||
using Skender.Stock.Indicators;
|
||||
using TALib;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
@@ -185,4 +188,113 @@ public sealed class PsarValidationTests
|
||||
Assert.True(reversals > 5, $"Expected > 5 reversals, got {reversals}");
|
||||
Assert.True(reversals < 250, $"Expected < 250 reversals, got {reversals}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void StreamingMatchesTalib()
|
||||
{
|
||||
/* TALib SAR uses the same Wilder parabolic SAR formula as QuanTAlib.
|
||||
Parameters: accelerationFactor=0.02 (step), maximum=0.20 (cap).
|
||||
Initialization differences produce a short divergence; values converge after first reversal.
|
||||
We accept up to 2% mismatch for edge-of-reversal rounding at period boundaries. */
|
||||
|
||||
var _data = new ValidationTestData();
|
||||
|
||||
double[] highData = _data.Bars.High.Values.ToArray();
|
||||
double[] lowData = _data.Bars.Low.Values.ToArray();
|
||||
double[] taOut = new double[_data.Bars.Count];
|
||||
|
||||
const double afStep = 0.02;
|
||||
const double afMax = 0.20;
|
||||
|
||||
var retCode = Functions.Sar<double>(
|
||||
highData, lowData,
|
||||
0..^0, taOut, out var outRange,
|
||||
afStep, afMax);
|
||||
Assert.Equal(Core.RetCode.Success, retCode);
|
||||
|
||||
(int offset, int length) = outRange.GetOffsetAndLength(taOut.Length);
|
||||
Assert.True(length > 100, $"TALib SAR produced only {length} values");
|
||||
|
||||
// QuanTAlib streaming
|
||||
var psar = new Psar(afStart: afStep, afIncrement: afStep, afMax: afMax);
|
||||
var qlSar = new double[_data.Bars.Count];
|
||||
for (int i = 0; i < _data.Bars.Count; i++)
|
||||
{
|
||||
_ = psar.Update(_data.Bars[i], isNew: true);
|
||||
qlSar[i] = psar.Sar;
|
||||
}
|
||||
|
||||
// Skip the first ~5 bars (initialization divergence), then require exact match.
|
||||
int skipBars = 5;
|
||||
int compared = 0;
|
||||
int matched = 0;
|
||||
for (int j = skipBars; j < length; j++)
|
||||
{
|
||||
int qi = j + offset;
|
||||
if (!double.IsFinite(qlSar[qi]) || !double.IsFinite(taOut[j])) { continue; }
|
||||
compared++;
|
||||
double diff = Math.Abs(qlSar[qi] - taOut[j]);
|
||||
if (diff <= 1e-9) { matched++; }
|
||||
}
|
||||
|
||||
// After initialization, QuanTAlib and TALib SAR should converge fully.
|
||||
// Accept up to 2% mismatch for edge-of-reversal rounding at period boundaries.
|
||||
double matchRate = compared > 0 ? (double)matched / compared : 0;
|
||||
Assert.True(matchRate >= 0.98,
|
||||
$"TALib SAR match rate {matchRate:P1} ({matched}/{compared}) < 98% — unexpected divergence");
|
||||
|
||||
_data.Dispose();
|
||||
}
|
||||
|
||||
// ── Cross-library: OoplesFinance ────────────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// Structural validation against Ooples <c>CalculateParabolicSAR</c>.
|
||||
/// Ooples PSAR uses the same Wilder acceleration factor algorithm (start=0.02, increment=0.02, max=0.2).
|
||||
/// Cross-library numeric equality is not asserted because reversal-point initialization
|
||||
/// diverges across implementations when the very first bar direction is ambiguous.
|
||||
/// Both must produce finite, positive output on the same OHLCV data.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void Psar_MatchesOoples_Structural()
|
||||
{
|
||||
var _data = new ValidationTestData();
|
||||
|
||||
var ooplesData = _data.SkenderQuotes.Select(q => new TickerData
|
||||
{
|
||||
Date = q.Date,
|
||||
Open = (double)q.Open,
|
||||
High = (double)q.High,
|
||||
Low = (double)q.Low,
|
||||
Close = (double)q.Close,
|
||||
Volume = (double)q.Volume
|
||||
}).ToList();
|
||||
|
||||
var stockData = new StockData(ooplesData);
|
||||
var oResult = stockData.CalculateParabolicSAR(start: 0.02, increment: 0.02, maximum: 0.2);
|
||||
var oValues = oResult.OutputValues.Values.First();
|
||||
|
||||
var psar = new Psar(afStart: 0.02, afIncrement: 0.02, afMax: 0.20);
|
||||
var qValues = new System.Collections.Generic.List<double>();
|
||||
foreach (var bar in _data.Data)
|
||||
{
|
||||
qValues.Add(psar.Update(bar).Value);
|
||||
}
|
||||
|
||||
Assert.True(oValues.Count > 0, "Ooples PSAR must produce output");
|
||||
|
||||
int finiteCount = 0;
|
||||
int warmup = 5;
|
||||
for (int i = warmup; i < Math.Min(oValues.Count, qValues.Count); i++)
|
||||
{
|
||||
if (double.IsFinite(oValues[i]) && double.IsFinite(qValues[i]) && qValues[i] > 0)
|
||||
{
|
||||
finiteCount++;
|
||||
}
|
||||
}
|
||||
|
||||
Assert.True(finiteCount > 100, $"Expected >100 finite positive PSAR pairs, got {finiteCount}");
|
||||
|
||||
_data.Dispose();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -76,6 +76,22 @@ At AF = 0.20 (maximum), SAR covers 20% of the EP-SAR gap per bar.
|
||||
|
||||
## Performance Profile
|
||||
|
||||
### Operation Count (Streaming Mode)
|
||||
|
||||
Parabolic SAR uses an adaptive acceleration factor with trend-reversal detection — O(1) per bar.
|
||||
|
||||
| Operation | Count | Cost (cycles) | Subtotal |
|
||||
| :--- | :---: | :---: | :---: |
|
||||
| Trend direction check | 1 | 2 cy | ~2 cy |
|
||||
| EP (extreme point) update | 1 | 2 cy | ~2 cy |
|
||||
| AF increment (conditional) | 1 | 2 cy | ~2 cy |
|
||||
| SAR = SAR + AF*(EP - SAR) via FMA | 1 | 1 cy | ~1 cy |
|
||||
| Reversal detection + reset | 1 | 3 cy | ~3 cy |
|
||||
| NaN guard + state update | 1 | 2 cy | ~2 cy |
|
||||
| **Total** | **O(1)** | — | **~12 cy** |
|
||||
|
||||
O(1) per bar. FMA computes SAR update in a single instruction. Reversal branching adds ~3 cy amortized. No SIMD in streaming — trend state is sequential.
|
||||
|
||||
| Operation | Complexity | Notes |
|
||||
|-----------|-----------|-------|
|
||||
| Update (streaming) | O(1) | State machine: constant work per bar |
|
||||
|
||||
@@ -94,6 +94,20 @@ In random walk data with GBM dynamics ($\mu = 0.05$, $\sigma = 0.20$), empirical
|
||||
|
||||
## Performance Profile
|
||||
|
||||
### Operation Count (Streaming Mode)
|
||||
|
||||
Swing High/Low detection compares centered bar against N neighbors on each side — O(1) with fixed lookback.
|
||||
|
||||
| Operation | Count | Cost (cycles) | Subtotal |
|
||||
| :--- | :---: | :---: | :---: |
|
||||
| Ring buffer update (high + low) | 2 | 3 cy | ~6 cy |
|
||||
| Compare center vs N left + N right neighbors | 2*N*2 | 2 cy | ~4N cy |
|
||||
| Signal assignment (swing high/low) | 2 | 1 cy | ~2 cy |
|
||||
| NaN guard + state update | 1 | 2 cy | ~2 cy |
|
||||
| **Total (N=5)** | **O(N)** | — | **~44 cy** |
|
||||
|
||||
O(N) per bar where N = lookback on each side. Signal delayed N bars. For N=5 the 10 comparisons are branchless SIMD-comparable.
|
||||
|
||||
### Implementation Design
|
||||
|
||||
The implementation uses two circular buffers with modular index arithmetic. Pattern evaluation checks $2L$ comparisons per direction (all neighbors against center), with early termination when both swing high and swing low are ruled out.
|
||||
|
||||
@@ -63,3 +63,33 @@ pivotLow = close[1] < close[2] AND close[1] < close[0]
|
||||
- [SWINGS: Swing High/Low Detection](../swings/Swings.md)
|
||||
- [FRACTALS: Williams Fractals](../fractals/Fractals.md)
|
||||
- [TTM_SQUEEZE: TTM Squeeze](../../dynamics/ttm_squeeze/TtmSqueeze.md)
|
||||
|
||||
|
||||
## Performance Profile
|
||||
|
||||
### Operation Count (Streaming Mode)
|
||||
|
||||
TTM Scalper Alert uses a 3-bar high/low range comparison with price action pattern matching — O(1) per bar.
|
||||
|
||||
| Operation | Count | Cost (cycles) | Subtotal |
|
||||
| :--- | :---: | :---: | :---: |
|
||||
| Update 3-bar high ring buffer | 1 | 3 cy | ~3 cy |
|
||||
| Update 3-bar low ring buffer | 1 | 3 cy | ~3 cy |
|
||||
| Compute 3-bar highest high | 1 | 4 cy | ~4 cy |
|
||||
| Compute 3-bar lowest low | 1 | 4 cy | ~4 cy |
|
||||
| Bar pattern comparison (buy/sell signal) | 1 | 3 cy | ~3 cy |
|
||||
| NaN guard + state update | 1 | 2 cy | ~2 cy |
|
||||
| **Total** | **O(1)** | — | **~19 cy** |
|
||||
|
||||
O(1) per bar. All state fits in two RingBuffers of size 3. Signal logic is a branchless comparison between current price and the 3-bar extremes.
|
||||
|
||||
### Batch Mode (SIMD Analysis)
|
||||
|
||||
| Operation | Vectorizable? | Notes |
|
||||
| :--- | :---: | :--- |
|
||||
| 3-bar rolling max (high) | Partial | Small window; scalar faster than SIMD setup |
|
||||
| 3-bar rolling min (low) | Partial | Same — short window overhead |
|
||||
| Signal comparison | Yes | Vector conditional-select for buy/sell |
|
||||
| Output array fill | Yes | Branchless signal assignment |
|
||||
|
||||
Limited SIMD benefit due to 3-bar window size — setup cost exceeds savings. The comparison/signal phase is SIMD-friendly for batch output.
|
||||
Reference in New Issue
Block a user