gavindiaz/QuanTAlib
1
0
Fork 0
mirror of https://github.com/mihakralj/QuanTAlib.git synced 2026-07-27 17:27:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix(docs): correct .md documentation across errors, dynamics, filters, forecasts, momentum, numerics, oscillators, reversals, statistics, trends, volatility, volume

Browse Source 
Deep review of all indicator categories verified .md headers against .cs WarmupPeriod, parameters, inputs, and outputs. Fixes include warmup corrections, parameter documentation, output type accuracy, and Pine Script alignment.
This commit is contained in:
Miha Kralj
2026-03-10 18:38:23 -07:00
parent 8906c62dcf
commit 35a6702b06
178 changed files with 2579 additions and 998 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/dynamics/impulse/Impulse.md
+2 -2
View File
@@ -7,14 +7,14 @@
| **Parameters** | `emaPeriod` (default 13), `macdFast` (default 12), `macdSlow` (default 26), `macdSignal` (default 9) |
| **Outputs** | Single series (Impulse) |
| **Output range** | Varies (see docs) |
| **Warmup** | 1 bar |
| **Warmup** | `Math.Max(emaPeriod, macdSlow) + macdSignal - 1` bars (default 34) |
### TL;DR
- The Elder Impulse System combines a 13-period EMA (trend inertia) with the MACD(12,26,9) histogram (momentum acceleration) to classify each bar as ...
- Parameterized by `emaperiod` (default 13), `macdfast` (default 12), `macdslow` (default 26), `macdsignal` (default 9).
- Output range: Varies (see docs).
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Requires `Math.Max(emaPeriod, macdSlow) + macdSignal - 1` bars (default 34) of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
> "The Impulse System identifies inflection points where a trend speeds up or slows down." -- Alexander Elder, *Come Into My Trading Room*
lib/dynamics/ravi/Ravi.md
+2 -2
View File
@@ -7,14 +7,14 @@
| **Parameters** | `shortPeriod` (default 7), `longPeriod` (default 65) |
| **Outputs** | Single series (Ravi) |
| **Output range** | Varies (see docs) |
| **Warmup** | 1 bar |
| **Warmup** | `longPeriod` bars (default 65) |
### TL;DR
- RAVI (Range Action Verification Index) measures trend strength by computing the absolute percentage divergence between a short-period SMA and a lon...
- Parameterized by `shortperiod` (default 7), `longperiod` (default 65).
- Output range: Varies (see docs).
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Requires `longPeriod` bars (default 65) of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
> "The simplest question in technical analysis is also the most important: is this market trending or not? RAVI answers it with two moving averages and a division."
lib/errors/huber/Huber.md
+2 -2
View File
@@ -3,11 +3,11 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual, Predicted (dual series) |
| **Parameters** | `period`, `delta` (default 1.345) |
| **Outputs** | Single series (Huber) |
| **Output range** | $\geq 0$ |
| **Warmup** | 1 bar |
| **Warmup** | `period` bars |
### TL;DR
lib/errors/logcosh/LogCosh.md
+3 -3
View File
@@ -3,11 +3,11 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual, Predicted (dual series) |
| **Parameters** | `period` |
| **Outputs** | Single series (UNKNOWN) |
| **Outputs** | Single series (LogCosh) |
| **Output range** | $\geq 0$ |
| **Warmup** | 1 bar |
| **Warmup** | `period` bars |
### TL;DR
lib/errors/maape/Maape.md
+3 -3
View File
@@ -3,11 +3,11 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual, Predicted (dual series) |
| **Parameters** | `period` |
| **Outputs** | Single series (MAAPE) |
| **Output range** | $\geq 0$ |
| **Warmup** | 1 bar |
| **Output range** | $[0, \pi/2]$ |
| **Warmup** | `period` bars |
### TL;DR
lib/errors/mae/Mae.md
+2 -2
View File
@@ -3,11 +3,11 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual, Predicted (dual series) |
| **Parameters** | `period` |
| **Outputs** | Single series (MAE) |
| **Output range** | $\geq 0$ |
| **Warmup** | 1 bar |
| **Warmup** | `period` bars |
### TL;DR
lib/errors/mapd/Mapd.md
+2 -2
View File
@@ -3,11 +3,11 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual, Predicted (dual series) |
| **Parameters** | `period` |
| **Outputs** | Single series (MAPD) |
| **Output range** | $\geq 0$ |
| **Warmup** | 1 bar |
| **Warmup** | `period` bars |
### TL;DR
lib/errors/mape/Mape.md
+2 -2
View File
@@ -3,11 +3,11 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual, Predicted (dual series) |
| **Parameters** | `period` |
| **Outputs** | Single series (MAPE) |
| **Output range** | $\geq 0$ |
| **Warmup** | 1 bar |
| **Warmup** | `period` bars |
### TL;DR
lib/errors/mase/Mase.md
+1 -1
View File
@@ -3,7 +3,7 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual, Predicted (dual series) |
| **Parameters** | `period` |
| **Outputs** | Single series (Mase) |
| **Output range** | $\geq 0$ |
lib/errors/mdae/Mdae.md
+1 -1
View File
@@ -3,7 +3,7 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual, Predicted (dual series) |
| **Parameters** | `period` |
| **Outputs** | Single series (Mdae) |
| **Output range** | $\geq 0$ |
lib/errors/mdape/Mdape.md
+1 -1
View File
@@ -3,7 +3,7 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual, Predicted (dual series) |
| **Parameters** | `period` |
| **Outputs** | Single series (Mdape) |
| **Output range** | $\geq 0$ |
lib/errors/me/Me.md
+3 -3
View File
@@ -3,11 +3,11 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual, Predicted (dual series) |
| **Parameters** | `period` |
| **Outputs** | Single series (ME) |
| **Output range** | $\geq 0$ |
| **Warmup** | 1 bar |
| **Output range** | Any (positive or negative) |
| **Warmup** | `period` bars |
### TL;DR
lib/errors/mpe/Mpe.md
+3 -3
View File
@@ -3,11 +3,11 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual, Predicted (dual series) |
| **Parameters** | `period` |
| **Outputs** | Single series (MPE) |
| **Output range** | $\geq 0$ |
| **Warmup** | 1 bar |
| **Output range** | Any (positive or negative) |
| **Warmup** | `period` bars |
### TL;DR
lib/errors/mrae/Mrae.md
+2 -2
View File
@@ -3,11 +3,11 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual, Predicted (dual series) |
| **Parameters** | `period` |
| **Outputs** | Single series (MRAE) |
| **Output range** | $\geq 0$ |
| **Warmup** | 1 bar |
| **Warmup** | `period` bars |
### TL;DR
lib/errors/mse/Mse.md
+2 -2
View File
@@ -3,11 +3,11 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual, Predicted (dual series) |
| **Parameters** | `period` |
| **Outputs** | Single series (MSE) |
| **Output range** | $\geq 0$ |
| **Warmup** | 1 bar |
| **Warmup** | `period` bars |
### TL;DR
lib/errors/msle/Msle.md
+2 -2
View File
@@ -3,11 +3,11 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual, Predicted (dual series) |
| **Parameters** | `period` |
| **Outputs** | Single series (MSLE) |
| **Output range** | $\geq 0$ |
| **Warmup** | 1 bar |
| **Warmup** | `period` bars |
### TL;DR
lib/errors/pseudohuber/PseudoHuber.md
+4 -4
View File
@@ -3,18 +3,18 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual vs Predicted (dual input) |
| **Parameters** | `period`, `delta` (default 1.0) |
| **Outputs** | Single series (UNKNOWN) |
| **Outputs** | Single series (PseudoHuber) |
| **Output range** | $\geq 0$ |
| **Warmup** | 1 bar |
| **Warmup** | `period` bars |
### TL;DR
- Pseudo-Huber Loss (also called Charbonnier Loss) is a smooth approximation to the Huber loss function.
- Parameterized by `period`, `delta` (default 1.0).
- Output range: $\geq 0$.
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Requires `period` bars of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
> "All the robustness of Huber, none of the discontinuities."
lib/errors/quantileloss/QuantileLoss.md
+3 -3
View File
@@ -3,11 +3,11 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual, Predicted (dual series) |
| **Parameters** | `period`, `quantile` (default 0.5) |
| **Outputs** | Single series (Quantile) |
| **Outputs** | Single series (QuantileLoss) |
| **Output range** | $\geq 0$ |
| **Warmup** | 1 bar |
| **Warmup** | `period` bars |
### TL;DR
lib/errors/rae/Rae.md
+1 -1
View File
@@ -3,7 +3,7 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual, Predicted (dual series) |
| **Parameters** | `period` |
| **Outputs** | Single series (Rae) |
| **Output range** | $\geq 0$ |
lib/errors/rmse/Rmse.md
+2 -2
View File
@@ -3,11 +3,11 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual, Predicted (dual series) |
| **Parameters** | `period` |
| **Outputs** | Single series (RMSE) |
| **Output range** | $\geq 0$ |
| **Warmup** | 1 bar |
| **Warmup** | `period` bars |
### TL;DR
lib/errors/rmsle/Rmsle.md
+3 -3
View File
@@ -3,18 +3,18 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual vs Predicted (dual input) |
| **Parameters** | `period` |
| **Outputs** | Single series (RMSLE) |
| **Output range** | $\geq 0$ |
| **Warmup** | 1 bar |
| **Warmup** | `period` bars |
### TL;DR
- Root Mean Squared Logarithmic Error is the square root of MSLE, providing an error metric in log-scale units.
- Parameterized by `period`.
- Output range: $\geq 0$.
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Requires `period` bars of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
> "RMSLE: because sometimes your errors need to be measured in decades, not dollars."
lib/errors/rse/Rse.md
+1 -1
View File
@@ -3,7 +3,7 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual vs Predicted (dual input) |
| **Parameters** | `period` |
| **Outputs** | Single series (Rse) |
| **Output range** | $\geq 0$ |
lib/errors/rsquared/Rsquared.md
+4 -4
View File
@@ -3,17 +3,17 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual vs Predicted (dual input) |
| **Parameters** | `period` |
| **Outputs** | Single series (R) |
| **Output range** | $\geq 0$ |
| **Outputs** | Single series (R²) |
| **Output range** | $(-\infty, 1]$ |
| **Warmup** | `period` bars |
### TL;DR
- The Coefficient of Determination (R²) measures the proportion of variance in the actual values that is predictable from the predicted values.
- Parameterized by `period`.
- Output range: $\geq 0$.
- Output range: $(-\infty, 1]$.
- Requires `period` bars of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
lib/errors/smape/Smape.md
+3 -3
View File
@@ -3,18 +3,18 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual vs Predicted (dual input) |
| **Parameters** | `period` |
| **Outputs** | Single series (SMAPE) |
| **Output range** | $\geq 0$ |
| **Warmup** | 1 bar |
| **Warmup** | `period` bars |
### TL;DR
- Symmetric Mean Absolute Percentage Error addresses a fundamental asymmetry in MAPE: the fact that over-predictions and under-predictions of the sam...
- Parameterized by `period`.
- Output range: $\geq 0$.
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Requires `period` bars of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
> "MAPE punishes based on who's right; SMAPE punishes based on how different they are."
lib/errors/theilu/TheilU.md
+1 -1
View File
@@ -3,7 +3,7 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual vs Predicted (dual input) |
| **Parameters** | `period` |
| **Outputs** | Single series (TheilU) |
| **Output range** | $\geq 0$ |
lib/errors/tukeybiweight/TukeyBiweight.md
+5 -5
View File
@@ -3,18 +3,18 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Parameters** | `period`, `c` (default DefaultC) |
| **Outputs** | Single series (UNKNOWN) |
| **Inputs** | Actual vs Predicted (dual input) |
| **Parameters** | `period`, `c` (default 4.685) |
| **Outputs** | Single series (TukeyBiweight) |
| **Output range** | $\geq 0$ |
| **Warmup** | 1 bar |
| **Warmup** | `period` bars |
### TL;DR
- Tukey's Biweight (also called Bisquare) is a redescending M-estimator that completely ignores errors beyond a threshold.
- Parameterized by `period`, `c` (default defaultc).
- Output range: $\geq 0$.
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Requires `period` bars of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
> "When outliers need to be silenced, not just quieted."
lib/errors/wmape/Wmape.md
+1 -1
View File
@@ -3,7 +3,7 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual vs Predicted (dual input) |
| **Parameters** | `period` |
| **Outputs** | Single series (Wmape) |
| **Output range** | $\geq 0$ |
lib/errors/wrmse/Wrmse.md
+1 -1
View File
@@ -3,7 +3,7 @@
| Property | Value |
| ---------------- | -------------------------------- |
| **Category** | Error Metric |
| **Inputs** | Source (close) |
| **Inputs** | Actual vs Predicted (dual input) |
| **Parameters** | `period` |
| **Outputs** | Single series (Wrmse) |
| **Output range** | $\geq 0$ |
lib/filters/agc/Agc.md
+12 -13
View File
@@ -6,15 +6,15 @@
| **Inputs** | Source (close) |
| **Parameters** | `decay` (default 0.991) |
| **Outputs** | Single series (AGC) |
| **Output range** | Tracks input |
| **Output range** | [-1, +1] (normalized) |
| **Warmup** | `1` bars |
### TL;DR
- The Automatic Gain Control normalizes any oscillating signal to the \[-1, +1\] range through exponential peak tracking.
- Parameterized by `decay` (default 0.991).
- Output range: Tracks input.
- Requires `1` bars of warmup before first valid output (IsHot = true).
- Output range: [-1, +1] (normalized amplitude).
- Requires `1` bar of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
> "The purpose of the AGC is to normalize the amplitude of any indicator to unity." — John F. Ehlers, TASC January 2015
@@ -86,26 +86,25 @@ Peak initializes to $10^{-10}$ (tiny positive) to avoid division by zero on the
### Operation Count (Streaming Mode)
AGC (Adaptive Gain Control) applies a slow EMA to estimate signal level, then scales the signal by the inverse of that level. O(1) per bar.
AGC uses exponential peak decay with a ratchet-up mechanism, then divides the signal by the tracked peak. O(1) per bar.
| Operation | Count | Cost (cycles) | Subtotal |
| :--- | :---: | :---: | :---: |
| Level EMA (FMA) | 1 | ~4 cy | ~4 cy |
| Gain = 1 / level (division) | 1 | ~10 cy | ~10 cy |
| Output multiply | 1 | ~3 cy | ~3 cy |
| **Total** | **3** | — | **~17 cycles** |
| Peak decay (multiply) | 1 | ~3 cy | ~3 cy |
| Abs + compare (ratchet) | 1 | ~2 cy | ~2 cy |
| Normalize (division) | 1 | ~10 cy | ~10 cy |
| **Total** | **3** | — | **~15 cycles** |
O(1) per bar. The division dominates; precomputing gain incrementally saves it but adds state. ~17 cycles/bar.
O(1) per bar. The division dominates. ~15 cycles/bar.
### Batch Mode (SIMD Analysis)
| Operation | Vectorizable? | Notes |
| :--- | :---: | :--- |
| Level EMA recursion | No | Sequential IIR dependency |
| Gain division | No | Depends on current EMA |
| Output multiply | N/A | Single scalar multiply |
| Peak decay + ratchet | No | Data-dependent branching (max of decay vs abs) |
| Normalize (division) | No | Depends on current peak |
Fully recursive. Batch throughput: ~17 cy/bar.
Fully sequential due to data-dependent peak tracking. Batch throughput: ~15 cy/bar.
| Metric | Value |
|---|---|
lib/filters/alaguerre/ALaguerre.md
+13 -9
View File
@@ -7,7 +7,7 @@
| **Parameters** | `length` (default 20), `medianLength` (default 5) |
| **Outputs** | Single series (ALaguerre) |
| **Output range** | Tracks input |
| **Warmup** | 1 bar |
| **Warmup** | `max(4, length)` bars |
| **Signature** | [alaguerre_signature](alaguerre_signature.md) |
### TL;DR
@@ -15,7 +15,7 @@
- The Adaptive Laguerre Filter extends Ehlers' four-element all-pass cascade by replacing the fixed damping factor with a per-bar adaptive alpha deri...
- Parameterized by `length` (default 20), `medianlength` (default 5).
- Output range: Tracks input.
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Requires `max(4, length)` bars of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
> "The best filter is one that knows when to listen closely and when to smooth aggressively." -- John F. Ehlers (paraphrased)
@@ -111,24 +111,28 @@ The filter requires $\max(4, N)$ bars before producing reliable output. The firs
### Operation Count (Streaming Mode)
Laguerre filter uses 4 cascaded Laguerre stages L0..L3, each an O(1) gamma-parameterized FMA, plus a final weighted combination.
Adaptive Laguerre combines HH/LL tracking error normalization (O(N) scan), median smoothing (O(M log M) sort), and 4-stage Laguerre cascade (O(1)).
| Operation | Count | Cost (cycles) | Subtotal |
| :--- | :---: | :---: | :---: |
| Tracking error computation | 1 | ~3 cy | ~3 cy |
| HH/LL scan over N-element buffer | N | ~2 cy | ~40 cy (N=20) |
| Median via insertion sort (M elements) | M log M | ~3 cy | ~25 cy (M=5) |
| Laguerre state update x4 (each: 2 FMA) | 8 | ~4 cy | ~32 cy |
| Weighted output combination (3 adds) | 3 | ~2 cy | ~6 cy |
| **Total** | **11** | — | **~38 cycles** |
| Weighted output combination | 3 | ~2 cy | ~6 cy |
| **Total** | — | — | **~106 cycles** (N=20, M=5) |
O(1) per bar. Four recursive stages with precomputed gamma constant. ~38 cycles/bar.
O(N + M log M) per bar due to HH/LL scan and median sort. Dominated by the lookback scan for large N.
### Batch Mode (SIMD Analysis)
| Operation | Vectorizable? | Notes |
| :--- | :---: | :--- |
| Laguerre stage recursion | No | Each stage `L[k][n]` depends on `L[k-1][n]` and `L[k][n-1]` |
| Weighted combination | No | Only 4 terms; SIMD overhead not worthwhile |
| HH/LL scan | Partial | Min/max over contiguous buffer amenable to `Vector<double>` |
| Median sort | No | Comparison-based sort, data-dependent |
| Laguerre cascade | No | Each stage depends on previous stage and previous bar |
Cascaded IIR stages cannot be vectorized. Batch throughput: ~38 cy/bar.
Adaptive overhead limits SIMD gains. Batch throughput: ~106 cy/bar (N=20, M=5).
| Metric | Value | Notes |
|--------|-------|-------|
lib/filters/baxterking/BaxterKing.md
+4 -4
View File
@@ -6,16 +6,16 @@
| **Inputs** | Source (close) |
| **Parameters** | `pLow` (default 6), `pHigh` (default 32), `k` (default 12) |
| **Outputs** | Single series (BaxterKing) |
| **Output range** | Tracks input |
| **Warmup** | 1 bar |
| **Output range** | Oscillates around zero |
| **Warmup** | `2K+1` bars (default 25) |
| **Signature** | [baxterking_signature](baxterking_signature.md) |
### TL;DR
- The **Baxter-King Band-Pass Filter** is a symmetric finite impulse response (FIR) filter that approximates the ideal spectral band-pass by truncati...
- Parameterized by `plow` (default 6), `phigh` (default 32), `k` (default 12).
- Output range: Tracks input.
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Output range: Oscillates around zero (extracts cyclical component).
- Requires `2K+1` bars of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
> "The business cycle is whatever remains after you strip away the trend and the noise. Baxter and King figured out the stripping."
lib/filters/bessel/Bessel.md
+2 -2
View File
@@ -7,7 +7,7 @@
| **Parameters** | `length` |
| **Outputs** | Single series (Bessel) |
| **Output range** | Tracks input |
| **Warmup** | 1 bar |
| **Warmup** | `length` bars |
| **Signature** | [bessel_signature](bessel_signature.md) |
### TL;DR
@@ -15,7 +15,7 @@
- The Bessel Filter is a 2nd-order low-pass IIR filter designed to preserve the **shape** and **timing** of price moves.
- Parameterized by `length`.
- Output range: Tracks input.
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Requires `length` bars of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
> When you care more about *when* the market turns than how aggressively you can torture the noise, you reach for a Bessel.
lib/filters/bpf/Bpf.md
+2 -2
View File
@@ -6,7 +6,7 @@
| **Inputs** | Source (close) |
| **Parameters** | `lowerPeriod`, `upperPeriod` |
| **Outputs** | Single series (BPF) |
| **Output range** | Tracks input |
| **Output range** | Oscillates around zero |
| **Warmup** | `Math.Max(lowerPeriod, upperPeriod)` bars |
| **Signature** | [bpf_signature](bpf_signature.md) |
@@ -14,7 +14,7 @@
- The **BPF** (BandPass Filter) is a second-order IIR architecture designed to surgically excise specific frequency components from a time series.
- Parameterized by `lowerperiod`, `upperperiod`.
- Output range: Tracks input.
- Output range: Oscillates around zero (bandpass extracts cyclic component).
- Requires `Math.Max(lowerPeriod, upperPeriod)` bars of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
lib/filters/cfitz/Cfitz.md
+2 -2
View File
@@ -6,7 +6,7 @@
| **Inputs** | Source (close) |
| **Parameters** | `pLow` (default 6), `pHigh` (default 32) |
| **Outputs** | Single series (Cfitz) |
| **Output range** | Tracks input |
| **Output range** | Oscillates around zero |
| **Warmup** | `2` bars |
| **Signature** | [cfitz_signature](cfitz_signature.md) |
@@ -14,7 +14,7 @@
- The **Christiano-Fitzgerald Band-Pass Filter** is an asymmetric full-sample filter that approximates the ideal spectral band-pass by using time-var...
- Parameterized by `plow` (default 6), `phigh` (default 32).
- Output range: Tracks input.
- Output range: Oscillates around zero (extracts cyclical component).
- Requires `2` bars of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
lib/filters/edcf/Edcf.md
+2 -2
View File
@@ -7,7 +7,7 @@
| **Parameters** | `length` (default 15) |
| **Outputs** | Single series (Edcf) |
| **Output range** | Tracks input |
| **Warmup** | 1 bar |
| **Warmup** | `length` bars |
| **Signature** | [edcf_signature](edcf_signature.md) |
### TL;DR
@@ -15,7 +15,7 @@
- The **Ehlers Distance Coefficient Filter (EDCF)** is a nonlinear adaptive FIR filter created by John F.
- Parameterized by `length` (default 15).
- Output range: Tracks input.
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Requires `length` bars of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
## Overview
lib/filters/gauss/Gauss.md
+1 -1
View File
@@ -14,7 +14,7 @@
- Gauss (Gaussian Filter) is a smoothing filter that applies a Gaussian kernel to time series data.
- Parameterized by `sigma` (default 1.0).
- Output range: Tracks input.
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Requires `2⌈3σ⌉+1` bars of warmup before first valid output (IsHot = true). Default: **7 bars** (σ=1.0).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
> "SMA smears data like cheap paint. Gaussian filtering respects the signal's soul."
lib/filters/hann/Hann.md
+1 -1
View File
@@ -15,7 +15,7 @@
- Hann (Hann Filter) is a Finite Impulse Response (FIR) smoothing filter that applies a Hann window to time series data.
- Parameterized by `length`.
- Output range: Tracks input.
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Requires `length` bars of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
> "The Hanning window whispers where the Boxcar screams. Smoothness is not just an aesthetic; it's a mathematical necessity."
lib/filters/hp/Hp.md
+1 -1
View File
@@ -14,7 +14,7 @@
- The Hodrick-Prescott (HP) filter is a widely used tool in macroeconomics for separating the cyclical component of a time series from raw data.
- Parameterized by `lambda` (default 1600.0).
- Output range: Tracks input.
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Requires `⌈2√λ⌉` bars of warmup before first valid output (IsHot = true). Default: **~80 bars** (λ=1600).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
> "Trends are not lines; they are curves that we simplify for our sanity, often at the cost of reality."
lib/filters/hpf/Hpf.md
+2 -2
View File
@@ -14,8 +14,8 @@
- The 2-Pole Highpass Filter (HPF) is designed to separate high-frequency components (like cycles and noise) from the underlying trend.
- Parameterized by `length` (default 40).
- Output range: Tracks input.
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Output range: Oscillates around zero (detrended signal).
- Requires `length` bars of warmup before first valid output (IsHot = true). Default: **40 bars**.
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
> "Noise is just signal you haven't figured out how to filter yet. Or maybe, it's the only signal that matters."
lib/filters/rmed/Rmed.md
+2 -2
View File
@@ -7,7 +7,7 @@
| **Parameters** | `period` (default 12) |
| **Outputs** | Single series (Rmed) |
| **Output range** | Tracks input |
| **Warmup** | 1 bar |
| **Warmup** | 5 bars (MedianWindow) |
| **Signature** | [rmed_signature](rmed_signature.md) |
### TL;DR
@@ -15,7 +15,7 @@
- RMED applies exponential smoothing to a 5-bar running median, creating a nonlinear IIR filter that rejects impulsive spike noise while providing sm...
- Parameterized by `period` (default 12).
- Output range: Tracks input.
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Requires **5 bars** of warmup (MedianWindow) before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
> "John Ehlers combined two tools that rarely meet: the median (nonlinear, spike-resistant) and the EMA (smooth, recursive). The median kills the spikes, the EMA smooths the survivors. Together they produce a filter that is both resistant and smooth."
lib/filters/roofing/Roofing.md
+4 -4
View File
@@ -6,15 +6,15 @@
| **Inputs** | Source (close) |
| **Parameters** | `hpLength` (default 48), `ssLength` (default 10) |
| **Outputs** | Single series (ROOFING) |
| **Output range** | Tracks input |
| **Warmup** | 1 bar |
| **Output range** | Oscillates around zero |
| **Warmup** | `hpLength` bars (default 48) |
### TL;DR
- The **Roofing Filter** is John Ehlers' bandpass architecture designed specifically for oscillator construction.
- Parameterized by `hplength` (default 48), `sslength` (default 10).
- Output range: Tracks input.
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Output range: Oscillates around zero (bandpass behavior).
- Requires `hpLength` bars of warmup before first valid output (IsHot = true). Default: **48 bars**.
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
> "The trend is your friend until it overwhelms the signal. The noise is your enemy until you mistake it for alpha."
lib/filters/spbf/Spbf.md
+4 -4
View File
@@ -6,15 +6,15 @@
| **Inputs** | Source (close) |
| **Parameters** | `shortPeriod` (default 40), `longPeriod` (default 60), `rmsPeriod` (default 50) |
| **Outputs** | Single series (SPBF) |
| **Output range** | Tracks input |
| **Warmup** | 1 bar |
| **Output range** | Oscillates around zero |
| **Warmup** | `max(longPeriod, rmsPeriod)` bars (default 60) |
### TL;DR
- The **Super Passband Filter** is John Ehlers' wide-band bandpass constructed by differencing two z-transformed EMAs with Ehlers-style smoothing ($\...
- Parameterized by `shortperiod` (default 40), `longperiod` (default 60), `rmsperiod` (default 50).
- Output range: Tracks input.
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Output range: Oscillates around zero.
- Requires `max(longPeriod, rmsPeriod)` bars of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
> "Two EMAs walk into a frequency domain. The difference between them is the only thing worth trading."
lib/filters/ssf2/ssf2.pine
+1 -1
View File
@@ -26,7 +26,7 @@ ssf2(series float src, simple int length) =>
float ssrc = nz(src, src[1])
float src1 = nz(src[1], ssrc)
float src2 = nz(src[2], src1)
ssf_internal := c1 * ssrc + c2 * nz(ssf_internal[1], src1) + c3 * nz(ssf_internal[2], src2)
ssf_internal := c1 * (ssrc + src1) * 0.5 + c2 * nz(ssf_internal[1], src1) + c3 * nz(ssf_internal[2], src2)
ssf_internal
// ---------- Main loop ----------
lib/filters/usf/Usf.md
+8 -9
View File
@@ -62,25 +62,24 @@ Where:
### Operation Count (Streaming Mode)
Universal Smooth Filter: adaptive-weight FIR that adjusts taps based on signal characteristics. O(N) per bar.
Ehlers Ultimate Smoother Filter (USF): 2-pole IIR low-pass filter with high-pass subtraction for zero-lag smoothing. Five FMA operations per bar.
| Operation | Count | Cost (cycles) | Subtotal |
| :--- | :---: | :---: | :---: |
| Adaptive weight derivation | N | ~8 cy | ~240 cy (N=30) |
| Weighted sum FMA | N | ~5 cy | ~150 cy |
| Normalization | 1 | ~3 cy | ~3 cy |
| **Total (N=30)** | **2N+1** | — | **~393 cycles** |
| Input combination (3 taps) | 3 | ~4 cy | ~12 cy |
| Feedback (2 taps) | 2 | ~4 cy | ~8 cy |
| State update | 4 | ~1 cy | ~4 cy |
| **Total** | **9** | — | **~24 cycles** |
O(N) per bar. Adaptive weights computed per bar (no precomputation) because they depend on current signal level. ~393 cycles for N=30.
O(1) per bar. Coefficients derived from period parameter; precomputed. ~24 cycles/bar.
### Batch Mode (SIMD Analysis)
| Operation | Vectorizable? | Notes |
| :--- | :---: | :--- |
| Adaptive weight computation | Partial | Independent per element; vectorizable if no data dependency |
| Weighted sum FMA | Yes | Standard dot product |
| USF recursion | No | y[n] depends on y[n-1] and y[n-2] |
SIMD potential: ~100 cy for N=30 if adaptive weights vectorized.
Batch throughput: ~24 cy/bar.
| Metric | Score | Notes |
| :--- | :--- | :--- |
lib/filters/voss/Voss.md
+11 -10
View File
@@ -6,7 +6,7 @@
| **Inputs** | Source (close) |
| **Parameters** | `period` (default 20), `predict` (default 3), `bandwidth` (default 0.25) |
| **Outputs** | Single series (VOSS) |
| **Output range** | Tracks input |
| **Output range** | Oscillates around zero |
| **Warmup** | `period` bars |
| **Signature** | [voss_signature](voss_signature.md) |
@@ -86,25 +86,26 @@ The Voss predictor stage is an IIR filter with `Order` feedback taps, each weigh
### Operation Count (Streaming Mode)
Voss-McCartney 1/f noise filter: octave-cascade of N random sources, each updated probabilistically. O(N) per bar worst-case, O(1) amortized.
Ehlers Voss Predictive Filter: two-stage pipeline — 2-pole bandpass filter (Stage 1) + weighted feedback predictor (Stage 2). O(Order) per bar where Order = 3 × Predict.
| Operation | Count | Cost (cycles) | Subtotal |
| :--- | :---: | :---: | :---: |
| Bit-scan (which octave to update) | 1 | ~3 cy | ~3 cy |
| RNG sample + accumulate | 1 | ~8 cy | ~8 cy |
| Running sum update | 1 | ~2 cy | ~2 cy |
| **Total (amortized)** | **3** | — | **~13 cycles** |
| BPF: diff + 3-term FMA | 3 | ~4 cy | ~12 cy |
| Voss: weighted sum loop | Order | ~5 cy | ~45 cy (Order=9) |
| Voss: gain × filt − sumC | 2 | ~4 cy | ~8 cy |
| State update (shifts) | 4 | ~1 cy | ~4 cy |
| **Total (Order=9)** | **Order+9** | — | **~69 cycles** |
O(1) amortized per bar. Each bar updates exactly 1 octave source on average. ~13 cycles/bar amortized.
O(Order) per bar. Order = 3 × Predict; at defaults (Predict=3), Order=9. ~69 cycles/bar.
### Batch Mode (SIMD Analysis)
| Operation | Vectorizable? | Notes |
| :--- | :---: | :--- |
| Octave update scheduling | No | Bit-count branching; data-dependent |
| RNG generation | Partial | SIMD RNG (e.g., xoshiro SIMD) available but niche |
| BPF recursion | No | y[n] depends on y[n-1] and y[n-2] |
| Voss weighted sum | Partial | Inner loop vectorizable but short (Order=9) |
Amortized O(1) makes SIMD gains minimal. Batch throughput: ~13 cy/bar.
Batch throughput: ~69 cy/bar at defaults.
| Metric | Value |
|--------|-------|
lib/filters/wavelet/Wavelet.md
+2 -2
View File
@@ -7,14 +7,14 @@
| **Parameters** | `levels` (default 4), `threshMult` (default 1.0) |
| **Outputs** | Single series (Wavelet) |
| **Output range** | Tracks input |
| **Warmup** | 1 bar |
| **Warmup** | `2^levels` bars (default 16) |
### TL;DR
- The Wavelet Denoising Filter applies an *à trous* (with holes) Haar wavelet decomposition with soft thresholding to remove high-frequency noise fro...
- Parameterized by `levels` (default 4), `threshmult` (default 1.0).
- Output range: Tracks input.
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Requires `2^levels` bars of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
> "The wavelet transform is to the Fourier transform what a microscope is to a telescope: same math, different scale."
lib/forecasts/afirma/Afirma.md
+8 -8
View File
@@ -137,18 +137,18 @@ $$
### Operation Count (Streaming Mode)
AFIRMA chains AR model estimation with IIR/FIR filtering — O(p) per bar where p = AR order.
Windowed FIR convolution — O(P) per bar where P = period (window length).
| Operation | Count | Cost (cycles) | Subtotal |
| :--- | :---: | :---: | :---: |
| AR coefficient estimation (p terms) | p | 4 cy | ~4p cy |
| FIR forward pass (p multiplies) | p | 1 cy | ~p cy |
| IIR feedback pass (p multiplies) | p | 1 cy | ~p cy |
| Output computation via FMA | 1 | 1 cy | ~1 cy |
| NaN guard + state update | 1 | 2 cy | ~2 cy |
| **Total (p=8)** | **O(p)** | — | **~49 cy** |
| RingBuffer write | 1 | ~2 cy | ~2 cy |
| FIR convolution (P FMA ops) | P | ~1 cy | ~P cy |
| Weight normalization | 1 | ~1 cy | ~1 cy |
| LS regression (if enabled) | n | ~2 cy | ~2n cy |
| NaN guard + state update | 1 | ~2 cy | ~2 cy |
| **Total (P=20)** | **O(P)** | — | **~25 cy** |
O(p) per bar where p = AR order. AR coefficient estimation dominates; FMA-fused filter passes are cheap. Streaming mode maintains p state variables.
O(P) per bar where P = window length. FMA-fused dot product dominates; LS regression adds O(n) where n = min(⌊(P−1)/2⌋, 50).
| Metric | Value | Notes |
| :--- | :---: | :--- |
lib/forecasts/afirma/afirma.pine
+2 -2
View File
@@ -7,7 +7,7 @@ indicator("Autoregressive FIR Moving Average (AFIRMA)", "AFIRMA", overlay=true)
//@param source Series to calculate AFIRMA from
//@param period Lookback period - window size
//@param windowType Window function type (1:Hanning, 2:Hamming, 3:Blackman, 4:Blackman-Harris)
//@param leastSquares Apply least squares cubic polynomial fitting for autoregressive prediction
//@param leastSquares Apply least squares linear regression fitting for autoregressive prediction
//@returns AFIRMA value, calculates from first bar using available data
//@optimized Uses windowing functions with O(n) complexity; least squares adds O(n) for polynomial fitting
afirma(series float src, simple int period, simple int windowType=4, simple bool leastSquares=false) =>
@@ -111,7 +111,7 @@ afirma(series float src, simple int period, simple int windowType=4, simple bool
i_period = input.int(20, "Period", minval=1)
i_source = input.source(close, "Source")
i_windowType = input.int(4, "Window Function", minval=1, maxval=4, tooltip="1:Hanning, 2:Hamming, 3:Blackman, 4:Blackman-Harris")
i_leastSquares = input.bool(false, "Least Squares Method", tooltip="Enable cubic polynomial fitting for autoregressive prediction")
i_leastSquares = input.bool(false, "Least Squares Method", tooltip="Enable linear regression fitting for autoregressive prediction")
// Calculation
afirma_value = afirma(i_source, i_period, i_windowType, i_leastSquares)
lib/momentum/asi/Asi.md
+1 -1
View File
@@ -7,7 +7,7 @@
| **Parameters** | `limitMove` (default 3.0) |
| **Outputs** | Single series (Asi) |
| **Output range** | Varies (see docs) |
| **Warmup** | `> 2` bars |
| **Warmup** | 2 bars |
### TL;DR
lib/momentum/bop/Bop.md
+1 -1
View File
@@ -7,7 +7,7 @@
| **Parameters** | None |
| **Outputs** | Single series (BOP) |
| **Output range** | Varies (see docs) |
| **Warmup** | `> 0` bars |
| **Warmup** | 0 bars (always hot) |
### TL;DR
lib/momentum/cci/Cci.md
+4 -4
View File
@@ -4,17 +4,17 @@
| ---------------- | -------------------------------- |
| **Category** | Momentum |
| **Inputs** | OHLCV bar (TBar) |
| **Parameters** | `period` (default DefaultPeriod) |
| **Parameters** | `period` (default 20) |
| **Outputs** | Single series (CCI) |
| **Output range** | Varies (see docs) |
| **Warmup** | `> period` bars |
| **Warmup** | `period` bars |
### TL;DR
- The Commodity Channel Index (CCI) is a versatile momentum-based oscillator developed by Donald Lambert in 1980.
- Parameterized by `period` (default defaultperiod).
- Parameterized by `period` (default 20).
- Output range: Varies (see docs).
- Requires `> period` bars of warmup before first valid output (IsHot = true).
- Requires `period` bars (20 default) of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
## Overview
lib/momentum/cfb/Cfb.md
+2 -2
View File
@@ -7,14 +7,14 @@
| **Parameters** | int[]? lengths = null |
| **Outputs** | Single series (CFB) |
| **Output range** | Varies (see docs) |
| **Warmup** | 1 bar |
| **Warmup** | `maxLen` bars (192 default) |
### TL;DR
- The Composite Fractal Behavior index measures trend duration by analyzing fractal efficiency across 96 simultaneous lookback periods (2 to 192 bars...
- Parameterized by int[]? lengths = null.
- Output range: Varies (see docs).
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Requires `maxLen` bars (192 default) of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
> "Mark Jurik's CFB is not a momentum indicator. It is a stopwatch for chaos."
lib/momentum/cmo/Cmo.md
+2 -2
View File
@@ -4,7 +4,7 @@
| ---------------- | -------------------------------- |
| **Category** | Momentum |
| **Inputs** | Source (close) |
| **Parameters** | `period` (default DefaultPeriod) |
| **Parameters** | `period` (default 14) |
| **Outputs** | Single series (Cmo) |
| **Output range** | $-100$ to $+100$ |
| **Warmup** | `period + 1` bars |
@@ -12,7 +12,7 @@
### TL;DR
- The Chande Momentum Oscillator (CMO) is a momentum indicator developed by Tushar Chande.
- Parameterized by `period` (default defaultperiod).
- Parameterized by `period` (default 14).
- Output range: $-100$ to $+100$.
- Requires `period + 1` bars of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
lib/momentum/macd/Macd.md
+2 -2
View File
@@ -7,14 +7,14 @@
| **Parameters** | `fastPeriod` (default 12), `slowPeriod` (default 26), `signalPeriod` (default 9) |
| **Outputs** | Multiple series (Signal, Histogram) |
| **Output range** | Varies (see docs) |
| **Warmup** | 1 bar |
| **Warmup** | `Max(fast, slow) + signal - 2` bars (33 default) |
### TL;DR
- The Moving Average Convergence Divergence measures momentum through the relationship between two exponential moving averages.
- Parameterized by `fastperiod` (default 12), `slowperiod` (default 26), `signalperiod` (default 9).
- Output range: Varies (see docs).
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Requires `Max(fast, slow) + signal - 2` bars (33 default) of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
> "The trend is your friend, until it bends." — Ed Seykota
lib/momentum/ppo/Ppo.md
+4 -4
View File
@@ -4,17 +4,17 @@
| ---------------- | -------------------------------- |
| **Category** | Momentum |
| **Inputs** | Source (close) |
| **Parameters** | `fastPeriod` (default DefaultFastPeriod), `slowPeriod` (default DefaultSlowPeriod), `signalPeriod` (default DefaultSignalPeriod) |
| **Parameters** | `fastPeriod` (default 12), `slowPeriod` (default 26), `signalPeriod` (default 9) |
| **Outputs** | Multiple series (Signal, Histogram) |
| **Output range** | Varies (see docs) |
| **Warmup** | 1 bar |
| **Warmup** | `slowPeriod + signalPeriod` bars (35 default) |
### TL;DR
- PPO (Percentage Price Oscillator) measures the percentage difference between a fast EMA and a slow EMA.
- Parameterized by `fastperiod` (default defaultfastperiod), `slowperiod` (default defaultslowperiod), `signalperiod` (default defaultsignalperiod).
- Parameterized by `fastPeriod` (default 12), `slowPeriod` (default 26), `signalPeriod` (default 9).
- Output range: Varies (see docs).
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Requires `slowPeriod + signalPeriod` bars (35 default) of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
> "MACD told you the spread in dollars. PPO tells you the spread in percent. One of those actually works across instruments."
lib/momentum/rsx/Rsx.md
+1 -1
View File
@@ -1,4 +1,4 @@
# RSX: Relative Strength Quality Index
# RSX: Relative Strength Xtra (Jurik RSX)
| Property | Value |
| ---------------- | -------------------------------- |
lib/momentum/tsi/Tsi.md
+6 -6
View File
@@ -4,17 +4,17 @@
| ---------------- | -------------------------------- |
| **Category** | Momentum |
| **Inputs** | Source (close) |
| **Parameters** | `longPeriod` (default DefaultLongPeriod), `shortPeriod` (default DefaultShortPeriod), `signalPeriod` (default DefaultSignalPeriod) |
| **Parameters** | `longPeriod` (default 25), `shortPeriod` (default 13), `signalPeriod` (default 13) |
| **Outputs** | Single series (Tsi) |
| **Output range** | $-1$ to $+1$ |
| **Warmup** | 1 bar |
| **Output range** | $-100$ to $+100$ |
| **Warmup** | `longPeriod + shortPeriod + signalPeriod` bars (51 default) |
### TL;DR
- The True Strength Index (TSI) is a momentum oscillator developed by William Blau that uses double-smoothed exponential moving averages of price mom...
- Parameterized by `longperiod` (default defaultlongperiod), `shortperiod` (default defaultshortperiod), `signalperiod` (default defaultsignalperiod).
- Output range: $-1$ to $+1$.
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Parameterized by `longPeriod` (default 25), `shortPeriod` (default 13), `signalPeriod` (default 13).
- Output range: $-100$ to $+100$.
- Requires `longPeriod + shortPeriod + signalPeriod` bars (51 default) of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
The True Strength Index (TSI) is a momentum oscillator developed by William Blau that uses double-smoothed exponential moving averages of price momentum to reduce noise and identify trend strength and direction.
lib/numerics/accel/accel.pine
+14 -69
View File
@@ -1,83 +1,28 @@
// Licensed under the Apache License, Version 2.0
// © mihakralj
//@version=6
indicator("Acceleration (Slope of Slope) (ACCEL)", "ACCEL", overlay=false, precision=8)
indicator("Second Derivative / Acceleration (ACCEL)", "ACCEL", overlay=false, precision=8)
//@function Calculates acceleration (slope of slope)
//@param src Source series to calculate slope from
//@param len Lookback period for calculation
//@returns acceleration
accel(series float src, simple int len1) =>
if len1 <= 1
runtime.error("Length 1 for slope calculation must be greater than 1")
var float sumX1 = 0.0, var float sumY1 = 0.0, var float sumXY1 = 0.0, var float sumX21 = 0.0
var int validCount1 = 0
var array<float> x_values1 = array.new_float(len1)
var array<float> y_values1 = array.new_float(len1)
var int head1 = 0
var int internal_time_counter1 = 0
if internal_time_counter1 >= len1
float oldX1 = array.get(x_values1, head1)
float oldY1 = array.get(y_values1, head1)
if not na(oldY1)
sumX1 := sumX1 - oldX1, sumY1 := sumY1 - oldY1
sumXY1 := sumXY1 - oldX1 * oldY1, sumX21 := sumX21 - oldX1 * oldX1
validCount1 := validCount1 - 1
float currentX1 = internal_time_counter1
float currentY1 = src
array.set(x_values1, head1, currentX1)
array.set(y_values1, head1, currentY1)
if not na(currentY1)
sumX1 := sumX1 + currentX1, sumY1 := sumY1 + currentY1
sumXY1 := sumXY1 + currentX1 * currentY1, sumX21 := sumX21 + currentX1 * currentX1
validCount1 := validCount1 + 1
head1 := (head1 + 1) % len1
internal_time_counter1 := internal_time_counter1 + 1
float current_slope = na
if validCount1 >= 2
float n1 = validCount1
float divisor1 = n1 * sumX21 - sumX1 * sumX1
if divisor1 != 0.0
current_slope := (n1 * sumXY1 - sumX1 * sumY1) / divisor1
var float sumX2 = 0.0, var float sumY2 = 0.0, var float sumXY2 = 0.0, var float sumX22 = 0.0
var int validCount2 = 0
var array<float> x_values2 = array.new_float(len1)
var array<float> y_values2 = array.new_float(len1)
var int head2 = 0
var int internal_time_counter2 = 0
if internal_time_counter2 >= len1
float oldX2 = array.get(x_values2, head2)
float oldY2 = array.get(y_values2, head2)
if not na(oldY2)
sumX2 := sumX2 - oldX2, sumY2 := sumY2 - oldY2
sumXY2 := sumXY2 - oldX2 * oldY2, sumX22 := sumX22 - oldX2 * oldX2
validCount2 := validCount2 - 1
float currentX2 = internal_time_counter2
float currentY2 = current_slope
array.set(x_values2, head2, currentX2)
array.set(y_values2, head2, currentY2)
if not na(currentY2)
sumX2 := sumX2 + currentX2, sumY2 := sumY2 + currentY2
sumXY2 := sumXY2 + currentX2 * currentY2, sumX22 := sumX22 + currentX2 * currentX2
validCount2 := validCount2 + 1
head2 := (head2 + 1) % len1
internal_time_counter2 := internal_time_counter2 + 1
float calculatedAccel = na
if validCount2 >= 2
float n2 = validCount2
float divisor2 = n2 * sumX22 - sumX2 * sumX2
if divisor2 != 0.0
calculatedAccel := (n2 * sumXY2 - sumX2 * sumY2) / divisor2
calculatedAccel
//@function Calculates the second finite difference (acceleration): Accel = V[t] - 2*V[t-1] + V[t-2]
//@param src Source series
//@returns Second difference. Returns 0.0 until 3 bars are available.
//@optimized Uses direct history access and FMA-equivalent for zero-allocation streaming.
accel(series float src) =>
float v0 = src
float v1 = src[1]
float v2 = src[2]
if na(v1) or na(v2)
0.0
else
v0 - 2.0 * v1 + v2
// ---------- Main loop ----------
// Inputs
i_period = input.int(14, "Period", minval=2)
i_source = input.source(close, "Source")
// Calculation
a = accel(i_source, i_period)
a = accel(i_source)
// Plot
plot(a, "Accel", color=color.yellow, linewidth=2)
lib/numerics/change/change.pine
+1 -1
View File
@@ -27,4 +27,4 @@ i_length = input.int(1, "Length", minval = 1)
result = change(i_source, i_length)
// Plot
plot(result, "Change %", color.blue, color=color.yellow, linewidth=2)
plot(result, "Change %", color=color.yellow, linewidth=2)
lib/numerics/cwt/Cwt.md
+2 -2
View File
@@ -7,14 +7,14 @@
| **Parameters** | `scale` (default 10.0), `omega0` (default 6.0) |
| **Outputs** | Single series (Cwt) |
| **Output range** | Varies (see docs) |
| **Warmup** | 1 bar |
| **Warmup** | windowSize (2K+1) bars, where K = round(3 × scale) |
### TL;DR
- CWT computes the magnitude of the Continuous Wavelet Transform at a specified scale using the Morlet wavelet, providing a time-frequency decomposit...
- Parameterized by `scale` (default 10.0), `omega0` (default 6.0).
- Output range: Varies (see docs).
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Requires windowSize (2K+1) bars of warmup before first valid output (IsHot = true), where K = round(3 × scale).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
CWT computes the magnitude of the Continuous Wavelet Transform at a specified scale using the Morlet wavelet, providing a time-frequency decomposition that measures the energy content of a specific frequency band at each point in time. Unlike Fourier analysis which loses time localization, the wavelet transform maintains both time and frequency information simultaneously. The output is a non-negative magnitude series where peaks indicate strong presence of the target frequency (determined by the scale parameter) and troughs indicate absence of that frequency component.
lib/numerics/exptrans/exptrans.pine
+5 -4
View File
@@ -9,16 +9,17 @@ indicator("Exponential Transformation (EXP)", "Exptrans", overlay=false)
//@optimized for performance and dirty data
expT(series float source) =>
if na(source)
runtime.error("Parameter 'source' cannot be na.")
math.exp(source)
na
else
math.exp(source)
// ---------- Main loop ----------
// Inputs
i_source = input(close, "Source")
i_source = input.source(close, "Source")
// Calculation
transformedSource = expT(i_source)
// Plot
plot(transformedSource, "Exponential Transformation", color=color.yellow, linewidth=2)
plot(transformedSource, "Exptrans", color=color.yellow, linewidth=2)
lib/numerics/fft/Fft.cs
+232 -109
View File
@@ -1,8 +1,11 @@
// FFT: Fast Fourier Transform — Dominant Cycle Detector
// Estimates the dominant cycle period in bars using a DFT on a windowed price buffer.
// Algorithm: Ehlers, J.F. "Cycle Analytics for Traders." Wiley, 2013.
// Hanning-windowed DFT across bins [minBin..maxBin], with parabolic interpolation
// for sub-bin period estimation. Output: dominant cycle period in bars (clamped).
// Estimates the dominant cycle period in bars using a radix-2 Cooley-Tukey FFT
// on a Hanning-windowed price buffer, with parabolic interpolation for sub-bin
// period estimation. Output: dominant cycle period in bars (clamped).
//
// Algorithm: Cooley, J.W. & Tukey, J.W. (1965). "An Algorithm for the Machine
// Calculation of Complex Fourier Series." Mathematics of Computation, 19(90).
// Ehlers, J.F. "Cycle Analytics for Traders." Wiley, 2013 (application context).
using System.Buffers;
using System.Runtime.CompilerServices;
@@ -12,15 +15,16 @@ namespace QuanTAlib;
/// <summary>
/// FFT: Fast Fourier Transform Dominant Cycle Detector
/// Computes the dominant cycle period using a Hanning-windowed DFT
/// over a rolling price buffer, with parabolic interpolation refinement.
/// Computes the dominant cycle period using a Hanning-windowed radix-2
/// Cooley-Tukey FFT over a rolling price buffer, with parabolic interpolation.
/// </summary>
/// <remarks>
/// Key properties:
/// - Output: dominant cycle period in bars, clamped to [minPeriod, maxPeriod]
/// - windowSize must be 32, 64, or 128
/// - windowSize must be 32, 64, or 128 (power of 2 for radix-2)
/// - WarmupPeriod = windowSize bars
/// - No allocation in Update (RingBuffer + precomputed Hanning weights)
/// - True O(N log N) radix-2 FFT with bit-reversal permutation
/// - Pre-allocated work arrays for zero-allocation streaming
/// - Parabolic interpolation on peak bin for sub-bin accuracy
/// </remarks>
[SkipLocalsInit]
@@ -31,8 +35,10 @@ public sealed class Fft : AbstractBase
private readonly int _maxPeriod;
private readonly int _minBin;
private readonly int _maxBin;
private readonly double _twoPiOverN;
private readonly double[] _hanning;
private readonly int[] _bitRev;
private readonly double[] _workRe;
private readonly double[] _workIm;
private readonly RingBuffer _buffer;
[StructLayout(LayoutKind.Auto)]
@@ -44,7 +50,7 @@ public sealed class Fft : AbstractBase
/// <summary>
/// Initializes a new Fft indicator.
/// </summary>
/// <param name="windowSize">DFT window size in bars. Must be 32, 64, or 128. Default 64.</param>
/// <param name="windowSize">FFT window size in bars. Must be 32, 64, or 128. Default 64.</param>
/// <param name="minPeriod">Minimum detectable cycle period. Must be >= 2. Default 4.</param>
/// <param name="maxPeriod">Maximum detectable cycle period. Must be &lt;= windowSize/2. Default 32.</param>
public Fft(int windowSize = 64, int minPeriod = 4, int maxPeriod = 32)
@@ -67,19 +73,31 @@ public sealed class Fft : AbstractBase
_windowSize = windowSize;
_minPeriod = minPeriod;
_maxPeriod = maxPeriod;
_twoPiOverN = 2.0 * Math.PI / windowSize;
int log2N = Log2(windowSize);
// bin k corresponds to period N/k; k=minBin → period=N/minBin=maxPeriod, k=maxBin → period=N/maxBin=minPeriod
// bin k corresponds to period N/k
_minBin = Math.Max(1, windowSize / maxPeriod);
_maxBin = Math.Min(windowSize / 2, windowSize / minPeriod);
// Precompute Hanning window: w[n] = 0.5 - 0.5*cos(2π*n/N), n=0..N-1
// Precompute Hanning window: w[n] = 0.5 - 0.5*cos(2π*n/N)
double twoPiOverN = 2.0 * Math.PI / windowSize;
_hanning = new double[windowSize];
for (int n = 0; n < windowSize; n++)
{
_hanning[n] = 0.5 - 0.5 * Math.Cos(_twoPiOverN * n);
_hanning[n] = 0.5 - 0.5 * Math.Cos(twoPiOverN * n);
}
// Precompute bit-reversal permutation table
_bitRev = new int[windowSize];
for (int i = 0; i < windowSize; i++)
{
_bitRev[i] = BitReverse(i, log2N);
}
// Pre-allocate work arrays (zero allocation in hot path)
_workRe = new double[windowSize];
_workIm = new double[windowSize];
_buffer = new RingBuffer(windowSize);
Name = $"Fft({windowSize},{minPeriod},{maxPeriod})";
WarmupPeriod = windowSize;
@@ -90,10 +108,6 @@ public sealed class Fft : AbstractBase
/// <summary>
/// Initializes a new Fft indicator with source for event-based chaining.
/// </summary>
/// <param name="source">Source indicator for chaining</param>
/// <param name="windowSize">DFT window size. Must be 32, 64, or 128. Default 64.</param>
/// <param name="minPeriod">Minimum detectable period. Must be >= 2. Default 4.</param>
/// <param name="maxPeriod">Maximum detectable period. Must be &lt;= windowSize/2. Default 32.</param>
public Fft(ITValuePublisher source, int windowSize = 64, int minPeriod = 4, int maxPeriod = 32)
: this(windowSize, minPeriod, maxPeriod)
{
@@ -103,59 +117,155 @@ public sealed class Fft : AbstractBase
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void HandleUpdate(object? sender, in TValueEventArgs e) => Update(e.Value, e.IsNew);
/// <summary>
/// Computes floor(log2(n)) for powers of 2.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static int Log2(int n)
{
int p = 0;
int x = n;
while (x > 1)
{
x >>= 1;
p++;
}
return p;
}
/// <summary>
/// Reverses the bits of x using 'bits' bit-width.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static int BitReverse(int x, int bits)
{
int r = 0;
for (int i = 0; i < bits; i++)
{
r = (r << 1) | (x & 1);
x >>= 1;
}
return r;
}
/// <summary>
/// In-place iterative radix-2 Cooley-Tukey FFT.
/// </summary>
/// <param name="re">Real part array (modified in-place)</param>
/// <param name="im">Imaginary part array (modified in-place)</param>
/// <param name="n">Array length (must be power of 2)</param>
/// <param name="bitRev">Pre-computed bit-reversal table</param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void FftInPlace(double[] re, double[] im, int n, int[] bitRev)
{
// Bit-reversal permutation
for (int i = 0; i < n; i++)
{
int j = bitRev[i];
if (j > i)
{
(re[i], re[j]) = (re[j], re[i]);
(im[i], im[j]) = (im[j], im[i]);
}
}
// Cooley-Tukey butterfly stages
int len = 2;
while (len <= n)
{
int half = len >> 1;
double angStep = -2.0 * Math.PI / len;
for (int start = 0; start < n; start += len)
{
for (int k = 0; k < half; k++)
{
double angle = angStep * k;
double wr = Math.Cos(angle);
double wi = Math.Sin(angle);
int i0 = start + k;
int i1 = i0 + half;
double ur = re[i0];
double ui = im[i0];
double vr = re[i1];
double vi = im[i1];
// Twiddle: t = w * v
double tr = Math.FusedMultiplyAdd(vr, wr, -(vi * wi));
double ti = Math.FusedMultiplyAdd(vr, wi, vi * wr);
re[i0] = ur + tr;
im[i0] = ui + ti;
re[i1] = ur - tr;
im[i1] = ui - ti;
}
}
len <<= 1;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private double ComputeDominantPeriod()
{
var span = _buffer.GetSpan();
int n = _windowSize;
double maxMag = 0.0;
int peakBin = _minBin;
double magBefore = 0.0;
double magAtPeak = 0.0;
double magAfter = 0.0;
// Fill work arrays: windowed data (oldest→newest), imag=0
for (int i = 0; i < n; i++)
{
_workRe[i] = span[i] * _hanning[i];
_workIm[i] = 0.0;
}
// Radix-2 FFT in-place
FftInPlace(_workRe, _workIm, n, _bitRev);
// Find peak magnitude in [minBin..maxBin]
double bestMag = -1.0;
int bestK = _minBin;
for (int k = _minBin; k <= _maxBin; k++)
{
double omegaK = _twoPiOverN * k;
double re = 0.0;
double im = 0.0;
for (int idx = 0; idx < n; idx++)
double mag = Math.FusedMultiplyAdd(_workRe[k], _workRe[k], _workIm[k] * _workIm[k]);
if (mag > bestMag)
{
// span[0]=oldest, span[n-1]=newest
// n=0 in DFT = current (newest): map DFT-n to span index (n-1-dftN)
// span[n-1-dftN]: dftN=0 → span[n-1] (newest), dftN=n-1 → span[0] (oldest)
double val = span[n - 1 - idx];
double xw = val * _hanning[idx];
double angle = omegaK * idx;
double cosA = Math.Cos(angle);
double sinA = Math.Sin(angle);
re = Math.FusedMultiplyAdd(xw, cosA, re);
im = Math.FusedMultiplyAdd(xw, -sinA, im);
}
double mag = Math.FusedMultiplyAdd(re, re, im * im);
if (mag > maxMag)
{
magBefore = magAtPeak;
magAfter = 0.0;
maxMag = mag;
magAtPeak = mag;
peakBin = k;
}
else if (peakBin > 0 && magAfter == 0.0)
{
magAfter = mag;
bestMag = mag;
bestK = k;
}
}
// Parabolic interpolation for sub-bin refinement
double denom = magBefore + 2.0 * maxMag + magAfter;
double shift = (denom > 0.0) ? (magBefore - magAfter) / denom : 0.0;
double dominantPeriod = (double)_windowSize / (peakBin + shift);
// Neighbor magnitudes for parabolic interpolation
double a, b, c;
b = bestMag;
if (bestK > _minBin)
{
a = Math.FusedMultiplyAdd(_workRe[bestK - 1], _workRe[bestK - 1],
_workIm[bestK - 1] * _workIm[bestK - 1]);
}
else
{
a = b;
}
if (bestK < _maxBin)
{
c = Math.FusedMultiplyAdd(_workRe[bestK + 1], _workRe[bestK + 1],
_workIm[bestK + 1] * _workIm[bestK + 1]);
}
else
{
c = b;
}
// Parabolic interpolation: shift = 0.5*(a-c)/(a - 2b + c)
double denom = a - 2.0 * b + c;
double shift = Math.Abs(denom) > 0.0 ? 0.5 * (a - c) / denom : 0.0;
double dominantPeriod = (double)_windowSize / (bestK + shift);
// Clamp to [minPeriod, maxPeriod]
return Math.Clamp(dominantPeriod, _minPeriod, _maxPeriod);
}
@@ -215,11 +325,6 @@ public sealed class Fft : AbstractBase
/// <summary>
/// Primes the indicator with historical values.
/// </summary>
/// <remarks>
/// Synthetic timestamps are generated by subtracting <c>step × source.Length</c>
/// from <see cref="DateTime.UtcNow"/>. For deterministic or replay-safe pipelines
/// use <see cref="Update(TValue, bool)"/> directly with explicit timestamps.
/// </remarks>
public override void Prime(ReadOnlySpan<double> source, TimeSpan? step = null)
{
TimeSpan interval = step ?? TimeSpan.FromSeconds(1);
@@ -239,8 +344,8 @@ public sealed class Fft : AbstractBase
}
/// <summary>
/// Computes dominant cycle period over a span of values using a sliding Hanning-windowed DFT.
/// Uses stackalloc for Hanning weights when windowSize &lt;= 64, otherwise ArrayPool.
/// Computes dominant cycle period over a span using sliding Hanning-windowed radix-2 FFT.
/// Uses stackalloc for work arrays when windowSize &lt;= 64, otherwise ArrayPool.
/// </summary>
public static void Batch(
ReadOnlySpan<double> src, Span<double> output,
@@ -271,15 +376,24 @@ public sealed class Fft : AbstractBase
throw new ArgumentException($"maxPeriod must be <= windowSize/2", nameof(maxPeriod));
}
int log2N = Log2(windowSize);
double twoPiOverN = 2.0 * Math.PI / windowSize;
int minBin = Math.Max(1, windowSize / maxPeriod);
int maxBin = Math.Min(windowSize / 2, windowSize / minPeriod);
double defaultPeriod = (minPeriod + maxPeriod) * 0.5;
double lastValid = defaultPeriod;
// Precompute Hanning window and bit-reversal table
const int StackallocThreshold = 64;
double[]? rentedW = null;
double[]? rentedH = null;
double[]? rentedRe = null;
double[]? rentedIm = null;
int[]? rentedBr = null;
scoped Span<double> hanning;
double[] workRe;
double[] workIm;
int[] bitRev;
if (windowSize <= StackallocThreshold)
{
@@ -287,15 +401,24 @@ public sealed class Fft : AbstractBase
}
else
{
rentedW = ArrayPool<double>.Shared.Rent(windowSize);
hanning = rentedW.AsSpan(0, windowSize);
rentedH = ArrayPool<double>.Shared.Rent(windowSize);
hanning = rentedH.AsSpan(0, windowSize);
}
// FFT work arrays (must be double[] for FftInPlace)
rentedRe = ArrayPool<double>.Shared.Rent(windowSize);
rentedIm = ArrayPool<double>.Shared.Rent(windowSize);
rentedBr = ArrayPool<int>.Shared.Rent(windowSize);
workRe = rentedRe;
workIm = rentedIm;
bitRev = rentedBr;
try
{
for (int n = 0; n < windowSize; n++)
{
hanning[n] = 0.5 - 0.5 * Math.Cos(twoPiOverN * n);
bitRev[n] = BitReverse(n, log2N);
}
for (int i = 0; i < src.Length; i++)
@@ -313,52 +436,49 @@ public sealed class Fft : AbstractBase
continue;
}
double maxMag = 0.0;
int peakBin = minBin;
double magBefore = 0.0;
double magAtPeak = 0.0;
double magAfter = 0.0;
// Fill work arrays with windowed data
for (int n = 0; n < windowSize; n++)
{
double v = src[i - windowSize + 1 + n];
if (!double.IsFinite(v))
{
v = lastValid;
}
workRe[n] = v * hanning[n];
workIm[n] = 0.0;
}
// Radix-2 FFT
FftInPlace(workRe, workIm, windowSize, bitRev);
// Find peak magnitude
double bestMag = -1.0;
int bestK = minBin;
for (int k = minBin; k <= maxBin; k++)
{
double omegaK = twoPiOverN * k;
double re = 0.0;
double im = 0.0;
for (int dftN = 0; dftN < windowSize; dftN++)
double mag = Math.FusedMultiplyAdd(workRe[k], workRe[k], workIm[k] * workIm[k]);
if (mag > bestMag)
{
// dftN=0 → newest (src[i]), dftN=windowSize-1 → oldest (src[start])
double v = src[i - dftN];
if (!double.IsFinite(v))
{
v = lastValid;
}
double xw = v * hanning[dftN];
double angle = omegaK * dftN;
re = Math.FusedMultiplyAdd(xw, Math.Cos(angle), re);
im = Math.FusedMultiplyAdd(xw, -Math.Sin(angle), im);
}
double mag = Math.FusedMultiplyAdd(re, re, im * im);
if (mag > maxMag)
{
magBefore = magAtPeak;
magAfter = 0.0;
maxMag = mag;
magAtPeak = mag;
peakBin = k;
}
else if (peakBin > 0 && magAfter == 0.0)
{
magAfter = mag;
bestMag = mag;
bestK = k;
}
}
double denom = magBefore + 2.0 * maxMag + magAfter;
double shift = (denom > 0.0) ? (magBefore - magAfter) / denom : 0.0;
double dominant = (double)windowSize / (peakBin + shift);
// Neighbor magnitudes for parabolic interpolation
double a = bestK > minBin
? Math.FusedMultiplyAdd(workRe[bestK - 1], workRe[bestK - 1],
workIm[bestK - 1] * workIm[bestK - 1])
: bestMag;
double c = bestK < maxBin
? Math.FusedMultiplyAdd(workRe[bestK + 1], workRe[bestK + 1],
workIm[bestK + 1] * workIm[bestK + 1])
: bestMag;
double denom = a - 2.0 * bestMag + c;
double shift = Math.Abs(denom) > 0.0 ? 0.5 * (a - c) / denom : 0.0;
double dominant = (double)windowSize / (bestK + shift);
double clamped = Math.Clamp(dominant, minPeriod, maxPeriod);
lastValid = clamped;
output[i] = clamped;
@@ -366,10 +486,13 @@ public sealed class Fft : AbstractBase
}
finally
{
if (rentedW != null)
if (rentedH != null)
{
ArrayPool<double>.Shared.Return(rentedW);
ArrayPool<double>.Shared.Return(rentedH);
}
ArrayPool<double>.Shared.Return(rentedRe);
ArrayPool<double>.Shared.Return(rentedIm);
ArrayPool<int>.Shared.Return(rentedBr);
}
}
lib/numerics/fft/Fft.md
+71 -52
View File
@@ -6,46 +6,51 @@
| **Inputs** | Source (close) |
| **Parameters** | `windowSize` (default 64), `minPeriod` (default 4), `maxPeriod` (default 32) |
| **Outputs** | Single series (Fft) |
| **Output range** | Varies (see docs) |
| **Warmup** | 1 bar |
| **Output range** | [minPeriod, maxPeriod] |
| **Warmup** | windowSize bars |
### TL;DR
- The FFT indicator computes the dominant cycle period in a price series using a Discrete Fourier Transform with a Hanning window.
- Parameterized by `windowsize` (default 64), `minperiod` (default 4), `maxperiod` (default 32).
- Output range: Varies (see docs).
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
- The FFT indicator computes the dominant cycle period in a price series using a radix-2 Cooley-Tukey Fast Fourier Transform with a Hanning window.
- Parameterized by `windowSize` (default 64), `minPeriod` (default 4), `maxPeriod` (default 32).
- Output range: [minPeriod, maxPeriod] bars.
- Requires windowSize bars of warmup before first valid output (IsHot = true).
- True $O(N \log N)$ radix-2 FFT with bit-reversal permutation and Cooley-Tukey butterflies.
The FFT indicator computes the dominant cycle period in a price series using a Discrete Fourier Transform with a Hanning window. Rather than outputting frequency-domain magnitudes, it returns the estimated dominant cycle period in bars, making it directly usable as an adaptive period input for other indicators. The implementation uses a brute-force DFT over a constrained frequency band (not a radix-2 FFT), with parabolic interpolation on the magnitude spectrum to achieve sub-bin frequency resolution. With window sizes of 32, 64, or 128 and $O(N \cdot N/2)$ complexity per bar, the indicator trades computational cost for precise cycle detection within user-specified period bounds.
The FFT indicator computes the dominant cycle period in a price series using a true radix-2 Cooley-Tukey Fast Fourier Transform with a Hanning window. Rather than outputting frequency-domain magnitudes, it returns the estimated dominant cycle period in bars, making it directly usable as an adaptive period input for other indicators. The implementation uses an in-place iterative radix-2 FFT with bit-reversal permutation and Cooley-Tukey butterfly operations, achieving $O(N \log N)$ complexity. Parabolic interpolation on the magnitude spectrum provides sub-bin frequency resolution. With window sizes restricted to powers of two (32, 64, or 128), the indicator achieves precise cycle detection within user-specified period bounds with pre-allocated work arrays for zero-allocation streaming.
## Historical Context
The Fourier transform, formalized by Joseph Fourier (1822), decomposes any periodic signal into sinusoidal components. The Fast Fourier Transform algorithm (Cooley and Tukey, 1965) reduced the DFT from $O(N^2)$ to $O(N \log N)$, enabling real-time spectral analysis. However, for the small window sizes used in financial cycle detection (32-128 samples), the asymptotic advantage of FFT over DFT is minimal, and the DFT avoids the power-of-two length constraint.
The Fourier transform, formalized by Joseph Fourier (1822), decomposes any periodic signal into sinusoidal components. The Fast Fourier Transform algorithm, published by James Cooley and John Tukey in 1965, reduced the DFT from $O(N^2)$ to $O(N \log N)$ by recursively decomposing the DFT into smaller sub-problems using the "butterfly" operation pattern. The radix-2 variant requires power-of-two input lengths and uses bit-reversal permutation followed by iterative butterfly stages.
John Ehlers pioneered the application of spectral analysis to financial markets in the 1990s and 2000s, using DFT-based cycle measurement to create adaptive indicators. His work demonstrated that financial time series contain quasi-periodic cycles with time-varying periods, typically in the 6-40 bar range. The dominant cycle period, extracted via spectral peak detection, can drive adaptive moving averages (MAMA, FAMA), adaptive RSI, and other indicators that benefit from knowing the current market rhythm.
John Ehlers pioneered the application of spectral analysis to financial markets in the 1990s and 2000s, using FFT-based cycle measurement to create adaptive indicators. His work demonstrated that financial time series contain quasi-periodic cycles with time-varying periods, typically in the 6-40 bar range. The dominant cycle period, extracted via spectral peak detection, can drive adaptive moving averages (MAMA, FAMA), adaptive RSI, and other indicators that benefit from knowing the current market rhythm.
The Hanning window (also called Hann window, after Julius von Hann) is applied to reduce spectral leakage. Without windowing, the sharp truncation of a finite data segment creates artificial high-frequency components that contaminate the spectrum. The Hanning window tapers the data to zero at both ends, suppressing sidelobes at the cost of slightly wider main lobes (reduced frequency resolution).
## Architecture and Physics
The computation pipeline has four stages:
The computation pipeline has five stages:
**Stage 1: Windowed DFT** computes the real and imaginary components of the Fourier coefficients for frequency bins $k$ ranging from `minBin` to `maxBin`:
**Stage 1: Windowing** applies the Hanning window to the rolling price buffer:
$$X[k] = \sum_{n=0}^{N-1} x[n] \cdot w[n] \cdot e^{-j 2\pi k n / N}$$
$$x_w[n] = x[n] \cdot w[n], \quad w[n] = 0.5 - 0.5\cos\!\left(\frac{2\pi n}{N}\right)$$
where $w[n] = 0.5 - 0.5\cos(2\pi n/N)$ is the Hanning window. Only bins corresponding to periods in `[minPeriod, maxPeriod]` are evaluated, reducing computation.
**Stage 2: Bit-reversal permutation** reorders the windowed data according to the bit-reversed indices, preparing for in-place butterfly computation. The permutation table is pre-computed in the constructor.
**Stage 2: Power spectrum peak** finds the bin $k^*$ with maximum squared magnitude $|X[k]|^2 = \text{Re}^2 + \text{Im}^2$. During the search, the magnitudes of the bins adjacent to the peak (one before, one after) are captured for interpolation.
**Stage 3: Cooley-Tukey butterflies** perform $\log_2(N)$ stages of butterfly operations. Each stage $s$ processes pairs of elements separated by $2^{s-1}$ positions, combining them with twiddle factors:
**Stage 3: Parabolic interpolation** refines the peak location using a three-point parabola fit on the magnitudes at bins $k^*-1$, $k^*$, $k^*+1$:
$$\begin{aligned}
X[i_0] &\leftarrow X[i_0] + W_N^k \cdot X[i_1] \\
X[i_1] &\leftarrow X[i_0] - W_N^k \cdot X[i_1]
\end{aligned}$$
$$\delta = \frac{M_{k^*-1} - M_{k^*+1}}{M_{k^*-1} + 2 M_{k^*} + M_{k^*+1}}$$
where $W_N^k = e^{-j2\pi k/N}$ is the twiddle factor.
The refined dominant period is $N / (k^* + \delta)$.
**Stage 4: Peak detection with parabolic interpolation** finds the bin $k^*$ with maximum squared magnitude in `[minBin, maxBin]`, then refines using a three-point parabolic fit:
**Stage 4: Clamping** ensures the output stays within `[minPeriod, maxPeriod]`.
$$\delta = \frac{0.5 \cdot (P[k^*-1] - P[k^*+1])}{P[k^*-1] - 2P[k^*] + P[k^*+1]}$$
**Stage 5: Period extraction and clamping** converts the refined bin index to period: $T = N / (k^* + \delta)$, clamped to `[minPeriod, maxPeriod]`.
**Window size trade-offs**: $N = 32$ gives coarse resolution (period bins spaced ~1 bar apart) but fast response; $N = 128$ gives fine resolution (~0.25 bar spacing) but sluggish adaptation. The default $N = 64$ balances resolution and responsiveness.
@@ -55,6 +60,12 @@ The **Discrete Fourier Transform** for $N$ samples:
$$X[k] = \sum_{n=0}^{N-1} x[n] \cdot e^{-j 2\pi k n / N}, \quad k = 0, 1, \ldots, N-1$$
**Radix-2 Cooley-Tukey decomposition** splits the DFT into even and odd indexed sub-problems:
$$X[k] = \sum_{r=0}^{N/2-1} x[2r] \cdot W_{N/2}^{kr} + W_N^k \sum_{r=0}^{N/2-1} x[2r+1] \cdot W_{N/2}^{kr}$$
This recursion, applied iteratively with bit-reversal permutation, achieves $O(N \log N)$ complexity.
**Hanning window**:
$$w[n] = 0.5 - 0.5\cos\!\left(\frac{2\pi n}{N}\right)$$
@@ -69,7 +80,7 @@ $$k_{\min} = \max\!\left(1,\; \left\lfloor\frac{N}{T_{\max}}\right\rfloor\right)
**Parabolic interpolation** for sub-bin precision:
$$\hat{k} = k^* + \frac{P[k^*-1] - P[k^*+1]}{P[k^*-1] + 2P[k^*] + P[k^*+1]}$$
$$\hat{k} = k^* + \frac{0.5 \cdot (P[k^*-1] - P[k^*+1])}{P[k^*-1] - 2P[k^*] + P[k^*+1]}$$
$$T_{\text{dominant}} = \frac{N}{\hat{k}}$$
@@ -78,28 +89,33 @@ $$T_{\text{dominant}} = \frac{N}{\hat{k}}$$
```
FFT(source, windowSize, minPeriod, maxPeriod):
N = windowSize
twoPiOverN = 2 * pi / N
minBin = max(1, N / maxPeriod)
maxBin = min(N/2, N / minPeriod)
// Stage 1: Apply Hanning window
for n = 0 to N-1:
workRe[n] = source[n] * hanning[n]
workIm[n] = 0
maxMag = 0; peakBin = 0
for k = minBin to maxBin:
re = 0; im = 0
for n = 0 to N-1:
w = 0.5 - 0.5 * cos(twoPiOverN * n) // Hanning
xw = source[n] * w
angle = twoPiOverN * k * n
re += xw * cos(angle)
im -= xw * sin(angle)
mag = re*re + im*im
if mag > maxMag:
track neighbor magnitudes
maxMag = mag; peakBin = k
// Stage 2: Bit-reversal permutation
for i = 0 to N-1:
j = bitReverse(i)
if j > i: swap(workRe[i], workRe[j])
// Parabolic interpolation
shift = (magBefore - magAfter) / (magBefore + 2*maxMag + magAfter)
dominantPeriod = N / (peakBin + shift)
return clamp(dominantPeriod, minPeriod, maxPeriod)
// Stage 3: Cooley-Tukey butterflies
len = 2
while len <= N:
half = len / 2
angStep = -2π / len
for start = 0 to N-1 step len:
for k = 0 to half-1:
w = exp(j * angStep * k)
butterfly(workRe, workIm, start+k, start+k+half, w)
len *= 2
// Stage 4: Peak detection + interpolation
peakBin = argmax |X[k]|² for k in [minBin..maxBin]
shift = 0.5*(P[k-1] - P[k+1]) / (P[k-1] - 2*P[k] + P[k+1])
// Stage 5: Period extraction
return clamp(N / (peakBin + shift), minPeriod, maxPeriod)
```
@@ -107,34 +123,37 @@ FFT(source, windowSize, minPeriod, maxPeriod):
### Operation Count (Streaming Mode)
FFT (DFT dominant cycle detector) evaluates B frequency bins, each requiring N multiply-accumulates — O(N*B) per bar.
FFT (radix-2 Cooley-Tukey) performs N/2 butterflies per stage across log₂(N) stages — O(N log N) per bar.
| Operation | Count | Cost (cycles) | Subtotal |
| :--- | :---: | :---: | :---: |
| Hanning window multiply | N | 2 cy | ~2N cy |
| DFT inner loop (B bins * N samples) | B*N | 4 cy | ~4*N*B cy |
| cos/sin evaluation (precomputed table) | 2*B*N | 0 cy | ~0 cy |
| Magnitude comparison + peak track | B | 2 cy | ~2B cy |
| Parabolic interpolation (3 points) | 1 | 5 cy | ~5 cy |
| **Total (N=64, B=10)** | **O(N*B)** | — | **~2617 cy** |
| Bit-reversal permutation | N | 1 cy | ~N cy |
| Butterfly operations (log₂N stages × N/2) | N/2 × log₂N | 8 cy | ~4N·log₂N cy |
| cos/sin per butterfly | N/2 × log₂N | 14 cy | ~7N·log₂N cy |
| Magnitude search (B bins) | B | 4 cy | ~4B cy |
| Parabolic interpolation | 1 | 10 cy | ~10 cy |
| **Total (N=64, B=10)** | **O(N log N)** | — | **~4362 cy** |
O(N*B) per bar where B = active frequency bins. Precomputed sin/cos tables eliminate transcendental cost. Suitable for 1-minute+ timeframes; not tick-data hot paths.
O(N log N) per bar. Pre-allocated work arrays ensure zero allocation in the hot path. Twiddle factor computation dominates; pre-computing sin/cos tables would reduce to ~2500 cy.
### Batch Mode (SIMD Analysis)
| Operation | Vectorizable? | Notes |
| :--- | :---: | :--- |
| Hanning window application | Yes | Vector multiply with precomputed weights |
| DFT inner dot product | Yes | FMA with sin/cos table lookup |
| Magnitude squared | Yes | Vector FMA (re^2 + im^2) |
| Bit-reversal permutation | No | Random access pattern; scalar only |
| Butterfly multiply-add | Yes | Complex FMA operations on paired elements |
| Magnitude squared | Yes | Vector FMA (re² + im²) |
| Peak search | Partial | Max reduction; SIMD-friendly |
Strong batch SIMD: inner dot products are FMA-vectorizable. AVX2 processes 4 complex outputs per 2 cycles. Expected 3-4× speedup for N=64.
Moderate SIMD potential: butterfly FMA operations are vectorizable within each stage. Bit-reversal permutation is inherently scalar. Expected 2× speedup over scalar for N=64.
## Resources
- Cooley, J.W. & Tukey, J.W. "An Algorithm for the Machine Calculation of Complex Fourier Series." Mathematics of Computation, 1965.
- Cooley, J.W. & Tukey, J.W. "An Algorithm for the Machine Calculation of Complex Fourier Series." *Mathematics of Computation*, 1965.
- Ehlers, J.F. "Cycle Analytics for Traders." Wiley, 2013.
- Ehlers, J.F. "Rocket Science for Traders." Wiley, 2001.
- Harris, F.J. "On the Use of Windows for Harmonic Analysis with the Discrete Fourier Transform." Proc. IEEE, 1978.
- Harris, F.J. "On the Use of Windows for Harmonic Analysis with the Discrete Fourier Transform." *Proc. IEEE*, 1978.
- Oppenheim, A.V. & Schafer, R.W. "Discrete-Time Signal Processing." 3rd edition, Pearson, 2010.
- PineScript reference: [`fft.pine`](fft.pine)
lib/numerics/ifft/Ifft.cs
+145 -74
View File
@@ -1,7 +1,10 @@
// IFFT: Inverse FFT Spectral Low-Pass Filter
// Reconstructs a filtered price signal by summing the DC component and
// the first H harmonics of the Hanning-windowed DFT. Output overlays on price.
// More harmonics → less smoothing; fewer harmonics → smoother output.
// IFFT: Inverse Fast Fourier Transform — Spectral Low-Pass Filter
// Reconstructs a filtered price signal by performing a forward radix-2 FFT,
// zeroing frequency bins above numHarmonics, then applying an inverse FFT.
// Output overlays on price. More harmonics → less smoothing; fewer → smoother.
//
// Algorithm: Cooley, J.W. & Tukey, J.W. (1965). Forward FFT → spectral
// truncation → inverse FFT reconstruction.
using System.Buffers;
using System.Runtime.CompilerServices;
@@ -11,16 +14,18 @@ namespace QuanTAlib;
/// <summary>
/// IFFT: Inverse FFT Spectral Low-Pass Filter
/// Reconstructs a filtered price value from the DC component plus
/// the first numHarmonics frequency bins of the Hanning-windowed DFT.
/// Reconstructs a filtered price value by performing a forward radix-2 FFT,
/// zeroing bins above numHarmonics (preserving conjugate symmetry),
/// then applying an inverse FFT to reconstruct the time-domain signal.
/// </summary>
/// <remarks>
/// Key properties:
/// - Output: reconstructed price (spectral low-pass filtered), overlays on price chart
/// - windowSize must be 32, 64, or 128
/// - windowSize must be 32, 64, or 128 (power of 2 for radix-2)
/// - numHarmonics clamped to [1, windowSize/2]
/// - WarmupPeriod = windowSize bars
/// - No allocation in Update (RingBuffer + precomputed Hanning weights)
/// - True O(N log N) radix-2 FFT/IFFT with bit-reversal permutation
/// - Pre-allocated work arrays for zero-allocation streaming
/// - Increasing harmonics increases detail (less smoothing)
/// </remarks>
[SkipLocalsInit]
@@ -28,9 +33,11 @@ public sealed class Ifft : AbstractBase
{
private readonly int _windowSize;
private readonly int _numHarmonics;
private readonly double _twoPiOverN;
private readonly double _invN;
private readonly double[] _hanning;
private readonly int[] _bitRev;
private readonly double[] _workRe;
private readonly double[] _workIm;
private readonly RingBuffer _buffer;
[StructLayout(LayoutKind.Auto)]
@@ -42,8 +49,8 @@ public sealed class Ifft : AbstractBase
/// <summary>
/// Initializes a new Ifft indicator.
/// </summary>
/// <param name="windowSize">DFT window size in bars. Must be 32, 64, or 128. Default 64.</param>
/// <param name="numHarmonics">Number of harmonics to reconstruct. Must be >= 1. Default 5.</param>
/// <param name="windowSize">FFT window size in bars. Must be 32, 64, or 128. Default 64.</param>
/// <param name="numHarmonics">Number of harmonics to preserve. Must be >= 1. Default 5.</param>
public Ifft(int windowSize = 64, int numHarmonics = 5)
{
if (windowSize != 32 && windowSize != 64 && windowSize != 128)
@@ -58,16 +65,28 @@ public sealed class Ifft : AbstractBase
_windowSize = windowSize;
_numHarmonics = Math.Min(numHarmonics, windowSize / 2);
_twoPiOverN = 2.0 * Math.PI / windowSize;
int log2N = Log2(windowSize);
_invN = 1.0 / windowSize;
// Precompute Hanning window: w[n] = 0.5 - 0.5*cos(2π*n/N), n=0..N-1
// Precompute Hanning window: w[n] = 0.5 - 0.5*cos(2π*n/N)
double twoPiOverN = 2.0 * Math.PI / windowSize;
_hanning = new double[windowSize];
for (int n = 0; n < windowSize; n++)
{
_hanning[n] = 0.5 - 0.5 * Math.Cos(_twoPiOverN * n);
_hanning[n] = 0.5 - 0.5 * Math.Cos(twoPiOverN * n);
}
// Precompute bit-reversal permutation table
_bitRev = new int[windowSize];
for (int i = 0; i < windowSize; i++)
{
_bitRev[i] = BitReverse(i, log2N);
}
// Pre-allocate work arrays (zero allocation in hot path)
_workRe = new double[windowSize];
_workIm = new double[windowSize];
_buffer = new RingBuffer(windowSize);
Name = $"Ifft({windowSize},{numHarmonics})";
WarmupPeriod = windowSize;
@@ -78,9 +97,6 @@ public sealed class Ifft : AbstractBase
/// <summary>
/// Initializes a new Ifft indicator with source for event-based chaining.
/// </summary>
/// <param name="source">Source indicator for chaining</param>
/// <param name="windowSize">DFT window size. Must be 32, 64, or 128. Default 64.</param>
/// <param name="numHarmonics">Number of harmonics to reconstruct. Must be >= 1. Default 5.</param>
public Ifft(ITValuePublisher source, int windowSize = 64, int numHarmonics = 5)
: this(windowSize, numHarmonics)
{
@@ -90,42 +106,99 @@ public sealed class Ifft : AbstractBase
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void HandleUpdate(object? sender, in TValueEventArgs e) => Update(e.Value, e.IsNew);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static int Log2(int n)
{
int p = 0;
int x = n;
while (x > 1)
{
x >>= 1;
p++;
}
return p;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static int BitReverse(int x, int bits)
{
int r = 0;
for (int i = 0; i < bits; i++)
{
r = (r << 1) | (x & 1);
x >>= 1;
}
return r;
}
/// <summary>
/// Applies spectral truncation: zeroes frequency bins outside the
/// preserved range [0..numHarmonics] and their conjugate mirrors
/// [N-numHarmonics..N-1], ensuring real-valued IFFT output.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static void SpectralTruncate(double[] re, double[] im, int n, int numHarmonics)
{
// Keep bins 0..numHarmonics and N-numHarmonics..N-1 (conjugate symmetry)
// Zero everything in between: bins numHarmonics+1..N-numHarmonics-1
int startZero = numHarmonics + 1;
int endZero = n - numHarmonics; // exclusive
for (int k = startZero; k < endZero; k++)
{
re[k] = 0.0;
im[k] = 0.0;
}
}
/// <summary>
/// Computes inverse FFT in-place using the conjugate method:
/// IFFT(X) = (1/N) * conj(FFT(conj(X)))
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static void IfftInPlace(double[] re, double[] im, int n, int[] bitRev, double invN)
{
// Conjugate input
for (int i = 0; i < n; i++)
{
im[i] = -im[i];
}
// Forward FFT
Fft.FftInPlace(re, im, n, bitRev);
// Conjugate output and scale by 1/N
for (int i = 0; i < n; i++)
{
re[i] *= invN;
im[i] = -im[i] * invN;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private double ComputeIfft()
{
var span = _buffer.GetSpan();
int n = _windowSize;
// DC component (k=0): sum of windowed values / N
double dcRe = 0.0;
for (int idx = 0; idx < n; idx++)
// Fill work arrays: windowed data (oldest→newest), imag=0
for (int i = 0; i < n; i++)
{
// span[0]=oldest, span[n-1]=newest
// dftN=0→newest, dftN=n-1→oldest → span index = n-1-dftN
double val = span[n - 1 - idx];
dcRe = Math.FusedMultiplyAdd(val, _hanning[idx], dcRe);
_workRe[i] = span[i] * _hanning[i];
_workIm[i] = 0.0;
}
double result = dcRe * _invN;
// Forward FFT
Fft.FftInPlace(_workRe, _workIm, n, _bitRev);
// Harmonics k=1..H: add 2*re/N at time n=0 (reconstruction at current bar)
for (int k = 1; k <= _numHarmonics; k++)
{
double omegaK = _twoPiOverN * k;
double re = 0.0;
// Spectral truncation: zero bins above numHarmonics
SpectralTruncate(_workRe, _workIm, n, _numHarmonics);
for (int idx = 0; idx < n; idx++)
{
double val = span[n - 1 - idx];
double xw = val * _hanning[idx];
double angle = omegaK * idx;
re = Math.FusedMultiplyAdd(xw, Math.Cos(angle), re);
}
// Inverse FFT to reconstruct filtered time-domain signal
IfftInPlace(_workRe, _workIm, n, _bitRev, _invN);
result = Math.FusedMultiplyAdd(2.0 * _invN, re, result);
}
return result;
// Return the newest sample (last position in the array)
return _workRe[n - 1];
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -200,8 +273,8 @@ public sealed class Ifft : AbstractBase
}
/// <summary>
/// Computes IFFT reconstruction over a span of values using a sliding Hanning-windowed DFT.
/// Uses stackalloc for Hanning weights when windowSize &lt;= 64, otherwise ArrayPool.
/// Computes IFFT reconstruction over a span using sliding Hanning-windowed
/// radix-2 FFT → spectral truncation → inverse FFT.
/// </summary>
public static void Batch(
ReadOnlySpan<double> src, Span<double> output,
@@ -228,12 +301,14 @@ public sealed class Ifft : AbstractBase
}
int clampedHarmonics = Math.Min(numHarmonics, windowSize / 2);
int log2N = Log2(windowSize);
double twoPiOverN = 2.0 * Math.PI / windowSize;
double invN = 1.0 / windowSize;
double lastValid = 0.0;
// Precompute Hanning window
const int StackallocThreshold = 64;
double[]? rentedW = null;
double[]? rentedH = null;
scoped Span<double> hanning;
if (windowSize <= StackallocThreshold)
@@ -242,15 +317,21 @@ public sealed class Ifft : AbstractBase
}
else
{
rentedW = ArrayPool<double>.Shared.Rent(windowSize);
hanning = rentedW.AsSpan(0, windowSize);
rentedH = ArrayPool<double>.Shared.Rent(windowSize);
hanning = rentedH.AsSpan(0, windowSize);
}
// FFT work arrays and bit-reversal table
double[] workRe = ArrayPool<double>.Shared.Rent(windowSize);
double[] workIm = ArrayPool<double>.Shared.Rent(windowSize);
int[] bitRev = ArrayPool<int>.Shared.Rent(windowSize);
try
{
for (int n = 0; n < windowSize; n++)
{
hanning[n] = 0.5 - 0.5 * Math.Cos(twoPiOverN * n);
bitRev[n] = BitReverse(n, log2N);
}
for (int i = 0; i < src.Length; i++)
@@ -268,52 +349,42 @@ public sealed class Ifft : AbstractBase
continue;
}
// DC component
double dcRe = 0.0;
for (int dftN = 0; dftN < windowSize; dftN++)
// Fill work arrays with windowed data (oldest→newest)
for (int n = 0; n < windowSize; n++)
{
double v = src[i - dftN];
double v = src[i - windowSize + 1 + n];
if (!double.IsFinite(v))
{
v = lastValid;
}
dcRe = Math.FusedMultiplyAdd(v, hanning[dftN], dcRe);
workRe[n] = v * hanning[n];
workIm[n] = 0.0;
}
double result = dcRe * invN;
// Forward FFT
Fft.FftInPlace(workRe, workIm, windowSize, bitRev);
// Harmonics
for (int k = 1; k <= clampedHarmonics; k++)
{
double omegaK = twoPiOverN * k;
double re = 0.0;
// Spectral truncation
SpectralTruncate(workRe, workIm, windowSize, clampedHarmonics);
for (int dftN = 0; dftN < windowSize; dftN++)
{
double v = src[i - dftN];
if (!double.IsFinite(v))
{
v = lastValid;
}
double xw = v * hanning[dftN];
re = Math.FusedMultiplyAdd(xw, Math.Cos(omegaK * dftN), re);
}
result = Math.FusedMultiplyAdd(2.0 * invN, re, result);
}
// Inverse FFT
IfftInPlace(workRe, workIm, windowSize, bitRev, invN);
// Extract newest sample
double result = workRe[windowSize - 1];
lastValid = result;
output[i] = result;
}
}
finally
{
if (rentedW != null)
if (rentedH != null)
{
ArrayPool<double>.Shared.Return(rentedW);
ArrayPool<double>.Shared.Return(rentedH);
}
ArrayPool<double>.Shared.Return(workRe);
ArrayPool<double>.Shared.Return(workIm);
ArrayPool<int>.Shared.Return(bitRev);
}
}
lib/numerics/ifft/Ifft.md
+69 -60
View File
@@ -1,4 +1,4 @@
# IFFT: Inverse Fast Fourier Transform (Spectral Filter)
# IFFT: Inverse Fast Fourier Transform (Spectral Low-Pass Filter)
| Property | Value |
| ---------------- | -------------------------------- |
@@ -6,64 +6,68 @@
| **Inputs** | Source (close) |
| **Parameters** | `windowSize` (default 64), `numHarmonics` (default 5) |
| **Outputs** | Single series (Ifft) |
| **Output range** | Varies (see docs) |
| **Warmup** | 1 bar |
| **Output range** | Varies (overlays on price) |
| **Warmup** | windowSize bars |
### TL;DR
- The Inverse FFT indicator reconstructs a smoothed version of the price series by performing a forward DFT, retaining only the lowest-frequency harm...
- Parameterized by `windowsize` (default 64), `numharmonics` (default 5).
- Output range: Varies (see docs).
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
- The IFFT indicator reconstructs a smoothed version of the price series using a true forward FFT → spectral truncation → inverse FFT pipeline.
- Parameterized by `windowSize` (default 64), `numHarmonics` (default 5).
- Output range: Varies (overlays on price chart).
- Requires windowSize bars of warmup before first valid output (IsHot = true).
- True $O(N \log N)$ radix-2 FFT/IFFT with bit-reversal permutation and Cooley-Tukey butterflies.
The Inverse FFT indicator reconstructs a smoothed version of the price series by performing a forward DFT, retaining only the lowest-frequency harmonics, and synthesizing the output via inverse transform. The result is a spectral low-pass filter that preserves the dominant cyclical components while discarding high-frequency noise. By controlling the number of retained harmonics $H$, the user adjusts the smoothness/responsiveness trade-off: $H = 1$ yields a near-sinusoidal trend, while $H = N/2$ reproduces the original (windowed) signal. The indicator overlays on price and provides a frequency-domain alternative to conventional moving averages.
The IFFT indicator reconstructs a smoothed version of the price series by performing a true radix-2 forward FFT, zeroing frequency bins above the specified number of harmonics (spectral truncation), then applying a true inverse FFT to reconstruct the filtered time-domain signal. The result is a spectral low-pass filter that preserves the dominant cyclical components while discarding high-frequency noise. By controlling the number of retained harmonics $H$, the user adjusts the smoothness/responsiveness trade-off: $H = 1$ yields a near-sinusoidal trend, while $H = N/2$ reproduces the original (windowed) signal. The indicator overlays on price and provides a frequency-domain alternative to conventional moving averages.
## Historical Context
Spectral filtering via Fourier decomposition dates to Joseph Fourier's 1822 work on heat conduction, where he showed that any periodic function can be represented as a sum of sinusoids. The idea of reconstructing a signal from a subset of its Fourier coefficients is foundational to signal compression (JPEG, MP3) and has been applied to financial time series since the 1970s.
Spectral filtering via Fourier decomposition dates to Joseph Fourier's 1822 work on heat conduction, where he showed that any periodic function can be represented as a sum of sinusoids. The Cooley-Tukey FFT algorithm (1965) made real-time spectral analysis practical by reducing complexity from $O(N^2)$ to $O(N \log N)$.
John Ehlers brought spectral methods to mainstream technical analysis through his books on cycle analytics. His approach typically uses the DFT to identify the dominant cycle, then constructs adaptive filters tuned to that cycle. The IFFT indicator takes the complementary approach: rather than extracting a single cycle period, it reconstructs the signal from the $H$ lowest-frequency components, producing a multi-harmonic trend estimate.
John Ehlers brought spectral methods to mainstream technical analysis through his books on cycle analytics. The IFFT indicator implements the classic spectral filtering paradigm: forward FFT to decompose into frequency components, selective retention of low-frequency bins, and inverse FFT to reconstruct the filtered signal.
The Hanning window applied before the forward DFT reduces spectral leakage, ensuring that the retained harmonics accurately represent the true low-frequency content rather than artifacts of the window boundary. The inverse step only uses the real part of the synthesis (cosine terms), since the output must be a real-valued price estimate. The factor of 2 in the inverse accounts for the conjugate symmetry of real-valued DFT coefficients.
The Hanning window applied before the forward FFT reduces spectral leakage, ensuring that the retained harmonics accurately represent the true low-frequency content rather than artifacts of the window boundary. Conjugate symmetry is preserved during spectral truncation to guarantee real-valued reconstruction.
## Architecture and Physics
The computation has three stages executed per bar:
The computation has four stages executed per bar:
**Stage 1: DC component** computes the windowed mean of the source over the window. This is the zero-frequency (average level) component:
**Stage 1: Forward FFT** applies a Hanning window to the rolling price buffer, then performs an in-place radix-2 Cooley-Tukey FFT with bit-reversal permutation:
$$\text{DC} = \frac{1}{N}\sum_{n=0}^{N-1} x[n] \cdot w[n]$$
$$X[k] = \text{FFT}\!\left(x[n] \cdot w[n]\right)$$
**Stage 2: Forward DFT for harmonics $k = 1$ to $H$** computes the real and imaginary Fourier coefficients for each retained harmonic. The Hanning window $w[n] = 0.5 - 0.5\cos(2\pi n/N)$ is applied to every sample.
where $w[n] = 0.5 - 0.5\cos(2\pi n/N)$.
**Stage 3: Inverse synthesis** reconstructs the current bar's value by summing the DC component plus twice the real part of each harmonic evaluated at $n = 0$ (the current bar):
**Stage 2: Spectral truncation** zeroes frequency bins outside the preserved range, keeping bins $k = 0, 1, \ldots, H$ and their conjugate mirrors $k = N-H, \ldots, N-1$:
$$\hat{x}[0] = \frac{\text{DC}_{\text{Re}}}{N} + \sum_{k=1}^{H} \frac{2 \cdot \text{Re}(X[k])}{N}$$
$$\tilde{X}[k] = \begin{cases} X[k] & \text{if } k \le H \text{ or } k \ge N-H \\ 0 & \text{otherwise} \end{cases}$$
The factor $2/N$ accounts for: (1) the $1/N$ normalization of the inverse DFT, and (2) the factor of 2 from collapsing the conjugate-symmetric negative frequencies.
This preserves conjugate symmetry ($\tilde{X}[N-k] = \tilde{X}[k]^*$), ensuring the inverse FFT produces real-valued output.
**Complexity**: The forward DFT for $H$ harmonics costs $O(N \cdot H)$ multiply-adds per bar. With $N = 64$ and $H = 5$ (defaults), this is ~320 multiply-adds per bar. The inverse synthesis at $n = 0$ reduces to just summing the real components, costing $O(H)$.
**Stage 3: Inverse FFT** reconstructs the filtered time-domain signal using the conjugate method:
**Smoothness control**: Fewer harmonics produce smoother output but introduce more lag and lose detail. The relationship between harmonics and equivalent moving average length is roughly: $H$ harmonics approximate the smoothness of an $N/(2H)$-period moving average, but with better frequency selectivity (sharper cutoff).
$$\hat{x}[n] = \frac{1}{N} \cdot \overline{\text{FFT}\!\left(\overline{\tilde{X}[k]}\right)}$$
This reuses the forward FFT algorithm by conjugating inputs, applying FFT, conjugating outputs, and scaling by $1/N$.
**Stage 4: Sample extraction** returns the value at position $N-1$ (the newest bar in the window).
**Complexity**: Two FFT passes of $O(N \log N)$ each, plus $O(N)$ for windowing and spectral truncation. Total: $O(N \log N)$ per bar.
**Smoothness control**: Fewer harmonics produce smoother output but introduce more lag. The relationship between harmonics and equivalent moving average length is roughly: $H$ harmonics approximate the smoothness of an $N/(2H)$-period moving average, with better frequency selectivity (sharper cutoff).
## Mathematical Foundation
The **forward DFT** with Hanning window:
The **forward FFT** with Hanning window (radix-2 Cooley-Tukey):
$$X[k] = \sum_{n=0}^{N-1} x[n] \cdot w[n] \cdot e^{-j 2\pi k n / N}$$
$$X[k] = \text{FFT}_N\!\left(x[n] \cdot w[n]\right), \quad k = 0, 1, \ldots, N-1$$
where $w[n] = 0.5 - 0.5\cos(2\pi n / N)$.
**Spectral truncation** (ideal low-pass in frequency domain):
The **inverse DFT** evaluated at the current bar ($n = 0$):
$$\tilde{X}[k] = X[k] \cdot H_{\text{LP}}[k], \quad H_{\text{LP}}[k] = \begin{cases} 1 & k \le H \text{ or } k \ge N-H \\ 0 & \text{otherwise} \end{cases}$$
$$\hat{x}[0] = \frac{1}{N}\sum_{k=0}^{N-1} X[k] \cdot e^{j 2\pi k \cdot 0 / N} = \frac{1}{N}\sum_{k=0}^{N-1} X[k]$$
**Inverse FFT** via conjugation:
Since $e^{j \cdot 0} = 1$, the inverse at $n = 0$ is simply the sum of all retained coefficients divided by $N$.
For a real-valued signal, $X[N-k] = X[k]^*$, so:
$$\hat{x}[0] = \frac{X[0]}{N} + \frac{2}{N}\sum_{k=1}^{H} \text{Re}(X[k])$$
$$\hat{x}[n] = \frac{1}{N} \cdot \overline{\text{FFT}_N\!\left(\overline{\tilde{X}[k]}\right)}$$
**Parseval's theorem** relates the energy retained:
@@ -75,27 +79,27 @@ $$\frac{\sum_{k=0}^{H} |X[k]|^2}{\sum_{k=0}^{N/2} |X[k]|^2} = \text{fraction of
IFFT(source, windowSize, numHarmonics):
N = windowSize
H = min(numHarmonics, N/2)
twoPiOverN = 2 * pi / N
// DC component (k=0)
dcRe = 0
// Stage 1: Window + Forward FFT
for n = 0 to N-1:
w = 0.5 - 0.5 * cos(twoPiOverN * n)
dcRe += source[n] * w
result = dcRe / N
workRe[n] = source[n] * hanning[n]
workIm[n] = 0
FFT_InPlace(workRe, workIm, N)
// Harmonics k=1..H
for k = 1 to H:
re = 0; im = 0
for n = 0 to N-1:
w = 0.5 - 0.5 * cos(twoPiOverN * n)
xw = source[n] * w
angle = twoPiOverN * k * n
re += xw * cos(angle)
im -= xw * sin(angle)
result += 2 * re / N // inverse at n=0
// Stage 2: Spectral truncation
for k = H+1 to N-H-1:
workRe[k] = 0
workIm[k] = 0
return result
// Stage 3: Inverse FFT (via conjugation)
for i = 0 to N-1: workIm[i] = -workIm[i]
FFT_InPlace(workRe, workIm, N)
for i = 0 to N-1:
workRe[i] /= N
workIm[i] = -workIm[i] / N
// Stage 4: Extract newest sample
return workRe[N-1]
```
@@ -103,32 +107,37 @@ IFFT(source, windowSize, numHarmonics):
### Operation Count (Streaming Mode)
IFFT (Inverse DFT reconstruction) sums B frequency components back into the time domain — O(N*B) per bar.
IFFT performs two radix-2 FFT passes (forward + inverse) plus spectral truncation — O(N log N) per bar.
| Operation | Count | Cost (cycles) | Subtotal |
| :--- | :---: | :---: | :---: |
| Complex multiply-accumulate (N * B) | N*B | 4 cy | ~4*N*B cy |
| cos/sin table lookup (precomputed) | 2*N*B | 0 cy | ~0 cy |
| Division by N for normalization | N | 1 cy | ~N cy |
| NaN guard + state update | 1 | 2 cy | ~2 cy |
| **Total (N=64, B=10)** | **O(N*B)** | — | **~2626 cy** |
| Hanning window multiply | N | 2 cy | ~2N cy |
| Forward FFT (N/2 × log₂N butterflies) | N/2 × log₂N | 8 cy | ~4N·log₂N cy |
| Spectral truncation | N-2H | 1 cy | ~(N-2H) cy |
| Conjugation (2×) | 2N | 1 cy | ~2N cy |
| Inverse FFT (N/2 × log₂N butterflies) | N/2 × log₂N | 8 cy | ~4N·log₂N cy |
| Scale by 1/N | N | 1 cy | ~N cy |
| **Total (N=64, H=5)** | **O(N log N)** | — | **~3254 cy** |
Same complexity as forward FFT. Precomputed trig tables allow the inner loop to reduce to 4 FMAs per bin. Paired with FFT for frequency-domain filtering.
Two FFT passes dominate cost. Pre-allocated work arrays ensure zero allocation in the hot path.
### Batch Mode (SIMD Analysis)
| Operation | Vectorizable? | Notes |
| :--- | :---: | :--- |
| Complex MAC (re*cos - im*sin) | Yes | FMA with precomputed table |
| Normalization | Yes | Vector divide by N |
| Output time-domain signal | Yes | Full SIMD reconstruction |
| Hanning window application | Yes | Vector multiply with precomputed weights |
| FFT butterfly operations | Yes | Complex FMA on paired elements |
| Spectral truncation (zeroing) | Yes | Vector zero-fill |
| IFFT butterfly operations | Yes | Same as forward FFT |
| Scale by 1/N | Yes | Vector multiply by constant |
Same SIMD profile as FFT forward pass. 3-4× batch speedup expected over scalar using Vector<double> FMA.
Good SIMD potential: both FFT passes are vectorizable. Expected 2× speedup over scalar for N=64.
## Resources
- Cooley, J.W. & Tukey, J.W. "An Algorithm for the Machine Calculation of Complex Fourier Series." *Mathematics of Computation*, 1965.
- Fourier, J.B.J. "Theorie Analytique de la Chaleur." Firmin Didot, 1822.
- Ehlers, J.F. "Cycle Analytics for Traders." Wiley, 2013.
- Oppenheim, A.V. & Schafer, R.W. "Discrete-Time Signal Processing." 3rd edition, Pearson, 2010.
- Bloomfield, P. "Fourier Analysis of Time Series: An Introduction." 2nd edition, Wiley, 2000.
- Priestley, M.B. "Spectral Analysis and Time Series." Academic Press, 1981.
- PineScript reference: [`ifft.pine`](ifft.pine)
lib/numerics/jerk/jerk.pine
+17 -100
View File
@@ -1,112 +1,29 @@
// Licensed under the Apache License, Version 2.0
// © mihakralj
//@version=6
indicator("Acceleration, Slope of Slope (JERK)", "JERK", overlay=false, precision=8)
indicator("Third Derivative / Jerk (JERK)", "JERK", overlay=false, precision=8)
//@function Calculates jerk (slope of slope of slope)
//@param src Source series to calculate slope from
//@param len Lookback period for calculation
//@returns jerk
jerk(series float src, simple int len1) =>
if len1 <= 1
runtime.error("Length 1 for first slope calculation must be greater than 1")
var float sumX1 = 0.0, var float sumY1 = 0.0, var float sumXY1 = 0.0, var float sumX21 = 0.0
var int validCount1 = 0
var array<float> x_values1 = array.new_float(len1)
var array<float> y_values1 = array.new_float(len1)
var int head1 = 0
var int internal_time_counter1 = 0
if internal_time_counter1 >= len1
float oldX1 = array.get(x_values1, head1)
float oldY1 = array.get(y_values1, head1)
if not na(oldY1)
sumX1 := sumX1 - oldX1, sumY1 := sumY1 - oldY1
sumXY1 := sumXY1 - oldX1 * oldY1, sumX21 := sumX21 - oldX1 * oldX1
validCount1 := validCount1 - 1
float currentX1 = internal_time_counter1
float currentY1 = src
array.set(x_values1, head1, currentX1)
array.set(y_values1, head1, currentY1)
if not na(currentY1)
sumX1 := sumX1 + currentX1, sumY1 := sumY1 + currentY1
sumXY1 := sumXY1 + currentX1 * currentY1, sumX21 := sumX21 + currentX1 * currentX1
validCount1 := validCount1 + 1
head1 := (head1 + 1) % len1
internal_time_counter1 := internal_time_counter1 + 1
float current_slope1 = na
if validCount1 >= 2
float n1 = validCount1
float divisor1 = n1 * sumX21 - sumX1 * sumX1
if divisor1 != 0.0
current_slope1 := (n1 * sumXY1 - sumX1 * sumY1) / divisor1
var float sumX2 = 0.0, var float sumY2 = 0.0, var float sumXY2 = 0.0, var float sumX22 = 0.0
var int validCount2 = 0
var array<float> x_values2 = array.new_float(len1)
var array<float> y_values2 = array.new_float(len1)
var int head2 = 0
var int internal_time_counter2 = 0
if internal_time_counter2 >= len1
float oldX2 = array.get(x_values2, head2)
float oldY2 = array.get(y_values2, head2)
if not na(oldY2)
sumX2 := sumX2 - oldX2, sumY2 := sumY2 - oldY2
sumXY2 := sumXY2 - oldX2 * oldY2, sumX22 := sumX22 - oldX2 * oldX2
validCount2 := validCount2 - 1
float currentX2 = internal_time_counter2
float currentY2 = current_slope1
array.set(x_values2, head2, currentX2)
array.set(y_values2, head2, currentY2)
if not na(currentY2)
sumX2 := sumX2 + currentX2, sumY2 := sumY2 + currentY2
sumXY2 := sumXY2 + currentX2 * currentY2, sumX22 := sumX22 + currentX2 * currentX2
validCount2 := validCount2 + 1
head2 := (head2 + 1) % len1
internal_time_counter2 := internal_time_counter2 + 1
float current_accel = na
if validCount2 >= 2
float n2 = validCount2
float divisor2 = n2 * sumX22 - sumX2 * sumX2
if divisor2 != 0.0
current_accel := (n2 * sumXY2 - sumX2 * sumY2) / divisor2
var float sumX3 = 0.0, var float sumY3 = 0.0, var float sumXY3 = 0.0, var float sumX23 = 0.0
var int validCount3 = 0
var array<float> x_values3 = array.new_float(len1)
var array<float> y_values3 = array.new_float(len1)
var int head3 = 0
var int internal_time_counter3 = 0
if internal_time_counter3 >= len1
float oldX3 = array.get(x_values3, head3)
float oldY3 = array.get(y_values3, head3)
if not na(oldY3)
sumX3 := sumX3 - oldX3, sumY3 := sumY3 - oldY3
sumXY3 := sumXY3 - oldX3 * oldY3, sumX23 := sumX23 - oldX3 * oldX3
validCount3 := validCount3 - 1
float currentX3 = internal_time_counter3
float currentY3 = current_accel
array.set(x_values3, head3, currentX3)
array.set(y_values3, head3, currentY3)
if not na(currentY3)
sumX3 := sumX3 + currentX3, sumY3 := sumY3 + currentY3
sumXY3 := sumXY3 + currentX3 * currentY3, sumX23 := sumX23 + currentX3 * currentX3
validCount3 := validCount3 + 1
head3 := (head3 + 1) % len1
internal_time_counter3 := internal_time_counter3 + 1
float calculatedjerk = na
if validCount3 >= 2
float n3 = validCount3
float divisor3 = n3 * sumX23 - sumX3 * sumX3
if divisor3 != 0.0
calculatedjerk := (n3 * sumXY3 - sumX3 * sumY3) / divisor3
calculatedjerk
//@function Calculates the third finite difference (jerk): Jerk = V[t] - 3*V[t-1] + 3*V[t-2] - V[t-3]
//@param src Source series
//@returns Third difference. Returns 0.0 until 4 bars are available.
//@optimized Uses direct history access and binomial coefficients [1,-3,3,-1].
jerk(series float src) =>
float v0 = src
float v1 = src[1]
float v2 = src[2]
float v3 = src[3]
if na(v1) or na(v2) or na(v3)
0.0
else
v0 - 3.0 * v1 + 3.0 * v2 - v3
// ---------- Main loop ----------
// ---------- Main loop ----------
// Inputs
i_period = input.int(14, "Period", minval=2)
i_source = input.source(close, "Source")
// Calculation
a = jerk(i_source, i_period)
j = jerk(i_source)
// Plot
plot(a, "jerk", color=color.yellow, linewidth=2)
plot(j, "Jerk", color=color.yellow, linewidth=2)
lib/numerics/lineartrans/lineartrans.pine
+17 -34
View File
@@ -1,46 +1,29 @@
// Licensed under the Apache License, Version 2.0
// © mihakralj
//@version=6
indicator("Linear Transformation (LINEAR)", "Lineartrans", overlay=false)
//@function Applies a linear transformation (y = a*(x - sma) + sma + b) relative to the source's SMA, calculated internally.
//@param source series float The input series to transform.
//@param period simple int The lookback period for the internal SMA calculation.
//@param a float The scaling factor (slope).
//@param b float The offset (intercept).
//@returns series float The linearly transformed series relative to its internally calculated SMA.
//@optimized for performance and dirty data
linear(series float source, float a, float b) =>
if na(source) or na(a) or na(b)
runtime.error("Parameters 'source', 'a', 'b' cannot be na and 'period' must be > 0.")
var int p = 200
var array<float> buffer = array.new_float(p, na)
var int head = 0
var float sum = 0.0
var int valid_count = 0
float oldest = array.get(buffer, head)
if not na(oldest)
sum -= oldest
valid_count -= 1
if not na(source)
sum += source
valid_count += 1
array.set(buffer, head, source)
head := (head + 1) % p
smaValue = nz(sum / valid_count, source)
a * (source - smaValue) + smaValue + b
indicator("Linear Scaling Transformer (LINEARTRANS)", "LINEARTRANS", overlay=true, precision=8)
//@function Applies a simple affine (linear) transformation: y = slope * x + intercept
//@param src Source series to transform
//@param a Slope (scaling factor). Default 1.0.
//@param b Intercept (offset). Default 0.0.
//@returns Linearly transformed value: a * src + b
//@optimized Single FMA operation per bar — O(1) with zero allocations.
lineartrans(series float src, float a, float b) =>
if na(src)
na
else
a * src + b
// ---------- Main loop ----------
// Inputs
i_source = input(close, "Source")
i_smaPeriod = input.int(200, "SMA Period", minval=1)
i_a = input.float(2.0, "Scale (a)")
i_b = input.float(20.0, "Offset (b)")
i_source = input.source(close, "Source")
i_slope = input.float(1.0, "Slope (a)")
i_intercept = input.float(0.0, "Intercept (b)")
// Calculation
transformedSource = linear(i_source, i_a, i_b)
result = lineartrans(i_source, i_slope, i_intercept)
// Plot
plot(transformedSource, "Linear Transformation", color=color.yellow, linewidth=2)
plot(result, "Lineartrans", color=color.yellow, linewidth=2)
lib/numerics/logtrans/logtrans.pine
+4 -4
View File
@@ -9,8 +9,8 @@ indicator("Logarithmic Transformation (LOG)", "Logtrans", overlay=false)
//@optimized for performance and dirty data
logT(series float source) =>
if na(source)
runtime.error("Parameter 'source' cannot be na.")
if source <= 0
na
else if source <= 0
na
else
math.log(source)
@@ -18,10 +18,10 @@ logT(series float source) =>
// ---------- Main loop ----------
// Inputs
i_source = input(close, "Source")
i_source = input.source(close, "Source")
// Calculation
transformedSource = logT(i_source)
// Plot
plot(transformedSource, "Log Transformation", color=color.green, color=color.yellow, linewidth=2)
plot(transformedSource, "Logtrans", color=color.yellow, linewidth=2)
lib/numerics/slope/slope.pine
+12 -47
View File
@@ -1,61 +1,26 @@
// Licensed under the Apache License, Version 2.0
// © mihakralj
//@version=6
indicator("Slope, Linear Regression (SLOPE)", "SLOPE", overlay=false, precision=8)
indicator("First Derivative / Velocity (SLOPE)", "SLOPE", overlay=false, precision=8)
//@function Calculates slope (linear regression)
//@param src Source series to calculate slope from
//@param len Lookback period for calculation
//@returns Slope value properly calculated
slope(series float src, simple int len) =>
if len <= 1
runtime.error("Length must be greater than 1")
var float sumX = 0.0
var float sumY = 0.0
var float sumXY = 0.0
var float sumX2 = 0.0
var int validCount = 0
var array<float> x_values = array.new_float(len)
var array<float> y_values = array.new_float(len)
var int head = 0
var int internal_time_counter = 0
if internal_time_counter >= len
float oldX = array.get(x_values, head)
float oldY = array.get(y_values, head)
if not na(oldY)
sumX := sumX - oldX
sumY := sumY - oldY
sumXY := sumXY - oldX * oldY
sumX2 := sumX2 - oldX * oldX
validCount := validCount - 1
float currentX = internal_time_counter
float currentY = src
array.set(x_values, head, currentX)
array.set(y_values, head, currentY)
if not na(currentY)
sumX := sumX + currentX
sumY := sumY + currentY
sumXY := sumXY + currentX * currentY
sumX2 := sumX2 + currentX * currentX
validCount := validCount + 1
head := (head + 1) % len
internal_time_counter := internal_time_counter + 1
float calculatedSlope = na
if validCount >= 2
float n = validCount
float divisor = n * sumX2 - sumX * sumX
if divisor != 0.0
calculatedSlope := (n * sumXY - sumX * sumY) / divisor
calculatedSlope
//@function Calculates the first finite difference (velocity): Slope = V[t] - V[t-1]
//@param src Source series
//@returns First difference of consecutive values. Returns 0.0 on first bar.
//@optimized Uses direct history access for zero-allocation streaming.
slope(series float src) =>
float prev = src[1]
if na(prev)
0.0
else
src - prev
// ---------- Main loop ----------
// Inputs
i_period = input.int(14, "Period", minval=2)
i_source = input.source(close, "Source")
// Calculation
s = slope(i_source, i_period)
s = slope(i_source)
// Plot
plot(s, "Slope", color=color.yellow, linewidth=2)
lib/numerics/sqrttrans/sqrttrans.pine
+4 -4
View File
@@ -9,8 +9,8 @@ indicator("Square Root Transformation (SQRT)", "Sqrttrans", overlay=false)
//@optimized for performance and dirty data
sqrtT(series float source) =>
if na(source)
runtime.error("Parameter 'source' cannot be na.")
if source < 0
na
else if source < 0
na
else
math.sqrt(source)
@@ -18,10 +18,10 @@ sqrtT(series float source) =>
// ---------- Main loop ----------
// Inputs
i_source = input(close, "Source")
i_source = input.source(close, "Source")
// Calculation
transformedSource = sqrtT(i_source)
// Plot
plot(transformedSource, "Square Root Transformation", color=color.yellow, linewidth=2)
plot(transformedSource, "Sqrttrans", color=color.yellow, linewidth=2)
lib/oscillators/ac/Ac.cs
+1 -1
View File
@@ -5,7 +5,7 @@ using System.Runtime.InteropServices;
namespace QuanTAlib;
/// <summary>
/// AC: Acceleration Oscillator
/// AC: Accelerator Oscillator
/// </summary>
/// <remarks>
/// Bill Williams' Acceleration Oscillator measures the acceleration or deceleration
lib/oscillators/ac/Ac.md
+1 -1
View File
@@ -1,4 +1,4 @@
# AC: Acceleration Oscillator
# AC: Accelerator Oscillator
> "Momentum tells you which way the wind is blowing. Acceleration tells you whether the wind is picking up." -- Bill Williams, paraphrased
lib/oscillators/bbb/bbb.pine
+1 -1
View File
@@ -1,7 +1,7 @@
// Licensed under the Apache License, Version 2.0
// © mihakralj
//@version=6
indicator("Bollinger %B", "BBB", overlay=false)
indicator("Bollinger %B (BBB)", "BBB", overlay=false)
//@function Calculates Bollinger Bands %B oscillator
//@param source Series to calculate %B from
lib/oscillators/cfo/cfo.pine
+1 -1
View File
@@ -1,7 +1,7 @@
// Licensed under the Apache License, Version 2.0
// © mihakralj
//@version=6
indicator("Chande Forecast Oscillator", "CFO", overlay=false)
indicator("Chande Forecast Oscillator (CFO)", "CFO", overlay=false)
//@function Chande Forecast Oscillator - measures percentage difference between price and forecasted price
//@param source Price data to analyze
lib/oscillators/coppock/Coppock.md
+2 -2
View File
@@ -4,7 +4,7 @@
| ---------------- | -------------------------------- |
| **Category** | Oscillator |
| **Inputs** | Source (close) |
| **Parameters** | `longRoc` (default DefaultLongRoc), `shortRoc` (default DefaultShortRoc), `wmaPeriod` (default DefaultWmaPeriod) |
| **Parameters** | `longRoc` (default 14), `shortRoc` (default 11), `wmaPeriod` (default 10) |
| **Outputs** | Single series (Coppock) |
| **Output range** | Varies (see docs) |
| **Warmup** | 1 bar |
@@ -12,7 +12,7 @@
### TL;DR
- The Coppock Curve is a long-term momentum oscillator that applies a Weighted Moving Average to the sum of two Rate of Change calculations at differ...
- Parameterized by `longroc` (default defaultlongroc), `shortroc` (default defaultshortroc), `wmaperiod` (default defaultwmaperiod).
- Parameterized by `longRoc` (default 14), `shortRoc` (default 11), `wmaPeriod` (default 10).
- Output range: Varies (see docs).
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
lib/oscillators/fisher04/fisher04.pine
+4 -3
View File
@@ -1,3 +1,6 @@
// Licensed under the Apache License, Version 2.0
// © mihakralj
//@version=6
// Fisher04: Ehlers Fisher Transform (2004 Cybernetic Analysis)
// Source: John Ehlers, "Cybernetic Analysis for Stocks and Futures", Wiley, 2004, Chapter 1
//
@@ -7,9 +10,7 @@
// Clamp threshold: 0.9999 vs 0.99→0.999
// Fisher multiplier: 0.25 vs 0.5
// Fisher IIR: 0.5 (same)
//@version=6
indicator("Fisher04 - Ehlers 2004 Cybernetic Analysis", shorttitle="Fisher04", overlay=false)
indicator("Ehlers Fisher Transform 2004 (FISHER04)", "FISHER04", overlay=false)
length = input.int(10, "Length", minval=1)
lib/oscillators/gator/gator.pine
+1 -1
View File
@@ -1,7 +1,7 @@
// Licensed under the Apache License, Version 2.0
// © mihakralj
//@version=6
indicator("Williams Gator Oscillator", "GATOR", overlay=false)
indicator("Williams Gator Oscillator (GATOR)", "GATOR", overlay=false)
//@function Calculates Williams Gator Oscillator from Alligator lines
//@param source Series to calculate from
lib/oscillators/inertia/inertia.pine
+1 -1
View File
@@ -1,7 +1,7 @@
// Licensed under the Apache License, Version 2.0
// © mihakralj
//@version=6
indicator("Inertia", "INERTIA", overlay=false)
indicator("Inertia Oscillator (INERTIA)", "INERTIA", overlay=false)
//@function Calculates Inertia oscillator measuring trend strength based on distance from linear regression
//@param source Source series to calculate Inertia for
lib/oscillators/kdj/kdj.pine
+1 -1
View File
@@ -1,7 +1,7 @@
// Licensed under the Apache License, Version 2.0
// © mihakralj
//@version=6
indicator("KDJ", "KDJ", overlay=false)
indicator("KDJ Oscillator (KDJ)", "KDJ", overlay=false)
//@function Calculates KDJ (K, D, J) lines - enhanced Stochastic Oscillator
//@param high Series of high prices
lib/oscillators/kst/Kst.md
+2 -2
View File
@@ -4,7 +4,7 @@
| ---------------- | -------------------------------- |
| **Category** | Oscillator |
| **Inputs** | Source (close) |
| **Parameters** | `r1` (default DefaultR1), `r2` (default DefaultR2), `r3` (default DefaultR3), `r4` (default DefaultR4), `s1` (default DefaultS1), `s2` (default DefaultS2), `s3` (default DefaultS3), `s4` (default DefaultS4), `sigPeriod` (default DefaultSigPeriod) |
| **Parameters** | `r1` (default 10), `r2` (default 15), `r3` (default 20), `r4` (default 30), `s1` (default 10), `s2` (default 10), `s3` (default 10), `s4` (default 15), `sigPeriod` (default 9) |
| **Outputs** | Multiple series (KstValue, Signal) |
| **Output range** | Varies (see docs) |
| **Warmup** | `Math.Max(Math.Max(r1, r2), Math.Max(r3, r4))
@@ -14,7 +14,7 @@
### TL;DR
- The Know Sure Thing is a multi-timeframe momentum oscillator that computes four Rate of Change values at progressively longer lookback periods, smo...
- Parameterized by `r1` (default defaultr1), `r2` (default defaultr2), `r3` (default defaultr3), `r4` (default defaultr4), `s1` (default defaults1), `s2` (default defaults2), `s3` (default defaults3), `s4` (default defaults4), `sigperiod` (default defaultsigperiod).
- Parameterized by `r1` (default 10), `r2` (default 15), `r3` (default 20), `r4` (default 30), `s1` (default 10), `s2` (default 10), `s3` (default 10), `s4` (default 15), `sigPeriod` (default 9).
- Output range: Varies (see docs).
- Requires `Math.Max(Math.Max(r1, r2), Math.Max(r3, r4))
+ Math.Max(Math.Max(s1, s2), Math.Max(s3, s4))
lib/oscillators/lrsi/lrsi.pine
+3 -2
View File
@@ -1,11 +1,12 @@
// Licensed under the Apache License, Version 2.0
// © mihakralj
//@version=6
// LRSI: Laguerre RSI
// John Ehlers, "Cybernetic Analysis for Stocks and Futures" (2004)
// A modified RSI that uses a 4-element Laguerre filter as its core moving average.
// The gamma parameter controls the damping of the filter stages, trading
// responsiveness against smoothness. Output is dimensionless [0, 1].
indicator("LRSI: Laguerre RSI", shorttitle="LRSI", overlay=false)
indicator("Laguerre RSI (LRSI)", "LRSI", overlay=false)
gamma = input.float(0.5, "Gamma", minval=0.0, maxval=1.0, step=0.01,
tooltip="Damping factor [0,1]. Lower = more responsive; higher = smoother.")
lib/oscillators/marketfi/marketfi.pine
+3 -1
View File
@@ -1,5 +1,7 @@
// Licensed under the Apache License, Version 2.0
// © mihakralj
//@version=6
indicator("MARKETFI: Market Facilitation Index", shorttitle="MARKETFI", overlay=false)
indicator("Market Facilitation Index (MARKETFI)", "MARKETFI", overlay=false)
// Bill Williams' Market Facilitation Index (BW MFI)
// Measures price movement efficiency per unit of volume.
lib/oscillators/pgo/pgo.pine
+1 -1
View File
@@ -1,7 +1,7 @@
// Licensed under the Apache License, Version 2.0
// © mihakralj
//@version=6
indicator("Pretty Good Oscillator", "PGO", overlay=false)
indicator("Pretty Good Oscillator (PGO)", "PGO", overlay=false)
//@function Calculate Pretty Good Oscillator (PGO)
//@param source Price data to analyze
lib/oscillators/qqe/Qqe.md
+2 -2
View File
@@ -4,7 +4,7 @@
| ---------------- | -------------------------------- |
| **Category** | Oscillator |
| **Inputs** | Source (close) |
| **Parameters** | `rsiPeriod` (default DefaultRsiPeriod), `smoothFactor` (default DefaultSmoothFactor), `qqeFactor` (default DefaultQqeFactor) |
| **Parameters** | `rsiPeriod` (default 14), `smoothFactor` (default 5), `qqeFactor` (default 4.236) |
| **Outputs** | Single series (Qqe) |
| **Output range** | Varies (see docs) |
| **Warmup** | `rsiPeriod + smoothFactor + darPeriod * 2` bars |
@@ -12,7 +12,7 @@
### TL;DR
- Quantitative Qualitative Estimation applies a multi-stage smoothing pipeline to RSI and then constructs dynamic volatility-based trailing bands aro...
- Parameterized by `rsiperiod` (default defaultrsiperiod), `smoothfactor` (default defaultsmoothfactor), `qqefactor` (default defaultqqefactor).
- Parameterized by `rsiPeriod` (default 14), `smoothFactor` (default 5), `qqeFactor` (default 4.236).
- Output range: Varies (see docs).
- Requires `rsiPeriod + smoothFactor + darPeriod * 2` bars of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
lib/oscillators/reflex/reflex.pine
+2 -4
View File
@@ -1,7 +1,5 @@
// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0
// https://mozilla.org/MPL/2.0/
// © QuanTAlib
// Licensed under the Apache License, Version 2.0
// © mihakralj
//@version=6
indicator("Ehlers Reflex Indicator (REFLEX)", "REFLEX", overlay = false)
lib/oscillators/stoch/stoch.pine
+1 -1
View File
@@ -1,7 +1,7 @@
// Licensed under the Apache License, Version 2.0
// © mihakralj
//@version=6
indicator("Stochastic Oscillator (STOCH)", "Stoch", overlay=false)
indicator("Stochastic Oscillator (STOCH)", "STOCH", overlay=false)
//@function Calculates the Stochastic Oscillator (%K and %D). %K = 100 * (close - lowest_low(kLength)) / (highest_high(kLength) - lowest_low(kLength)). %D = SMA(%K, dPeriod). Uses efficient deque implementation for min/max and buffer-based SMA.
//@param kLength `simple int` The lookback period for calculating highest high and lowest low.
lib/oscillators/stochrsi/stochrsi.pine
+1 -1
View File
@@ -1,7 +1,7 @@
// Licensed under the Apache License, Version 2.0
// © mihakralj
//@version=6
indicator("Stochastic RSI (STOCHRSI)", "StochRSI", overlay=false)
indicator("Stochastic RSI (STOCHRSI)", "STOCHRSI", overlay=false)
//@function Calculates Stochastic RSI oscillator
//@param source Source series to calculate STOCHRSI for
lib/oscillators/trendflex/trendflex.pine
+1 -1
View File
@@ -2,7 +2,7 @@
// © mihakralj
//@version=6
// Indicator algorithm (C) 2013 John F. Ehlers
indicator(" Ehlers Trendflex Indicator (TRENDFLEX)", "TRENDFLEX", overlay=false)
indicator("Ehlers Trendflex (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
lib/oscillators/trix/trix.pine
+1 -1
View File
@@ -1,7 +1,7 @@
// Licensed under the Apache License, Version 2.0
// © mihakralj
//@version=6
indicator("TRIX", "TRIX", overlay=false)
indicator("Triple Exponential Average (TRIX)", "TRIX", overlay=false)
//@function Calculates TRIX oscillator with compensation
//@param source Series to calculate TRIX from
lib/oscillators/ttm_wave/ttm_wave.pine
+67
View File
@@ -0,0 +1,67 @@
// Licensed under the Apache License, Version 2.0
// © mihakralj
//@version=6
indicator("TTM Wave (TTM_WAVE)", "TTM_WAVE", overlay=false)
//@function EMA — standard exponential moving average for MACD computation.
//@param src Source series
//@param length EMA period
//@returns EMA value
ema_calc(series float src, simple int length) =>
float alpha = 2.0 / (length + 1)
var float result = 0.0
result := bar_index == 0 ? src : alpha * src + (1 - alpha) * result
result
//@function MACD histogram — (fast_ema - slow_ema) - signal_ema(fast_ema - slow_ema)
// This is the second derivative of momentum: acceleration of the spread.
//@param src Source series
//@param fast Fast EMA period
//@param slow Slow EMA period
//@param signal Signal EMA period (same as slow for TTM Wave)
//@returns MACD histogram value
macd_hist(series float src, simple int fast, simple int slow, simple int signal) =>
float fast_ema = ema_calc(src, fast)
float slow_ema = ema_calc(src, slow)
float macd_line = fast_ema - slow_ema
float signal_line = ema_calc(macd_line, signal)
macd_line - signal_line
//@function TTM Wave — six parallel MACD histogram channels at Fibonacci periods.
// Wave A (short-term): channels 1 (8,34,34) and 2 (8,55,55)
// Wave B (medium-term): channels 3 (8,89,89) and 4 (8,144,144)
// Wave C (long-term): channels 5 (8,233,233) and 6 (8,377,377)
// All channels share fast period 8. Signal period equals slow period.
//@param src Source series (default: close)
//@returns [waveA1, waveA2, waveB1, waveB2, waveC1, waveC2]
//@reference John Carter, "Mastering the Trade" (2005, 2012)
//@optimized Six independent EMA cascades, O(1) per bar per channel
ttm_wave(series float src) =>
float waveA1 = macd_hist(src, 8, 34, 34)
float waveA2 = macd_hist(src, 8, 55, 55)
float waveB1 = macd_hist(src, 8, 89, 89)
float waveB2 = macd_hist(src, 8, 144, 144)
float waveC1 = macd_hist(src, 8, 233, 233)
float waveC2 = macd_hist(src, 8, 377, 377)
[waveA1, waveA2, waveB1, waveB2, waveC1, waveC2]
// ── Inputs ──
float i_src = input.source(close, "Source")
// ── Calculation ──
[waveA1, waveA2, waveB1, waveB2, waveC1, waveC2] = ttm_wave(i_src)
// ── Plot (thinkorswim color convention) ──
// Wave A: yellow/green (short-term momentum)
plot(waveA1, "Wave A1", color=color.yellow, style=plot.style_histogram, linewidth=2)
plot(waveA2, "Wave A2", color=color.lime, style=plot.style_histogram, linewidth=2)
// Wave B: magenta/pink (medium-term momentum)
plot(waveB1, "Wave B1", color=color.fuchsia, style=plot.style_histogram, linewidth=2)
plot(waveB2, "Wave B2", color=color.new(color.fuchsia, 40), style=plot.style_histogram, linewidth=2)
// Wave C: red/orange (long-term momentum)
plot(waveC1, "Wave C1", color=color.red, style=plot.style_histogram, linewidth=2)
plot(waveC2, "Wave C2", color=color.orange, style=plot.style_histogram, linewidth=2)
hline(0, "Zero", color=color.gray, linestyle=hline.style_dotted)
lib/reversals/chandelier/Chandelier.md
+2 -2
View File
@@ -4,7 +4,7 @@
| ---------------- | -------------------------------- |
| **Category** | Reversal |
| **Inputs** | OHLCV bar (TBar) |
| **Parameters** | `period` (default DefaultPeriod), `multiplier` (default DefaultMultiplier) |
| **Parameters** | `period` (default 22), `multiplier` (default 3.0) |
| **Outputs** | Single series (Chandelier) |
| **Output range** | Varies (see docs) |
| **Warmup** | `period + 1` bars |
@@ -12,7 +12,7 @@
### TL;DR
- The Chandelier Exit computes ATR-based trailing stop levels that hang from the highest high (for longs) or rise from the lowest low (for shorts) ov...
- Parameterized by `period` (default defaultperiod), `multiplier` (default defaultmultiplier).
- Parameterized by `period` (default 22), `multiplier` (default 3.0).
- Output range: Varies (see docs).
- Requires `period + 1` bars of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
lib/reversals/chandelier/chandelier.pine
+45
View File
@@ -0,0 +1,45 @@
// Licensed under the Apache License, Version 2.0
// © mihakralj
//@version=6
indicator("Chandelier Exit (CHANDELIER)", "CHANDELIER", overlay=true)
//@function Chandelier Exit — ATR-based trailing stops that hang from the highest high
// (ExitLong) or rise from the lowest low (ExitShort) over a lookback period.
// Uses SMA-seeded Wilder's RMA for ATR, matching Skender/TradingView convention.
//@param period Lookback for ATR and rolling HH/LL (default 22)
//@param multiplier ATR scaling factor (default 3.0)
//@returns [exitLong, exitShort] — two overlay stop levels
//@reference Charles Le Beau; Alexander Elder, "Come Into My Trading Room" (2002)
//@optimized O(1) per bar using ta.rma, ta.highest, ta.lowest
chandelier(simple int period = 22, simple float multiplier = 3.0) =>
if period < 1
runtime.error("Period must be >= 1")
if multiplier <= 0
runtime.error("Multiplier must be > 0")
// True Range
float tr = na(close[1]) ? high - low : math.max(high - low, math.max(math.abs(high - close[1]), math.abs(low - close[1])))
// Wilder's ATR (RMA = EMA with alpha = 1/period, SMA-seeded)
float atr = ta.rma(tr, period)
// Rolling extremes over the lookback window
float hh = ta.highest(high, period)
float ll = ta.lowest(low, period)
// Chandelier exits
float exit_long = hh - multiplier * atr
float exit_short = ll + multiplier * atr
[exit_long, exit_short]
// ── Inputs ──
int i_period = input.int(22, "Period", minval=1)
float i_multiplier = input.float(3.0, "Multiplier", minval=0.01, step=0.1)
// ── Calculation ──
[exit_long, exit_short] = chandelier(i_period, i_multiplier)
// ── Plot ──
plot(exit_long, "Exit Long", color=color.green, linewidth=2)
plot(exit_short, "Exit Short", color=color.red, linewidth=2)
lib/reversals/ckstop/Ckstop.md
+2 -2
View File
@@ -4,7 +4,7 @@
| ---------------- | -------------------------------- |
| **Category** | Reversal |
| **Inputs** | OHLCV bar (TBar) |
| **Parameters** | `atrPeriod` (default DefaultAtrPeriod), `multiplier` (default DefaultMultiplier), `stopPeriod` (default DefaultStopPeriod) |
| **Parameters** | `atrPeriod` (default 10), `multiplier` (default 1.0), `stopPeriod` (default 9) |
| **Outputs** | Single series (Ckstop) |
| **Output range** | Varies (see docs) |
| **Warmup** | `atrPeriod + stopPeriod` bars |
@@ -12,7 +12,7 @@
### TL;DR
- The Chande Kroll Stop computes adaptive trailing stop levels using ATR-smoothed volatility envelopes around rolling extremes.
- Parameterized by `atrperiod` (default defaultatrperiod), `multiplier` (default defaultmultiplier), `stopperiod` (default defaultstopperiod).
- Parameterized by `atrPeriod` (default 10), `multiplier` (default 1.0), `stopPeriod` (default 9).
- Output range: Varies (see docs).
- Requires `atrPeriod + stopPeriod` bars of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
lib/reversals/ckstop/ckstop.pine
+52
View File
@@ -0,0 +1,52 @@
// Licensed under the Apache License, Version 2.0
// © mihakralj
//@version=6
indicator("Chande Kroll Stop (CKSTOP)", "CKSTOP", overlay=true)
//@function Chande Kroll Stop — adaptive trailing stop using ATR-smoothed volatility
// envelopes around rolling extremes, then smoothed through a second window.
// Stage 1: first_high_stop = HH(p) - m*ATR, first_low_stop = LL(p) + m*ATR
// Stage 2: StopShort = highest(first_high_stop, x), StopLong = lowest(first_low_stop, x)
//@param atr_period ATR and first-stop extreme lookback (default 10)
//@param multiplier ATR scaling factor (default 1.0)
//@param stop_period Second smoothing window (default 9)
//@returns [stop_long, stop_short] — two overlay stop levels
//@reference Chande & Kroll, "The New Technical Trader" (1994)
//@optimized O(1) per bar using ta.rma, ta.highest, ta.lowest
ckstop(simple int atr_period = 10, simple float multiplier = 1.0, simple int stop_period = 9) =>
if atr_period < 1
runtime.error("ATR period must be >= 1")
if multiplier <= 0
runtime.error("Multiplier must be > 0")
if stop_period < 1
runtime.error("Stop period must be >= 1")
// True Range
float tr = na(close[1]) ? high - low : math.max(high - low, math.max(math.abs(high - close[1]), math.abs(low - close[1])))
// ATR via Wilder's RMA
float atr = ta.rma(tr, atr_period)
// Stage 1: First stops (volatility envelope)
float hh = ta.highest(high, atr_period)
float ll = ta.lowest(low, atr_period)
float first_high_stop = hh - multiplier * atr
float first_low_stop = ll + multiplier * atr
// Stage 2: Smoothed stops over stop_period
float stop_short = ta.highest(first_high_stop, stop_period)
float stop_long = ta.lowest(first_low_stop, stop_period)
[stop_long, stop_short]
// ── Inputs ──
int i_atr_period = input.int(10, "ATR Period", minval=1)
float i_multiplier = input.float(1.0, "Multiplier", minval=0.01, step=0.1)
int i_stop_period = input.int(9, "Stop Period", minval=1)
// ── Calculation ──
[stop_long, stop_short] = ckstop(i_atr_period, i_multiplier, i_stop_period)
// ── Plot ──
plot(stop_long, "Stop Long", color=color.green, linewidth=2)
plot(stop_short, "Stop Short", color=color.red, linewidth=2)
lib/reversals/fractals/Fractals.cs
+1 -1
View File
@@ -1,6 +1,6 @@
// FRACTALS: Williams Fractals
// Five-bar pattern identifying local highs (up fractals) and local lows (down fractals).
// Created by Larry Williams (1995, "Trading Chaos").
// Created by Bill Williams (1995, "Trading Chaos").
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
lib/reversals/psar/Psar.md
+2 -2
View File
@@ -4,7 +4,7 @@
| ---------------- | -------------------------------- |
| **Category** | Reversal |
| **Inputs** | OHLCV bar (TBar) |
| **Parameters** | `afStart` (default DefaultAfStart), `afIncrement` (default DefaultAfIncrement), `afMax` (default DefaultAfMax) |
| **Parameters** | `afStart` (default 0.02), `afIncrement` (default 0.02), `afMax` (default 0.20) |
| **Outputs** | Single series (Psar) |
| **Output range** | Varies (see docs) |
| **Warmup** | `1` bars |
@@ -12,7 +12,7 @@
### TL;DR
- The Parabolic Stop And Reverse (PSAR) is a trend-following overlay indicator created by J.
- Parameterized by `afstart` (default defaultafstart), `afincrement` (default defaultafincrement), `afmax` (default defaultafmax).
- Parameterized by `afStart` (default 0.02), `afIncrement` (default 0.02), `afMax` (default 0.20).
- Output range: Varies (see docs).
- Requires `1` bars of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
lib/reversals/sarext/sarext.pine
+124
View File
@@ -0,0 +1,124 @@
// Licensed under the Apache License, Version 2.0
// © mihakralj
//@version=6
indicator("Parabolic SAR Extended (SAREXT)", "SAREXT", overlay=true)
//@function Parabolic SAR Extended — asymmetric PSAR with separate long/short AF parameters,
// auto-detect or forced initial direction, and an offset applied on reversal.
// Output is sign-encoded: positive SAR = long mode, negative SAR = short mode.
//@param start_value Initial direction: >0 force long, <0 force short, 0 auto-detect from DM
//@param offset_on_reverse Gap added to SAR on reversal (default 0)
//@param af_init_long Initial AF for long positions (default 0.02)
//@param af_long AF increment per new EP in long (default 0.02)
//@param af_max_long Maximum AF for long (default 0.20)
//@param af_init_short Initial AF for short positions (default 0.02)
//@param af_short AF increment per new EP in short (default 0.02)
//@param af_max_short Maximum AF for short (default 0.20)
//@returns Sign-encoded SAR value (positive = long, negative = short)
//@reference J. Welles Wilder Jr., "New Concepts in Technical Trading Systems" (1978)
//@optimized O(1) per bar, state-machine with asymmetric acceleration factors
sarext(simple float start_value = 0.0, simple float offset_on_reverse = 0.0,
simple float af_init_long = 0.02, simple float af_long = 0.02, simple float af_max_long = 0.20,
simple float af_init_short = 0.02, simple float af_short = 0.02, simple float af_max_short = 0.20) =>
if af_init_long <= 0 or af_long <= 0 or af_max_long <= af_init_long
runtime.error("Long AF parameters invalid")
if af_init_short <= 0 or af_short <= 0 or af_max_short <= af_init_short
runtime.error("Short AF parameters invalid")
if offset_on_reverse < 0
runtime.error("Offset must be >= 0")
var bool is_long = true
var float sar = low
var float ep = high
var float af = af_init_long
if bar_index == 0
// Bar 0: collect first bar data
is_long := true
sar := high
ep := low
af := af_init_short
float(na)
else if bar_index == 1
// Bar 1: determine initial direction
if start_value > 0
is_long := true
sar := math.min(low[1], low)
ep := math.max(high[1], high)
af := af_init_long
else if start_value < 0
is_long := false
sar := math.max(high[1], high)
ep := math.min(low[1], low)
af := af_init_short
else
// Auto-detect from DM
float plus_dm = high - high[1]
float minus_dm = low[1] - low
if plus_dm > minus_dm and plus_dm > 0
is_long := true
sar := math.min(low[1], low)
ep := math.max(high[1], high)
af := af_init_long
else
is_long := false
sar := math.max(high[1], high)
ep := math.min(low[1], low)
af := af_init_short
is_long ? sar : -sar
else
// Bar 2+: standard SAR state machine with asymmetric AF
float new_sar = sar + af * (ep - sar)
if is_long
new_sar := math.min(new_sar, low[1])
if bar_index > 1
new_sar := math.min(new_sar, low[2])
if low <= new_sar
// Reverse to short
is_long := false
new_sar := ep + offset_on_reverse
ep := low
af := af_init_short
else
if high > ep
ep := high
af := math.min(af + af_long, af_max_long)
else
new_sar := math.max(new_sar, high[1])
if bar_index > 1
new_sar := math.max(new_sar, high[2])
if high >= new_sar
// Reverse to long
is_long := true
new_sar := ep - offset_on_reverse
ep := high
af := af_init_long
else
if low < ep
ep := low
af := math.min(af + af_short, af_max_short)
sar := new_sar
is_long ? sar : -sar
// ── Inputs ──
float i_start = input.float(0.0, "Start Value (0=auto)")
float i_offset = input.float(0.0, "Offset on Reverse", minval=0)
float i_af_init_long = input.float(0.02, "AF Init Long", minval=0.001, step=0.001)
float i_af_long = input.float(0.02, "AF Long", minval=0.001, step=0.001)
float i_af_max_long = input.float(0.20, "AF Max Long", minval=0.01, step=0.01)
float i_af_init_short = input.float(0.02, "AF Init Short", minval=0.001, step=0.001)
float i_af_short = input.float(0.02, "AF Short", minval=0.001, step=0.001)
float i_af_max_short = input.float(0.20, "AF Max Short", minval=0.01, step=0.01)
// ── Calculation ──
float result = sarext(i_start, i_offset, i_af_init_long, i_af_long, i_af_max_long,
i_af_init_short, i_af_short, i_af_max_short)
float sar_val = math.abs(nz(result))
bool is_long = nz(result) > 0
float sar_above = not is_long ? sar_val : na
float sar_below = is_long ? sar_val : na
// ── Plot ──
plot(sar_above, "SAREXT Above", color=color.red, style=plot.style_linebr, linewidth=2)
plot(sar_below, "SAREXT Below", color=color.green, style=plot.style_linebr, linewidth=2)
lib/reversals/swings/Swings.md
+2 -2
View File
@@ -4,7 +4,7 @@
| ---------------- | -------------------------------- |
| **Category** | Reversal |
| **Inputs** | OHLCV bar (TBar) |
| **Parameters** | `lookback` (default DefaultLookback) |
| **Parameters** | `lookback` (default 5) |
| **Outputs** | Single series (Swings) |
| **Output range** | Varies (see docs) |
| **Warmup** | 1 bar |
@@ -12,7 +12,7 @@
### TL;DR
- Swing High/Low detection identifies local price extremes using a configurable lookback window.
- Parameterized by `lookback` (default defaultlookback).
- Parameterized by `lookback` (default 5).
- Output range: Varies (see docs).
- Requires 1 bar of warmup before first valid output (IsHot = true).
- Validated against TA-Lib, Skender, and Tulip reference implementations where available.
lib/statistics/acf/acf.pine
+87
View File
@@ -0,0 +1,87 @@
// Licensed under the Apache License, Version 2.0
// © mihakralj
//@version=6
indicator("Autocorrelation Function (ACF)", "ACF", overlay=false)
//@function Calculates autocorrelation at a specified lag using a circular buffer
//@param src series float Input data series
//@param len simple int Lookback period for calculation
//@param lag simple int Lag order for autocorrelation (default 1)
//@returns float Autocorrelation coefficient between -1 and 1
//@optimized for performance using running sums and biased estimator (divide by n)
acf(series float src, simple int len, simple int lag) =>
if len <= 0
runtime.error("Period must be greater than 0")
if lag < 1
runtime.error("Lag must be at least 1")
if len <= lag + 1
runtime.error("Period must be greater than lag + 1")
var int p = math.max(1, len)
var array<float> buffer = array.new_float(p, na)
var int head = 0, var int count = 0
float oldest = array.get(buffer, head)
if not na(oldest)
count -= 1
if not na(src)
array.set(buffer, head, src)
count += 1
else
array.set(buffer, head, na)
head := (head + 1) % p
if count <= lag
na
else
// Calculate mean
float sum = 0.0
int validN = 0
for i = 0 to p - 1
float val = array.get(buffer, i)
if not na(val)
sum += val
validN += 1
if validN <= lag
na
else
float mean = sum / validN
// Calculate variance (population): Σ(x - mean)² / n
float variance = 0.0
for i = 0 to p - 1
float val = array.get(buffer, i)
if not na(val)
float diff = val - mean
variance += diff * diff
variance /= validN
if variance <= 0
0.0
else
// Calculate autocovariance at lag k (biased: divide by n)
// Need to iterate in temporal order through the circular buffer
int startIdx = count < p ? 0 : head
float autocovariance = 0.0
for t = lag to count - 1
int currentIdx = (startIdx + t) % p
int laggedIdx = (startIdx + t - lag) % p
float xt = array.get(buffer, currentIdx)
float xtk = array.get(buffer, laggedIdx)
if not na(xt) and not na(xtk)
autocovariance += (xt - mean) * (xtk - mean)
autocovariance /= validN
// ACF = γ_k / γ_0, clamped to [-1, 1]
float result = autocovariance / variance
math.max(-1.0, math.min(1.0, result))
// ---------- Main loop ----------
// Inputs
i_source = input.source(close, "Source")
i_period = input.int(20, "Period", minval=3)
i_lag = input.int(1, "Lag", minval=1)
// Calculation
acf_value = acf(i_source, i_period, i_lag)
// Plot
plot(acf_value, "ACF", color=color.yellow, linewidth=2)
lib/statistics/pacf/pacf.pine
+132
View File
@@ -0,0 +1,132 @@
// Licensed under the Apache License, Version 2.0
// © mihakralj
//@version=6
indicator("Partial Autocorrelation Function (PACF)", "PACF", overlay=false)
//@function Calculates partial autocorrelation at a specified lag using Durbin-Levinson recursion
//@param src series float Input data series
//@param len simple int Lookback period for calculation
//@param lag simple int Lag order for partial autocorrelation (default 1)
//@returns float Partial autocorrelation coefficient between -1 and 1
//@optimized using Durbin-Levinson recursion to remove shorter-lag effects
pacf(series float src, simple int len, simple int lag) =>
if len <= 0
runtime.error("Period must be greater than 0")
if lag < 1
runtime.error("Lag must be at least 1")
if len <= lag + 1
runtime.error("Period must be greater than lag + 1")
var int p = math.max(1, len)
var array<float> buffer = array.new_float(p, na)
var int head = 0, var int count = 0
float oldest = array.get(buffer, head)
if not na(oldest)
count -= 1
if not na(src)
array.set(buffer, head, src)
count += 1
else
array.set(buffer, head, na)
head := (head + 1) % p
if count <= lag
na
else
// Calculate mean
float sum = 0.0
int validN = 0
for i = 0 to p - 1
float val = array.get(buffer, i)
if not na(val)
sum += val
validN += 1
if validN <= lag
na
else
float mean = sum / validN
// Calculate variance (population): Σ(x - mean)² / n
float variance = 0.0
for i = 0 to p - 1
float val = array.get(buffer, i)
if not na(val)
float diff = val - mean
variance += diff * diff
variance /= validN
if variance <= 0
0.0
else
// Calculate ACF for lags 0 to target lag
int startIdx = count < p ? 0 : head
array<float> acfValues = array.new_float(lag + 1, 0.0)
array.set(acfValues, 0, 1.0)
for k = 1 to lag
float autocovariance = 0.0
for t = k to count - 1
int currentIdx = (startIdx + t) % p
int laggedIdx = (startIdx + t - k) % p
float xt = array.get(buffer, currentIdx)
float xtk = array.get(buffer, laggedIdx)
if not na(xt) and not na(xtk)
autocovariance += (xt - mean) * (xtk - mean)
autocovariance /= validN
array.set(acfValues, k, autocovariance / variance)
// Durbin-Levinson recursion
float pacfResult = na
if lag == 1
// PACF at lag 1 equals ACF at lag 1
pacfResult := array.get(acfValues, 1)
else
array<float> phi = array.new_float(lag + 1, 0.0)
array<float> phiPrev = array.new_float(lag + 1, 0.0)
// Initialize: φ_11 = r_1
array.set(phi, 1, array.get(acfValues, 1))
// Iterate for k = 2 to target lag
for k = 2 to lag
// Copy phi to phiPrev
for j = 0 to lag
array.set(phiPrev, j, array.get(phi, j))
// numerator = r_k - Σ(φ_{k-1,j} * r_{k-j}) for j=1..k-1
float numerator = array.get(acfValues, k)
for j = 1 to k - 1
numerator -= array.get(phiPrev, j) * array.get(acfValues, k - j)
// denominator = 1 - Σ(φ_{k-1,j} * r_j) for j=1..k-1
float denominator = 1.0
for j = 1 to k - 1
denominator -= array.get(phiPrev, j) * array.get(acfValues, j)
if math.abs(denominator) < 1e-15
pacfResult := 0.0
break
// φ_kk = numerator / denominator
array.set(phi, k, numerator / denominator)
// Update: φ_kj = φ_{k-1,j} - φ_kk * φ_{k-1,k-j}
for j = 1 to k - 1
array.set(phi, j, array.get(phiPrev, j) - array.get(phi, k) * array.get(phiPrev, k - j))
if na(pacfResult)
pacfResult := array.get(phi, lag)
// Clamp to [-1, 1]
math.max(-1.0, math.min(1.0, pacfResult))
// ---------- Main loop ----------
// Inputs
i_source = input.source(close, "Source")
i_period = input.int(20, "Period", minval=3)
i_lag = input.int(1, "Lag", minval=1)
// Calculation
pacf_value = pacf(i_source, i_period, i_lag)
// Plot
plot(pacf_value, "PACF", color=color.yellow, linewidth=2)

Some files were not shown because too many files have changed in this diff Show More