FIGARCHResult#

class cultivars.univariate.conditional_variance.FIGARCHResult(*, endog, fittedvalues, resid, llf, nobs, n_params, mean, const, omega, conditional_variance, truncation, phi, d, beta)[source]#

A fitted fractionally integrated conditional-variance model.

The FIGARCH(1, d, 1) variance of Baillie, Bollerslev and Mikkelsen,

\[\sigma_t^2 = \omega + \beta\,\sigma_{t-1}^2 + \bigl[1 - \beta L - (1 - \phi L)(1 - L)^d\bigr]\,\varepsilon_t^2,\]

is estimated in its ARCH(\(\infty\)) form

\[\sigma_t^2 = \frac{\omega}{1 - \beta} + \sum_{k=1}^{\infty} \lambda_k\, \varepsilon_{t-k}^2, \qquad \lambda(L) = 1 - \frac{(1 - \phi L)(1 - L)^d}{1 - \beta L},\]

with the sum cut at truncation lags and the tail applied to a backcast. The weights decay as \(k^{d-1}\) rather than geometrically, and \(\lambda(1) = 1\) for every \(d > 0\): the shocks’ total weight is unity, which is why persistence is one by construction, no half-life exists, and the process is not covariance stationary. Everything the geometric families report from a single decay rate is therefore withheld here rather than approximated; the one number this family adds is d.

Variables:

  • truncation – Number of infinite-order weights retained.

  • phi – Short-memory numerator weight of the fractional polynomial.

  • d – Fractional integration order.

  • beta – Denominator weight.

Note

phi, d and beta are each searched on \((0, 1)\) and omega on \((0, \infty)\), with any draw whose retained weights turn negative rejected; the estimate cannot land on d = 0 exactly, so has_long_memory is a threshold on the point estimate, not a test, and a short-memory series will still come back with a positive d. The inherited fields and properties are those of GARCHResult; half_life returns inf here and there is no unconditional_variance. Standard errors are not yet reported by this estimator.

See also

References

Baillie, R. T., Bollerslev, T., & Mikkelsen, H. O. (1996). Fractionally integrated generalized autoregressive conditional heteroskedasticity. Journal of Econometrics, 74(1), 3-30.

Chung, C.-F. (1999). Estimating the fractionally integrated GARCH model. Working paper, National Taiwan University.

Example

A series with a persistent GARCH variance, read as long memory:

>>> rng = np.random.default_rng(0)
>>> n = 1500
>>> h, y = np.ones(n), np.zeros(n)
>>> for t in range(1, n):
...     h[t] = 0.05 + 0.1 * y[t - 1] ** 2 + 0.85 * h[t - 1]
...     y[t] = np.sqrt(h[t]) * rng.standard_normal()
>>> res = FIGARCH(y).fit()
>>> list(res.params), res.truncation
(['const', 'omega', 'phi', 'd', 'beta'], 1000)
>>> bool(0.0 < res.d < 1.0), res.has_long_memory
(True, True)
>>> res.persistence, res.is_covariance_stationary, res.half_life
(1.0, False, inf)

Attributes#

truncation

Number of ARCH(\(\infty\)) weights retained before the backcast tail.

phi

Short-memory numerator weight, in \((0, 1)\).

d

Fractional integration order, in \((0, 1)\).

beta

Denominator weight, in \((0, 1)\).

conditional_variance

conditional_volatility

Conditional standard deviation, sqrt(conditional_variance).

const

endog

fittedvalues

half_life

Periods for a variance shock to decay by half.

has_long_memory

Whether d is far enough from zero to imply hyperbolic decay.

information_criteria

AIC, BIC, and HQIC derived from the likelihood and parameter count.

is_covariance_stationary

Always False; see persistence.

llf

mean

n_params

nobs

omega

params

Estimated parameters keyed by display name, in table order.

persistence

Unity, by construction.

resid

standardized_resid

Mean residuals scaled by the fitted conditional volatility.

Methods#

compare(*others[, criterion])

Rank this result against others by an information criterion.

likelihood_ratio_test(unrestricted)

Test this result as the restricted model against a nesting one.

simulate([n, seed, burn])

Refused: a long-memory variance has no finite-state recursion to start from.

summary()

The estimation summary, renderable as text, HTML, or a dataframe.

to_dict()

The aligned per-observation outputs as plain numpy arrays.

to_pandas(*[, index])

The aligned per-observation outputs as a pandas.DataFrame.

to_polars()

The aligned per-observation outputs as a polars.DataFrame.