It's natural in data analysis applications for parameters to have bounds; variances can't be negative, GARCH coefficients must sum to less than one for stationarity, and mixing proportions live between zero and one.

When you estimate these models by maximum likelihood, the optimizer needs to respect those bounds, not just at the solution, but throughout the search. If optimization searches wander into invalid territory, it can impact the reliability and convergence of your results. For example, you may get complex numbers from negative variances, explosive forecasts from non-stationary GARCH, or likelihoods that make no sense.

GAUSS 26.0.1 introduces minimize, the first new GAUSS optimizer in over 10 years, to handle this cleanly.

The minimize optmizer let's you specify bounds directly and GAUSS internally keeps parameters feasible at every iteration. No more log-transforms, no penalty functions, and no doublechecking.

In today's blog, we'll see the new minimize function in action, as we walk through two examples:

• A GARCH estimation where variance parameters must be positive
• A Stochastic frontier models where both variance components must be positive.

In both cases, bounded optimization makes estimation easier and aligns results with theory.

Why Bounds Matter

To see why this matters in practice, let’s look at a familiar example. Consider a GARCH(1,1) model:

$\sigma^2_t = \omega + \alpha \varepsilon^2_{t-1} + \beta \sigma^2_{t-1}$

For this model to be well-defined and economically meaningful:

• The baseline variance must be positive ($\omega \gt 0$)
• Shocks and persistence must contribute non-negatively to variance ($\alpha \geq 0$, $\beta \geq 0$)
• The model must be stationary ($\alpha + \beta \lt 1$)

The traditional workaround is to estimate transformed parameters, $\log(\omega)$ instead of $\omega$, then convert back. This works, but it distorts the optimization surface and complicates standard error calculations. You're not estimating the parameters you care about; you're estimating transforms and hoping the numerics work out.

With bounded optimization, you estimate $\omega$, $\alpha$, and $\beta$ directly, with the optimizer respecting the constraints throughout.

Example 1: GARCH(1,1) on Commodity Returns

Let's estimate a GARCH(1,1) model on a dataset of 248 observations of commodity price returns (this data is included in the GAUSS 26 examples directory).

Step One: Data and Likelihood

First, we load the data and specify our log-likelihood objective function.

// Load returns data (ships with GAUSS)
fname = getGAUSShome("examples/df_returns.gdat");
returns = loadd(fname, "rcpi");

// GARCH(1,1) negative log-likelihood
proc (1) = garch_negll(theta, y);
    local omega, alpha, beta_, sigma2, ll, t;

    omega = theta[1];
    alpha = theta[2];
    beta_ = theta[3];

    sigma2 = zeros(rows(y), 1);

    // Initialize with sample variance
    sigma2[1] = stdc(y)^2;

    // Variance recursion
    for t (2, rows(y), 1);
        sigma2[t] = omega + alpha * y[t-1]^2 + beta_ * sigma2[t-1];
    endfor;

    // Gaussian log-likelihood
    ll = -0.5 * sumc(ln(2*pi) + ln(sigma2) + (y.^2) ./ sigma2);

    retp(-ll);  // Return negative for minimization
endp;

Step Two: Setting Up Optimization

Now we set up the bounded optimization with:

• $\omega \gt 0$ (small positive lower bound to avoid numerical issues)
• $\alpha \geq 0$
• $\beta \geq 0$

Because minimize handles simple box constraints, we impose individual upper bounds on $\alpha$ and $\beta$ to keep the optimizer in a reasonable region. We'll verify the stationarity condition, $\alpha + \beta \lt 1$ after estimation.

// Starting values
theta0 = { 0.00001,   // omega (small, let data speak)
           0.05,      // alpha
           0.90 };    // beta

// Set up minimize
struct minimizeControl ctl;
ctl = minimizeControlCreate();

// Bounds: all parameters positive, alpha + beta < 1
ctl.bounds = { 1e-10      1,      // omega in [1e-10, 1]
               0          1,      // alpha in [0, 1]
               0     0.9999 };    // beta in [0, 0.9999]

Step Three: Running the Model

Finally, we call minimize to run our model.

// Estimate
struct minimizeOut out;
out = minimize(&garch_negll, theta0, returns, ctl);

Results and Visualization

After estimation, we'll extract the conditional variance series and confirm the stationarity condition:

// Extract estimates
omega_hat = out.x[1];
alpha_hat = out.x[2];
beta_hat = out.x[3];

print "omega = " omega_hat;
print "alpha = " alpha_hat;
print "beta  = " beta_hat;
print "alpha + beta = " alpha_hat + beta_hat;
print "Iterations: " out.iterations;

Output:

omega = 0.0000070
alpha = 0.380
beta  = 0.588

alpha + beta = 0.968
Iterations: 39

There are a few noteworthy results:

1. The high persistence ($\alpha + \beta \approx 0.97$) means volatility shocks decay slowly.
2. The relatively high $\alpha$ (0.38) indicates that recent shocks have substantial immediate impact on variance.
3. The optimization converged in 39 iterations with all parameters staying inside their bounds throughout. No invalid variance evaluations, no numerical exceptions.

Visualizing the conditional variance alongside the original series provides further insight:

// Compute conditional variance series for plotting
T = rows(returns);
sigma2_hat = zeros(T, 1);
sigma2_hat[1] = stdc(returns)^2;

for t (2, T, 1);
    sigma2_hat[t] = omega_hat + alpha_hat * returns[t-1]^2 + beta_hat * sigma2_hat[t-1];
endfor;

// Plot returns and conditional volatility
struct plotControl plt;
plt = plotGetDefaults("xy");
plotSetTitle(&plt, "GARCH(1,1): Returns and Conditional Volatility");
plotSetYLabel(&plt, "Returns / Volatility");

plotLayout(2, 1, 1);
plotXY(plt, seqa(1, 1, T), returns);

plotLayout(2, 1, 2);
plotSetTitle(&plt, "Conditional Standard Deviation");
plotXY(plt, seqa(1, 1, T), sqrt(sigma2_hat));

The plot shows volatility clustering: periods of high volatility tend to persist, consistent with what we observe in commodity markets.

Example 2: Stochastic Frontier Model

Stochastic frontier analysis separates random noise from systematic inefficiency. It's widely used in productivity analysis to measure how far firms operate below their production frontier.

The model:

$y = X\beta + v - u$

where:

• $v \sim N(0, \sigma^2_v)$ — symmetric noise (measurement error, luck)
• $u \sim N^+(0, \sigma^2_u)$ — one-sided inefficiency (always reduces output)

Both variance components must be positive. If the optimizer tries $\sigma^2_v \lt 0$ or $\sigma^2_u \lt 0$, the likelihood involves square roots of negative numbers.

Step One: Data and Likelihood

For this example, we'll simulate data from a Cobb-Douglas production function with inefficiency. This keeps the example self-contained and lets you see exactly what's being estimated.

// Simulate production data
rndseed 8675309;
n = 500;

// Inputs (labor, capital, materials)
labor = exp(2 + 0.5*rndn(n, 1));
capital = exp(3 + 0.7*rndn(n, 1));
materials = exp(2.5 + 0.4*rndn(n, 1));

// True parameters
beta_true = { 1.5,    // constant
              0.4,    // labor elasticity
              0.3,    // capital elasticity
              0.25 }; // materials elasticity
sig2_v_true = 0.02;   // noise variance
sig2_u_true = 0.08;   // inefficiency variance

// Generate output with noise (v) and inefficiency (u)
v = sqrt(sig2_v_true) * rndn(n, 1);
u = sqrt(sig2_u_true) * abs(rndn(n, 1));  // half-normal

X = ones(n, 1) ~ ln(labor) ~ ln(capital) ~ ln(materials);
y = X * beta_true + v - u;  // inefficiency reduces output

After simulating our data, we specify the log-likelihood function for minimization:

// Stochastic frontier log-likelihood (half-normal inefficiency)
proc (1) = sf_negll(theta, y, X);
    local k, beta_, sig2_v, sig2_u, sigma, lambda;
    local eps, z, ll;

    k = cols(X);
    beta_ = theta[1:k];
    sig2_v = theta[k+1];
    sig2_u = theta[k+2];

    sigma = sqrt(sig2_v + sig2_u);
    lambda = sqrt(sig2_u / sig2_v);

    eps = y - X * beta_;
    z = -eps * lambda / sigma;

    ll = -0.5*ln(2*pi) + ln(2) - ln(sigma)
         - 0.5*(eps./sigma).^2 + ln(cdfn(z));

    retp(-sumc(ll));
endp;

Step Two: Setting Up Optimization

As we did in our previous example, we begin with our starting values. For this model, we run OLS and use the residual variance as starting values:

