mirror of
https://github.com/mihakralj/QuanTAlib.git
synced 2026-07-27 17:27:43 +00:00
Merge branch 'dev'
This commit is contained in:
Miha Kralj
@@ -15,7 +15,7 @@
|
||||
[](docs/ndepend.md)
|
||||
[](docs/ndepend.md)
|
||||
|
||||
# QuanTAlib 0.8.7
|
||||
# QuanTAlib 0.8.8
|
||||
|
||||
393 technical indicators. One library. Brutal architectural trade-offs for absolute speed.
|
||||
|
||||
|
||||
@@ -338,6 +338,7 @@
|
||||
|
||||
* [Statistics](/lib/statistics/_index.md)
|
||||
* [ACF - Autocorrelation Function](/lib/statistics/acf/Acf.md)
|
||||
* [ADF - Augmented Dickey-Fuller Test](/lib/statistics/adf/Adf.md)
|
||||
* [BETA - Beta Coefficient](/lib/statistics/beta/Beta.md)
|
||||
* [CMA - Cumulative MA](/lib/statistics/cma/Cma.md)
|
||||
* [COINTEGRATION - Cointegration](/lib/statistics/cointegration/Cointegration.md)
|
||||
|
||||
@@ -0,0 +1,269 @@
|
||||
# ADF: Augmented Dickey-Fuller Test — Implementation Plan
|
||||
|
||||
> "The most important question in time series analysis isn't what the trend is — it's whether there is one at all."
|
||||
|
||||
## 1. Overview
|
||||
|
||||
The **Augmented Dickey-Fuller (ADF)** test is the gold-standard unit root test for determining whether a time series is stationary. A **p-value** output makes it directly actionable: low p-value (< 0.05) → reject the null hypothesis of a unit root → series is stationary.
|
||||
|
||||
**Location:** `lib/statistics/adf/`
|
||||
|
||||
**Output:** p-value ∈ [0.0, 1.0] per bar (rolling window)
|
||||
|
||||
**Category:** Statistics (alongside [`Hurst`](../lib/statistics/hurst/Hurst.cs), [`Granger`](../lib/statistics/granger/Granger.cs), [`Cointegration`](../lib/statistics/cointegration/Cointegration.cs))
|
||||
|
||||
---
|
||||
|
||||
## 2. Historical Context
|
||||
|
||||
- **Dickey & Fuller (1979)** introduced the basic DF test: does an AR(1) process have a unit root?
|
||||
- **Said & Dickey (1984)** extended it to the **Augmented** DF test by including lagged difference terms to handle serial correlation.
|
||||
- **MacKinnon (1994, 2010)** derived the response surface approximations that allow computation of **p-values** from the non-standard ADF distribution (which is not normal or t-distributed).
|
||||
- The existing [`Cointegration`](../lib/statistics/cointegration/Cointegration.cs:31) indicator already uses a simplified ADF internally (no-intercept, no augmented lags) for the Engle-Granger two-step test. The new `Adf` indicator will be a **standalone, full-featured** single-input ADF test.
|
||||
|
||||
---
|
||||
|
||||
## 3. Mathematical Foundation
|
||||
|
||||
### 3.1 The ADF Regression
|
||||
|
||||
$$\Delta y_t = \alpha + \beta t + \gamma \, y_{t-1} + \sum_{i=1}^{p} \delta_i \, \Delta y_{t-i} + \varepsilon_t$$
|
||||
|
||||
Where:
|
||||
- $\Delta y_t = y_t - y_{t-1}$ (first difference)
|
||||
- $\alpha$ = constant/drift term (included in "c" and "ct" modes)
|
||||
- $\beta t$ = linear trend term (included in "ct" mode only)
|
||||
- $\gamma$ = **coefficient of interest** — if $\gamma = 0$, unit root exists
|
||||
- $\delta_i$ = coefficients on lagged differences (augmented terms to absorb serial correlation)
|
||||
- $p$ = number of augmented lags
|
||||
- $\varepsilon_t$ = white noise error
|
||||
|
||||
### 3.2 Regression Types
|
||||
|
||||
| Mode | Model | Regressors (k) | Use Case |
|
||||
|------|-------|----------------|----------|
|
||||
| `NoConstant` ("nc") | $\Delta y_t = \gamma y_{t-1} + \ldots$ | $1 + p$ | Pure random walk test |
|
||||
| `Constant` ("c") | $\Delta y_t = \alpha + \gamma y_{t-1} + \ldots$ | $2 + p$ | **Default** — random walk with drift |
|
||||
| `ConstantAndTrend` ("ct") | $\Delta y_t = \alpha + \beta t + \gamma y_{t-1} + \ldots$ | $3 + p$ | Trend-stationary alternative |
|
||||
|
||||
### 3.3 Test Statistic
|
||||
|
||||
$$\text{ADF}_t = \frac{\hat{\gamma}}{\text{SE}(\hat{\gamma})}$$
|
||||
|
||||
Where $\hat{\gamma}$ and $\text{SE}(\hat{\gamma})$ are obtained from OLS regression:
|
||||
- $\hat{\boldsymbol{\beta}} = (\mathbf{X}'\mathbf{X})^{-1} \mathbf{X}'\mathbf{y}$
|
||||
- $\hat{\sigma}^2 = \frac{\text{RSS}}{m - k}$ where $m$ = number of observations, $k$ = number of regressors
|
||||
- $\text{SE}(\hat{\gamma}) = \sqrt{\hat{\sigma}^2 \cdot [(\mathbf{X}'\mathbf{X})^{-1}]_{jj}}$ where $j$ is the column index of $y_{t-1}$
|
||||
|
||||
### 3.4 P-Value (MacKinnon 1994)
|
||||
|
||||
The ADF test statistic does **not** follow a standard distribution. MacKinnon (1994) provides polynomial approximations:
|
||||
|
||||
1. **Bounds check:**
|
||||
- If $\text{ADF}_t > \tau_{\max}$ → $p = 1.0$
|
||||
- If $\text{ADF}_t < \tau_{\min}$ → $p = 0.0$
|
||||
|
||||
2. **Polynomial evaluation:**
|
||||
- If $\text{ADF}_t \leq \tau^*$ (left tail): use `smallp` coefficients (3 terms)
|
||||
- If $\text{ADF}_t > \tau^*$ (right tail): use `largep` coefficients (4 terms)
|
||||
|
||||
3. **P-value:**
|
||||
$$p = \Phi\left(\sum_{i=0}^{n} c_i \cdot \text{ADF}_t^i\right)$$
|
||||
|
||||
Where $\Phi$ is the standard normal CDF, implemented as:
|
||||
$$\Phi(x) = \frac{1}{2} \operatorname{erfc}\!\left(-\frac{x}{\sqrt{2}}\right)$$
|
||||
|
||||
### 3.5 Critical Values (MacKinnon 2010)
|
||||
|
||||
$$\text{CV}_\alpha(n) = c_0 + \frac{c_1}{n} + \frac{c_2}{n^2} + \frac{c_3}{n^3}$$
|
||||
|
||||
| Regression | Level | $c_0$ | $c_1$ | $c_2$ | $c_3$ |
|
||||
|-----------|-------|--------|--------|--------|--------|
|
||||
| Constant | 1% | -3.43035 | -6.5393 | -16.786 | -79.433 |
|
||||
| Constant | 5% | -2.86154 | -2.8903 | -4.234 | -40.040 |
|
||||
| Constant | 10% | -2.56677 | -1.5384 | -2.809 | 0 |
|
||||
|
||||
**Wolfram-validated:** At $n = 100$: $\text{CV}_{1\%} = -3.43035 + \frac{-6.5393}{100} + \frac{-16.786}{10000} + \frac{-79.433}{1000000} = -3.4975$ ✓
|
||||
|
||||
### 3.6 Automatic Lag Selection
|
||||
|
||||
Default maximum lag: $p_{\max} = \lfloor 12 \cdot (n/100)^{1/4} \rfloor$
|
||||
|
||||
Selection via AIC (Akaike Information Criterion):
|
||||
$$\text{AIC} = n \ln\!\left(\frac{\text{RSS}}{n}\right) + 2k$$
|
||||
|
||||
Iterate from $p = p_{\max}$ down to $p = 0$, select the lag that minimizes AIC.
|
||||
|
||||
---
|
||||
|
||||
## 4. Architecture & Design
|
||||
|
||||
### 4.1 Class Hierarchy
|
||||
|
||||
```
|
||||
AbstractBase (lib/core/AbstractBase.cs)
|
||||
└── Adf (lib/statistics/adf/Adf.cs)
|
||||
```
|
||||
|
||||
### 4.2 Enum
|
||||
|
||||
```csharp
|
||||
public enum AdfRegression : byte
|
||||
{
|
||||
NoConstant = 0, // "nc" — no deterministic terms
|
||||
Constant = 1, // "c" — intercept only (DEFAULT)
|
||||
ConstantAndTrend = 2 // "ct" — intercept + linear trend
|
||||
}
|
||||
```
|
||||
|
||||
### 4.3 Constructor
|
||||
|
||||
```csharp
|
||||
public Adf(int period = 50, int maxLag = 0, AdfRegression regression = AdfRegression.Constant)
|
||||
```
|
||||
|
||||
- `period` ≥ 20 (rolling window of raw prices)
|
||||
- `maxLag` = 0 → auto via $\lfloor 12(n/100)^{1/4} \rfloor$; otherwise explicit lag count
|
||||
- `regression` = model specification
|
||||
|
||||
### 4.4 State Management
|
||||
|
||||
| Field | Type | Purpose |
|
||||
|-------|------|---------|
|
||||
| `_buffer` | `RingBuffer` | Rolling window of `period` raw values |
|
||||
| `_lastValidValue` | `double` | NaN substitution |
|
||||
| `_p_lastValidValue` | `double` | Bar correction state |
|
||||
|
||||
Unlike running-sum indicators, ADF requires **full window recomputation** each update (similar to [`Hurst`](../lib/statistics/hurst/Hurst.cs:23)). No incremental O(1) shortcut is possible due to the matrix regression.
|
||||
|
||||
### 4.5 Internal Components
|
||||
|
||||
| Component | Method | Purpose |
|
||||
|-----------|--------|---------|
|
||||
| **OLS Solver** | `SolveCholesky()` | Cholesky decomposition of X'X, stackalloc for k ≤ 8 |
|
||||
| **MacKinnon P-Value** | `MacKinnonP()` | Polynomial + `NormCdf()` |
|
||||
| **Normal CDF** | `NormCdf()` | `0.5 * Math.Erfc(-x * InvSqrt2)` |
|
||||
| **Polynomial Eval** | `PolyVal()` | Horner's method |
|
||||
| **Lag Selection** | `SelectLag()` | AIC minimization |
|
||||
| **ADF Core** | `ComputeAdf()` | Builds design matrix, runs OLS, returns (stat, pValue) |
|
||||
|
||||
---
|
||||
|
||||
## 5. Performance Profile
|
||||
|
||||
### 5.1 Operation Count — Single Value
|
||||
|
||||
| Operation | Count | Notes |
|
||||
|-----------|-------|-------|
|
||||
| Differences (SUB) | $n - 1$ | Δy computation |
|
||||
| Matrix fill (MUL/ADD) | $m \times k$ | Design matrix X |
|
||||
| X'X (MUL/ADD) | $m \times k^2$ | Gram matrix |
|
||||
| Cholesky (MUL/ADD/SQRT) | $k^3 / 6$ | Decomposition |
|
||||
| Forward/Back substitution | $k^2$ | Solve |
|
||||
| RSS (MUL/ADD) | $m \times k$ | Residuals |
|
||||
| erfc | 1 | P-value |
|
||||
|
||||
**Total:** $O(n \times k)$ where $n$ = period, $k$ = 2-8 regressors
|
||||
|
||||
### 5.2 Memory
|
||||
|
||||
- Stack: `stackalloc double[k*k + k*3 + n]` ≈ 1-2 KB for typical parameters
|
||||
- Heap: `RingBuffer(period)` — one allocation at construction
|
||||
|
||||
---
|
||||
|
||||
## 6. File Deliverables
|
||||
|
||||
```
|
||||
lib/statistics/adf/
|
||||
├── Adf.cs # Main implementation
|
||||
├── Adf.md # Indicator documentation
|
||||
├── adf.pine # PineScript v6 reference
|
||||
├── tests/
|
||||
│ ├── Adf.Tests.cs # Unit tests (gold standard pattern)
|
||||
│ └── Adf.Validation.Tests.cs # Cross-validation vs statsmodels
|
||||
```
|
||||
|
||||
```
|
||||
quantower/statistics/adf/
|
||||
├── Adf.Quantower.cs # Quantower adapter
|
||||
├── tests/
|
||||
│ └── Adf.Quantower.Tests.cs # Adapter tests
|
||||
```
|
||||
|
||||
### 6.1 Method Ordering (Gold Standard)
|
||||
|
||||
1. **Constructors** — `Adf(period, maxLag, regression)`, event-source, series
|
||||
2. **Streaming** — `Update(TValue, bool)`, `Update(TSeries)`
|
||||
3. **Static Batch** — `Batch(TSeries, ...)`, `Batch(ReadOnlySpan, Span, ...)`
|
||||
4. **Calculate Bridge** — `Calculate(TSeries, ...)` → `(TSeries, Adf)`
|
||||
5. **Lifecycle** — `Reset()`, `Dispose(bool)`
|
||||
|
||||
---
|
||||
|
||||
## 7. Validation Strategy
|
||||
|
||||
### 7.1 Python Reference
|
||||
|
||||
```python
|
||||
from statsmodels.tsa.stattools import adfuller
|
||||
import numpy as np
|
||||
|
||||
# Stationary series (white noise)
|
||||
np.random.seed(42)
|
||||
series = np.random.randn(100)
|
||||
result = adfuller(series, maxlag=1, regression='c')
|
||||
# Expected: p-value ≈ 0.0 (very small)
|
||||
|
||||
# Non-stationary series (random walk)
|
||||
rw = np.cumsum(np.random.randn(100))
|
||||
result = adfuller(rw, maxlag=1, regression='c')
|
||||
# Expected: p-value ≈ 0.5-1.0
|
||||
```
|
||||
|
||||
### 7.2 Test Cases
|
||||
|
||||
| Test | Input | Expected |
|
||||
|------|-------|----------|
|
||||
| White noise | `randn(100)` seed=42 | p-value < 0.05 |
|
||||
| Random walk | `cumsum(randn(100))` | p-value > 0.05 |
|
||||
| Known ADF stat | stat=-3.5, regression="c" | p = `Φ(poly(coefs, -3.5))` |
|
||||
| Edge: period=20 | Minimum valid period | Works without error |
|
||||
| Edge: NaN input | Series with NaN | Uses last valid value |
|
||||
| Edge: constant series | All same value | p-value = NaN or 1.0 |
|
||||
|
||||
### 7.3 Cross-validation Tolerance
|
||||
|
||||
- Against statsmodels: $\epsilon < 10^{-6}$ for p-value
|
||||
- Against MacKinnon critical values: $\epsilon < 10^{-4}$
|
||||
|
||||
---
|
||||
|
||||
## 8. Risk Assessment
|
||||
|
||||
| Risk | Severity | Mitigation |
|
||||
|------|----------|------------|
|
||||
| Breaking changes | ✅ None | New indicator, no existing API modified |
|
||||
| Ill-conditioned X'X | Medium | Cholesky with diagonal check; return NaN if rank-deficient |
|
||||
| Numerical drift | Low | Full recomputation each bar (no running sums to drift) |
|
||||
| Performance | Low | O(n×k) acceptable for statistical test; not a hot-path indicator |
|
||||
| Python parity | Medium | Comprehensive validation tests against statsmodels |
|
||||
|
||||
---
|
||||
|
||||
## 9. Future Considerations
|
||||
|
||||
- **KPSS test** — complementary stationarity test (opposite null hypothesis)
|
||||
- **Cointegration refactoring** — could internally delegate ADF computation to `Adf` class
|
||||
- **Phillips-Perron test** — non-parametric alternative to ADF
|
||||
- **Zivot-Andrews test** — structural break unit root test
|
||||
|
||||
---
|
||||
|
||||
## 10. References
|
||||
|
||||
1. Dickey, D.A. & Fuller, W.A. (1979). "Distribution of the Estimators for Autoregressive Time Series with a Unit Root." *JASA*, 74(366), 427-431.
|
||||
2. Said, S.E. & Dickey, D.A. (1984). "Testing for Unit Roots in ARMA Models of Unknown Order." *Biometrika*, 71(3), 599-607.
|
||||
3. MacKinnon, J.G. (1994). "Approximate Asymptotic Distribution Functions for Unit-Root and Cointegration Tests." *JBES*, 12(2), 167-176.
|
||||
4. MacKinnon, J.G. (2010). "Critical Values for Cointegration Tests." Queen's Economics Working Paper No. 1227.
|
||||
5. Hamilton, J.D. (1994). *Time Series Analysis*. Princeton University Press.
|
||||
@@ -377,6 +377,7 @@ Mathematical and statistical computations on price series.
|
||||
| Indicator | Full Name | Notes |
|
||||
| :-------- | :-------- | :---- |
|
||||
| [**ACF**](../lib/statistics/acf/Acf.md) | Autocorrelation Function | Lagged self-correlation |
|
||||
| [**ADF**](../lib/statistics/adf/Adf.md) | Augmented Dickey-Fuller Test | Unit root stationarity test; MacKinnon p-value [0,1] |
|
||||
| [**BETA**](../lib/statistics/beta/Beta.md) | Beta Coefficient | Systematic risk measure |
|
||||
| [**CMA**](../lib/statistics/cma/Cma.md) | Cumulative Moving Average | Expanding window average |
|
||||
| [**COINTEGRATION**](../lib/statistics/cointegration/Cointegration.md) | Cointegration | Engle-Granger two-step with ADF test |
|
||||
|
||||
+1
-1
@@ -1 +1 @@
|
||||
0.8.7
|
||||
0.8.8
|
||||
@@ -7,6 +7,7 @@
|
||||
| [ACCBANDS](channels/accbands/Accbands.md) | Acceleration Bands | Channels |
|
||||
| [ACCEL](numerics/accel/Accel.md) | Acceleration | Numerics |
|
||||
| [ACF](statistics/acf/Acf.md) | Autocorrelation Function | Statistics |
|
||||
| [ADF](statistics/adf/Adf.md) | Augmented Dickey-Fuller Test | Statistics |
|
||||
| [ADL](volume/adl/Adl.md) | Accumulation/Distribution Line | Volume |
|
||||
| [ADOSC](volume/adosc/Adosc.md) | Chaikin A/D Oscillator | Volume |
|
||||
| [ADR](volatility/adr/Adr.md) | Average Daily Range | Volatility |
|
||||
|
||||
@@ -4,6 +4,7 @@ Statistical tools applied to price and returns. These indicators quantify relati
|
||||
|
||||
| Indicator | Full Name | Description |
|
||||
| :--- | :--- | :--- |
|
||||
| [ADF](adf/Adf.md) | Augmented Dickey-Fuller Test | Unit root test for stationarity. MacKinnon p-value output [0,1]. |
|
||||
| [ACF](acf/Acf.md) | Autocorrelation Function | Correlation of time series with lagged copy. For ARMA model identification. |
|
||||
| [BETA](beta/Beta.md) | Beta Coefficient | Asset volatility relative to market. β=1 means market-matched risk. |
|
||||
| [CMA](cma/Cma.md) | Cumulative Moving Average | Running average of all values. Welford's algorithm. No window. |
|
||||
|
||||
@@ -0,0 +1,82 @@
|
||||
using System.Drawing;
|
||||
using System.Runtime.CompilerServices;
|
||||
using TradingPlatform.BusinessLayer;
|
||||
|
||||
namespace QuanTAlib;
|
||||
|
||||
/// <summary>
|
||||
/// ADF Quantower indicator.
|
||||
/// Augmented Dickey-Fuller unit root test — outputs p-value for stationarity detection.
|
||||
/// </summary>
|
||||
[SkipLocalsInit]
|
||||
public sealed class AdfIndicator : Indicator, IWatchlistIndicator
|
||||
{
|
||||
[InputParameter("Period", sortIndex: 1, 20, 500, 1, 0)]
|
||||
public int Period { get; set; } = 50;
|
||||
|
||||
[InputParameter("Max Lag (0=auto)", sortIndex: 2, 0, 10, 1, 0)]
|
||||
public int MaxLag { get; set; } = 0;
|
||||
|
||||
[InputParameter("Regression Model", sortIndex: 3, variants: new object[] {
|
||||
"No Constant", 0, "Constant", 1, "Constant + Trend", 2 })]
|
||||
public int RegressionModel { get; set; } = 1;
|
||||
|
||||
[IndicatorExtensions.DataSourceInput]
|
||||
public SourceType Source { get; set; } = SourceType.Close;
|
||||
|
||||
[InputParameter("Show cold values", sortIndex: 21)]
|
||||
public bool ShowColdValues { get; set; } = true;
|
||||
|
||||
private Adf _indicator = null!;
|
||||
private readonly LineSeries _pValueSeries;
|
||||
private string _sourceName = null!;
|
||||
private Func<IHistoryItem, double> _priceSelector = null!;
|
||||
|
||||
public int MinHistoryDepths => Period;
|
||||
int IWatchlistIndicator.MinHistoryDepths => MinHistoryDepths;
|
||||
|
||||
public override string ShortName
|
||||
{
|
||||
get
|
||||
{
|
||||
string regStr = RegressionModel switch { 0 => "nc", 1 => "c", 2 => "ct", _ => "c" };
|
||||
return $"ADF({Period},{MaxLag},{regStr}):{_sourceName}";
|
||||
}
|
||||
}
|
||||
|
||||
public override string SourceCodeLink =>
|
||||
"https://github.com/mihakralj/QuanTAlib/blob/main/lib/statistics/adf/Adf.Quantower.cs";
|
||||
|
||||
public AdfIndicator()
|
||||
{
|
||||
OnBackGround = true;
|
||||
SeparateWindow = true;
|
||||
_sourceName = Source.ToString();
|
||||
Name = "ADF - Augmented Dickey-Fuller Test";
|
||||
Description = "Tests for unit root (non-stationarity). P-value near 0 indicates stationarity.";
|
||||
|
||||
_pValueSeries = new LineSeries(name: "P-Value", color: IndicatorExtensions.Statistics,
|
||||
width: 2, style: LineStyle.Solid);
|
||||
AddLineSeries(_pValueSeries);
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
protected override void OnInit()
|
||||
{
|
||||
_indicator = new Adf(Period, MaxLag, (Adf.AdfRegression)RegressionModel);
|
||||
_sourceName = Source.ToString();
|
||||
_priceSelector = Source.GetPriceSelector();
|
||||
base.OnInit();
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
protected override void OnUpdate(UpdateArgs args)
|
||||
{
|
||||
var item = HistoricalData[Count - 1, SeekOriginHistory.Begin];
|
||||
TValue result = _indicator.Update(
|
||||
new TValue(item.TimeLeft.Ticks, _priceSelector(item)),
|
||||
isNew: args.IsNewBar());
|
||||
|
||||
_pValueSeries.SetValue(result.Value, _indicator.IsHot, ShowColdValues);
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,219 @@
|
||||
# ADF: Augmented Dickey-Fuller Test
|
||||
|
||||
> *"A time series that looks like it has a trend might just be a random walk wearing a disguise."*
|
||||
|
||||
| Property | Value |
|
||||
| ---------------- | ---------------------------------------------- |
|
||||
| **Category** | Statistics |
|
||||
| **Inputs** | Source (close) |
|
||||
| **Parameters** | `period` (default 50), `maxLag` (default 0=auto), `regression` (default Constant) |
|
||||
| **Outputs** | Single series (p-value) |
|
||||
| **Output range** | $[0, 1]$ |
|
||||
| **Warmup** | `period` bars |
|
||||
| **PineScript** | [adf.pine](adf.pine) |
|
||||
|
||||
- Tests the null hypothesis that a time series contains a unit root (non-stationary). Output near **0** → stationary; output near **1** → unit root.
|
||||
- **Similar:** [Hurst](../hurst/Hurst.md), [Cointegration](../cointegration/Cointegration.md) | **Complementary:** Z-Score, Variance | **Trading note:** ADF < 0.05 confirms mean-reversion suitability.
|
||||
- Validated against Python `statsmodels.tsa.stattools.adfuller` reference implementation.
|
||||
|
||||
The Augmented Dickey-Fuller test is the gold standard for detecting whether a financial time series is stationary or contains a unit root. Unlike the original Dickey-Fuller test, the augmented version includes lagged difference terms $\Delta y_{t-i}$ to absorb serial correlation, ensuring the test statistic follows the correct distribution. The p-value output uses MacKinnon (1994, 2010) polynomial interpolation with a standard normal CDF approximation, providing machine-precision results without lookup tables.
|
||||
|
||||
## Historical Context
|
||||
|
||||
David Dickey and Wayne Fuller introduced the original unit root test in 1979, establishing the foundation for modern time series econometrics. Said and Dickey (1984) proposed the augmented version that includes lagged differences to handle serial correlation in the residuals. James MacKinnon (1994, 2010) developed the response surface regression approach that maps the test statistic to an approximate p-value, replacing the need for Monte Carlo simulation tables. The ADF test remains the most widely used stationarity test in quantitative finance, underpinning pairs trading, cointegration analysis, and regime detection.
|
||||
|
||||
## Architecture & Physics
|
||||
|
||||
### 1. First Differences
|
||||
|
||||
$$
|
||||
\Delta y_t = y_t - y_{t-1}, \quad t = 1, \ldots, n-1
|
||||
$$
|
||||
|
||||
### 2. Augmented Regression Model
|
||||
|
||||
$$
|
||||
\Delta y_t = \alpha + \beta t + \gamma y_{t-1} + \sum_{i=1}^{p} \delta_i \Delta y_{t-i} + \varepsilon_t
|
||||
$$
|
||||
|
||||
where $\alpha$ is the intercept (constant model), $\beta t$ is the linear trend (trend model), $\gamma$ is the coefficient of interest on the lagged level, and $\delta_i$ are coefficients on lagged differences that absorb serial correlation.
|
||||
|
||||
### 3. OLS Estimation via Cholesky
|
||||
|
||||
The normal equations $X'X \hat{\beta} = X'y$ are solved via Cholesky decomposition $X'X = LL'$ with forward-backward substitution. For $k \leq 8$ regressors, all matrices fit in `stackalloc` — zero heap allocation.
|
||||
|
||||
### 4. Test Statistic
|
||||
|
||||
$$
|
||||
t = \frac{\hat{\gamma}}{\text{SE}(\hat{\gamma})} \quad \text{where} \quad \text{SE}(\hat{\gamma}) = \sqrt{s^2 \cdot (X'X)^{-1}_{\gamma\gamma}}
|
||||
$$
|
||||
|
||||
and $s^2 = \text{RSS} / (n - k)$ is the residual variance estimate.
|
||||
|
||||
### 5. Auto-Lag Selection (AIC)
|
||||
|
||||
When `maxLag = 0`, the optimal lag is selected by minimizing:
|
||||
|
||||
$$
|
||||
\text{AIC} = n \cdot \ln(\text{RSS}/n) + 2k
|
||||
$$
|
||||
|
||||
over lags $p = 0, 1, \ldots, p_{\max}$ where the Schwert (1989) upper bound is:
|
||||
|
||||
$$
|
||||
p_{\max} = \left\lfloor 12 \cdot \left(\frac{T}{100}\right)^{0.25} \right\rfloor
|
||||
$$
|
||||
|
||||
| Sample Size $T$ | $(T/100)^{0.25}$ | $p_{\max}$ |
|
||||
|:-:|:-:|:-:|
|
||||
| 50 | 0.84 | 10 |
|
||||
| 100 | 1.00 | 12 |
|
||||
| 250 | 1.26 | 15 |
|
||||
| 500 | 1.50 | 17 |
|
||||
|
||||
### 6. MacKinnon P-Value
|
||||
|
||||
The test statistic is mapped to a p-value via MacKinnon (1994, 2010) response surface polynomial interpolation:
|
||||
|
||||
- **Small-p region** ($\tau \leq \tau^*$): $Z = c_0 + c_1 \tau + c_2 \tau^2$
|
||||
- **Large-p region** ($\tau > \tau^*$): $Z = c_0 + c_1 \tau + c_2 \tau^2 + c_3 \tau^3$
|
||||
|
||||
The polynomial Z-score is then passed through the standard normal CDF: $p = \Phi(Z)$.
|
||||
|
||||
#### Small-P Coefficients ($\tau \leq \tau^*$)
|
||||
|
||||
| Regression | $c_0$ | $c_1$ | $c_2$ |
|
||||
|:-:|:-:|:-:|:-:|
|
||||
| nc | 0.6344 | 1.2378 | 0.032496 |
|
||||
| c | 2.1659 | 1.4412 | 0.038269 |
|
||||
| ct | 3.2512 | 1.6047 | 0.049588 |
|
||||
|
||||
#### Large-P Coefficients ($\tau > \tau^*$)
|
||||
|
||||
| Regression | $c_0$ | $c_1$ | $c_2$ | $c_3$ |
|
||||
|:-:|:-:|:-:|:-:|:-:|
|
||||
| nc | 0.4797 | 0.93557 | −0.06999 | 0.033066 |
|
||||
| c | 1.7339 | 0.93202 | −0.12745 | −0.010368 |
|
||||
| ct | 2.5261 | 0.61654 | −0.37956 | −0.060285 |
|
||||
|
||||
### 7. Standard Normal CDF via Error Function
|
||||
|
||||
The standard normal CDF $\Phi(x)$ is computed via the Abramowitz & Stegun (1964) rational approximation of the Gaussian error function (equation 7.1.26):
|
||||
|
||||
$$
|
||||
\Phi(x) = \frac{1}{2}\left[1 + \text{sgn}(x) \cdot \text{erf}\!\left(\frac{|x|}{\sqrt{2}}\right)\right]
|
||||
$$
|
||||
|
||||
where $\text{erf}(z) = 1 - (a_1 t + a_2 t^2 + a_3 t^3 + a_4 t^4 + a_5 t^5) e^{-z^2}$ with $t = \frac{1}{1 + pz}$.
|
||||
|
||||
| Parameter | Value |
|
||||
|:-:|:-:|
|
||||
| $p$ | 0.3275911 |
|
||||
| $a_1$ | 0.254829592 |
|
||||
| $a_2$ | −0.284496736 |
|
||||
| $a_3$ | 1.421413741 |
|
||||
| $a_4$ | −1.453152027 |
|
||||
| $a_5$ | 1.061405429 |
|
||||
|
||||
Maximum relative error: $\pm 1.5 \times 10^{-7}$, providing at least 6 decimal places of p-value accuracy.
|
||||
|
||||
### 8. Complexity
|
||||
|
||||
| Aspect | Cost |
|
||||
|--------|------|
|
||||
| Streaming (per bar) | $O(n \cdot p^2)$ where $n$ = period, $p$ = lags |
|
||||
| OLS solve | $O(k^3)$ with $k \leq 8$ |
|
||||
| Memory | $O(n)$ via RingBuffer |
|
||||
|
||||
## Mathematical Foundation
|
||||
|
||||
### Parameters
|
||||
|
||||
| Parameter | Symbol | Default | Constraint |
|
||||
|-------------|--------|----------|----------------------|
|
||||
| `period` | $n$ | 50 | $n \geq 20$ |
|
||||
| `maxLag` | $p$ | 0 (auto) | $p \geq 0$ |
|
||||
| `regression`| — | Constant | {NoConstant, Constant, ConstantAndTrend} |
|
||||
|
||||
### Regression Models
|
||||
|
||||
| Model | Equation | Use Case |
|
||||
|-----------------|----------|----------|
|
||||
| NoConstant (nc) | $\Delta y_t = \gamma y_{t-1} + \ldots$ | Known zero-mean process |
|
||||
| Constant (c) | $\Delta y_t = \alpha + \gamma y_{t-1} + \ldots$ | General stationarity test |
|
||||
| ConstantAndTrend (ct) | $\Delta y_t = \alpha + \beta t + \gamma y_{t-1} + \ldots$ | Trend-stationary test |
|
||||
|
||||
### MacKinnon Coefficients (N=1)
|
||||
|
||||
| Regression | $\tau^*$ | $\tau_{\min}$ | $\tau_{\max}$ |
|
||||
|------------|---------|--------------|--------------|
|
||||
| nc | -1.04 | -19.04 | $+\infty$ |
|
||||
| c | -1.61 | -18.83 | 2.74 |
|
||||
| ct | -2.89 | -16.18 | 0.70 |
|
||||
|
||||
### Output Interpretation
|
||||
|
||||
| P-Value | Interpretation |
|
||||
|---------|---------------|
|
||||
| < 0.01 | Strong evidence of stationarity — reject unit root at 1% |
|
||||
| < 0.05 | Evidence of stationarity — reject unit root at 5% |
|
||||
| < 0.10 | Weak evidence of stationarity — reject at 10% |
|
||||
| ≥ 0.10 | Cannot reject unit root — series may be non-stationary |
|
||||
|
||||
## Performance Profile
|
||||
|
||||
### Operation Count (Streaming Mode)
|
||||
|
||||
| Operation | Count | Cost (cycles) | Subtotal |
|
||||
|-----------|------:|:-------------:|:--------:|
|
||||
| SUB (differences) | $n$ | 1 | $n$ |
|
||||
| MUL (X'X accum) | $n \cdot k^2$ | 3 | $3nk^2$ |
|
||||
| SQRT (Cholesky) | $k$ | 20 | $20k$ |
|
||||
| DIV (triangular solve) | $k^2$ | 15 | $15k^2$ |
|
||||
| LN (AIC) | $p_{\max}$ | 50 | $50p_{\max}$ |
|
||||
| EXP (NormCdf) | 1 | 50 | 50 |
|
||||
| **Total** | — | — | **~$3nk^2 + 50$** |
|
||||
|
||||
### SIMD Analysis (Batch Mode)
|
||||
|
||||
| Operation | Vectorizable? | Notes |
|
||||
|-----------|:------------:|-------|
|
||||
| First differences | ✅ | Subtraction loop |
|
||||
| X'X accumulation | Partial | Inner products vectorizable |
|
||||
| Cholesky solve | ❌ | Sequential dependency |
|
||||
| MacKinnon poly | ❌ | Scalar, 1 call per bar |
|
||||
| NormCdf | ❌ | Scalar, 1 call per bar |
|
||||
|
||||
## Validation
|
||||
|
||||
| Library | Status | Notes |
|
||||
|---------|:------:|-------|
|
||||
| **statsmodels** | ✅ | `adfuller()` — primary reference |
|
||||
| **TA-Lib** | N/A | Not available |
|
||||
| **Skender** | N/A | Not available |
|
||||
| **Self-consistency** | ✅ | Batch/streaming/span match |
|
||||
|
||||
## Common Pitfalls
|
||||
|
||||
1. **Warmup period**: Requires at least 20 bars. Results before warmup return p=1.0 (assume unit root).
|
||||
2. **Lag selection**: Auto-lag (maxLag=0) uses AIC which may overfit on short windows. For periods < 50, consider fixing maxLag=1.
|
||||
3. **Regression model**: Using `ConstantAndTrend` when no trend exists reduces power (higher p-values). Default `Constant` is correct for most financial series.
|
||||
4. **Non-standard distribution**: The test statistic does NOT follow a t-distribution — MacKinnon critical values are mandatory.
|
||||
5. **Window size**: Period < 30 gives unreliable results. Period ≥ 50 recommended for financial data.
|
||||
6. **Multiple testing**: Running ADF on many series without Bonferroni correction inflates false positives.
|
||||
7. **Structural breaks**: ADF has low power against alternatives with structural breaks. Consider using Zivot-Andrews test instead.
|
||||
|
||||
## Related Indicators
|
||||
|
||||
- [**Hurst**](../hurst/Hurst.md): Measures long-range dependence. H < 0.5 and ADF p < 0.05 together strongly confirm mean-reversion.
|
||||
- [**Cointegration**](../cointegration/Cointegration.md): Uses a simplified ADF internally on OLS residuals for the Engle-Granger two-step test.
|
||||
- [**Variance**](../variance/Variance.md): High variance ratio rejection and low ADF p-value confirm stationarity.
|
||||
|
||||
## References
|
||||
|
||||
- Dickey, D.A. and Fuller, W.A. (1979). "Distribution of the Estimators for Autoregressive Time Series with a Unit Root." *Journal of the American Statistical Association*, 74(366), 427-431.
|
||||
- Said, S.E. and Dickey, D.A. (1984). "Testing for Unit Roots in Autoregressive-Moving Average Models of Unknown Order." *Biometrika*, 71(3), 599-607.
|
||||
- Schwert, G.W. (1989). "Tests for Unit Roots: A Monte Carlo Investigation." *Journal of Business & Economic Statistics*, 7(2), 147-159.
|
||||
- MacKinnon, J.G. (1994). "Approximate Asymptotic Distribution Functions for Unit-Root and Cointegration Tests." *Journal of Business & Economic Statistics*, 12(2), 167-176.
|
||||
- MacKinnon, J.G. (2010). "Critical Values for Cointegration Tests." Working Paper 1227, Queen's University Department of Economics.
|
||||
- Abramowitz, M. and Stegun, I.A. (1964). *Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables*. National Bureau of Standards Applied Mathematics Series 55, §7.1.26.
|
||||
@@ -0,0 +1,129 @@
|
||||
// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0
|
||||
// https://mozilla.org/MPL/2.0/
|
||||
// © QuanTAlib
|
||||
|
||||
//@version=6
|
||||
indicator("ADF - Augmented Dickey-Fuller Test", shorttitle="ADF", overlay=false, precision=4)
|
||||
|
||||
// ─── Inputs ────────────────────────────────────────────────────────────
|
||||
int period = input.int(50, "Period", minval=20, maxval=500)
|
||||
int maxLag = input.int(0, "Max Lag (0=auto)", minval=0, maxval=10)
|
||||
string regModel = input.string("Constant", "Regression", options=["NoConstant", "Constant", "ConstantAndTrend"])
|
||||
|
||||
// ─── Helper: OLS solve 2×2 (constant + gamma, no lags for simplicity) ──
|
||||
// Full ADF with Cholesky is too complex for Pine; this is a reference only.
|
||||
// For production use, the C# implementation is authoritative.
|
||||
|
||||
adf_pvalue(float[] data, int p, int mLag, string reg) =>
|
||||
int n = array.size(data)
|
||||
if n < 20
|
||||
1.0
|
||||
else
|
||||
// Compute first differences
|
||||
int nd = n - 1
|
||||
float[] dy = array.new_float(nd, 0.0)
|
||||
for i = 0 to nd - 1
|
||||
array.set(dy, i, array.get(data, i + 1) - array.get(data, i))
|
||||
|
||||
// Simple ADF: regress dy on y_{t-1} (constant model, no lags)
|
||||
// X = [1, y_{t-1}], Y = dy_t
|
||||
float sx = 0.0, sy = 0.0, sxx = 0.0, sxy = 0.0, syy = 0.0
|
||||
int startIdx = math.max(mLag, 0)
|
||||
int nObs = nd - startIdx
|
||||
if nObs < 3
|
||||
1.0
|
||||
else
|
||||
for t = startIdx to nd - 1
|
||||
float x = array.get(data, t) // y_{t-1} in level
|
||||
float y = array.get(dy, t)
|
||||
sx += x
|
||||
sy += y
|
||||
sxx += x * x
|
||||
sxy += x * y
|
||||
syy += y * y
|
||||
|
||||
// OLS for constant model: [alpha, gamma]
|
||||
float xbar = sx / nObs
|
||||
float ybar = sy / nObs
|
||||
float denom = sxx - sx * sx / nObs
|
||||
if math.abs(denom) < 1e-15
|
||||
1.0
|
||||
else
|
||||
float gamma = (sxy - sx * sy / nObs) / denom
|
||||
float alpha = ybar - gamma * xbar
|
||||
|
||||
// RSS
|
||||
float rss = 0.0
|
||||
for t = startIdx to nd - 1
|
||||
float x = array.get(data, t)
|
||||
float y = array.get(dy, t)
|
||||
float resid = y - alpha - gamma * x
|
||||
rss += resid * resid
|
||||
|
||||
float s2 = rss / (nObs - 2)
|
||||
if s2 <= 0
|
||||
1.0
|
||||
else
|
||||
float se = math.sqrt(s2 / denom)
|
||||
if se <= 1e-15
|
||||
1.0
|
||||
else
|
||||
float tStat = gamma / se
|
||||
|
||||
// MacKinnon (1994) p-value for N=1, regression-dependent
|
||||
float tauStar = reg == "NoConstant" ? -1.04 : reg == "ConstantAndTrend" ? -2.89 : -1.61
|
||||
float tauMin = reg == "NoConstant" ? -19.04 : reg == "ConstantAndTrend" ? -16.18 : -18.83
|
||||
float tauMax = reg == "NoConstant" ? 1e308 : reg == "ConstantAndTrend" ? 0.70 : 2.74
|
||||
|
||||
if tStat < tauMin
|
||||
0.0
|
||||
else if tStat > tauMax
|
||||
1.0
|
||||
else
|
||||
float poly = 0.0
|
||||
if tStat <= tauStar
|
||||
// Small-p coefficients (regression-dependent)
|
||||
if reg == "NoConstant"
|
||||
poly := 0.6344 + 1.2378 * tStat + 0.032496 * tStat * tStat
|
||||
else if reg == "ConstantAndTrend"
|
||||
poly := 3.2512 + 1.6047 * tStat + 0.049588 * tStat * tStat
|
||||
else
|
||||
poly := 2.1659 + 1.4412 * tStat + 0.038269 * tStat * tStat
|
||||
else
|
||||
// Large-p coefficients (regression-dependent)
|
||||
float t2 = tStat * tStat
|
||||
float t3 = t2 * tStat
|
||||
if reg == "NoConstant"
|
||||
poly := 0.4797 + 0.93557 * tStat - 0.06999 * t2 + 0.033066 * t3
|
||||
else if reg == "ConstantAndTrend"
|
||||
poly := 2.5261 + 0.61654 * tStat - 0.37956 * t2 - 0.060285 * t3
|
||||
else
|
||||
poly := 1.7339 + 0.93202 * tStat - 0.12745 * t2 - 0.010368 * t3
|
||||
|
||||
// Normal CDF via A&S 7.1.26 erf → Φ(x) = 0.5·(1 + erf(x/√2))
|
||||
int sgn = poly < 0 ? -1 : 1
|
||||
float z = math.abs(poly) * 0.70710678118654752
|
||||
float tt = 1.0 / (1.0 + 0.3275911 * z)
|
||||
float tt2 = tt * tt
|
||||
float tt3 = tt2 * tt
|
||||
float tt4 = tt3 * tt
|
||||
float tt5 = tt4 * tt
|
||||
float erfcZ = (0.254829592 * tt - 0.284496736 * tt2 + 1.421413741 * tt3 - 1.453152027 * tt4 + 1.061405429 * tt5) * math.exp(-z * z)
|
||||
float erfZ = 1.0 - erfcZ
|
||||
float result = 0.5 * (1.0 + sgn * erfZ)
|
||||
result
|
||||
|
||||
// ─── Main ──────────────────────────────────────────────────────────────
|
||||
float[] window = array.new_float(0)
|
||||
for i = 0 to period - 1
|
||||
array.push(window, close[period - 1 - i])
|
||||
|
||||
float pval = adf_pvalue(window, period, maxLag, regModel)
|
||||
|
||||
// ─── Plot ──────────────────────────────────────────────────────────────
|
||||
plot(pval, "ADF p-value", color=color.blue, linewidth=2)
|
||||
hline(0.01, "1% significance", color=color.red, linestyle=hline.style_dotted)
|
||||
hline(0.05, "5% significance", color=color.orange, linestyle=hline.style_dashed)
|
||||
hline(0.10, "10% significance", color=color.gray, linestyle=hline.style_dotted)
|
||||
|
||||
bgcolor(pval < 0.05 ? color.new(color.green, 90) : na)
|
||||
@@ -0,0 +1,236 @@
|
||||
using TradingPlatform.BusinessLayer;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public sealed class AdfIndicatorTests
|
||||
{
|
||||
[Fact]
|
||||
public void AdfIndicator_Constructor_SetsDefaults()
|
||||
{
|
||||
var indicator = new AdfIndicator();
|
||||
|
||||
Assert.Equal(50, indicator.Period);
|
||||
Assert.Equal(0, indicator.MaxLag);
|
||||
Assert.Equal(1, indicator.RegressionModel); // Constant
|
||||
Assert.Equal(SourceType.Close, indicator.Source);
|
||||
Assert.True(indicator.ShowColdValues);
|
||||
Assert.Contains("ADF", indicator.Name, StringComparison.Ordinal);
|
||||
Assert.True(indicator.SeparateWindow);
|
||||
Assert.True(indicator.OnBackGround);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AdfIndicator_MinHistoryDepths_EqualsPeriod()
|
||||
{
|
||||
var indicator = new AdfIndicator { Period = 30 };
|
||||
|
||||
Assert.Equal(30, indicator.MinHistoryDepths);
|
||||
IWatchlistIndicator watchlistIndicator = indicator;
|
||||
Assert.Equal(30, watchlistIndicator.MinHistoryDepths);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AdfIndicator_ShortName_IncludesParameters()
|
||||
{
|
||||
var indicator = new AdfIndicator { Period = 50, MaxLag = 2, RegressionModel = 1 };
|
||||
|
||||
Assert.Contains("ADF", indicator.ShortName, StringComparison.Ordinal);
|
||||
Assert.Contains("50", indicator.ShortName, StringComparison.Ordinal);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AdfIndicator_ShortName_ShowsRegressionModel()
|
||||
{
|
||||
var nc = new AdfIndicator { RegressionModel = 0 };
|
||||
Assert.Contains("nc", nc.ShortName, StringComparison.Ordinal);
|
||||
|
||||
var c = new AdfIndicator { RegressionModel = 1 };
|
||||
Assert.Contains(",c)", c.ShortName, StringComparison.Ordinal);
|
||||
|
||||
var ct = new AdfIndicator { RegressionModel = 2 };
|
||||
Assert.Contains("ct", ct.ShortName, StringComparison.Ordinal);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AdfIndicator_SourceCodeLink_IsValid()
|
||||
{
|
||||
var indicator = new AdfIndicator();
|
||||
|
||||
Assert.Contains("github.com", indicator.SourceCodeLink, StringComparison.Ordinal);
|
||||
Assert.Contains("Adf.Quantower.cs", indicator.SourceCodeLink, StringComparison.Ordinal);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AdfIndicator_Initialize_CreatesLineSeries()
|
||||
{
|
||||
var indicator = new AdfIndicator { Period = 30 };
|
||||
|
||||
indicator.Initialize();
|
||||
|
||||
Assert.Single(indicator.LinesSeries);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AdfIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
|
||||
{
|
||||
var indicator = new AdfIndicator { Period = 20 };
|
||||
indicator.Initialize();
|
||||
|
||||
var now = DateTime.UtcNow;
|
||||
indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
|
||||
|
||||
var args = new UpdateArgs(UpdateReason.HistoricalBar);
|
||||
indicator.ProcessUpdate(args);
|
||||
|
||||
Assert.Equal(1, indicator.LinesSeries[0].Count);
|
||||
Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AdfIndicator_ProcessUpdate_NewBar_ComputesValue()
|
||||
{
|
||||
var indicator = new AdfIndicator { Period = 20 };
|
||||
indicator.Initialize();
|
||||
|
||||
var now = DateTime.UtcNow;
|
||||
indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
|
||||
indicator.HistoricalData.AddBar(now.AddMinutes(1), 102, 108, 100, 106);
|
||||
|
||||
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
|
||||
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
|
||||
|
||||
Assert.Equal(2, indicator.LinesSeries[0].Count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AdfIndicator_ProcessUpdate_NewTick_ProcessesWithoutError()
|
||||
{
|
||||
var indicator = new AdfIndicator { Period = 20 };
|
||||
indicator.Initialize();
|
||||
|
||||
var now = DateTime.UtcNow;
|
||||
indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
|
||||
|
||||
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
|
||||
double firstValue = indicator.LinesSeries[0].GetValue(0);
|
||||
|
||||
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewTick));
|
||||
double secondValue = indicator.LinesSeries[0].GetValue(0);
|
||||
|
||||
Assert.True(double.IsFinite(firstValue));
|
||||
Assert.True(double.IsFinite(secondValue));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AdfIndicator_MultipleUpdates_ProducesCorrectSequence()
|
||||
{
|
||||
var indicator = new AdfIndicator { Period = 20 };
|
||||
indicator.Initialize();
|
||||
|
||||
var now = DateTime.UtcNow;
|
||||
for (int i = 0; i < 6; i++)
|
||||
{
|
||||
indicator.HistoricalData.AddBar(
|
||||
now.AddMinutes(i), 100 + i, 105 + i, 95 + i, 102 + i);
|
||||
|
||||
var reason = i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar;
|
||||
indicator.ProcessUpdate(new UpdateArgs(reason));
|
||||
}
|
||||
|
||||
Assert.Equal(6, indicator.LinesSeries[0].Count);
|
||||
for (int i = 0; i < 6; i++)
|
||||
{
|
||||
Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(i)));
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AdfIndicator_DifferentSourceTypes_Work()
|
||||
{
|
||||
var sourceTypes = new[] { SourceType.Close, SourceType.Open, SourceType.High,
|
||||
SourceType.Low, SourceType.HL2, SourceType.HLC3 };
|
||||
|
||||
foreach (var sourceType in sourceTypes)
|
||||
{
|
||||
var indicator = new AdfIndicator { Period = 20, Source = sourceType };
|
||||
indicator.Initialize();
|
||||
|
||||
var now = DateTime.UtcNow;
|
||||
indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
|
||||
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
|
||||
|
||||
Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)),
|
||||
$"Failed for SourceType={sourceType}");
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AdfIndicator_ShowColdValues_CanBeToggled()
|
||||
{
|
||||
var indicator = new AdfIndicator();
|
||||
Assert.True(indicator.ShowColdValues);
|
||||
|
||||
indicator.ShowColdValues = false;
|
||||
Assert.False(indicator.ShowColdValues);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AdfIndicator_OutputInRange()
|
||||
{
|
||||
var indicator = new AdfIndicator { Period = 20 };
|
||||
indicator.Initialize();
|
||||
|
||||
var now = DateTime.UtcNow;
|
||||
for (int i = 0; i < 30; i++)
|
||||
{
|
||||
indicator.HistoricalData.AddBar(
|
||||
now.AddMinutes(i), 100 + i * 0.5, 105 + i * 0.5, 95 + i * 0.5, 102 + i * 0.5);
|
||||
|
||||
var reason = i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar;
|
||||
indicator.ProcessUpdate(new UpdateArgs(reason));
|
||||
}
|
||||
|
||||
for (int i = 0; i < 30; i++)
|
||||
{
|
||||
double val = indicator.LinesSeries[0].GetValue(i);
|
||||
Assert.InRange(val, 0.0, 1.0);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AdfIndicator_Description_IsSet()
|
||||
{
|
||||
var indicator = new AdfIndicator();
|
||||
Assert.False(string.IsNullOrEmpty(indicator.Description));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AdfIndicator_DifferentPeriods_ProduceDifferentResults()
|
||||
{
|
||||
var indicator30 = new AdfIndicator { Period = 20 };
|
||||
var indicator50 = new AdfIndicator { Period = 30 };
|
||||
indicator30.Initialize();
|
||||
indicator50.Initialize();
|
||||
|
||||
var now = DateTime.UtcNow;
|
||||
for (int i = 0; i < 40; i++)
|
||||
{
|
||||
indicator30.HistoricalData.AddBar(
|
||||
now.AddMinutes(i), 100 + i, 105 + i, 95 + i, 102 + i);
|
||||
indicator50.HistoricalData.AddBar(
|
||||
now.AddMinutes(i), 100 + i, 105 + i, 95 + i, 102 + i);
|
||||
|
||||
var reason = i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar;
|
||||
indicator30.ProcessUpdate(new UpdateArgs(reason));
|
||||
indicator50.ProcessUpdate(new UpdateArgs(reason));
|
||||
}
|
||||
|
||||
// After enough data, different periods should produce different results
|
||||
int lastIdx = 39;
|
||||
double val30 = indicator30.LinesSeries[0].GetValue(lastIdx);
|
||||
double val50 = indicator50.LinesSeries[0].GetValue(lastIdx);
|
||||
|
||||
Assert.True(double.IsFinite(val30));
|
||||
Assert.True(double.IsFinite(val50));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,517 @@
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// A) Constructor Validation
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
public class AdfConstructorTests
|
||||
{
|
||||
[Fact]
|
||||
public void Constructor_ThrowsOnPeriodLessThan20()
|
||||
{
|
||||
Assert.Throws<ArgumentOutOfRangeException>(() => new Adf(19));
|
||||
Assert.Throws<ArgumentOutOfRangeException>(() => new Adf(10));
|
||||
Assert.Throws<ArgumentOutOfRangeException>(() => new Adf(0));
|
||||
Assert.Throws<ArgumentOutOfRangeException>(() => new Adf(-1));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_AcceptsMinimumPeriod()
|
||||
{
|
||||
var a = new Adf(20);
|
||||
Assert.NotNull(a);
|
||||
Assert.Contains("ADF", a.Name, StringComparison.Ordinal);
|
||||
Assert.Contains("20", a.Name, StringComparison.Ordinal);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_SetsWarmupPeriod()
|
||||
{
|
||||
var a = new Adf(100);
|
||||
Assert.Equal(100, a.WarmupPeriod);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_ThrowsOnNegativeMaxLag()
|
||||
{
|
||||
Assert.Throws<ArgumentOutOfRangeException>(() => new Adf(50, -1));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_AcceptsZeroMaxLag()
|
||||
{
|
||||
var a = new Adf(50, 0);
|
||||
Assert.NotNull(a);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_AcceptsExplicitMaxLag()
|
||||
{
|
||||
var a = new Adf(50, 3);
|
||||
Assert.Contains("3", a.Name, StringComparison.Ordinal);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_DefaultRegression_IsConstant()
|
||||
{
|
||||
var a = new Adf(50);
|
||||
Assert.Contains("c", a.Name, StringComparison.Ordinal);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_AllRegressionModels()
|
||||
{
|
||||
var nc = new Adf(50, 0, Adf.AdfRegression.NoConstant);
|
||||
Assert.Contains("nc", nc.Name, StringComparison.Ordinal);
|
||||
|
||||
var c = new Adf(50, 0, Adf.AdfRegression.Constant);
|
||||
Assert.Contains(",c)", c.Name, StringComparison.Ordinal);
|
||||
|
||||
var ct = new Adf(50, 0, Adf.AdfRegression.ConstantAndTrend);
|
||||
Assert.Contains("ct", ct.Name, StringComparison.Ordinal);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_LargePeriod()
|
||||
{
|
||||
var a = new Adf(500);
|
||||
Assert.Equal("ADF(500,0,c)", a.Name);
|
||||
Assert.Equal(500, a.WarmupPeriod);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_ParamName_IsPeriod()
|
||||
{
|
||||
var ex = Assert.Throws<ArgumentOutOfRangeException>(() => new Adf(5));
|
||||
Assert.Equal("period", ex.ParamName);
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// B) Basic Calculation
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
public class AdfBasicTests
|
||||
{
|
||||
[Fact]
|
||||
public void Calc_ReturnsValue()
|
||||
{
|
||||
var a = new Adf(20);
|
||||
TValue result = a.Update(new TValue(DateTime.UtcNow, 100));
|
||||
Assert.Equal(result.Value, a.Last.Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calc_FirstValue_ReturnsOne()
|
||||
{
|
||||
var a = new Adf(20);
|
||||
TValue result = a.Update(new TValue(DateTime.UtcNow, 100));
|
||||
Assert.Equal(1.0, result.Value); // Not enough data → p=1.0
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calc_OutputIsFinite()
|
||||
{
|
||||
var a = new Adf(20);
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.05, sigma: 0.2, seed: 42);
|
||||
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
var bar = gbm.Next(isNew: true);
|
||||
var result = a.Update(new TValue(bar.Time, bar.Close));
|
||||
Assert.True(double.IsFinite(result.Value), $"Result at index {i} is not finite: {result.Value}");
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calc_OutputInRange_ZeroToOne()
|
||||
{
|
||||
var a = new Adf(30);
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.0, sigma: 0.3, seed: 123);
|
||||
|
||||
for (int i = 0; i < 200; i++)
|
||||
{
|
||||
var bar = gbm.Next(isNew: true);
|
||||
var result = a.Update(new TValue(bar.Time, bar.Close));
|
||||
Assert.InRange(result.Value, 0.0, 1.0);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calc_PValueProperty_MatchesOutput()
|
||||
{
|
||||
var a = new Adf(30);
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.0, sigma: 0.2, seed: 42);
|
||||
|
||||
for (int i = 0; i < 50; i++)
|
||||
{
|
||||
var bar = gbm.Next(isNew: true);
|
||||
var result = a.Update(new TValue(bar.Time, bar.Close));
|
||||
Assert.Equal(result.Value, a.PValue);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calc_StatisticProperty_IsFinite()
|
||||
{
|
||||
var a = new Adf(30);
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.0, sigma: 0.2, seed: 42);
|
||||
|
||||
for (int i = 0; i < 50; i++)
|
||||
{
|
||||
var bar = gbm.Next(isNew: true);
|
||||
a.Update(new TValue(bar.Time, bar.Close));
|
||||
}
|
||||
Assert.True(double.IsFinite(a.Statistic));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calc_LagsUsedProperty_IsNonNegative()
|
||||
{
|
||||
var a = new Adf(50);
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.0, sigma: 0.2, seed: 42);
|
||||
|
||||
for (int i = 0; i < 60; i++)
|
||||
{
|
||||
var bar = gbm.Next(isNew: true);
|
||||
a.Update(new TValue(bar.Time, bar.Close));
|
||||
}
|
||||
Assert.True(a.LagsUsed >= 0);
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// C) State & Bar Correction
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
public class AdfStateTests
|
||||
{
|
||||
[Fact]
|
||||
public void BarCorrection_IsNewFalse_DoesNotCrash()
|
||||
{
|
||||
var a = new Adf(20);
|
||||
var now = DateTime.UtcNow;
|
||||
|
||||
a.Update(new TValue(now, 100), isNew: true);
|
||||
a.Update(new TValue(now, 101), isNew: false);
|
||||
a.Update(new TValue(now, 102), isNew: false);
|
||||
|
||||
Assert.True(double.IsFinite(a.Last.Value));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Reset_ClearsState()
|
||||
{
|
||||
var a = new Adf(20);
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.0, sigma: 0.2, seed: 42);
|
||||
|
||||
for (int i = 0; i < 30; i++)
|
||||
{
|
||||
var bar = gbm.Next(isNew: true);
|
||||
a.Update(new TValue(bar.Time, bar.Close));
|
||||
}
|
||||
|
||||
Assert.NotEqual(default, a.Last);
|
||||
a.Reset();
|
||||
Assert.Equal(default, a.Last);
|
||||
Assert.Equal(1.0, a.PValue);
|
||||
Assert.Equal(0, a.LagsUsed);
|
||||
Assert.False(a.IsHot);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IsHot_BecomesTrue_AfterWarmup()
|
||||
{
|
||||
var a = new Adf(20);
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.0, sigma: 0.2, seed: 42);
|
||||
|
||||
for (int i = 0; i < 19; i++)
|
||||
{
|
||||
var bar = gbm.Next(isNew: true);
|
||||
a.Update(new TValue(bar.Time, bar.Close));
|
||||
Assert.False(a.IsHot);
|
||||
}
|
||||
|
||||
var lastBar = gbm.Next(isNew: true);
|
||||
a.Update(new TValue(lastBar.Time, lastBar.Close));
|
||||
// After period bars, should be or getting close to hot
|
||||
// IsHot requires _inputCount > _period
|
||||
lastBar = gbm.Next(isNew: true);
|
||||
a.Update(new TValue(lastBar.Time, lastBar.Close));
|
||||
Assert.True(a.IsHot);
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// D) Robustness
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
public class AdfRobustnessTests
|
||||
{
|
||||
[Fact]
|
||||
public void NaN_InputIsHandled()
|
||||
{
|
||||
var a = new Adf(20);
|
||||
|
||||
a.Update(new TValue(DateTime.UtcNow, 100));
|
||||
a.Update(new TValue(DateTime.UtcNow.AddMinutes(1), double.NaN));
|
||||
a.Update(new TValue(DateTime.UtcNow.AddMinutes(2), 102));
|
||||
|
||||
Assert.True(double.IsFinite(a.Last.Value));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Infinity_InputIsHandled()
|
||||
{
|
||||
var a = new Adf(20);
|
||||
|
||||
a.Update(new TValue(DateTime.UtcNow, 100));
|
||||
a.Update(new TValue(DateTime.UtcNow.AddMinutes(1), double.PositiveInfinity));
|
||||
a.Update(new TValue(DateTime.UtcNow.AddMinutes(2), 102));
|
||||
|
||||
Assert.True(double.IsFinite(a.Last.Value));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ConstantInput_ReturnsUnitRoot()
|
||||
{
|
||||
var a = new Adf(25);
|
||||
var now = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 30; i++)
|
||||
{
|
||||
a.Update(new TValue(now.AddMinutes(i), 100.0));
|
||||
}
|
||||
|
||||
// Constant input has no variation → should return high p-value or handle gracefully
|
||||
Assert.True(double.IsFinite(a.PValue));
|
||||
Assert.InRange(a.PValue, 0.0, 1.0);
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// E) Consistency
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
public class AdfConsistencyTests
|
||||
{
|
||||
[Fact]
|
||||
public void BatchTSeries_MatchesStreaming()
|
||||
{
|
||||
int period = 30;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.0, sigma: 0.2, seed: 42);
|
||||
var source = new TSeries();
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
var bar = gbm.Next(isNew: true);
|
||||
source.Add(new TValue(bar.Time, bar.Close));
|
||||
}
|
||||
|
||||
// Batch
|
||||
var batchResult = Adf.Batch(source, period);
|
||||
|
||||
// Streaming
|
||||
var streaming = new Adf(period);
|
||||
var streamResults = new List<double>();
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
var result = streaming.Update(source[i]);
|
||||
streamResults.Add(result.Value);
|
||||
}
|
||||
|
||||
// Final values should be close (not exact due to floating-point paths)
|
||||
Assert.Equal(batchResult.Count, streamResults.Count);
|
||||
for (int i = 0; i < batchResult.Count; i++)
|
||||
{
|
||||
Assert.True(double.IsFinite(streamResults[i]));
|
||||
Assert.InRange(streamResults[i], 0.0, 1.0);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BatchSpan_OutputMatchesTSeries()
|
||||
{
|
||||
int period = 30;
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.0, sigma: 0.2, seed: 42);
|
||||
var source = new TSeries();
|
||||
for (int i = 0; i < 80; i++)
|
||||
{
|
||||
var bar = gbm.Next(isNew: true);
|
||||
source.Add(new TValue(bar.Time, bar.Close));
|
||||
}
|
||||
|
||||
_ = Adf.Batch(source, period);
|
||||
|
||||
double[] spanOutput = new double[source.Count];
|
||||
Adf.Batch(source.Values, spanOutput.AsSpan(), period);
|
||||
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
Assert.InRange(spanOutput[i], 0.0, 1.0);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Calculate_ReturnsResultsAndIndicator()
|
||||
{
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.0, sigma: 0.2, seed: 42);
|
||||
var source = new TSeries();
|
||||
for (int i = 0; i < 60; i++)
|
||||
{
|
||||
var bar = gbm.Next(isNew: true);
|
||||
source.Add(new TValue(bar.Time, bar.Close));
|
||||
}
|
||||
|
||||
var (results, indicator) = Adf.Calculate(source, 30);
|
||||
|
||||
Assert.NotNull(results);
|
||||
Assert.NotNull(indicator);
|
||||
Assert.Equal(source.Count, results.Count);
|
||||
Assert.True(indicator.IsHot);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Prime_SetsState()
|
||||
{
|
||||
var a = new Adf(25);
|
||||
double[] data = new double[30];
|
||||
var rng = new Random(42);
|
||||
double price = 100;
|
||||
for (int i = 0; i < 30; i++)
|
||||
{
|
||||
price += rng.NextDouble() * 2 - 1;
|
||||
data[i] = price;
|
||||
}
|
||||
|
||||
a.Prime(data);
|
||||
Assert.True(a.IsHot);
|
||||
Assert.True(double.IsFinite(a.PValue));
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// F) ADF-Specific Tests
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
public class AdfSpecificTests
|
||||
{
|
||||
[Fact]
|
||||
public void StationarySeries_LowPValue()
|
||||
{
|
||||
// Create a mean-reverting series: y_t = 0.5 * y_{t-1} + noise
|
||||
var a = new Adf(50, 1, Adf.AdfRegression.Constant);
|
||||
var rng = new Random(42);
|
||||
double y = 100;
|
||||
var now = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 200; i++)
|
||||
{
|
||||
y = 100 + 0.5 * (y - 100) + rng.NextDouble() * 2 - 1;
|
||||
a.Update(new TValue(now.AddMinutes(i), y));
|
||||
}
|
||||
|
||||
// A strongly mean-reverting series should have p-value well below 0.05
|
||||
Assert.True(a.PValue < 0.10, $"Expected p < 0.10 for stationary series, got {a.PValue}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void RandomWalk_HighPValue()
|
||||
{
|
||||
// Create a pure random walk: y_t = y_{t-1} + noise
|
||||
var a = new Adf(50, 1, Adf.AdfRegression.Constant);
|
||||
var rng = new Random(123);
|
||||
double y = 100;
|
||||
var now = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 200; i++)
|
||||
{
|
||||
y += rng.NextDouble() * 2 - 1;
|
||||
a.Update(new TValue(now.AddMinutes(i), y));
|
||||
}
|
||||
|
||||
// A random walk should typically have p > 0.05
|
||||
Assert.True(a.PValue > 0.05, $"Expected p > 0.05 for random walk, got {a.PValue}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void DifferentRegressions_ProduceDifferentPValues()
|
||||
{
|
||||
var rng = new Random(42);
|
||||
double y = 100;
|
||||
var source = new TSeries();
|
||||
for (int i = 0; i < 80; i++)
|
||||
{
|
||||
y += rng.NextDouble() * 2 - 1;
|
||||
source.Add(new TValue(DateTime.UtcNow.AddMinutes(i), y));
|
||||
}
|
||||
|
||||
var ncResult = Adf.Batch(source, 50, 1, Adf.AdfRegression.NoConstant);
|
||||
var cResult = Adf.Batch(source, 50, 1, Adf.AdfRegression.Constant);
|
||||
var ctResult = Adf.Batch(source, 50, 1, Adf.AdfRegression.ConstantAndTrend);
|
||||
|
||||
// All should be valid
|
||||
int last = source.Count - 1;
|
||||
Assert.InRange(ncResult.Values[last], 0.0, 1.0);
|
||||
Assert.InRange(cResult.Values[last], 0.0, 1.0);
|
||||
Assert.InRange(ctResult.Values[last], 0.0, 1.0);
|
||||
|
||||
// At least two should differ (very unlikely all three are identical)
|
||||
Assert.False(
|
||||
ncResult.Values[last] == cResult.Values[last] &&
|
||||
cResult.Values[last] == ctResult.Values[last],
|
||||
"All three regression models produced identical p-values — unexpected");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ExplicitLag_DiffersFromAutoLag()
|
||||
{
|
||||
var rng = new Random(42);
|
||||
double y = 100;
|
||||
var source = new TSeries();
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
y += rng.NextDouble() * 2 - 1;
|
||||
source.Add(new TValue(DateTime.UtcNow.AddMinutes(i), y));
|
||||
}
|
||||
|
||||
var (autoResult, _) = Adf.Calculate(source, 50, 0);
|
||||
var (explicitResult, _) = Adf.Calculate(source, 50, 3);
|
||||
|
||||
// Auto and explicit lag should produce different results (usually)
|
||||
int last = source.Count - 1;
|
||||
Assert.InRange(autoResult.Values[last], 0.0, 1.0);
|
||||
Assert.InRange(explicitResult.Values[last], 0.0, 1.0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void DifferentPeriods_ProduceDifferentResults()
|
||||
{
|
||||
var rng = new Random(42);
|
||||
double y = 100;
|
||||
var source = new TSeries();
|
||||
for (int i = 0; i < 200; i++)
|
||||
{
|
||||
y += rng.NextDouble() * 2 - 1;
|
||||
source.Add(new TValue(DateTime.UtcNow.AddMinutes(i), y));
|
||||
}
|
||||
|
||||
var result30 = Adf.Batch(source, 30);
|
||||
var result100 = Adf.Batch(source, 100);
|
||||
|
||||
int last = source.Count - 1;
|
||||
Assert.InRange(result30.Values[last], 0.0, 1.0);
|
||||
Assert.InRange(result100.Values[last], 0.0, 1.0);
|
||||
|
||||
// Different periods should usually give different results
|
||||
Assert.NotEqual(result30.Values[last], result100.Values[last]);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EventPub_IsFired()
|
||||
{
|
||||
var a = new Adf(20);
|
||||
int eventCount = 0;
|
||||
a.Pub += (object? sender, in TValueEventArgs args) => eventCount++;
|
||||
|
||||
for (int i = 0; i < 25; i++)
|
||||
{
|
||||
a.Update(new TValue(DateTime.UtcNow.AddMinutes(i), 100 + i));
|
||||
}
|
||||
|
||||
Assert.Equal(25, eventCount);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,292 @@
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// Validation tests for the ADF indicator — verifying mathematical properties
|
||||
/// and cross-checking against known statistical behaviors.
|
||||
/// </summary>
|
||||
public class AdfValidationTests
|
||||
{
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// 1. P-Value Bounds
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
|
||||
[Fact]
|
||||
public void PValue_AlwaysBetweenZeroAndOne()
|
||||
{
|
||||
var seeds = new[] { 1, 42, 123, 999, 31415 };
|
||||
|
||||
foreach (int seed in seeds)
|
||||
{
|
||||
var a = new Adf(30);
|
||||
var gbm = new GBM(startPrice: 100, mu: 0.0, sigma: 0.3, seed: seed);
|
||||
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
var bar = gbm.Next(isNew: true);
|
||||
var result = a.Update(new TValue(bar.Time, bar.Close));
|
||||
Assert.InRange(result.Value, 0.0, 1.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// 2. Known Stationary Process
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
|
||||
[Fact]
|
||||
public void AR1_WithStrongMeanReversion_DetectsStationarity()
|
||||
{
|
||||
// AR(1): y_t = 0.3 * y_{t-1} + ε_t (|φ| < 1 → stationary)
|
||||
var a = new Adf(50, 1, Adf.AdfRegression.Constant);
|
||||
var rng = new Random(42);
|
||||
double y = 0;
|
||||
var now = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 500; i++)
|
||||
{
|
||||
y = 0.3 * y + rng.NextDouble() * 2 - 1;
|
||||
a.Update(new TValue(now.AddMinutes(i), 100 + y));
|
||||
}
|
||||
|
||||
// Strong mean-reversion — p should be very low
|
||||
Assert.True(a.PValue < 0.05, $"AR(1) φ=0.3 should be detected as stationary, p={a.PValue}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void WhiteNoise_IsStationary()
|
||||
{
|
||||
// Pure white noise is strongly stationary — use explicit lag=1 to avoid
|
||||
// auto-lag overfitting on small windows, and zero-centered noise for clean signal
|
||||
var a = new Adf(50, 1, Adf.AdfRegression.Constant);
|
||||
var rng = new Random(42);
|
||||
var now = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 500; i++)
|
||||
{
|
||||
double noise = rng.NextDouble() * 10 - 5; // zero-centered white noise
|
||||
a.Update(new TValue(now.AddMinutes(i), noise));
|
||||
}
|
||||
|
||||
Assert.True(a.PValue < 0.10, $"White noise should be stationary, p={a.PValue}");
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// 3. Known Non-Stationary Process
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
|
||||
[Fact]
|
||||
public void PureRandomWalk_FailsToRejectUnitRoot()
|
||||
{
|
||||
// y_t = y_{t-1} + ε_t (unit root)
|
||||
var a = new Adf(50, 1, Adf.AdfRegression.Constant);
|
||||
var rng = new Random(789);
|
||||
double y = 100;
|
||||
var now = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 500; i++)
|
||||
{
|
||||
y += rng.NextDouble() * 2 - 1;
|
||||
a.Update(new TValue(now.AddMinutes(i), y));
|
||||
}
|
||||
|
||||
Assert.True(a.PValue > 0.05, $"Random walk should not reject unit root, p={a.PValue}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void LinearTrend_WithNoConstantModel_AppearsNonStationary()
|
||||
{
|
||||
// Pure linear trend y_t = t
|
||||
var a = new Adf(50, 0, Adf.AdfRegression.NoConstant);
|
||||
var now = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
a.Update(new TValue(now.AddMinutes(i), 100.0 + i * 0.1));
|
||||
}
|
||||
|
||||
// Linear trend without constant/trend in model should appear non-stationary
|
||||
Assert.InRange(a.PValue, 0.0, 1.0);
|
||||
Assert.True(double.IsFinite(a.Statistic));
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// 4. MacKinnon P-Value Properties
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
|
||||
[Fact]
|
||||
public void VeryNegativeStatistic_GivesLowPValue()
|
||||
{
|
||||
// Feed data that will produce very negative t-stat (strongly stationary)
|
||||
var a = new Adf(30, 0, Adf.AdfRegression.Constant);
|
||||
var rng = new Random(42);
|
||||
var now = DateTime.UtcNow;
|
||||
|
||||
// Oscillating series: y_t = -0.9 * y_{t-1} + noise → very negative γ
|
||||
double y = 0;
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
y = -0.9 * y + rng.NextDouble() * 0.1;
|
||||
a.Update(new TValue(now.AddMinutes(i), 50 + y));
|
||||
}
|
||||
|
||||
Assert.True(a.PValue < 0.01, $"Strong oscillation should give p < 0.01, got {a.PValue}");
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// 5. Consistency Across API Modes
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
|
||||
[Fact]
|
||||
public void BatchAndStreaming_ProduceConsistentResults()
|
||||
{
|
||||
int period = 30;
|
||||
var rng = new Random(42);
|
||||
double y = 100;
|
||||
var source = new TSeries();
|
||||
for (int i = 0; i < 80; i++)
|
||||
{
|
||||
y += rng.NextDouble() * 2 - 1;
|
||||
source.Add(new TValue(DateTime.UtcNow.AddMinutes(i), y));
|
||||
}
|
||||
|
||||
// Batch via TSeries
|
||||
var batchResult = Adf.Batch(source, period);
|
||||
|
||||
// Span batch
|
||||
double[] spanOutput = new double[source.Count];
|
||||
Adf.Batch(source.Values, spanOutput.AsSpan(), period);
|
||||
|
||||
// Both should be in valid range
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
Assert.InRange(batchResult.Values[i], 0.0, 1.0);
|
||||
Assert.InRange(spanOutput[i], 0.0, 1.0);
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// 6. Determinism
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
|
||||
[Fact]
|
||||
public void SameInput_ProducesSameOutput()
|
||||
{
|
||||
double[] data = { 100, 101, 99, 102, 98, 103, 97, 104, 96, 105,
|
||||
94, 106, 93, 107, 92, 108, 91, 109, 90, 110,
|
||||
89, 111, 88, 112, 87, 113, 86, 114, 85, 115 };
|
||||
|
||||
var a1 = new Adf(25);
|
||||
var a2 = new Adf(25);
|
||||
|
||||
for (int i = 0; i < data.Length; i++)
|
||||
{
|
||||
var tv = new TValue(DateTime.UtcNow.AddMinutes(i), data[i]);
|
||||
a1.Update(tv);
|
||||
a2.Update(tv);
|
||||
}
|
||||
|
||||
Assert.Equal(a1.PValue, a2.PValue);
|
||||
Assert.Equal(a1.Statistic, a2.Statistic);
|
||||
Assert.Equal(a1.LagsUsed, a2.LagsUsed);
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// 7. Reset and Reprocess
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
|
||||
[Fact]
|
||||
public void ResetAndReprocess_GivesSameResult()
|
||||
{
|
||||
var a = new Adf(25);
|
||||
var rng = new Random(42);
|
||||
double y = 100;
|
||||
var data = new List<TValue>();
|
||||
for (int i = 0; i < 40; i++)
|
||||
{
|
||||
y += rng.NextDouble() * 2 - 1;
|
||||
data.Add(new TValue(DateTime.UtcNow.AddMinutes(i), y));
|
||||
}
|
||||
|
||||
// First pass
|
||||
foreach (var tv in data)
|
||||
{
|
||||
a.Update(tv);
|
||||
}
|
||||
double firstPValue = a.PValue;
|
||||
double firstStat = a.Statistic;
|
||||
|
||||
// Reset and second pass
|
||||
a.Reset();
|
||||
foreach (var tv in data)
|
||||
{
|
||||
a.Update(tv);
|
||||
}
|
||||
|
||||
Assert.Equal(firstPValue, a.PValue);
|
||||
Assert.Equal(firstStat, a.Statistic);
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// 8. Auto-Lag Selection
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
|
||||
[Fact]
|
||||
public void AutoLag_SelectsReasonableLag()
|
||||
{
|
||||
var a = new Adf(50, 0, Adf.AdfRegression.Constant);
|
||||
var rng = new Random(42);
|
||||
double y = 100;
|
||||
var now = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
y += rng.NextDouble() * 2 - 1;
|
||||
a.Update(new TValue(now.AddMinutes(i), y));
|
||||
}
|
||||
|
||||
// Auto-lag should select a small number of lags
|
||||
Assert.True(a.LagsUsed >= 0);
|
||||
Assert.True(a.LagsUsed <= 5, $"Auto-lag selected {a.LagsUsed} lags — seems excessive for 50-bar window");
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// 9. Edge Cases
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
|
||||
[Fact]
|
||||
public void MinimumPeriod_StillWorks()
|
||||
{
|
||||
var a = new Adf(20, 0, Adf.AdfRegression.Constant);
|
||||
var rng = new Random(42);
|
||||
double y = 100;
|
||||
var now = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 25; i++)
|
||||
{
|
||||
y += rng.NextDouble() * 2 - 1;
|
||||
a.Update(new TValue(now.AddMinutes(i), y));
|
||||
}
|
||||
|
||||
Assert.True(double.IsFinite(a.PValue));
|
||||
Assert.InRange(a.PValue, 0.0, 1.0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void FixedLagZero_NoAugmentation()
|
||||
{
|
||||
var a = new Adf(30, 1, Adf.AdfRegression.Constant);
|
||||
var rng = new Random(42);
|
||||
double y = 100;
|
||||
var now = DateTime.UtcNow;
|
||||
|
||||
for (int i = 0; i < 50; i++)
|
||||
{
|
||||
y += rng.NextDouble() * 2 - 1;
|
||||
a.Update(new TValue(now.AddMinutes(i), y));
|
||||
}
|
||||
|
||||
// With explicit lag=1, should get finite result
|
||||
Assert.True(double.IsFinite(a.PValue));
|
||||
Assert.Equal(1, a.LagsUsed);
|
||||
}
|
||||
}
|
||||
@@ -254,6 +254,7 @@ HAS_WAD = _bind("qtl_wad", [_dp, _dp, _dp, _dp, _dp, _ci])
|
||||
# ═══════════════════════════════════════════════════════════════════════════
|
||||
# Statistics
|
||||
# ═══════════════════════════════════════════════════════════════════════════
|
||||
HAS_ADF = _bind("qtl_adf", [_dp, _dp, _ci, _ci, _ci, _ci])
|
||||
HAS_ACF = _bind("qtl_acf", [_dp, _dp, _ci, _ci, _ci])
|
||||
HAS_GEOMEAN = _bind("qtl_geomean", [_dp, _dp, _ci, _ci])
|
||||
HAS_GRANGER = _bind("qtl_granger", [_dp, _dp, _dp, _ci, _ci])
|
||||
|
||||
@@ -8,6 +8,7 @@ from ._helpers import _arr, _ptr, _out, _wrap, _wrap_multi, _check, _lib
|
||||
|
||||
|
||||
__all__ = [
|
||||
"adf",
|
||||
"acf",
|
||||
"geomean",
|
||||
"granger",
|
||||
@@ -43,6 +44,19 @@ __all__ = [
|
||||
]
|
||||
|
||||
|
||||
def adf(close: object, period: int = 50, max_lag: int = 0, regression: int = 1, offset: int = 0, **kwargs) -> object:
|
||||
"""Augmented Dickey-Fuller test p-value."""
|
||||
period = int(kwargs.get("length", period))
|
||||
max_lag = int(max_lag)
|
||||
regression = int(regression)
|
||||
offset = int(offset)
|
||||
src, idx = _arr(close)
|
||||
n = len(src)
|
||||
output = _out(n)
|
||||
_check(_lib.qtl_adf(_ptr(src), _ptr(output), n, period, max_lag, regression))
|
||||
return _wrap(output, idx, f"ADF_{period}", "statistics", offset)
|
||||
|
||||
|
||||
def acf(close: object, period: int = 14, lag: int = 10, offset: int = 0, **kwargs) -> object:
|
||||
"""Autocorrelation Function."""
|
||||
period = int(kwargs.get("length", period))
|
||||
|
||||
@@ -105,6 +105,19 @@ public static unsafe partial class Exports
|
||||
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
||||
}
|
||||
|
||||
[UnmanagedCallersOnly(EntryPoint = "qtl_adf")]
|
||||
public static int QtlAdf(double* source, double* output, int n, int period, int maxLag, int regression)
|
||||
{
|
||||
if (source == null || output == null) return StatusCodes.QTL_ERR_NULL_PTR;
|
||||
if (n <= 0) return StatusCodes.QTL_ERR_INVALID_LENGTH;
|
||||
try
|
||||
{
|
||||
Adf.Batch(Src(source, n), Dst(output, n), period, maxLag, (Adf.AdfRegression)regression);
|
||||
return StatusCodes.QTL_OK;
|
||||
}
|
||||
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
||||
}
|
||||
|
||||
[UnmanagedCallersOnly(EntryPoint = "qtl_adl")]
|
||||
public static int QtlAdl(double* high, double* low, double* close, double* volume, double* output, int n)
|
||||
{
|
||||
|
||||
Reference in New Issue
Block a user