## Stata 15 help for arch

```
[TS] arch -- Autoregressive conditional heteroskedasticity (ARCH) family of
estimators

Syntax

arch depvar [indepvars] [if] [in] [weight] [, options]

options                     Description
-------------------------------------------------------------------------
Model
noconstant                suppress constant term
arch(numlist)             ARCH terms
garch(numlist)            GARCH terms
saarch(numlist)           simple asymmetric ARCH terms
tarch(numlist)            threshold ARCH terms
aarch(numlist)            asymmetric ARCH terms
narch(numlist)            nonlinear ARCH terms
narchk(numlist)           nonlinear ARCH terms with single shift
abarch(numlist)           absolute value ARCH terms
atarch(numlist)           absolute threshold ARCH terms
sdgarch(numlist)          lags of s_t
earch(numlist)            new terms in Nelson's EGARCH model
egarch(numlist)           lags of ln(s_t^2)
parch(numlist)            power ARCH terms
tparch(numlist)           threshold power ARCH terms
aparch(numlist)           asymmetric power ARCH terms
nparch(numlist)           nonlinear power ARCH terms
nparchk(numlist)          nonlinear power ARCH terms with single shift
pgarch(numlist)           power GARCH terms
constraints(constraints)  apply specified linear constraints
collinear                 keep collinear variables

Model 2
archm                     include ARCH-in-mean term in the
mean-equation specification
archmlags(numlist)        include specified lags of conditional
variance in mean equation
archmexp(exp)             apply transformation in exp to any
ARCH-in-mean terms
arima(#p, #d, #q)         specify ARIMA(p,d,q) model for dependent
variable
ar(numlist)               autoregressive terms of the structural model
disturbance
ma(numlist)               moving-average terms of the structural model
disturbances

Model 3
distribution(dist [#])    use dist distribution for errors (may be
gaussian, normal, t, or ged; default is
gaussian)
het(varlist)              include varlist in the specification of the
conditional variance
savespace                 conserve memory during estimation

Priming
arch0(xb)                 compute priming values on the basis of the
expected unconditional variance; the
default
arch0(xb0)                compute priming values on the basis of the
estimated variance of the residuals from
OLS
arch0(xbwt)               compute priming values on the basis of the
weighted sum of squares from OLS residuals
arch0(xb0wt)              compute priming values on the basis of the
weighted sum of squares from OLS residuals,
with more weight at earlier times
arch0(zero)               set priming values of ARCH terms to zero
arch0(#)                  set priming values of ARCH terms to #
arma0(zero)               set all priming values of ARMA terms to zero;
the default
arma0(p)                  begin estimation after observation p, where p
is the maximum AR lag in model
arma0(q)                  begin estimation after observation q, where q
is the maximum MA lag in model
arma0(pq)                 begin estimation after observation (p + q)
arma0(#)                  set priming values of ARMA terms to #
condobs(#)                set conditioning observations at the start of
the sample to #

SE/Robust
vce(vcetype)              vcetype may be opg, robust, or oim

Reporting
level(#)                  set confidence level; default is level(95)
detail                    report list of gaps in time series
nocnsreport               do not display constraints
display_options           control columns and column formats, row
spacing, and line width

Maximization
maximize_options          control the maximization process; seldom used

coeflegend                display legend instead of statistics
-------------------------------------------------------------------------
You must tsset your data before using arch; see [TS] tsset.
depvar and varlist may contain time-series operators; see tsvarlist.
by, fp, rolling, statsby, and xi are allowed; see prefix.
iweights are allowed; see weight.
coeflegend does not appear in the dialog box.
See [TS] arch postestimation for features available after estimation.

To fit an ARCH(#m) model with Gaussian errors, type

. arch depvar ..., arch(1/#m)

To fit a GARCH(#m,#k) model assuming that the errors follow Student's t
distribution with 7 degrees of freedom, type

. arch depvar ..., arch(1/#m) garch(1/#k) distribution(t 7)

You can also fit many other models.

ARCH/GARCH

Statistics > Time series > ARCH/GARCH > ARCH and GARCH models

EARCH/EGARCH

Statistics > Time series > ARCH/GARCH > Nelson's EGARCH model

ABARCH/ATARCH/SDGARCH

Statistics > Time series > ARCH/GARCH > Threshold ARCH model

ARCH/TARCH/GARCH

Statistics > Time series > ARCH/GARCH > GJR form of threshold ARCH
model

ARCH/SAARCH/GARCH

Statistics > Time series > ARCH/GARCH > Simple asymmetric ARCH model

PARCH/PGARCH

Statistics > Time series > ARCH/GARCH > Power ARCH model

NARCH/GARCH

Statistics > Time series > ARCH/GARCH > Nonlinear ARCH model

NARCHK/GARCH

Statistics > Time series > ARCH/GARCH > Nonlinear ARCH model with one
shift

APARCH/PGARCH

Statistics > Time series > ARCH/GARCH > Asymmetric power ARCH model

NPARCH/PGARCH

Statistics > Time series > ARCH/GARCH > Nonlinear power ARCH model

Description

arch fits regression models in which the volatility of a series varies
through time.  Usually, periods of high and low volatility are grouped
together.  ARCH models estimate future volatility as a function of prior
volatility.  To accomplish this, arch fits models of autoregressive
conditional heteroskedasticity (ARCH) by using conditional maximum
likelihood.  In addition to ARCH terms, models may include multiplicative
heteroskedasticity.  Gaussian (normal), Student's t, and generalized
error distributions are supported.

Concerning the regression equation itself, models may also contain
ARCH-in-mean and ARMA terms.

The following are commonly fitted models:

Common term                               Options to specify
---------------------------------------------------------------------
ARCH                                      arch()

GARCH                                     arch() garch()

ARCH-in-mean                              archm arch() [garch()]

GARCH with ARMA terms                     arch() garch() ar() ma()

EGARCH                                    earch() egarch()

TARCH, threshold ARCH                     abarch() atarch() sdgarch()

GJR, form of threshold ARCH               arch() tarch() [garch()]

SAARCH, simple asymmetric ARCH            arch() saarch() [garch()]

PARCH, power ARCH                         parch() [pgarch()]

NARCH, nonlinear ARCH                     narch() [garch()]

NARCHK, NARCH with one shift              narchk() [garch()]

A-PARCH, asymmetric power ARCH            aparch() [pgarch()]

NPARCH, nonlinear power ARCH              nparch() [pgarch()]
---------------------------------------------------------------------

Options

+-------+
----+ Model +------------------------------------------------------------

noconstant; see [R] estimation options.

arch(numlist) specifies the ARCH terms (lags of e_t^2).

Specify arch(1) to include first-order terms, arch(1/2) to specify
first- and second-order terms, arch(1/3) to specify first-, second-,
and third-order terms, etc.  Terms may be omitted.  Specify
arch(1/3 5) to specify terms with lags 1, 2, 3, and 5.  All the
options work this way.

arch() may not be specified with aarch(), narch(), narchk(),
nparchk(), or nparch(), as this would result in collinear terms.

garch(numlist) specifies the GARCH terms (lags of s_t^2).

saarch(numlist) specifies the simple asymmetric ARCH terms.  Adding these
terms is one way to make the standard ARCH and GARCH models respond
asymmetrically to positive and negative innovations.  Specifying
saarch() with arch() and garch() corresponds to the SAARCH model of
Engle (1990).

saarch() may not be specified with narch(), narchk(), nparchk(), or
nparch(), as this would result in collinear terms.

tarch(numlist) specifies the threshold ARCH terms.  Adding these is
another way to make the standard ARCH and GARCH models respond
asymmetrically to positive and negative innovations.  Specifying
tarch() with arch() and garch() corresponds to one form of the GJR
model (Glosten, Jagannathan, and Runkle 1993).

tarch() may not be specified with tparch() or aarch(), as this would
result in collinear terms.

aarch(numlist) specifies the lags of the two-parameter term
a(|e_t|+g*e_t)^2.  This term provides the same underlying form of
asymmetry as including arch() and tarch(), but it is expressed in a
different way.

aarch() may not be specified with arch() or tarch(), as this would
result in collinear terms.

narch(numlist) specifies lags of the two-parameter term a(e_t-ki)^2.
This term allows the minimum conditional variance to occur at a value
of lagged innovations other than zero.  For any term specified at lag
L, the minimum contribution to conditional variance of that lag
occurs when the squared innovations at that lag are equal to the
estimated constant k_L.

narch() may not be specified with arch(), saarch(), narchk(),
nparchk(), or nparch(), as this would result in collinear terms.

narchk(numlist) specifies lags of the two-parameter term a(e_t-k)^2; this
is a variation of narch() with k held constant for all lags.

narchk() may not be specified with arch(), saarch(), narch(),
nparchk(), or nparch(), as this would result in collinear terms.

abarch(numlist) specifies lags of the term |e_t|.

atarch(numlist) specifies lags of |e_t|(e_t > 0), where (e_t > 0)
represents the indicator function returning 1 when true and 0 when
false.  Like the TARCH terms, these ATARCH terms allow the effect of
unanticipated innovations to be asymmetric about zero.

sdgarch(numlist) specifies lags of s_t.  Combining atarch(), abarch(),
and sdgarch() produces the model by Zakoian (1994) that the author
called the TARCH model.  The acronym TARCH, however, refers to any
model using thresholding to obtain asymmetry.

earch(numlist) specifies lags of the two-parameter term
a*z_t+g*(|z_t|- sqrt(2/pi)).  These terms represent the influence of
news -- lagged innovations -- in Nelson's (1991) EGARCH model.  For
these terms, z_t=e_t/s_t, and arch assumes z_t ~ N(0,1).  Nelson
derived the general form of an EGARCH model for any assumed
distribution and performed estimation assuming a generalized error
distribution (GED).  See Hamilton (1994) for a derivation where z_t
is assumed normal.  The z_t terms can be parameterized in either of
these two equivalent ways.  arch uses Nelson's original
parameterization; see Hamilton (1994) for an equivalent alternative.

egarch(numlist) specifies lags of ln(s_t^2).

For the following options, the model is parameterized in terms of
h(e_t)^p and s_t^p.  One p is estimated, even when more than one option
is specified.

parch(numlist) specifies lags of |e_t|^p.  parch() combined with pgarch()
corresponds to the class of nonlinear models of conditional variance
suggested by Higgins and Bera (1992).

tparch(numlist) specifies lags of (e_t>0)|e_t|^p, where (e_t > 0)
represents the indicator function returning 1 when true and 0 when
false.  As with tarch(), tparch() specifies terms that allow for a
differential impact of "good" (positive innovations) and "bad"
(negative innovations) news for lags specified by numlist.

tparch() may not be specified with tarch(), as this would result in
collinear terms.

aparch(numlist) specifies lags of the two-parameter term
a(|e_t|+g*e_t)^p.  This asymmetric power ARCH model, A-PARCH, was
proposed by Ding, Granger, and Engle (1993) and corresponds to a
Box-Cox function in the lagged innovations.  The authors fit the
original A-PARCH model on more than 16,000 daily observations of the
Standard and Poor's 500, and for good reason.  As the number of
parameters and the flexibility of the specification increase, more
data are required to estimate the parameters of the conditional
heteroskedasticity.  See Ding, Granger, and Engle (1993) for a
discussion of how seven popular ARCH models nest within the A-PARCH
model.

When g goes to 1, the full term goes to zero for many observations
and can then be numerically unstable.

nparch(numlist) specifies lags of the two-parameter term a|e_t-ki|^p.

nparch() may not be specified with arch(), saarch(), narch(),
narchk(), or nparchk(), as this would result in collinear terms.

nparchk(numlist) specifies lags of the two-parameter term a|e_t-k|^p;
this is a variation of nparch() with k held constant for all lags.
This is a direct analog of narchk(), except for the power of p.
nparchk() corresponds to an extended form of the model of Higgins and
Bera (1992) as presented by Bollerslev, Engle, and Nelson (1994).
nparchk() would typically be combined with the pgarch() option.

nparchk() may not be specified with arch(), saarch(), narch(),
narchk(), or nparch(), as this would result in collinear terms.

pgarch(numlist) specifies lags of (s_t)^p.

constraints(constraints), collinear; see [R] estimation options.

+---------+
----+ Model 2 +----------------------------------------------------------

archm specifies that an ARCH-in-mean term be included in the
specification of the mean equation.  This term allows the expected
value of depvar to depend on the conditional variance.  ARCH-in-mean
is most commonly used in evaluating financial time series when a
theory supports a tradeoff between asset risk and return.  By
default, no ARCH-in-mean terms are included in the model.

archm specifies that the contemporaneous expected conditional
variance be included in the mean equation.

archmlags(numlist) is an expansion of archm that includes lags of the
conditional variance s_t^2 in the mean equation.  To specify a
contemporaneous and once-lagged variance, specify either archm
archmlags(1) or archmlags(0/1).

archmexp(exp) applies the transformation in exp to any ARCH-in-mean terms
in the model.  The expression should contain an X wherever a value of
the conditional variance is to enter the expression.  This option can
be used to produce the commonly used ARCH-in-mean of the conditional
standard deviation.

arima(#p,#d,#q) is an alternative, shorthand notation for specifying
autoregressive models in the dependent variable.  The dependent
variable and any independent variables are differenced #d times, 1
through #p lags of autocorrelations are included, and 1 through #q
lags of moving averages are included.  For example, the specification

. arch y, arima(2,1,3)

is equivalent to

. arch D.y, ar(1/2) ma(1/3)

The former is easier to write for classic ARIMA models of the mean
equation, but it is not nearly as expressive as the latter.  If gaps
in the AR or MA lags are to be modeled, or if different operators are
to be applied to independent variables, the latter syntax is
required.

ar(numlist) specifies the autoregressive terms of the structural model
disturbance to be included in the model.  For example, ar(1/3)
specifies that lags 1, 2, and 3 of the structural disturbance be
included in the model.  ar(1,4) specifies that lags 1 and 4 be
included, possibly to account for quarterly effects.

If the model does not contain regressors, these terms can also be
considered autoregressive terms for the dependent variable; see [TS]
arima.

ma(numlist) specifies the moving-average terms to be included in the
model.  These are the terms for the lagged innovations or white-noise
disturbances.

+---------+
----+ Model 3 +----------------------------------------------------------

distribution(dist [#]) specifies the distribution to assume for the error
term.  dist may be gaussian, normal, t, or ged.  gaussian and normal
are synonyms, and # cannot be specified with them.

If distribution(t) is specified, arch assumes that the errors follow
Student's t distribution, and the degree-of-freedom parameter is
estimated along with the other parameters of the model.  If
distribution(t #) is specified, then arch uses Student's t
distribution with # degrees of freedom.  # must be greater than 2.

If distribution(ged) is specified, arch assumes that the errors have
a generalized error distribution, and the shape parameter is
estimated along with the other parameters of the model.  If
distribution(ged #) is specified, then arch uses the generalized
error distribution with shape parameter #.  # must be positive.  The
generalized error distribution is identical to the normal
distribution when the shape parameter equals 2.

het(varlist) specifies that varlist be included in the specification of
the conditional variance.  varlist may contain time-series operators.
This varlist enters the variance specification collectively as
multiplicative heteroskedasticity; see Judge et al. (1985).  If het()
is not specified, the model will not contain multiplicative
heteroskedasticity.

savespace conserves memory by retaining only those variables required for
estimation.  The original dataset is restored after estimation.  This
option is rarely used and should be specified only if there is
insufficient memory to fit a model without the option.  arch requires
considerably more temporary storage during estimation than most
estimation commands in Stata.

+---------+
----+ Priming +----------------------------------------------------------

arch0(cond_method) is a rarely used option that specifies how to compute
the conditioning (presample or priming) values for s_t^2 and e_t^2.
In the presample period, it is assumed that s_t^2 = e_t^2 and that
this value is constant.  If arch0() is not specified, the priming
values are computed as the expected unconditional variance given the
current estimates of the b coefficients and any ARMA parameters.  See
[TS] arch for details.

arma0(cond_method) is a rarely used option that specifies how the e_t
values are initialized at the beginning of the sample for the ARMA
component, if the model has one.  This option has an effect only when
AR or MA terms are included in the model (the ar(), ma(), or arima()
option specified).  See [TS] arch for details.

condobs(#) is a rarely used option that specifies a fixed number of
conditioning observations at the start of the sample.  Over these
priming observations, the recursions necessary to generate predicted
disturbances are performed, but only to initialize preestimation
values of e_t, e_t^2, and s_t^2.  Any required lags of e_t before the
initialization period are taken to be their expected value of 0 (or
the value specified in arma0()), and required values of e_t^2 and
s_t^2 assume the values specified by arch0().  condobs() can be used
if conditioning observations are desired for the lags in the ARCH
terms of the model.  If arma() is also specified, the maximum number
of conditioning observations required by arma() and condobs(#) is
used.

+-----------+
----+ SE/Robust +--------------------------------------------------------

vce(vcetype) specifies the type of standard error reported, which
includes types that are robust to some kinds of misspecification
(robust) and that are derived from asymptotic theory (oim, opg); see
[R] vce_option.

For ARCH models, the robust or quasi-maximum likelihood estimates
(QMLE) of variance are robust to symmetric nonnormality in the
disturbances.  The robust variance estimates generally are not robust
to functional misspecification of the mean equation; see Bollerslev
and Wooldridge (1992).

The robust variance estimates computed by arch are based on the full
Huber/White/sandwich formulation, as discussed in [P] _robust.  Many
other software packages report robust estimates that set some terms
to their expectations of zero (Bollerslev and Wooldridge 1992), which
saves them from calculating second derivatives of the log-likelihood
function.

+-----------+
----+ Reporting +--------------------------------------------------------

level(#); see [R] estimation options.

detail specifies that a detailed list of any gaps in the series be
reported, including gaps due to missing observations or missing data
for the dependent variable or independent variables.

nocnsreport; see [R] estimation options.

display_options:  noci, nopvalues, vsquish, cformat(%fmt), pformat(%fmt),
sformat(%fmt), and nolstretch; see [R] estimation options.

+--------------+
----+ Maximization +-----------------------------------------------------

maximize_options:  difficult, technique(algorithm_spec), iterate(#),
[no]log, trace, gradient, showstep, hessian, showtolerance,
tolerance(#), ltolerance(#), gtolerance(#), nrtolerance(#),
nonrtolerance, and from(init_specs); see [R] maximize for all options
except gtolerance(), and see below for information on gtolerance().

These options are often more important for ARCH models than for other
maximum likelihood models because of convergence problems associated
with ARCH models -- ARCH model likelihoods are notoriously difficult
to maximize.

Setting technique() to something other than the default or BHHH
changes the vcetype to vce(oim).

The following options are all related to maximization and are either
particularly important in fitting ARCH models or not available for
most other estimators.

gtolerance(#) specifies the tolerance for the gradient relative to
the coefficients.  When |g_i*b_i| < gtolerance() for all
parameters b_i and the corresponding elements of the gradient
g_i, the gradient tolerance criterion is met.  The default
gradient tolerance for arch is gtolerance(.05).

gtolerance(999) may be specified to disable the gradient
criterion.  If the optimizer becomes stuck with repeated "(backed
up)" messages, the gradient probably still contains substantial
values, but an uphill direction cannot be found for the
likelihood.  With this option, results can often be obtained, but
whether the global maximum likelihood has been found is unclear.

When the maximization is not going well, it is also possible to
set the maximum number of iterations (see [R] maximize) to the
point where the optimizer appears to be stuck and to inspect the
estimation results at that point.

from(init_specs) specifies the initial values of the coefficients.
ARCH models may be sensitive to initial values and may have
coefficient values that correspond to local maximums.  The
default starting values are obtained via a series of regressions,
producing results that, on the basis of asymptotic theory, are
consistent for the b and ARMA parameters and generally reasonable
for the rest.  Nevertheless, these values may not always be
feasible in that the likelihood function cannot be evaluated at
the initial values arch first chooses.  In such cases, the
estimation function is restarted with ARCH and ARMA parameters
initialized to zero.  It is possible, but unlikely, that even
these values will be infeasible and that you will have to supply
initial values yourself.

The standard syntax for from() accepts a matrix, a list of
values, or coefficient name value pairs; see [R] maximize.  arch
also allows the following:

from(archb0) sets the starting value for all the ARCH/GARCH/...
parameters in the conditional-variance equation to 0.

from(armab0) sets the starting value for all ARMA parameters in
the model to 0.

from(archb0 armab0) sets the starting values for all
ARCH/GARCH/... and ARMA parameters to 0.

The following option is available with arch but is not shown in the
dialog box:

coeflegend; see [R] estimation options.

Examples

---------------------------------------------------------------------------
Setup
. webuse wpi1

ARCH model with three lags
. arch D.ln_wpi, arch(1/3)

GARCH(2,1) model
. arch D.ln_wpi, arch(1/2) garch(1)

Same as above, but assuming that errors follow the generalized error
distribution
. arch D.ln_wpi, arch(1/2) garch(1) distribution(ged)

---------------------------------------------------------------------------
Setup
. webuse urates

GARCH(1,1) model with covariates
. arch illinois indiana kentucky, arch(1) garch(1)

Same as above, but assuming that errors follow Student's t distribution
with 6 degrees of freedom
. arch illinois indiana kentucky, arch(1) garch(1) distribution(t 6)

---------------------------------------------------------------------------
Setup
. webuse wpi1

GARCH(1,1) model with ARMA disturbances
. arch D.ln_wpi, ar(1) ma(1 4) arch(1) garch(1)

EGARCH model with ARMA disturbances
. arch D.ln_wpi, ar(1) ma(1 4) earch(1) egarch(1)

Setup
. constraint 1 (3/4)*[ARCH]l1.arch = [ARCH]l2.arch
. constraint 2 (2/4)*[ARCH]l1.arch = [ARCH]l3.arch
. constraint 3 (1/4)*[ARCH]l1.arch = [ARCH]l4.arch

ARCH model with constraints
. arch D.ln_wpi, ar(1) ma(1 4) arch(1/4) constraint(1/3)

---------------------------------------------------------------------------
Setup
. webuse dow1

Threshold ARCH model
. arch D.ln_dow, tarch(1)
---------------------------------------------------------------------------

Stored results

arch stores the following in e():

Scalars
e(N)                number of observations
e(N_gaps)           number of gaps
e(condobs)          number of conditioning observations
e(k)                number of parameters
e(k_eq)             number of equations in e(b)
e(k_eq_model)       number of equations in overall model test
e(k_dv)             number of dependent variables
e(k_aux)            number of auxiliary parameters
e(df_m)             model degrees of freedom
e(ll)               log likelihood
e(chi2)             chi-squared
e(p)                p-value for model test
e(archi)            sigma_0^2=epsilon_0^2, priming values
e(archany)          1 if model contains ARCH terms, 0 otherwise
e(tdf)              degrees of freedom for Student's t distribution
e(shape)            shape parameter for generalized error distribution
e(tmin)             minimum time
e(tmax)             maximum time
e(power)            varphi for power ARCH terms
e(rank)             rank of e(V)
e(ic)               number of iterations
e(rc)               return code
e(converged)        1 if converged, 0 otherwise

Macros
e(cmd)              arch
e(cmdline)          command as typed
e(depvar)           name of dependent variable
e(covariates)       list of covariates
e(eqnames)          names of equations
e(wtype)            weight type
e(wexp)             weight expression
e(title)            title in estimation output
e(tmins)            formatted minimum time
e(tmaxs)            formatted maximum time
e(dist)             distribution for error term: gaussian, t, or ged
e(mhet)             1 if multiplicative heteroskedasticity
e(dfopt)            yes if degrees of freedom for t distribution or
shape parameter for GED distribution was
estimated, no otherwise
e(chi2type)         Wald; type of model chi-squared test
e(vce)              vcetype specified in vce()
e(vcetype)          title used to label Std. Err.
e(ma)               lags for moving-average terms
e(ar)               lags for autoregressive terms
e(arch)             lags for ARCH terms
e(archm)            ARCH-in-mean lags
e(archmexp)         ARCH-in-mean exp
e(earch)            lags for EARCH terms
e(egarch)           lags for EGARCH terms
e(aarch)            lags for AARCH terms
e(narch)            lags for NARCH terms
e(aparch)           lags for A-PARCH terms
e(nparch)           lags for NPARCH terms
e(saarch)           lags for SAARCH terms
e(parch)            lags for PARCH terms
e(tparch)           lags for TPARCH terms
e(abarch)           lags for ABARCH terms
e(tarch)            lags for TARCH terms
e(atarch)           lags for ATARCH terms
e(sdgarch)          lags for SDGARCH terms
e(pgarch)           lags for PGARCH terms
e(garch)            lags for GARCH terms
e(opt)              type of optimization
e(ml_method)        type of ml method
e(user)             name of likelihood-evaluator program
e(technique)        maximization technique
e(tech)             maximization technique, including number of
iterations
e(tech_steps)       number of iterations performed before switching
techniques
e(properties)       b V
e(estat_cmd)        program used to implement estat
e(predict)          program used to implement predict
e(marginsok)        predictions allowed by margins
e(marginsnotok)     predictions disallowed by margins

Matrices
e(b)                coefficient vector
e(Cns)              constraints matrix
e(ilog)             iteration log (up to 20 iterations)
e(V)                variance-covariance matrix of the estimators
e(V_modelbased)     model-based variance

Functions
e(sample)           marks estimation sample

References

Bollerslev, T., R. F. Engle, and D. B. Nelson. 1994.  ARCH models.  In
Handbook of Econometrics, Volume IV, ed.  R. F. Engle and D. L.

Bollerslev, T., and J. M. Wooldridge. 1992.  Quasi-maximum likelihood
estimation and inference in dynamic models with time-varying
covariances. Econometric Reviews 11: 143-172.

Ding, Z., C. W. J. Granger, and R. F. Engle. 1993.  A long memory
property of stock market returns and a new model.  Journal of
Empirical Finance 1: 83-106.

Engle, R. F. 1990. Discussion: Stock volatility and the crash of '87.
Review of Financial Studies 3: 103-106.

Glosten, L. R., R. Jagannathan, and D. E. Runkle. 1993.  On the relation
between the expected value and the volatility of the nominal excess
return on stocks. Journal of Finance 48: 1779-1801.

Hamilton, J. D. 1994. Time Series Analysis.  Princeton: Princeton
University Press.

Higgins, M. L., and A. K. Bera. 1992.  A class of nonlinear ARCH models.
International Economic Review 33:  137-158.

Judge, G. G., W. E. Griffiths, R. C. Hill, H. Lütkepohl, and T.-C. Lee.
1985. The Theory and Practice of Econometrics. 2nd ed. New York:
Wiley.

Nelson, D. B. 1991. Conditional heteroskedasticity in asset returns:  A
new approach. Econometrica 59: 347-370.

Zakoian, J. M. 1994. Threshold heteroskedastic models.  Journal of
Economic Dynamics and Control 18: 931-955.

```