// OLS for starting values
beta_ols = invpd(X'X) * X'y;
resid = y - X * beta_ols;
sig2_ols = meanc(resid.^2);

// Starting values: Split residual variance 
// between noise and inefficiency
theta0 = beta_ols | (0.5 * sig2_ols) | (0.5 * sig2_ols);

We leave our coefficients unbounded but constrain the variances to be positive:

// Bounds: coefficients unbounded, variances positive
k = cols(X);
struct minimizeControl ctl;
ctl = minimizeControlCreate();
ctl.bounds = (-1e300 * ones(k, 1) | 0.001 | 0.001) ~ (1e300 * ones(k+2, 1));

Step Three: Running the Model

Finally, we call minimize to estimate our model:

// Estimate
struct minimizeOut out;
out = minimize(&sf_negll, theta0, y, X, ctl);

Results and Visualization

Now that we've estimated our model, let's examine our results.

// Extract estimates
k = cols(X);
beta_hat = out.x[1:k];
sig2_v_hat = out.x[k+1];
sig2_u_hat = out.x[k+2];

print "Coefficients:";
print "  constant     = " beta_hat[1];
print "  ln(labor)    = " beta_hat[2];
print "  ln(capital)  = " beta_hat[3];
print "  ln(materials)= " beta_hat[4];
print "";
print "Variance components:";
print "  sig2_v (noise)       = " sig2_v_hat;
print "  sig2_u (inefficiency)= " sig2_u_hat;
print "  ratio sig2_u/total   = " sig2_u_hat / (sig2_v_hat + sig2_u_hat);
print "";
print "Iterations: " out.iterations;

This prints out coefficients and variance components:

Coefficients:
  constant     = 1.51
  ln(labor)    = 0.39
  ln(capital)  = 0.31
  ln(materials)= 0.24

Variance components:
  sig2_v (noise)       = 0.022
  sig2_u (inefficiency)= 0.087
  ratio sig2_u/total   = 0.80

Iterations: 38

The estimates recover the true parameters reasonably well. The variance ratio ($\approx 0.80$) tells us that most residual variation is systematic inefficiency, not measurement error — an important finding for policy.

We can also compute and plot firm-level efficiency scores:

// Compute efficiency estimates (Jondrow et al. 1982)
eps = y - X * beta_hat;
sigma = sqrt(sig2_v_hat + sig2_u_hat);
lambda = sqrt(sig2_u_hat / sig2_v_hat);

mu_star = -eps * sig2_u_hat / (sig2_v_hat + sig2_u_hat);
sig_star = sqrt(sig2_v_hat * sig2_u_hat / (sig2_v_hat + sig2_u_hat));

// E[u|eps] - conditional mean of inefficiency
u_hat = mu_star + sig_star * (pdfn(mu_star/sig_star) ./ cdfn(mu_star/sig_star));

// Technical efficiency: TE = exp(-u)
TE = exp(-u_hat);

// Plot efficiency distribution
struct plotControl plt;
plt = plotGetDefaults("hist");
plotSetTitle(&plt, "Distribution of Technical Efficiency");
plotSetXLabel(&plt, "Technical Efficiency (1 = frontier)");
plotSetYLabel(&plt, "Frequency");
plotHist(plt, TE, 20);

print "Mean efficiency: " meanc(TE);
print "Min efficiency:  " minc(TE);
print "Max efficiency:  " maxc(TE);

Mean efficiency: 0.80
Min efficiency:  0.41
Max efficiency:  0.95

The histogram shows substantial variation in efficiency — some firms operate near the frontier (TE $\approx$ 0.95), while others produce 40-50% below their potential. This is the kind of insight that drives productivity research.

Both variance estimates stayed positive throughout optimization. No log-transforms needed, and the estimates apply directly to the parameters we care about.

When to Use minimize

The minimize procedure is designed for one thing: optimization with bound constraints. If that's all you need, it's the right tool.

For the GARCH and stochastic frontier examples above — and most MLE problems where parameters have natural bounds — minimize handles it directly.

Conclusion

Bounded parameters show up constantly in econometric models: variances, volatilities, probabilities, shares. GAUSS 26.0.1 gives you a clean way to handle them with minimize. As we saw today minimize:

• Set bounds in the control structure
• Optimizer respects bounds throughout (not just at the solution)
• No log-transforms or penalty functions
• Included in base GAUSS

If you've been working around parameter bounds with transforms or checking for invalid values inside your likelihood function, this is the cleaner path.

Further Reading

• GARCH estimation in GAUSS
• Introduction to stochastic frontier models

Introduction

We’re excited to share the official release of Time Series MT (TSMT) 4.0!

This release provide a major upgrade to our GAUSS time series tools. With over 40 new features, enhancements, and improvements, TSMT 4.0 significantly expanding the scope and usability of TSMT.

With the TSMT 4.0 library, you can run SVAR models out of the box, without complicated programming. Easy to use new features allow you to:

• Estimate reduced-form VAR parameters, impulse response functions (IRFs), and forecast error variance decompositions (FEVDs) with ease.
• Apply built-in identification strategies like Cholesky decomposition, sign restrictions, and long-run restrictions.
• Visualize results using new, streamlined functions for plotting IRFs and FEVDs.

TSMT 4.0 makes complex SVAR analysis more accessible—without sacrificing analytical rigor.

SARIMA Modeling: Now Smarter and More Flexible

SMT 4.0 delivers a complete overhaul of its SARIMA modeling capabilities, bringing you:

• Enhanced numerical stability and robust covariance estimation.
• Intelligent enforcement of stationarity and invertibility conditions.
• Simplified estimation with smart defaults and fewer required inputs.
• Support for special cases like white noise and random walks, with or without drift.
• Accurate standard error estimation via the delta method.

These upgrades streamline SARIMA modeling and help ensure more reliable results across a wider range of model structures.

More Insightful Model Diagnostics and Reporting

================================================================================
Model:                 ARIMA(1,1,1)          Dependent variable:             wpi
Time Span:              1960-01-01:          Valid cases:                    123
                        1990-10-01

SSE:                         64.512          Degrees of freedom:             121
Log Likelihood:             369.791          RMSE:                         0.724
AIC:                        369.791          SEE:                          0.730
SBC:                       -729.958          Durbin-Watson:                1.876
R-squared:                    0.449          Rbar-squared:                 0.440
================================================================================
Coefficient                Estimate      Std. Err.        T-Ratio     Prob |>| t
================================================================================

AR[1,1]                       0.883          0.063         13.965          0.000
MA[1,1]                       0.420          0.121          3.472          0.001
Constant                      0.081          0.730          0.111          0.911
================================================================================

We’ve reimagined the output experience in TSMT 4.0, making it easier to interpret and compare model results:

• Output reports are now cleaner, clearer, and more informative.
• Expanded diagnostics help you quickly evaluate model assumptions and performance.
• Built-in summaries make it simple to assess multiple models side-by-side.

With TSMT 4.0, you’ll spend less time deciphering output and more time drawing insights.

Seamless Integration with GAUSS Dataframes

library tsmt;

// Load dataframe
fname = getGAUSSHome("pkgs/tsmt/examples/var_enders_trans.gdat");
data = loadd(fname);

// Estimate the model
call varmaFit(data, "spread + d_lip_detrend + d4_unem", 3);

TSMT 4.0 fully embraces the GAUSS dataframe ecosystem, offering:

• Automatic recognition of variable names and time spans.
• No manual reformatting required, just load your time series data and go.
• Outputs that automatically interpret dates and provide human-readable labeling.

This integration minimizes setup time and boosts productivity, especially when working with large or complex datasets.

Try Out The GAUSS Time Series MT 4.0 Library

State space models are a powerful tool for analyzing time series data, especially when you want to estimate unobserved components like trends or cycles. But traditionally, setting up these models—even for something as common as ARIMA—can be tedious.

The GAUSS arimaSS function, available in the Time Series MT 4.0 library, lets you estimate state space ARIMA models without manually building the full state space structure. It’s a cleaner, faster, and more reliable way to work with ARIMA models.

In this post, we’ll revisit our inflation modeling example using updated data from the Federal Reserve Economic Data (FRED) database. Along the way, we’ll demonstrate how arimaSS works, how it simplifies the modeling process, and how easy it is to generate forecasts from your results.

Why use arimaSS in TSMT?

In our earlier state-space inflation example, we manually set up the state space model. This process required a solid understanding of state space modeling, specifically:

• Setting up the system matrices.
• Initializing state vectors.
• Managing model dynamics.
• Specifying parameter starting values.

In comparison, the arimaSS function handles all of this setup automatically. It internally constructs the appropriate model structure and runs the Kalman filter using standard ARIMA specifications.

Overall, the arimaSS function provides:

• Simplified syntax: No need to manually define matrices or system dynamics. This not only saves time but also reduces the chance of errors or model misspecification.
• More robust estimates: Behind-the-scenes improvements, such as enhanced covariance computations and stationarity enforcement, lead to more accurate and stable parameter estimates.
• Compatibility with forecasting tools: The arimaSS output structure integrates directly with TSMT tools for computing and plotting forecasts.

The arimaSS Procedure

The arimaSS procedure has two required inputs:

1. A time series dataset.
2. The AR order.

It also allows four optional inputs for model customization:

1. The order of differencing.
2. The moving average order.
3. An indicator controlling whether a constant is included in the model.
4. An indicator controlling whether a trend is included in the the model.

General Usage

aOut = arimaSS(y, p [, d, q, trend, const]);

Y

Tx1 or Tx2 time series data. May include date variable, which will be removed from the data matrix and is not included in the model as a regressor.

p

Scalar, the number of autoregressive lags included in the model.

d

Optional, scalar, the order of differencing. Default = 0.

q

Optional, scalar, the moving average order. Default = 0.

trend

Optional, scalar, an indicator variable to include a trend in the model. Set to 1 to include trend, 0 otherwise. Default = 0.

const

Optional, an indicator variable to include a constant in the model. Set to 1 to include constant, 0 otherwise. Default = 1.

All returns are stored in an arimaOut structure, including:

• Estimated parameters.
• Model diagnostics and summary statistics.
• Model description.

The complete contents of the arimaOut structure include:

Example: Modeling Inflation

Today, we’ll use a simple, albeit naive, model of inflation. This model is based on a CPI inflation index created from the FRED CPIAUCNS monthly dataset.

To begin, we’ll load and prepare our data directly from the FRED database.

Loading data from FRED

Using the fred_load and fred_set procedures, we will:

• Pull the continuously compounded annual rate of change from FRED.
• Include data starting from January 1971 (1971m1).

// Set observation start date
fred_params = fred_set("observation_start", "1971-01-01");

// Specify units to be 
// continuous compounded annual 
// rate of change
fred_params = fred_set("units", "cca");

// Specify series to pull
series = "CPIAUCNS";

// Pull data from FRED
cpi_data = fred_load(series, fred_params);

// Preview data
head(cpi_data);

This prints the first five observations:

            date         CPIAUCNS
      1971-01-01        0.0000000
      1971-02-01        3.0112900
      1971-03-01        3.0037600
      1971-04-01        2.9962600
      1971-05-01        5.9701600 

To further preview our data, let's create a quick plot of the inflation series using the plotXY procedure and a formula string:

plotXY(cpi_data, "CPIAUCNS~date");

For fun, let’s add a reference line to visualize the Fed’s long-run average inflation target of 2%:

// Add inflation target line at 2%
plotAddHLine(2);

As one final visualization, let's look at the 5 year (60 month) moving average line:

// Compute moving average
ma_5yr = movingAve(cpi_data[., "CPIAUCNS"], 60);

// Add to time series plot
plotXY(cpi_data[., "date"], ma_5yr);

// Add inflation targetting line at 2%
plotAddHLine(2);

The moving average plot highlights long-term trends, filtering out short-term fluctuations and noise:

1. The Disinflation Era: (app. 1980-1993): This period is marked by the steep decline in inflation from the double-digit highs of the early 1980s to around 3% by the early 1990s, an outcome of aggressive monetary policy by the Federal Reserve.
2. The ‘Great Moderation’ (mid-1990s- mid-2000s): Inflation remained relatively stable and low, hovering near the Fed's 2% target, marked here with a horizontal line for reference.
3. Post-GFC stagnation (2008-2020): After the 2008 Global Financial Crisis, inflation trended even lower, with the 5-year average dipping below 2% for an extended period, reflecting sluggish demand and persistent slack.
4. Recent surge: The sharp rise beginning around 2021 reflects the post-pandemic spike in inflation, pushing the 5-year average above 3% for the first time in over a decade.

We’ll make one final transformation before estimation by converting the "CPIAUCNS" values from percentages to decimals.

cpi_data[., "CPIAUCNS"] = cpi_data[., "CPIAUCNS"]/100;

ARIMA Estimation

Now that we’ve loaded our data, we’re ready to estimate our model using arimaSS. We’ll start with a simple AR(2) model. Based on the earlier visualization, it’s reasonable to include a constant but exclude a trend, so we’ll use the default settings for those options.

call arimaSS(cpi_data, 2);

There are a few helpful things to note about this:

1. We did not need to remove the date vector from cpi_data before passing it to arimaSS. Most TSMT functions allow you to include a date vector with your time series. In fact, this is recommended, GAUSS will automatically detect and use the date vector to generate more informative results reports.
2. In this example, we are not storing the output. Instead, we are printing it directly to the screen using the call keyword.
3. Because this is strictly an AR model and we’re using the default deterministic components, we only need two inputs: the data and the AR order.

A detailed results report is printed to screen:

================================================================================
Model:                 ARIMA(2,0,0)          Dependent variable:        CPIAUCNS
Time Span:              1971-01-01:          Valid cases:                    652
                        2025-04-01

SSE:                          0.839          Degrees of freedom:             648
Log Likelihood:           -1244.565          RMSE:                         0.036
AIC:                      -2497.130          SEE:                          0.210
SBC:                      -2463.210          Durbin-Watson:                1.999
R-squared:                    0.358          Rbar-squared:                 0.839
================================================================================
Coefficient                Estimate      Std. Err.        T-Ratio     Prob |>| t
--------------------------------------------------------------------------------

Constant                    0.03832        0.00349       10.97118        0.00000
CPIAUCNS L(1)               0.59599        0.03715       16.04180        0.00000
CPIAUCNS L(2)               0.00287        0.03291        0.08726        0.93046
Sigma2 CPIAUCNS             0.00129        0.00007       18.05493        0.00000
================================================================================

There are some interesting observations from our results:

1. The estimated constant is statistically significant and equal to 0.038 (3.8%). This is higher than the Fed’s long-run inflation target of 2%, but not by much. It’s also important to note that our dataset begins well before the era of formal Fed inflation targeting.
2. All coefficients are statistically significant except for the CPIAUCNS L(2) coefficient.
3. The table header includes the timespan of our data. This was automatically detected because we included a date vector with our input. If no date vector is included, the timespan will be reported as unknown.

Extra credit: Looping For Model Selection

The arimaSS procedure doesn’t currently provide built-in optimal lag selection. However, we can write a simple for loop and use an array of structures to identify the best lag length.

Our goal is to select the model with the lowest AIC, allowing for a maximum of 6 lags.

Two tools will help us with this task:

1. An array of structures to store the results from each model.
2. A vector to store the AIC values from each model.

// Set maximum lags
maxlags = 6;

// Declare a single array
struct arimamtOut amo;

// Reshape to create structure array
amo = reshape(amo, maxlags, 1);

// AIC storage vector
aic_vector = zeros(maxlags, 1);

Next, we’ll loop through our models. In each iteration, we will:

1. Store the results in a separate arimamtOut structure.
2. Extract the AIC and store it in our AIC vector.
3. Adjust the sample size so that each lag selection iteration uses the same number of observations.

// Loop through lag possibilities
for i(1, maxlags, 1);
    // Trim data to enforce sample
    // size consistency 
    y_i = trimr(cpi_data, maxlags-i, 0);

    // Estimate the current 
    // AR(i) model
    amo[i] = arimaSS(y_i, i);

    // Store AIC for easy comparison
    aic_vector[i] = amo[i].aic;
endfor;

Finally, we will use the minindc procedure to find the index of the minimum AIC:

// Optimal lag is equal to location
// of minimum AIC
opt_lag = minindc(aic_vector);

// Print optimal lags
print "Optimal lags:"; opt_lag;

// Select the final output structure
struct arimamtOut amo_final;
amo_final = amo[opt_lag];

The optimal lags based on the minimum AIC is 8, yielding the following results:

================================================================================
Model:                 ARIMA(8,0,0)          Dependent variable:        CPIAUCNS
Time Span:              1971-01-01:          Valid cases:                    652
                        2025-04-01

SSE:                          0.803          Degrees of freedom:             642
Log Likelihood:           -1258.991          RMSE:                         0.035
AIC:                      -2537.982          SEE:                          0.080
SBC:                      -2453.182          Durbin-Watson:                1.998
R-squared:                    0.385          Rbar-squared:                 0.939
================================================================================
Coefficient                Estimate      Std. Err.        T-Ratio     Prob |>| t
--------------------------------------------------------------------------------

Constant                    0.03824        0.00512        7.46526        0.00000
CPIAUCNS L(1)               0.58055        0.03917       14.82047        0.00000
CPIAUCNS L(2)              -0.03968        0.04730       -0.83883        0.40156
CPIAUCNS L(3)              -0.01156        0.05062       -0.22833        0.81939
CPIAUCNS L(4)               0.09288        0.04151        2.23749        0.02525
CPIAUCNS L(5)               0.02322        0.04773        0.48639        0.62669
CPIAUCNS L(6)              -0.06863        0.04505       -1.52333        0.12767
CPIAUCNS L(7)               0.16048        0.04038        3.97391        0.00007
CPIAUCNS L(8)              -0.00313        0.02778       -0.11281        0.91018
Sigma2 CPIAUCNS             0.00123        0.00007       18.05512        0.00000
================================================================================

Conclusion

The arimaSS function offers a streamlined approach to estimating ARIMA models in state space form, eliminating the need for manual specification of system matrices and initial values. This makes it easier to explore models, experiment with lag structures, and generate forecasts, especially for users who may not be deeply familiar with state space modeling.

Further Reading

1. Introduction to the Fundamentals of Time Series Data and Analysis
2. Importing FRED Data to GAUSS
3. Understanding State-Space Models (An Inflation Example)
4. Getting Started with Time Series in GAUSS
   

In structural vector autoregressive (SVAR) modeling, one of the core challenges is identifying the structural shocks that drive the system's dynamics.

Traditional identification approaches often rely on short-run or long-run restrictions, which require strong theoretical assumptions about contemporaneous relationships or long-term behavior.

Sign restriction identification provides greater flexibility by allowing economists to specify only the direction, positive, negative, or neutral, of variable responses to shocks, based on theory.

In this blog, we’ll show you how to implement sign restriction identification using the new GAUSS procedure, svarFit, introduced in TSMT 4.0.

We’ll walk through how to:

• Specify sign restrictions.
• Estimate the SVAR model.
• Interpret the resulting impulse response functions (IRFs).

By the end of this guide, you’ll have a solid understanding of how to apply sign restrictions to uncover meaningful economic relationships.

What are Sign Restrictions?

Sign restrictions are a method of identifying structural shocks in SVAR models by specifying the expected direction of response of endogenous variables.

Sign restrictions:

• Do not impose exact constraints on parameter values or long-term impacts; they only require that impulse responses move in a particular direction for a specified period.
• Are flexible and less reliant on strict parametric assumptions than other identification methods.
• Rely on qualitative economic insights, making them less prone to model specification errors.

For example, in a monetary policy shock, economic theory might suggest that an increase in interest rates should lead to a decline in output and inflation in the short run. An SVAR sign restriction identification approach would enforce these directional movements.

Estimating SVAR Models in GAUSS

The svarFit procedure, available in TSMT 4.0, offers an all-in-one tool for:

• Estimating reduced-form parameters of VAR models.
• Implementing structural identification.
• Deriving impulse response functions (IRFs), forecast error variance decompositions (FEVDs), and historical decompositions (HDs).

While the procedure provides intuitive defaults for quick and easy estimation, it also offers the flexibility to fully customize your model.

For a detailed, step-by-step walkthrough of the estimation process, refer to my previous blog post:
Estimating SVAR Models with GAUSS.
That post offers guidance on setting up the model, estimating reduced-form parameters, and performing structural identification.

Implementing Sign Restrictions with svarFit

The svarFit procedure allows you to specify sign restrictions as a structural identification method. This is done in three primary steps:

1. Set the identification method to sign restrictions.
2. Define the sign restriction matrix.
3. Specify the shock variables and impacted horizons.

Example: Sign Restricted Responses to Supply, Demand, and Monetary Policy Shocks

Let's explore an empirical example capturing the dynamic relationships between inflation, unemployment, and the federal funds rate.

We’ll impose economically meaningful sign restrictions to identify three key shocks:

These restrictions allow us to apply economic theory to untangle the underlying structural drivers behind observed movements in the data.

Step One: Loading Our Data

The first step in our model is to load the data from the data_narsignrestrict.dta file.

/*
** Data import
*/
fname = "data_narsignrestrict.dta";
data_shortrun = loadd(fname);

Step Two: Specifying the VAR Model

In this example, we will estimate a SVAR(2) model which includes three endogenous variables and a constant:

$$\begin{aligned} \ln\text{inflat}_t = c_1 &+ a_{11} \ln\text{inflat}_{t-1} + a_{12} \ln\text{fedfunds}_{t-1} + a_{13} \ln\text{unempl}_{t-1} \\ &+ a_{14} \ln\text{inflat}_{t-2} + a_{15} \ln\text{fedfunds}_{t-2} + a_{16} \ln\text{unempl}_{t-2} \\ &+ \gamma_1 t + u_{1t} \\ \ln\text{fedfunds}_t = c_2 &+ a_{21} \ln\text{inflat}_{t-1} + a_{22} \ln\text{fedfunds}_{t-1} + a_{23} \ln\text{unempl}_{t-1} \\ &+ a_{24} \ln\text{inflat}_{t-2} + a_{25} \ln\text{fedfunds}_{t-2} + a_{26} \ln\text{unempl}_{t-2} \\ &+ \gamma_2 t + u_{2t} \\ \ln\text{unempl}_t = c_3 &+ a_{31} \ln\text{inflat}_{t-1} + a_{32} \ln\text{fedfunds}_{t-1} + a_{33} \ln\text{unempl}_{t-1} \\ &+ a_{34} \ln\text{inflat}_{t-2} + a_{35} \ln\text{fedfunds}_{t-2} + a_{36} \ln\text{unempl}_{t-2} \\ &+ \gamma_3 t + u_{3t} \\ \end{aligned}$$

/*
** Specifying the model
*/
// Three endogenous variable
// No exogenous variables  
formula = "lninflat + lnunempl + lnfedfunds";

// Specify number of lags
lags = 2;

// Include constant
const = 1;

Step Three: Set up Sign Restrictions

To set up sign restrictions we need to:

1. Specify sign restrictions as the identification method using the ident input.
2. Set up the sign restriction matrix using the irf.signRestrictions member of the svarControl structure.
3. Define the restricted shock variables and the restriction horizon using the irf.restrictedShock and irf.restrictionHorizon members of the svarControl structure.

/*
** Sign restriction setup
*/
// Specify identication method
ident = "sign";

// Declare controls structure
// Fill with defaults
struct svarControl Sctl;
Sctl = svarControlCreate();

// Specify to use sign restrictions
Sctl.irf.ident = "sign";

// Specify which shock variable is restricted
Sctl.irf.restrictedShock = { 1, 2, 3 };

// Set up restrictions horizon
Sctl.irf.restrictionHorizon = { 1, 1, 1 };

// Set up restrictions matrix
// A row for each shock, and a column for each variable
//             lninflat     lnunempl     lnfedfunds
// shock           
// supply          -           -             -
// demand          +           -             +
// monetary        -           +             +
Sctl.irf.signRestrictions = { -1  1 -1,
                               1 -1  1,
                              -1  1  1 };

Step Four: Estimate Model

Finally, we estimate our model using svarFit.

/*
** Estimate VAR model
*/
struct svarOut sOut;
sOut = svarFit(data_shortrun, formula, ident, const, lags, Sctl);

Calling the svarFit procedure loads the svarOut structure with results and automatically prints results to the screen.

=====================================================================================================
Model:                      SVAR(2)                               Number of Eqs.:                   3
Time Span:              1960-01-01:                               Valid cases:                    162
                        2000-10-01                                                                   
Log Likelihood:             406.137                               AIC:                        -13.305
                                                                  SBC:                        -12.962
=====================================================================================================
Equation                             R-sq                  DW                 SSE                RMSE

lninflat                          0.76855             2.10548            17.06367             0.33180 
lnunempl                          0.97934             4.92336             0.21507             0.03725 
lnfedfunds                        0.94903             2.30751             1.80772             0.10799 
=====================================================================================================
Results for reduced form equation lninflat
=====================================================================================================
          Coefficient            Estimate           Std. Err.             T-Ratio          Prob |>| t
-----------------------------------------------------------------------------------------------------

             Constant             0.06817             0.20780             0.32804             0.74332 
        lninflat L(1)             0.59712             0.07736             7.71851             0.00000 
        lnunempl L(1)            -1.14092             0.67732            -1.68448             0.09410 
      lnfedfunds L(1)             0.30207             0.25870             1.16765             0.24474 
        lninflat L(2)             0.25045             0.08002             3.12976             0.00209 
        lnunempl L(2)             1.05780             0.65416             1.61703             0.10790 
      lnfedfunds L(2)            -0.16005             0.26135            -0.61237             0.54119 
=====================================================================================================
Results for reduced form equation lnunempl
=====================================================================================================
          Coefficient            Estimate           Std. Err.             T-Ratio          Prob |>| t
-----------------------------------------------------------------------------------------------------

             Constant             0.01819             0.02333             0.77975             0.43673 
        lninflat L(1)             0.01173             0.00869             1.35062             0.17878 
        lnunempl L(1)             1.55876             0.07604            20.49928             0.00000 
      lnfedfunds L(1)             0.01946             0.02904             0.66991             0.50391 
        lninflat L(2)            -0.00899             0.00898            -1.00024             0.31875 
        lnunempl L(2)            -0.59684             0.07344            -8.12681             0.00000 
      lnfedfunds L(2)             0.00563             0.02934             0.19193             0.84805 
=====================================================================================================
Results for reduced form equation lnfedfunds
=====================================================================================================
          Coefficient            Estimate           Std. Err.             T-Ratio          Prob |>| t
-----------------------------------------------------------------------------------------------------

             Constant             0.16038             0.06764             2.37124             0.01896 
        lninflat L(1)             0.02722             0.02518             1.08115             0.28131 
        lnunempl L(1)            -1.14540             0.22046            -5.19558             0.00000 
      lnfedfunds L(1)             1.03509             0.08420            12.29300             0.00000 
        lninflat L(2)             0.04302             0.02605             1.65183             0.10059 
        lnunempl L(2)             1.09553             0.21292             5.14528             0.00000 
      lnfedfunds L(2)            -0.12063             0.08507            -1.41801             0.15820 
=====================================================================================================

Step Five: Visualize Dynamics

Once our model is estimated, we can gain insight into the system's dynamics by plotting:

1. Impulse response functions.
2. Forecast error variance decompositions.

First, let's look at the responses to a demand shock (lnunempl):

/*
** Visualizing dynamics
*/
// Plot IRFs of `lnunempl` shock 
plotIRF(sOut, "lnunempl", 1);

// Plot FEVDs of `lnunempl` shock
plotFEVD(sOut, "lnunempl", 1);

The plotIRF procedure generates a grid plot of IRF to a shock :

The plotFEVD procedure generates an area plot of the FEVD:

What Do We See in the IRF and FEVD Plots?

The dynamic responses to a demand shock in lnunempl provide useful insights into how the system behaves over time. Below, we highlight key observations from the forecast error variance decompositions (FEVDs) and impulse response functions (IRFs).

Forecast Error Variance Decomposition (FEVD)

The FEVD plot shows the contribution of each variable to the forecast variance of lnunempl over time:

• In the short run (periods 0–2), lnunempl itself accounts for most of the variation.
• As the forecast horizon increases, the role of lninflat grows, eventually contributing around 40% of the variation.
• The largest and most persistent contribution comes from lnfedfunds, which stabilizes above 45%, highlighting its long-term influence on unemployment dynamics.
• The share of lnunempl decreases steadily, dropping below 20% in later periods—suggesting that external variables explain more of the variation over time.

Impulse Response Functions (IRFs)

The IRFs to a shock in lnunempl display the dynamic responses of each variable in the system:

• lninflat responds positively with a hump-shaped profile. It peaks around period 4–5 before gradually returning to baseline.
• lnunempl initially declines but then reverses and increases slightly, indicating a short-run drop followed by a modest rebound.
• lnfedfunds responds sharply with a peak around period 4, suggesting a monetary tightening reaction. The response tapers off over time but remains positive.

These dynamics are consistent with a demand-driven shock: falling unemployment puts upward pressure on inflation and triggers an increase in interest rates.

Step Six: Analyze Historical Decomposition

Next, we'll examine the historical decomposition of the lnunempl variable. Historical decompositions allow us to break down the observed movements in a variable over time into contributions from each structural shock identified in the model.

This provides valuable insight into which shocks were most influential during specific periods and helps explain how demand, supply, and monetary policy shocks have shaped the path of unemployment.

// Plot HDs for `lnunempl` 
plotHD(sOut, "lnunempl", 1);

The plotHD procedure generates a time-series bar plot of the HD:

What We See in the HD Plot?

The HD plot shows the time-varying contributions of each structural shock to fluctuations in lnunempl:

• Inflation shocks (lninflat) explain a significant share of unemployment increases in the middle portion of the sample. Their contribution is mostly positive during that period, suggesting inflationary pressure played a role in raising unemployment.

• Unemployment shocks (lnunempl) dominate early and late periods of the sample. These are likely capturing idiosyncratic or residual variation not explained by the other two shocks.

• Federal funds rate shocks (lnfedfunds) play a more modest but noticeable role during downturns. Their influence is generally negative, suggesting that monetary tightening helped reduce unemployment volatility in those windows.

Overall, the decomposition illustrates that no single shock dominates throughout the entire sample. Different drivers shape the evolution of unemployment depending on the macroeconomic context.

Conclusion

Today's blog demonstrates how sign restriction identification in SVAR models can provide meaningful insights into the structural dynamics behind key macroeconomic variables.

Using economically motivated sign restrictions, we were able:

• Uncover and interpret the dynamic responses to different shocks.
• Visualize the relative importance of each shock over time.
• Trace the evolving drivers of unemployment through historical decomposition.

These findings show how SVAR models, when combined with flexible identification strategies like sign restrictions, offer a powerful framework for modeling complex macroeconomic interactions.

Further Reading

1. Introduction to the Fundamentals of Time Series Data and Analysis
2. Introduction to the Fundamentals of Vector Autoregressive Models
3. The Intuition Behind Impulse Response Functions and Forecast Error Variance Decomposition
4. Introduction to Granger Causality
5. Understanding and Solving the Structural Vector Autoregressive Identification Problem
6. The Structural VAR Model at Work: Analyzing Monetary Policy

Try Out GAUSS TSMT 4.0

Structural Vector Autoregressive (SVAR) models provide a structured approach to modeling dynamics and understanding the relationships between multiple time series variables. Their ability to capture complex interactions among multiple endogenous variables makes SVAR models fundamental tools in economics and finance. However, traditional software for estimating SVAR models has often been complicated, making analysis difficult to perform and interpret.

In today's blog, we present a step-by-step guide to using the new GAUSS procedure, svarFit, introduced in TSMT 4.0.

Understanding SVAR Models

A Structural Vector Autoregression (SVAR) model extends the basic Vector Autoregression (VAR) model by incorporating economic theory through restrictions that help identify structural shocks. This added structure allows analysts to understand how unexpected changes (shocks) in one variable impact others within the system over time.

Reduced Form vs. Structural Form

• Reduced Form: Represents observable relationships without assumptions about the underlying economic structure. This form is purely data-driven and descriptive.
• Structural Form: Applies economic theory through restrictions, enabling the identification of structural shocks. This form provides deeper insights into causal relationships.

The svarFit Procedure

The svarFit procedure is an all-in-one tool for estimating SVAR models. It provides a streamlined approach to specifying, estimating, and analyzing SVAR models in GAUSS. With svarFit, you can:

1. Estimate the reduced form VAR model.
2. Apply short-run, long-run, or sign restrictions to identify structural shocks.
3. Analyze dynamics through Impulse Response Functions (IRF), Forecast Error Variance Decomposition (FEVD), and Historical Decompositions (HD).
4. Bootstrap confidence intervals to make statistical inferences with greater reliability.

General Usage

sOut = svarFit(data, formula [, ident, const, lags, ctl])
sOut = svarFit(Y [, X_exog, ident, const, lags, ctl])

data

String or dataframe, filename or dataframe to be used with formula string.

formula

String, model formula string.

Y

TxM or Tx(M+1) time series data. May include date variable, which will be removed from the data matrix and is not included in the model as a regressor.

X_exog

Optional, matrix or dataframe, exogenous variables. If specified, the model is estimated as a VARX model. The exogenous variables are assumed to be stationary and are included in the model as additional regressors. May include a date variable, which will be removed from the data matrix and is not included in the model as a regressor.

ident

Optional, string, the identification method. Options include: "oir" = zero short-run restrictions, "bq" = zero long-run restrictions, "sign" = sign restrictions.

const

Optional, scalar, specifying deterministic components of model. 0 = No constant or trend, 1 = Constant, 2 = Constant and trend. Default = 1.

lags

Optional, scalar, number of lags to include in VAR model. If not specified, optimal lags will be computed using the information criterion specified in ctl.ic.

ctl

Optional, an instance of the svarControl structure used for setting advanced controls for estimation.

---

Specifying the Model

The svarFit is fully compatible with GAUSS dataframes, allowing for intuitive model specification using formula strings. This makes it easy to set up and estimate VAR models directly from your data.

For example, suppose we want to model the relationship between GDP Growth Rate (GR_GDP) and Inflation Rate (IR) over time. A VAR(2) model with two lags can be represented mathematically as follows:

$$\begin{aligned} GR\_GDP_t = c_1 &+ a_{11} GR\_GDP_{t-1} + a_{12} IR_{t-1} \\ &+ a_{13} GR\_GDP_{t-2} + a_{14} IR_{t-2} + u_{1t} \\ IR_t = c_2 &+ a_{21} GR\_GDP_{t-1} + a_{22} IR_{t-1} \\ &+ a_{23} GR\_GDP_{t-2} + a_{24} IR_{t-2} + u_{2t} \end{aligned}$$

Assume that our data is already loaded into a GAUSS dataframe, econ_data. This model can be directly specified for estimation using a formula string:

// Estimate SVAR model 
call svarFit(econ_data, "GR_GDP + IR");

Now, let's extend our model by including an exogenous variable, interest rate (INT), to this model. Our extended VAR(2) model equations are updated as follows:

$$\begin{aligned} GR\_GDP_t = c_1 &+ a_{11} GR\_GDP_{t-1} + a_{12} IR_{t-1} + a_{13} GR\_GDP_{t-2} + a_{14} IR_{t-2} \\ &+ b_1 INT_t + u_{1t} \\ IR_t = c_2 &+ a_{21} GR\_GDP_{t-1} + a_{22} IR_{t-1} + a_{23} GR\_GDP_{t-2} + a_{24} IR_{t-2} \\ &+ b_2 INT_t + u_{2t} \end{aligned}$$

To include this exogenous variable in our model specification, we simply update the formula string using the "~" symbol:

// Estimate model 
call svarFit(econ_data, "GR_GDP + IR ~ INT");

Storing Results with svarOut

When we estimate SVAR models using svarFit, the results are stored in an svarOut structure. This structure is designed for intuitive access to key outputs, such as model coefficients, residuals, IRFs, and more.

// Declare output structure
struct svarOut sOut;

// Estimate model
sOut = svarFit(econ_data, "GR_GDP + IR ~ INT");

Beyond storing results, the svarOut structure is used for many post-estimation functions, such as plotIRF, plotFEVD and plotHD.

Example One: Applying Short Run Restrictions

As a first example, let's start with the default behavior of svarFit, which is to estimate Short-Run Restrictions.

Short-Run Restrictions:

• Assume that certain relationships between variables are instantaneous.
• Are useful for modeling the immediate impacts of economic shocks, such as changes in interest rates or policy decisions.
• Rely on a lower triangular matrix (Cholesky decomposition), which implies that variable ordering matters.

Loading Our Data

In this example, we will apply short-run restrictions to a VAR model with three endogenous variables: Inflation (Inflat), Unemployment (Unempl), and the Federal Funds Rate (Fedfund).

First, we load the dataset from the file "data_shortrun.dta" and specify our formula string:

/*
** Load data
*/
fname = "data_shortrun.dta";
data_shortrun = loadd(fname);

// Specify model formula string 
// Three endogenous variable
// No exogenous variables 
formula = "Inflat + Unempl + Fedfunds";

In this case the order of the variables in the formula string implies:

• Inflat affects Unempl and Fedfunds contemporaneously.
• Unempl affects Fedfunds but not Inflat contemporaneously.
• Fedfunds does not affect the other variables contemporaneously.

Estimating Default Model

If we want to use model defaults, this is all we need to setup prior to estimation.

// Declare output structure
// for storing results
struct svarOut sOut;

// Estimate model with defaults
sOut = svarFit(data_shortrun, formula);

The svarFit procedure prints the reduced-form estimates:

=====================================================================================================
Model:                      SVAR(6)                               Number of Eqs.:                   3
Time Span:              1960-01-01:                               Valid cases:                    158
                        2000-10-01                                                                   
Log Likelihood:            -344.893                               AIC:                         -3.464
                                                                  SBC:                         -2.418
=====================================================================================================
Equation                             R-sq                  DW                 SSE                RMSE

Inflat                            0.86474             1.93244           129.75134             0.96616 
Unempl                            0.98083             7.89061             7.05807             0.22534 
Fedfunds                          0.93764             2.81940            97.09873             0.83579 
=====================================================================================================
Results for reduced form equation Inflat
=====================================================================================================
          Coefficient            Estimate           Std. Err.             T-Ratio          Prob |>| t
-----------------------------------------------------------------------------------------------------

             Constant             0.78598             0.39276             2.00116             0.04732 
          Inflat L(1)             0.61478             0.08430             7.29320             0.00000 
          Unempl L(1)            -1.20719             0.40464            -2.98335             0.00337 
        Fedfunds L(1)             0.12674             0.10292             1.23142             0.22024 
          Inflat L(2)             0.08949             0.09798             0.91339             0.36262 
          Unempl L(2)             2.17171             0.66854             3.24845             0.00146 
        Fedfunds L(2)            -0.05198             0.13968            -0.37216             0.71034 
          Inflat L(3)             0.04730             0.09946             0.47556             0.63514 
          Unempl L(3)            -1.01991             0.70890            -1.43872             0.15248 
        Fedfunds L(3)             0.02764             0.14328             0.19292             0.84731 
          Inflat L(4)             0.18545             0.09767             1.89877             0.05967 
          Unempl L(4)            -0.95056             0.70881            -1.34106             0.18209 
        Fedfunds L(4)            -0.11887             0.14160            -0.83945             0.40266 
          Inflat L(5)            -0.07630             0.09902            -0.77052             0.44230 
          Unempl L(5)             1.07985             0.68944             1.56628             0.11956 
        Fedfunds L(5)             0.14800             0.13465             1.09912             0.27361 
          Inflat L(6)             0.14879             0.08763             1.69800             0.09174 
          Unempl L(6)            -0.17321             0.38210            -0.45330             0.65104 
        Fedfunds L(6)            -0.16674             0.10030            -1.66238             0.09869 
=====================================================================================================
Results for reduced form equation Unempl
=====================================================================================================
          Coefficient            Estimate           Std. Err.             T-Ratio          Prob |>| t
-----------------------------------------------------------------------------------------------------

             Constant             0.05439             0.09160             0.59376             0.55364 
          Inflat L(1)             0.04011             0.01966             2.03992             0.04325 
          Unempl L(1)             1.47354             0.09438            15.61362             0.00000 
        Fedfunds L(1)            -0.00510             0.02400            -0.21231             0.83218 
          Inflat L(2)            -0.02196             0.02285            -0.96086             0.33829 
          Unempl L(2)            -0.52754             0.15592            -3.38329             0.00093 
        Fedfunds L(2)             0.06812             0.03258             2.09107             0.03834 
          Inflat L(3)             0.00214             0.02320             0.09211             0.92674 
          Unempl L(3)             0.10859             0.16534             0.65680             0.51239 
        Fedfunds L(3)            -0.04923             0.03342            -1.47314             0.14297 
          Inflat L(4)            -0.02574             0.02278            -1.12973             0.26053 
          Unempl L(4)            -0.32361             0.16532            -1.95752             0.05229 
        Fedfunds L(4)             0.03248             0.03303             0.98338             0.32713 
          Inflat L(5)             0.02071             0.02309             0.89691             0.37132 
          Unempl L(5)             0.36505             0.16080             2.27026             0.02473 
        Fedfunds L(5)            -0.01161             0.03141            -0.36975             0.71213 
          Inflat L(6)            -0.00669             0.02044            -0.32745             0.74382 
          Unempl L(6)            -0.14897             0.08912            -1.67160             0.09685 
        Fedfunds L(6)            -0.00212             0.02339            -0.09070             0.92786 
=====================================================================================================
Results for reduced form equation Fedfunds
=====================================================================================================
          Coefficient            Estimate           Std. Err.             T-Ratio          Prob |>| t
-----------------------------------------------------------------------------------------------------

             Constant             0.28877             0.33977             0.84990             0.39684 
          Inflat L(1)             0.05831             0.07292             0.79960             0.42530 
          Unempl L(1)            -1.93356             0.35004            -5.52374             0.00000 
        Fedfunds L(1)             0.93246             0.08903            10.47324             0.00000 
          Inflat L(2)             0.22166             0.08476             2.61524             0.00990 
          Unempl L(2)             2.17717             0.57833             3.76457             0.00025 
        Fedfunds L(2)            -0.37931             0.12083            -3.13915             0.00207 
          Inflat L(3)            -0.08237             0.08604            -0.95729             0.34008 
          Unempl L(3)            -0.96474             0.61325            -1.57317             0.11795 
        Fedfunds L(3)             0.53848             0.12395             4.34438             0.00003 
          Inflat L(4)            -0.00264             0.08449            -0.03123             0.97513 
          Unempl L(4)             1.41077             0.61317             2.30078             0.02289 
        Fedfunds L(4)            -0.14852             0.12249            -1.21246             0.22739 
          Inflat L(5)            -0.15941             0.08566            -1.86101             0.06486 
          Unempl L(5)            -0.74153             0.59641            -1.24333             0.21584 
        Fedfunds L(5)             0.34789             0.11648             2.98663             0.00333 
          Inflat L(6)             0.09898             0.07580             1.30579             0.19378 
          Unempl L(6)             0.01450             0.33055             0.04387             0.96507 
        Fedfunds L(6)            -0.38014             0.08677            -4.38099             0.00002 
=====================================================================================================

The reported reduced-form results include:

• The date range identified in the dataframe, data_shortrun.
• The model estimated, based on the selected optimal number of lags, in this case SVAR(6).
• Model diagnostics including R-squared (R-sq), the Durbin-Watson statistic (DW), Sum of the Squared Errors (SSE), and Root Mean Squared Errors (RMSE), by equation.
• Parameter estimates, printed separately for each equation.

Customizing Our Model

The default model is a good start but suppose we want to make the following customizations:

• Include two exogenous variables, trend and trendsq.
• Exclude a constant.
• Estimate a VAR(2) model.
• Change the IRF/FEVD horizon from 20 to 40.
• Change the IRF/FEVD confidence level from 95% to 68%

"~"

svarControl

svarControl

Putting everything together:

// Load library
new;
library tsmt;

/*
** Load data
*/
fname = "data_shortrun.dta";
data_shortrun = loadd(fname);

// Specify model formula string 
// Three endogenous variable
// Two exogenous variables  
formula = "Inflat + Unempl + Fedfunds ~ trend + trendsq";

// Identification method
ident = "oir";

// Estimate VAR(2)
lags = 2;

// Constant off
const = 0;

// Declare control structure
// and fill with defaults
struct svarControl sCtl;
sCtl = svarControlCreate();

// Update IRF/FEVD settings
sCtl.irf.nsteps = 40;
sCtl.irf.cl = 0.68;

/*
** Estimate VAR model
*/
struct svarOut sOut2;
sOut2 = svarFit(data_shortrun, formula, ident, const, lags, sCtl);

=====================================================================================================
Model:                      SVAR(2)                               Number of Eqs.:                   3
Time Span:              1960-01-01:                               Valid cases:                    162
                        2000-10-01                                                                   
Log Likelihood:            -413.627                               AIC:                         -3.185
                                                                  SBC:                         -2.842
=====================================================================================================
Equation                             R-sq                  DW                 SSE                RMSE

Inflat                            0.83877             1.78639           159.81843             1.01872 
Unempl                            0.97835             5.82503             8.01756             0.22817 
Fedfunds                          0.91719             2.20585           135.51524             0.93807 
=====================================================================================================
Results for reduced form equation Inflat
=====================================================================================================
          Coefficient            Estimate           Std. Err.             T-Ratio          Prob |>| t
-----------------------------------------------------------------------------------------------------

          Inflat L(1)             0.65368             0.07951             8.22173             0.00000 
          Unempl L(1)            -0.36875             0.34207            -1.07799             0.28272 
        Fedfunds L(1)             0.19093             0.09600             1.98894             0.04848 
          Inflat L(2)             0.17424             0.08324             2.09308             0.03798 
          Unempl L(2)             0.30882             0.33838             0.91265             0.36285 
        Fedfunds L(2)            -0.16561             0.09995            -1.65695             0.09956 
                trend             0.03084             0.01278             2.41268             0.01701 
              trendsq            -0.00019             0.00008            -2.55370             0.01163 
=====================================================================================================
Results for reduced form equation Unempl
=====================================================================================================
          Coefficient            Estimate           Std. Err.             T-Ratio          Prob |>| t
-----------------------------------------------------------------------------------------------------

          Inflat L(1)             0.04566             0.01781             2.56408             0.01130 
          Unempl L(1)             1.48522             0.07662            19.38488             0.00000 
        Fedfunds L(1)             0.01387             0.02150             0.64508             0.51983 
          Inflat L(2)            -0.02556             0.01864            -1.37111             0.17234 
          Unempl L(2)            -0.51248             0.07579            -6.76186             0.00000 
        Fedfunds L(2)             0.02509             0.02239             1.12095             0.26406 
                trend            -0.00587             0.00286            -2.05169             0.04189 
              trendsq             0.00003             0.00002             1.99972             0.04729 
=====================================================================================================
Results for reduced form equation Fedfunds
=====================================================================================================
          Coefficient            Estimate           Std. Err.             T-Ratio          Prob |>| t
-----------------------------------------------------------------------------------------------------

          Inflat L(1)             0.00902             0.07321             0.12316             0.90214 
          Unempl L(1)            -1.28526             0.31499            -4.08026             0.00007 
        Fedfunds L(1)             0.93532             0.08840            10.58097             0.00000 
          Inflat L(2)             0.19137             0.07665             2.49660             0.01359 
          Unempl L(2)             1.25710             0.31159             4.03445             0.00009 
        Fedfunds L(2)            -0.05845             0.09204            -0.63513             0.52629 
                trend             0.00195             0.01177             0.16561             0.86868 
              trendsq             0.00000             0.00007             0.03606             0.97128 
=====================================================================================================

Visualizing dynamics

The TSMT 4.0 library also includes a set of tools for quickly plotting dynamic shock responses after SVAR estimation. These functions take a filled svarOut structure and generate pre-formatted plots of IRFs, FEVDs, or HDs.

Let's plot the IRFs, FEVDs, and HDs in response to a shock to Inflat from our customized model:

// Specify shock variable
shk_var = "Inflat";

// Plot IRFs
plotIRF(sout, shk_var);

// Plot FEVDs
plotFEVD(sout, shk_var);

// Plot HDs
plotHD(sout, shk_var);

This generates a grid plot of IRFs:

An area plot of the FEVDs:

And a bar plot of the HDs:

Example Two: Applying Long Run Restrictions

Long-run restrictions are often used in macroeconomic analysis to reflect theoretical assumptions about how certain shocks affect the economy over time. In this example, we follow the Blanchard-Quah (1989) approach to impose a long-run restriction that shocks to Unemployment do not affect GDP Growth in the long run.

Setting Up the Model

First we load our long-run dataset, data_longrun.dta, specify the model formula string and turn the constant off.

// Load the dataset
fname = "data_longrun.dta";
data_longrun = loadd(fname);

// Specify the model formula with two endogenous variables
formula = "GDPGrowth + Unemployment";

// Set lags to missing to use optimal lags
lags = miss();

// Constant off
const = 0;

To change the identification method, we use the optional ident input. There are three possible settings for identification, "oir", "bq", and "sign".

// Use BQ identification
ident = "bq";

Next we declare an instance of the svarControl structure and specify our irf settings.

// Declare the control structure
struct svarControl sCtl;
sCtl = svarControlCreate();

// Set irf Cl
sctl.irf.cl = 0.68;

// Expand horizon
sctl.irf.nsteps = 40;

Finally, we estimate our model and plot the dynamic responses.

// Estimate the SVAR model with long-run restrictions
struct svarOut sOut;
sOut = svarFit(data_longrun, formula, ident, const, lags, sCtl);

// Specify shock variable
shk_var = "GDPGrowth";

// Plot IRFs
plotIRF(sOut, shk_var);

// Plot FEVDs
plotFEVD(sOut, shk_var);

// Plot HDs
plotHD(sOut, shk_var);

This generates a grid plot of IRFs:

An area plot of the FEVDs:

And a bar plot of the HDs:

Conclusion

The svarFit procedure, introduced in TSMT 4.0, makes it much easier to estimate and analyze SVAR models in GAUSS. In this post, we walked through how to apply both short-run and long-run restrictions to understand the structural dynamics between variables.

With just a few lines of code, you can estimate the model, specify identification restrictions, and visualize the results. This flexibility allows you to tailor your analysis to different economic theories without getting bogged down in complex setups.

You can find the code and data for today's blog here.

Further Reading

1. Introduction to the Fundamentals of Time Series Data and Analysis
2. Introduction to the Fundamentals of Vector Autoregressive Models
3. The Intuition Behind Impulse Response Functions and Forecast Error Variance Decomposition
4. Introduction to Granger Causality
5. Understanding and Solving the Structural Vector Autoregressive Identification Problem
6. The Structural VAR Model at Work: Analyzing Monetary Policy
7. Sign Restricted SVAR in GAUSS

Try Out GAUSS TSMT 4.0

The Constrained Maximum Likelihood (CML) library was one of the original constrained optimization tools in GAUSS. Like many GAUSS libraries, it was later updated to an "MT" version.

The "MT" version libraries, named for their use of multi-threading, provide significant performance improvements, greater flexibility, and a more intuitive parameter-handling system.

This blog post explores:

• The key features, differences, and benefits of upgrading from CML to CMLMT.
• A practical example to help you transition code from CML to CMLMT.

Key Features Comparison

Before diving into the details of transitioning from CML to CMLMT, it’s useful to understand how these two libraries compare. The table below highlights key differences, from optimization algorithms to constraint handling.

Advantages of CMLMT

Beyond just performance improvements, CMLMT introduces several key advantages that make it a more powerful and user-friendly tool for constrained maximum likelihood estimation. These improvements do more than just support multi-threading, they provide greater flexibility, efficiency, and accuracy in model estimation.

Some of the most notable advantages include:

1. Threading & Multi-Core Support: CMLMT enables multi-threading, significantly speeding up numerical derivatives and bootstrapping, whereas CML is single-threaded.
2. Simplified Parameter Handling: Only CMLMT supports both a simple parameter vector and the PV structure for advanced models. Additionally, CMLMT allows dynamic arguments, making it easier to pass data to the log-likelihood function.
3. More Efficient Log-Likelihood Computation: CMLMT integrates the analytic computation of log-likelihood, first derivatives, and second derivatives into a user-specified log-likelihood procedure, reducing redundancy.
4. Augmented Lagrangian Method: CMLMT introduces an Augmented Lagrangian Penalty Line Search for handling constrained optimization.
5. Enhanced Statistical Inference: CMLMT includes bootstrapping, profile likelihoods, and hypothesis testing improvements, which are limited in CML.

Converting a CML Model to CMLMT

Let's use a simple example to walk through the step-by-step transition from CML to CMLMT. In this model, we will perform constrained maximum likelihood estimation for a Poisson model.

The dataset is included in the CMLMT library.

Original CML Code

We will start by estimating the model using CML:

new;
library cml;
#include cml.ext;
cmlset;

// Load data
data = loadd(getGAUSSHome("pkgs/cmlmt/examples/cmlmtpsn.dat"));

// Set constraints for first two coefficients
// to be equal
_cml_A = { 1 -1 0 };   
_cml_B = { 0 };  

// Specify starting parameters
beta0 = .5|.5|.5;

// Run optimization
{ _beta, f0, g, cov, retcode } = CMLprt(cml(data, 0, &logl, beta0));

// Specify log-likelihood function
proc logl(b, data);
   local m, x, y;

   // Extract x and y
   y = data[., 1];
   x = data[., 2:4];

   m = x * b;

  retp(y .* m - exp(m));
endp;

This code prints the following output:

Mean log-likelihood       -0.670058
Number of cases     100

Covariance of the parameters computed by the following method:
Inverse of computed Hessian

Parameters    Estimates     Std. err.    Gradient
------------------------------------------------------------------
P01              0.1199        0.1010      0.0670
P02              0.1199        0.1010     -0.0670
P03              0.8343        0.2648      0.0000

Number of iterations    5
Minutes to convergence     0.00007

Step One: Switch to CMLMT Library

The first step in updating our program file is to load the CMLMT library instead of the CML library.

// Clear workspace and load library
new;
library cml;

// Clear workspace and load library
new;
library cmlmt;

Step Two: Load Data

Since data loading is handled by GAUSS base procedures, no changes are necessary.

// Load data
x = loadd(getGAUSSHome("pkgs/cmlmt/examples/cmlmtpsn.dat"));

// Extract x and y
y = x[., 1];
x = x[., 2:4];

Step Three: Setting Constraints

The next step is to convert the global variables used to control optimization in CML into members of the cmlmtControl structure. To do this, we need to:

1. Declare an instance of the cmlmtControl structure.
2. Initialize the cmlmtControl structure with default values using cmlmtControlCreate.
3. Assign the constraint vectors to the corresponding cmlmtControl structure members.

// Set constraints for first two coefficients
// to be equal
_cml_A = { 1 -1 0 };   
_cml_B = { 0 };  

//Declare and initialize control structure
struct cmlmtControl ctl;
ctl = cmlmtControlCreate();

// Set constraints for first two coefficients
// to be equal
ctl.A = { 1 -1 0 };   
ctl.B = { 0 };       

Step Four: Specify Starting Values

In our original CML code, we specified the starting parameters using a vector of values. In the CMLMT library, we can specify the starting values using either a parameter vector or a PV structure.

The advantage of the PV structure is that it allows parameters to be stored in different formats, such as symmetric matrices or matrices with fixed parameters. This, in turn, can simplify calculations inside the log-likelihood function.

If we use the parameter vector option, we don't need to make any changes to our original code:

// Specify starting parameters
beta0 = .5|.5|.5;

Using the PV structure option requires additional steps:

1. Declare an instance of the PV structure.
2. Initialize the PV structure using the PVCreate procedure.
3. Use the PVpack functions to create and define specific parameter types within the PV structure.

// Declare instance of 'PV' struct
struct PV p0;

// Initialize p0
p0 = pvCreate();

// Create parameter vector
beta0 = .5|.5|.5;

// Load parameters into p0
p0 = pvPack(p0, beta0, "beta");

Step Five: The Likelihood Function

In CML, the likelihood function takes only two parameters:

1. A parameter vector.
2. A data matrix.

// Specify log-likelihood function
proc logl(b, data);
   local m, x, y;

   // Extract x and y
   y = data[., 1];
   x = data[., 2:4];

   m = x * b;

  retp(y .* m - exp(m));
endp;

The likelihood function in CMLMT is enhanced in several ways:

1. We can pass as many arguments as needed to the likelihood function. This allows us to simplify the function, which, in turn, can speed up optimization.
2. We return output from the likelihood function in the form of the modelResults structure. This makes computations thread-safe and allows us to specify both gradients and Hessians inside the likelihood function:
   • The likelihood function values are stored in the mm.function member.
   • The gradients are stored in the mm.gradient member.
   • The Hessians are stored in the mm.hessian member.
3. The last input into the likelihood function must be ind.ind is passed to your log-likelihood function when it is called by CMLMT. It tells your function whether CMLMT needs you to compute the gradient and Hessian, or just the function value. (see online examples). NOTE: You are never required to compute the gradient or Hessian if requested by ind. If you do not compute it, CMLMT will compute numerical derivatives.

// Specify log-likelihood function
// Allows separate arguments for y & x
// Also has 'ind' as last argument
proc logl(b, y, x, ind);
   local m;

   // Declare modeResult structure
   struct modelResults mm;

   // Likelihood computation
   m = x * b;

   // If the first element of 'ind' is not zero,
   // CMLMT wants us to compute the function value
   // which we assign to mm.function
   if ind[1];
      mm.function = y .* m - exp(m);
   endif;

   retp(mm);
endp;

Step Six: Run Optimization

We estimate the maximum likelihood parameters in CML using the cml procedure. The cml procedure returns five parameters, and a results table is printed using the cmlPrt procedure.

/*
** Run optimization
*/
// Run optimization
{ _beta, f0, g, cov, retcode } = cml(data, 0, &logl, beta0);

// Print results
CMLprt(_beta, f0, g, cov, retcode);

In CMLMT, estimation is performed using the cmlmt procedure. The cmlmt procedure returns a cmlmtResults structure, and a results table is printed using the cmlmtPrt procedure.

To convert to cmlmt, we take the following steps:

1. Declare an instance of the cmlmtResults structure.
2. Call the cmlmt procedure. Following an initial pointer to the log-likelihood function, the parameter and data inputs are passed to cmlmt in the exact order they are specified in the log-likelihood function.
3. The output from cmlmt is stored in the cmlmtResults structure, out.

/*
** Run optimization
*/
// Declare output structure
struct cmlmtResults out;

// Run estimation
out = cmlmt(&logl, beta0, y, x, ctl);

// Print output
cmlmtPrt(out);

Conclusion

Upgrading from CML to CMLMT provides faster performance, improved numerical stability, and easier parameter management. The addition of multi-threading, better constraint handling, and enhanced statistical inference makes CMLMT a powerful upgrade for GAUSS users.

If you're still using CML, consider transitioning to CMLMT for a more efficient and flexible modeling experience!

Further Reading

1. Beginner's Guide To Maximum Likelihood Estimation
2. Maximum Likelihood Estimation in GAUSS
3. Ordered Probit Estimation with Constrained Maximum Likelihood

Try out The GAUSS Constrained Maximum Likelihood MT Library

Categorical data plays a key role in data analysis, offering a structured way to capture qualitative relationships. Before running any models, simply examining the distribution of categorical data can provide valuable insights into underlying patterns.

Whether summarizing survey responses or exploring demographic trends, fundamental statistical tools, such as frequency counts and tabulations, help reveal these patterns.

GAUSS offers several tools for summarizing and visualizing categorical data, including:

• tabulate: Quickly compute cross-tabulations and summary tables.
• frequency: Generate frequency counts and relative frequencies.
• plotFreq: Create visual representations of frequency distributions.

In GAUSS 25, these functions received significant enhancements, making them more powerful and user-friendly. In this post, we'll explore these improvements and demonstrate their practical applications.

Frequency Counts

The GAUSS frequency function generates frequency tables for categorical variables. In GAUSS 25, it has been enhanced to utilize metadata from dataframes, automatically detecting and displaying variable names. Additionally, the function now includes an option to sort the frequency table, making it easier to analyze distributions.

Example: Counting Product Categories

For this example, we'll use a hypothetical dataset containing 50 observations of two categorical variables: Product_Type and Region. You can download the dataset here.

To start, we'll load the data using loadd:

/*
** Sample product sales data
*/
// Import sales dataframe
product_data = loadd(__FILE_DIR $+ "product_data.csv");

// Preview data
head(product_data);

    Product_Type           Region
     Electronics             East
      Home Goods             West
       Furniture            North
            Toys             East
      Home Goods            North

Next, we will compute the frequency counts of the Product_Type variable:

// Compute frequency counts
frequency(product_data, "Product_Type");

=============================================
   Product_Type     Count   Total %    Cum. %
=============================================

       Clothing         8        16        16
    Electronics        13        26        42
      Furniture        10        20        62
     Home Goods         7        14        76
           Toys        12        24       100
=============================================
          Total        50       100

We can also generate a sorted frequency table, using the optional sorting argument:

// Compute frequency counts
frequency(product_data, "Product_Type", 1);

=============================================
   Product_Type     Count   Total %    Cum. %
=============================================

    Electronics        13        26        26
           Toys        12        24        50
      Furniture        10        20        70
       Clothing         8        16        86
     Home Goods         7        14       100
=============================================
          Total        50       100  

Tabulating Categorical Data

While frequency counts help us understand individual categories, the tabulate function allows us to explore relationships between categorical variables. This function performs cross-tabulations, offering deeper insights into categorical distributions. In GAUSS 25, it was enhanced with new options for calculating row and column percentages, making comparisons easier.

Example: Cross-Tabulating Product Type and Region

Now let's look at the relationship between Product_Type and Region.

// Generate cross-tabulation
call tabulate(product_data, "Product_Type ~ Region");

=====================================================================================
   Product_Type                              Region                             Total
=====================================================================================
                      East          North          South           West

       Clothing          1              5              1              1             8
    Electronics          5              1              5              2            13
      Furniture          3              3              1              3            10
     Home Goods          1              3              2              1             7
           Toys          4              3              2              3            12
          Total         14             15             11             10            50

=====================================================================================

By default, the tabulate function generates absolute counts. However, in some cases, relative frequencies provide more meaningful insights. In GAUSS 25, tabulate now includes options to calculate row and column percentages, making it easier to compare distributions across categories.

This is done using the tabControl structure and the rowPercent or columnPercent members.

• Row percentages show how the distribution of product types varies across regions.
• Column percentages highlight the composition of product types within each region.

/*
** Relative tabulations
*/ 
struct tabControl tCtl;
tCtl = tabControlCreate();

// Specify row percentages
tCtl.rowPercent = 1;

// Tabulate
call tabulate(product_data, "Product_Type ~ Region", tCtl);

=====================================================================================
   Product_Type                               Region                            Total
=====================================================================================
                       East          North          South           West

       Clothing        12.5           62.5           12.5           12.5          100
    Electronics        38.5            7.7           38.5           15.4          100
      Furniture        30.0           30.0           10.0           30.0          100
     Home Goods        14.3           42.9           28.6           14.3          100
           Toys        33.3           25.0           16.7           25.0           99

=====================================================================================
Table reports row percentages.

Alternatively we can find the column percentages:

/*
** Relative column tabulations
*/ 
struct tabControl tCtl;
tCtl = tabControlCreate();

// Compute row percentages
tCtl.columnPercent = 1;

// Tabulate product types
call tabulate(product_data, "Product_Type ~ Region", tCtl);

===========================================================================
   Product_Type                                  Region

===========================================================================
                          East          North          South           West

       Clothing            7.1           33.3            9.1           10.0
    Electronics           35.7            6.7           45.5           20.0
      Furniture           21.4           20.0            9.1           30.0
     Home Goods            7.1           20.0           18.2           10.0
           Toys           28.6           20.0           18.2           30.0
          Total            100            100            100            100

===========================================================================
Table reports column percentages.

Visualizing Distributions

While tables provide numerical insights, frequency plots offer an intuitive visual representation. GAUSS 25 enhancements to the plotFreq function include:

• Automatic category labeling for better clarity.
• New support for the by keyword to split data by category.
• New percentage distributions.

Example: Visualizing Product Type Percent Distribution

To start, let's look at the percentage distribution of product type. To help with interpretation, we'll sort the graph by frequency and use a percentage axis:

// Sort frequencies
sort = 1;

// Report percentage axis
pct_axis = 1;

// Generate frequency plot
plotFreq(product_data, "Product_Type", sort, pct_axis);

Example: Visualizing Product Type Distribution by Region

Next, let's visualize the distribution of the product types across regions using the plotFreq function and the by keyword:

// Generate frequency plot
plotFreq(product_data, "Product_Type + by(Region)");

Conclusion

In this blog, we've demonstrated how updates to frequency, tabulate, and plotFreq in GAUSS 25 make categorical data analysis more efficient and insightful. These enhancements provide better readability, enhanced cross-tabulations, and more intuitive visualization options.

Further Reading

1. Introduction to Categorical Variables.
2. Easy Management of Categorical Variables
3. What is a GAUSS Dataframe and Why Should You Care?.
4. Getting Started With Survey Data In GAUSS.

Introduction

If you're an applied researcher, chances are you've used hypothesis testing before. It's an essential tool in practical applications — whether you're validating economic models, assessing policy impacts, or making data-driven business and financial decisions.

The power of hypothesis testing lies in its ability to provide a structured framework for making objective decisions based on data rather than intuition or anecdotal evidence. It allows us to systematically check the validity of our assumptions and models. The idea is simple — by formulating null and alternative hypotheses, we can determine whether observed relationships between variables are statistically significant or simply due to chance.

In today’s blog, we’ll take a closer look at the statistical intuition behind hypothesis testing using the Wald Test and provide a step-by-step guide for implementing hypothesis testing in GAUSS.

Understanding the Intuition of Hypothesis Testing

We don’t need to completely understand the mathematical background of hypothesis testing with the Wald Test to use it effectively. However, having some background will help ensure correct implementation and interpretation.

The Null Hypothesis

At the heart of hypothesis testing is the null hypothesis. It formally represents the assumptions we want to test.

In mathematical terms, it is constructed as a set of linear restrictions on our parameters and is given by:

$$ H_0: R\beta = q $$

where:

• $R$ is a matrix specifying the linear constraints on the parameters.
• $q$ is a vector of hypothesized values.
• $\beta$ is the vector of model parameters.

The null hypothesis captures two key pieces of information:

• Information from our observed data, reflected in the estimated model parameters.
• The assumptions we are testing, represented by the linear constraints and hypothesized values.

The Wald Test Statistic

After formulating the null hypothesis, the Wald Test Statistic is computed as:

$$ W = (R\hat{\beta} - q)' (R\hat{V}R')^{-1} (R\hat{\beta} - q) $$

where $\hat{V}$ is the estimated variance-covariance matrix.

The Intuition of the Wald Test Statistic

Let's take a closer look at the components of the test statistic.

The first component of the test statistic, $(R\hat{\beta} - q)$, measures how much the observed parameters differ from the null hypothesis:

• If our constraints hold exactly, $R\hat{\beta} = q$, and the test statistic is zero.
• Because the test statistic squares the deviation, it captures differences in either direction.
• The larger this component, the farther the observed data are from the null hypothesis.
• A larger deviation leads to a larger test statistic.

The second component of the test statistic, $(R\hat{V}R')^{-1}$, accounts for the variability in our data:

• As the variability of our data increases, $(R\hat{V}R')$ increases.
• Since the squared deviation is divided by this component, an increase in variability leads to a lower test statistic. Intuitively, high variability implies that even a large deviation from the null hypothesis might not be statistically significant.
• Scaling by variability prevents us from rejecting the null hypothesis due to high uncertainty in the estimates.

Interpreting the Wald Test Statistic

Understanding the Wald Test can help us better interpret its results. In general, the larger the Wald Test statistic:

• The further our observed data deviates from $H_0$.
• The less likely our observed data are under $H_0$.
• The more likely we are to reject $H_0$.

To make more specific conclusions, we can use the p-value of our test statistic. The F-test alternative used by the GAUSS waldTest procedure follows an F distribution:

$$ F \sim F(q, d) $$

where:

• $q$ is the number of constraints.
• $d$ is the residual degrees of freedom.

The p-value, compared to a chosen significance level $\alpha$, helps us determine whether to reject the null hypothesis. It represents the probability of observing a test statistic as extreme as (or more extreme than) the calculated Wald Test statistic, assuming the null hypothesis is true.

Thus:

• If $p \leq \alpha$, we reject $H_0$.
• If $p > \alpha$, we fail to reject $H_0$.

The GAUSS waldTest Procedure

In GAUSS, hypothesis testing can be performed using the waldTest procedure, introduced in GAUSS 25.

The waldTest procedure can be used in two ways:

• Post-estimation with a filled output structure after estimation using olsmt, gmmfit, glm, or quantilefit.
• Directly, using an estimated parameter vector and variance matrix.

Post-estimation Usage

If used post-estimation, the waldTest procedure has one required input and four optional inputs:

{ waldtest, p_value } = waldTest(out [, R, q, tau, joint])

out

Post-estimation filled output structure. Valid structure types include: olsmtOut, gmmOut, glmOut, and qfitOut.

R

Optional, LHS of the null hypothesis. Should be specified in terms of the model variables, with a separate row for each hypothesis. The function accepts linear combinations of the model variables.

q

Optional, RHS of the null hypothesis. Must be numeric vector.

tau

Optional, tau level corresponding to the testing hypothesis. Default is to jointly tests across all tau values. Only valid for the qfitOut structure.

joint

Optional, specification to test quantileFit hypotheses jointly across all coefficients for the qfitOut structure.

---

Data Matrices

If data matrices are used, the waldTest procedure has two required inputs and four optional inputs:

{ waldtest, p_value } = waldTest(sigma, params [, R, q, df_residuals, varnames])

sigma

Parameter variance-covariance estimation.

params

Parameter estimates.

R

Optional, LHS of the null hypothesis. Should be specified in terms of the model variables, with a separate row for each hypothesis. The function accepts linear combinations of the model variables.

q

Optional, RHS of the null hypothesis. Must be numeric vector.

df_residuals

Optional, model degrees of freedom for the F-test.

varnames

Optional, variable names.

---

Specifying The Null Hypothesis for Testing

By default, the waldTest procedure tests whether all estimated parameters jointly equal zero. This provides a quick way to assess the overall explanatory power of a model. However, the true strength of the waldTest procedure lies in its ability to test any linear combination of estimated parameters.

Specifying the hypothesis for testing is intuitive and can be done using variable names instead of manually constructing constraint matrices. This user-friendly approach:

• Reduces errors.
• Speeds up workflow.
• Allows us to focus on interpreting results rather than setting up complex computations.

Now, let's take a closer look at the two inputs used to specify the null hypothesis: the R and q inputs.

The R Restriction Input

The optional R input specifies the restrictions to be tested. This input:

• Must be a string array.
• Should use your model variable names.
• Can include any linear combination of the model variables.
• Should have one row for every hypothesis to be jointly tested.

For example, suppose we estimate the model:

$$ \hat{mpg} = \beta_0 + \beta_1 \cdot weight + \beta_2 \cdot axles $$

and want to test whether the coefficients on weight and axles are equal.

To specify this restriction, we define R as follows:

// Set R to test
// if the coefficient on weight 
// and axles are equal (weight - axles = 0)
R = "weight - axles";

The q Input

The optional q input specifies the right-hand side (RHS) of the null hypothesis. By default, it tests whether all hypotheses have a value of 0.

To test hypothesized values other than zero, we must specify the q input.

The q input must:

• Be a numerical vector.
• Have one row for every hypothesis to be jointly tested.

Continuing our previous example, suppose we want to test whether the coefficient on weight equals 2.

// Set R to test 
// coefficient on weight = 2
R = "weight";

// Set hypothesized value
// using q
q = 2;

The waldTest Procedure in Action

The best way to familiarize ourselves with the waldTest procedure is through hands-on examples. Throughout these examples, we will use a hypothetical dataset containing four variables: income, education, experience, and hours.

You can download the dataset here.

Let's start by loading the data into GAUSS.

// Load data into GAUSS 
data  = loadd("waldtest_data.csv");

// Preview data
head(data);

          income        education       experience            hours
       45795.000        19.000000        24.000000        64.000000
       30860.000        14.000000        26.000000        30.000000
       106820.00        11.000000        25.000000        64.000000
       84886.000        13.000000        28.000000        66.000000
       36265.000        21.000000        28.000000        76.000000 

Example 1: Testing a Single Hypothesis After OLS

In our first example, we will estimate an ordinary least squares (OLS) model:

$$ income = \beta_0 + \beta_1 \cdot education + \beta_2 \cdot experience + \beta_3 \cdot hours $$

and test the null hypothesis that the estimated coefficient on education is equal to the estimated coefficient on experience:

$$ H_0: \beta_1 - \beta_2 = 0. $$

First, we estimate the OLS model using olsmt:

// Estimate ols model 
// Store results in the
// olsOut structure
struct olsmtOut ols_out;
ols_out = olsmt(data, "income ~ education + experience + hours");

Ordinary Least Squares
====================================================================================
Valid cases:                       50          Dependent variable:            income
Missing cases:                      0          Deletion method:                 None
Total SS:                    4.19e+10          Degrees of freedom:                46
R-squared:                     0.0352          Rbar-squared:                 -0.0277
Residual SS:                 4.04e+10          Std. err of est:             2.96e+04
F(3,46):                        0.559          Probability of F:               0.645
====================================================================================
                            Standard                    Prob       Lower       Upper
Variable        Estimate       Error     t-value        >|t|       Bound       Bound
------------------------------------------------------------------------------------

CONSTANT           51456       26566      1.9369    0.058913     -613.63  1.0352e+05
education         397.36      919.54     0.43213     0.66767     -1404.9      2199.7
experience        77.251      453.39     0.17038     0.86546     -811.39      965.89
hours             384.83      302.48      1.2723     0.20967     -208.02      977.68
====================================================================================

Next, we use waldtest to test our hypothesis:

// Test if coefficients for education and experience are equal
R = "education - experience";
call waldTest(ols_out, R);

===================================
Wald test of null joint hypothesis:
education - experience =  0
-----------------------------------
F( 1, 46 ):                  0.0978
Prob > F :                   0.7559
===================================

Since the test statistic is 0.0978 and the p-value is 0.756, we fail to reject the null hypothesis, suggesting that the coefficients are not significantly different.

Example 2: Testing Multiple Hypotheses After GLM

In our second example, let's use waldTest to test multiple hypotheses jointly after using glm. We will estimate the same model as in our first example. However, this time we will use the waldTest procedure to jointly test two hypotheses:

$$ \begin{align} H_0: & \quad \beta_1 - \beta_2 = 0 \\ & \quad \beta_1 + \beta_2 = 1 \end{align} $$

First, we estimate the GLM model:

// Run GLM estimation with normal family (equivalent to OLS)
struct glmOut glm_out;
glm_out = glm(data, "income ~ education + experience + hours", "normal");

Generalized Linear Model
===================================================================
Valid cases:              50           Dependent variable:   income
Degrees of freedom:       46           Distribution          normal
Deviance:           4.04e+10           Link function:      identity
Pearson Chi-square: 4.04e+10           AIC:                1177.405
Log likelihood:         -584           BIC:                1186.965
Dispersion:        878391845           Iterations:             1186
Number of vars:            4

===================================================================
                                   Standard                    Prob
Variable               Estimate       Error     t-value        >|t|
-------------------------------------------------------------------

CONSTANT                  51456       26566      1.9369    0.058913
education                397.36      919.54     0.43213     0.66767
experience               77.251      453.39     0.17038     0.86546
hours                    384.83      302.48      1.2723     0.20967
===================================================================

Next, we test our joint hypothesis. For this test, keep in mind:

• We must specify a q input because one of our hypothesized values is different from zero.
• Our R and q inputs will each have two rows because we are jointly testing two hypotheses.

// Define multiple hypotheses:
// 1. education - experience = 0
// 2. education + experience = 1
R = "education - experience" $| "education + experience";
q = 0 | 1; 

// Perform Wald test for joint hypotheses
call waldTest(glm_out, R, q);

===================================
Wald test of null joint hypothesis:

education - experience =  0
education + hours      =  1
-----------------------------------
F( 2, 46 ):                  0.5001
Prob > F :                   0.6097
===================================

Since the test statistic is 0.5001 and the p-value is 0.6097:

• We fail to reject the null hypothesis, indicating that the constraints hold within the limits of statistical significance.
• Our observed data does not provide statistical evidence to conclude that either restriction is violated.

Example 3: Using Data Matrices

While waldTest is convenient for use after GAUSS estimation procedures, there may be cases where we need to apply it after manual parameter computations. In such cases, we can input our estimated parameters and covariance matrix directly using data matrices.

Let's repeat the first example but manually compute our OLS estimation:

// Run OLSMT estimation with manual computation of beta and sigma
X = ones(rows(data), 1) ~ data[., "education" "experience" "hours"];
y = data[., "income"];

// Compute beta manually
params = invpd(X'X) * X'y;

// Compute residuals and sigma
residuals = y - X * params;
n = rows(y);
k = cols(X);
sigma = (residuals'residuals) / (n - k) * invpd(X'X);

We can now use the manually computed params and sigma with waldTest. However, we must also provide the following additional information:

• The residual degrees of freedom.
• The variable names.

// Define hypothesis: education - experience = 0
R = "education - experience";
q = 0;

// Find degrees of freedom 
df_residuals = n - k;

// Specify variable names
varnames = "CONSTANT"$|"experience"$|"education"$|"hours";

// Perform Wald test
call waldTest(sigma, params, R, q, df_residuals, varnames);

===================================
Wald test of null joint hypothesis:
education - experience =  0
-----------------------------------
F( 1, 46 ):                  0.0978
Prob > F :                   0.7559
===================================

Conclusion

In today’s blog, we explored the intuition behind hypothesis testing and demonstrated how to implement the Wald Test in GAUSS using the waldTest procedure.

We covered:

• What the Wald Test is and why it matters in statistical modeling.
• Key features of the waldTest procedure.
• Step-by-step examples of applying waldTest after different estimation methods.

The code and data from this blog can be found here.

Further Reading

1. More Research, Less Effort with GAUSS 25!.
2. Exploring and Cleaning Panel Data with GAUSS 25.

Introduction

In this video, you'll learn the basics of panel data analysis in GAUSS. We demonstrate panel data modeling start to finish, from loading data to running a group specific intercept model.

Summary and Timeline

You'll see firsthand how to:

• Load and verify panel data.
• Merge data from different sources.
• Convert between wide and long form panel data.
• Explore and clean data.
• Create panel data plots.
• Prepare panel data for estimation.
• Estimate a model with group-specific intercepts.

Timeline

0:41 Set the current working directory.
1:03 Load panel data from an Excel file.
5:32 Merging data from different sources.
06:53 Preliminary data cleaning.
08:40 Panel data plots.
11:12 Stationarity testing.
11:56 Convert long form to wide form panel data.
14:49 Estimate a model with group-specific intercepts.

Additional Resources

1. How to Load Excel Data Into GAUSS
2. Transforming Panel Data to Long Form in GAUSS
3. Visualizing COVID-19 Panel Data With GAUSS 22
4. What is a GAUSS Dataframe and Why Should You Care?
5. Managing String Data with GAUSS Dataframes
6. The GAUSS Data Management Guide
7. How to Aggregate Panel Data in GAUSS
8. Panel Data Stationarity Test With Structural Breaks

Introduction

In this video, you'll learn the basics of choice data analysis in GAUSS. Our video demonstration shows just how quick and easy it is to get started with everything from data loading to discrete data modeling.

Summary and Timeline

You'll see firsthand how to:

• Load and verify survey data.
• Compute descriptive statistics.
• Merge data from different sources.
• Create basic scatter and frequency plots.
• Fit a basic probit model.

Timeline

0:52 Load and verify CSV survey data.
2:53 Change the base case of a categorical variable.
5:24 Merge dataframes.
06:40 Descriptive statistics.
09:25 XY and frequency plots.
11:11 Create an indicator variable from a categorical choice variable.
12:25 Create a categorical variable and set the labels for the levels.
14:47 Estimate a probit model.

Additional Resources

1. How to Load Excel Data Into GAUSS
2. Easy Management of Categorical Variables
3. Getting Started with Survey Data in GAUSS
4. What is a GAUSS Dataframe and Why Should You Care?
5. Managing String Data with GAUSS Dataframes
6. The GAUSS Data Management Guide
7. Anchoring Vignettes and the Compound Hierarchical Ordered Probit (CHOPIT) Model