In this blog we will explore how to set up and interpret cointegration results using a real-world time series example. We will cover the case with no structural breaks as well as the case with one unknown structural break using tools from the GAUSS tspdlib library.

Dataset

In this blog, we will use the famous Nelson-Plosser time series data. The dataset contains macroeconomic fundamentals for the United States.

We will be using three of these fundamentals:

• M2 money stock.
• Bond yield (measured by the basic yields of 30-year corporate bonds).
• S&P 500 index stock prices.

The time series data is annual data, covering 1900 - 1970.

Preparing for Cointegration

In order to prepare for cointegration testing, we will take some preliminary time series modeling steps. We will:

• Establish our underlying theory.
• Visualize our time series data.
• Perform unit root testing.

Establishing an Underlying Theory

In this example, we will examine the macroeconomic question of whether stock prices are linked to macroeconomic indicators. In particular, we will examine if there is a cointegrated, long-run relationship between the S&P 500 price index and monetary policy indicators of the M2 money stock and the bond yields.

Mathematically we will consider the cointegrated relationship:

$$y_{sp, t} = c + \beta_1 y_{money, t} + \beta_2y_{bond, t} + u_t$$

Time Series Visualization

When visualizing time series data, we look for visual evidence of:

• The comovements between our variables.
• The presence of deterministic components such as constants and time trends.
• Potential structural breaks.

Our time series plots give us some important considerations for our testing, providing visual evidence to support:

1. Comovements between the variables.
2. At least one structural break in the time series dynamics of all three of our variables.
3. A potential time trend in the datasets, especially in the later years of the sample.

Unit Root Testing

Prior to testing for cointegration between our time series data, we should check for unit roots in the data. We will do this using the adf procedure in the tspdlib library to conduct the Augmented Dickey-Fuller unit root test.

Our ADF test statistics are greater than the 10% critical value for all of our time series. This implies that we cannot reject the null hypothesis of a unit root for any of our time series data.

Unit Root Testing with Structural Breaks

What about the potential structural break that we see in our time series data? Does this have an impact on our unit root testing?

Using the adf_1break procedure in the tspdlib library to test for unit roots with a single structural break in the trend and constant we get the following results.

Our ADF test statistics again suggest that even when accounting for the structural break, we cannot reject the null hypothesis of a unit root for any of our time series data.

Conducting our Cointegration Tests

Having concluded that there is evidence for unit roots in our data, we can now run our cointegration tests.

When setting up cointegration tests, there are a number of assumptions that we must specify:

• Which normalization we want to use.
• The deterministic components to include in our model.
• The maximum number of lags to allow in our test.
• The information criterion to use to select the optimal number of lags.

To better understand these general assumptions, let’s look at the simplest of our tests, the Engle-Granger cointegration test.

Normalization

In the two-stage, residual-based cointegration tests which we will consider today, normalization amounts to deciding which variable is our dependent variable and which variables are our independent variables in the cointegration regression.

We will choose our normalization to reflect our theoretical question of whether the S&P 500 index is cointegrated with the money stock and the bond yield. As we mentioned earlier, this means we will consider the cointegrated relationship:

$$y_{sp, t} = c + \beta_1 y_{money, t} + \beta_2 y_{bond, t} + u_t$$

// Set fname to name of dataset
fname = "nelsonplosser.dta";

// Load three variables from the dataset 
// and remove rows with missing values
coint_data = packr(loadd(fname, "sp500 + m + bnd"));

// Define y and x matrix
y = coint_data[., 1];
x = coint_data[., 2 3];

The Deterministic Component

The second assumption we must make about our Engle-Granger test is which model we wish to use. To understand how to make this decision, let's look closer at what this input means.

The Engle-Granger test is a two-step test:

• Estimate the cointegration regression.
• Test for stationary in the residuals using the ADF unit root test.

When we specify which model to use we impact two things:

1. The deterministic components which are used in the first-stage cointegration regression.
2. The distribution of the test statistic.

There are three options to choose from:

1. No constant or trend (model = 0) $$y_{sp, t} = \beta_1 y_{money, t} + \beta_2 y_{bond, t} + u_t$$

2. Constant (model = 1) $$y_{sp, t} = \alpha + \beta_1 y_{money, t} + \beta_2 y_{bond, t} + u_t$$

3. Constant and trend (model = 2) $$y_{sp, t} = \alpha + \delta t + \beta_1 y_{money, t} + \beta_2 y_{bond, t} + u_t$$

For our example, we will include a constant and trend in our first-stage cointegration regression by setting:

// Select model with constant and trend
model = 2;

The Lag Specifications

In the second-stage ADF residual unit root test, the error terms should be serially independent. To account for possible autocorrelation, lags of the first differences of the residual can be included in ADF test regression.

The GAUSS coint_egranger will automatically determine the optimal number of lags to include in the second-stage regression based on two user inputs:

1. The maximum number of lags to allow.
2. The criterion to use to determine the optimal number of lags:
   • The Akaike information criterion (AIC) [ic = 0]
   • The Schwarz information criterion (SIC) [ic = 1]
   • The t-stat criterion [ic = 2]

/*
** Information Criterion: 
** 1=Akaike; 
** 2=Schwarz; 
** 3=t-stat sign.
*/
ic = 2; 

// Maximum number of lags 
pmax = 12;  

Calling our Cointegration Test

Now that we have loaded our data and chosen the test settings, we can call the coint_egranger procedure:

// Perform Engle-Granger Cointegration Test
{ tau_eg, cvADF_eg } = coint_egranger(y, x, model, pmax, ic);

Interpreting Our Cointegration Results

In order to interpret our cointegration results, let's revisit the two steps of the Engle-Granger test:

1. Estimate the cointegration regression.
2. Test the residuals from the cointegration regression for unit roots.

The Engle-Granger test statistic for cointegration reduces to an ADF unit root test of the residuals of the cointegration regression:

• If the residuals contain a unit root, then there is no cointegration.
• The null hypothesis of the ADF test is that the residuals have a unit root. Therefore, the Engle-Granger test considers the null hypothesis that there is no cointegration.
• As the Engle-Granger test statistic decreases:
  • We are more likely to reject the null hypothesis of no cointegration.
  • We have stronger evidence that the variables are cointegrated.

After running our cointegration test we obtain the following results:

-----------Engle-Granger Test---------------------------
-----------Constant and Trend---------------------------
H0: no co-integration (EG, 1987 & P0, 1990)

     Test      Statistic   CV(1%,      5%,      10%)
   ------      -------------------------------------
   EG_ADF         -2.105   -4.645   -4.157   -3.843

We can see that:

• Our test statistic of -2.105 is larger than the critical values at the 1%, 5%, and 10% levels.
• We cannot reject the null hypothesis of no cointegration.
• We do not find evidence in support of the cointegration of the S&P 500 with the U.S. money stock and bond yield.

Conducting our Cointegration Tests with One Structural Break

Earlier we saw that the potential structural break in our data did not change our unit root test conclusion. We should also see if the structural break has an impact on our cointegration testing.

To do this we will use the Gregory-Hansen cointegration test which can be implemented using the coint_ghansen test in the tspdlib library.

We can carry over all of our coint_egranger testing specifications, except our model specification.

The Model Specification

When implementing the Gregory-Hansen test, we must decide on a model which specifies:

• Which deterministic components are present in the cointegration regression.
• How the structural break affects the cointegration regression.

There are four modeling options to choose from

1. The level shift [model = 1]
   
   $$y_{sp, t} = \mu_1(1 - d_{\tau}) + \mu_{1,\tau} d_{\tau} + \beta_1 y_{money, t} + \beta_2 y_{bond, t} + u_t$$
   In this model, there is a structural break at time $\tau$ and $d_{\tau}$ is an indicator variable equal to 1 when $t >= \tau$. The constant before the structural break is $\mu_1$ and the constant after the structural break is $\mu_2$.
   
   
2. The level shift with trend [model = 2]
   
   $$y_{sp, t} = \mu_1(1 - d_{\tau}) + \mu_{1,\tau} d_{\tau} + \delta t + \beta_1 y_{money, t} + \beta_2 y_{bond, t} + u_t$$
   In this model, the structural break again affects the constant. However, there is also a time trend included in the model.
   
   
3. The regime shift [model = 3]
   
   $$y_{sp, t} = \mu_1(1 - d_{\tau}) + \mu_{1,\tau} d_{\tau} + \beta_1(1 - d_{\tau})y_{money, t} +$$ $$\beta_{1,\tau}d_{\tau}y_{money, t} + \beta_2(1 - d_{\tau}) y_{bond, t} + \beta_{2,\tau}d_{\tau}y_{bond, t} + u_t$$
   In this model, the structural break affects the constant and regression coefficients.
   
   
4. The regime and trend shift shift [model = 4]
   
   $$y_{sp, t} = \mu_1(1 - d_{\tau}) + \mu_{1,\tau} d_{\tau} + \delta_1(1 - d_{\tau}) t + \delta_{1,\tau}d_{\tau}t + \beta_1(1 - d_{\tau})y_{money, t} +$$ $$\beta_{1,\tau}d_{\tau}y_{money, t} + \beta_2(1 - d_{\tau}) y_{bond, t} + \beta_{2,\tau}d_{\tau}y_{bond, t} + u_t$$

In this model, the structural break again affects the constant, the regression coefficients, and the trend.

For example, let's consider the last case, where the constant, coefficients, and trend are all impacted by the structural break:

// Set fname to name of dataset
fname = "nelsonplosser.dta";

// Load three variables from the dataset
// and remove rows with missing values
coint_data = packr(loadd(fname, "sp500 + m + bnd"));

// Define y and x matrix
y = coint_data[., 1];
x = coint_data[., 2 3];

// Regime and trend shift
model = 4; 

/*
** Information Criterion: 
** 1=Akaike; 
** 2=Schwarz; 
** 3=t-stat sign.
*/
ic = 2; 

// Maximum number of lags 
pmax = 12;  

/*
** Long run variance computation
** 1 = iid
** 2 = Bartlett
** 3 = Quadratic Spectral (QS);
** 4 = SPC with Bartlett /see (Sul, Phillips & Choi, 2005)
** 5 = SPC with QS;
** 6 = Kurozumi with Bartlett
** 7 = Kurozumi with QS
*/ 
varm = 1;

// Bandwidth for variance 
bwl=1;

// Data trimming
trimm=0.1;

// Perform cointegration test
{ ADF_min_gh, TBadf_gh, Zt_min_gh, TBzt_gh, Za_min_gh, TBza_gh, cvADFZt_gh, cvZa_gh } =
    coint_ghansen(y, x, model, bwl, ic, pmax, varm, trimm);

Interpreting Our Cointegration Results with One Structural Break

The coint_ghansen procedure provides more extensive results than the coint_egranger test. In particular, the Gregory-Hansen test:

• Performs Augmented Dickey-Fuller testing on the residuals from the cointegration regression.
• Perform the Phillips-Perron testing on the residuals from the cointegration regression.
• Identifies structural breaks.

Cointegration results with one structural break

Cointegration test results
After calling the coint_ghansen procedure and testing all possible models, we obtain the following test statistic results:

As we can see from these results, there is no evidence that our S&P 500 Index is cointegrated with the money stock and bond yield.

Structural break results
The coint_ghansen procedure also returns estimates for break dates based on the $ADF$, $Z_t$, and $Z_{\alpha}$ tests:

What can we Conclude from the Gregory-Hansen Cointegration Test?

The results from our Gregory Hansen cointegration test provide some important conclusions:

• There is no support for cointegration.
• Incorporating a structural break does NOT change our conclusion that there is no cointegration.

Note that while the Gregory-Hansen test does estimate break dates, it does not provide the statistical evidence to conclude whether these are statistically significant break dates or not.

Conclusion

Today's blog looks closer at the Engle-Granger and Gregory-Hansen residual-based cointegration tests. By building a better understanding of how the tests work and what assumptions we make when running the tests, you will be better equipped to interpret the test results.

In particular, today we learned

• How to prepare for cointegration testing.
• How to set up the specifications for cointegration tests.
• How to interpret the results from the Engle-Granger and Gregory-Hansen cointegration tests.

Cointegration is an important tool for modeling the long-run relationships in time series data. If you work with time series data, you will likely find yourself needing to use cointegration at some point.

This blog provides an in-depth introduction to cointegration and will cover all the nuts and bolts you need to get started. In particular, we will look at:

• The fundamentals of cointegration.
• The error correction model.
• How to prepare for cointegration testing.
• What cointegration tests to use with and without structural breaks.
• How to interpret cointegration tests.
• How to perform cointegration tests in GAUSS.

Though not necessary, you may find it helpful to review the blogs on time series modeling and unit root testing before continuing with this blog.

What is Cointegration?

Economic theory suggests that many time series datasets will move together, fluctuating around a long-run equilibrium. In econometrics and statistics, this long-run equilibrium is tested and measured using the concept of cointegration.

Cointegration occurs when two or more nonstationary time series:

• Have a long-run equilibrium.
• Move together in such a way that their linear combination results in a stationary time series. 
• Share an underlying common stochastic trend.

The Mathematics of Cointegration

To understand the mathematics of cointegration, let's consider a group of time series, $Y_t$, which is composed of three separate time series:

$$y_1 = (y_{11}, y_{12}, \ldots, y_{1t})$$ $$y_2 = (y_{21}, y_{22}, \ldots, y_{2t})$$ $$y_3 = (y_{31}, y_{32}, ..., y_{3t})$$

All three series are nonstationary time series.

Cointegration implies that while $y_1$, $y_2$, and $y_3$ are independently nonstationary, they can be combined in a way that their linear combination is stationary :

$$\beta Y_t = \beta_1 y_{1t} + \beta_2 y_{2t} + \beta_3 y_{3t} \sim I(0)$$

The Cointegrating Vector
In the context of cointegration, $\beta$ is commonly known as the cointegrating vector. This vector:

• Dictates how cointegrating series are combined.
• Does not have to be unique - there can be multiple ways of cointegrating.

Normalization Because there can be multiple cointegrating vectors that fit the same economic model, we must impose identification restrictions to normalize the cointegrating vector for estimation.

A common normalization of the cointegrating vector is to set $\beta = ( 1,  -\beta_2, \ldots, -\beta_N)$. For example, applying these restrictions to our earlier system yields

$$\beta Y_t = y_{1t} - \beta_2 y_{2t} - \beta_3 y_{3t} \sim I(0)$$

Part of the appeal of this normalization is that it can be rewritten in a standard regression form

$$y_{1t} = \beta_2 y_{2t} + \beta_3 y_{3t} + u_t$$

where $u_t$ is a stationary cointegrating error component. Intuitively, $u_t$ can be thought of as short-term deviations from the long-run equilibrium. 

While the regression format is a common normalization, it is important to remember that economic theory should inform our identifying restrictions.

What is the Error Correction Model?

Cointegration implies that time series will be connecting through an error correction model. The error correction model is important in time series analysis because it allows us to better understand long-run dynamics. Additionally, failing to properly model cointegrated variables can result in biased estimates.

The error correction model:

• Reflects the long-run equilibrium relationships of variables.
• Includes a short-run dynamic adjustment mechanism that describes how variables adjust when they are out of equilibrium.
• Uses adjustment coefficients to measure the forces that push the relationship towards long-run equilibrium.

The Mathematics of the Error Correction Model

Let's assume that there is a bivariate cointegrated system with $Y_t = (y_{1t}, y_{2t})$ and a cointegrating vector $\beta = (1, -\beta_2)$ such that

$$\beta Y_{t} = y_{1t} - \beta_2 y_{2t}$$

The error correction model depicts the dynamics of a variable as a function of the deviations from long-run equilibrium

$$\Delta y_{1t} = c_1 + \alpha_1 (y_{1,t-1} - \beta_2 y_{2,t-1}) + \sum_j \psi^j_{11} \Delta y_{1, t-j} + \sum_j \psi^j_{12} \Delta y_{2, t-j} + \epsilon_1t$$ $$\Delta y_{2t} = c_2 + \alpha_2 (y_{1,t-1} - \beta_2 y_{2,t-1}) + \sum_j \psi^j_{21} \Delta y_{1, t-j} + \sum_j \psi^j_{22} \Delta y_{2, t-j} + \epsilon_2t$$

Estimating the Error Correction Model

If the cointegrating vector has been previously estimated, then standard OLS or DOLS can be used to estimate the error correction relationship. In this case:

• The estimate of the cointegrating vector can be treated like a known variable.
• The estimated disequilibrium error can be treated like a known variable.

The ECM relationship can be estimated using OLS, seemingly unrelated regressions (SUR), or maximum likelihood estimation.

The Vector Error Correction Model (VECM)

The vector error correction model (VECM) is the multivariate extension of the ECM. If we are working in a vector autoregressive context, cointegration implies a VECM such that

$$\Delta Y_t = \Phi D_t + \Pi Y_{t-1} + \Gamma_1 \Delta Y_{t-1} + \cdots + \Gamma_{p-1} \Delta Y_{t-p+1} + \epsilon_t$$

Like the ECM, the VECM parameters reflect the long-run and short-run dynamics of system as shown in the table below:

Estimating the VECM

The VECM model can be estimated using the Johansen method:

• Estimate the appropriate VAR(p) model for $Y_t$.
• Determine the number of cointegrating vectors, using a likelihood ratio test for the rank of $\Pi$.
• Impose identifying restrictions to normalize the cointegrating vector.
• Using the normalized cointegrating vectors, estimate the resulting VECM by maximum likelihood.

Preparing For Cointegration Tests

Before jumping directly to cointegration testing, there are a number of other time series modeling steps that we should consider first.

Establishing Underlying Theory

One of the key considerations prior to testing for cointegration, is whether there is theoretical support for the cointegrating relationship.  It is important to remember that cointegration occurs when separate time series share an underlying stochastic trend. The idea of a shared trend should be supported by economic theory.

As an example, consider growth theory which suggests that productivity is a key driver of economic growth. As such, it acts as the common trend, driving the comovements of many indicators of economic growth. Hence, this theory implies that consumption, investment, and income are all cointegrated. 

Time Series Visualization

One of the first steps in time series modeling should be data visualization. Time series plots provide good preliminary insights into the behavior of time series data:

• Is a series mean-reverting or has explosive behavior?
• Does it have a time trend?
• Is there seasonality?
• Are there structural breaks?

Unit Root Testing

We've established that cointegration occurs between nonstationary, I(1), time series. This implies that before testing for or estimating a cointegrating relationship, we should perform unit root testing. 

Our previous blog, "How to Conduct Unit Root Testing in GAUSS", provides an in-depth look at how to perform unit root testing in GAUSS.  

GAUSS tools for performing unit root tests are available in a number of libraries, including the Time Series MT (TSMT), the open-source TSPDLIB, and the coint libraries.  All of these can be directly located and installed using the GAUSS package manager. 

Full example programs for testing for unit roots using TSMT procedures and TSPDLIB procedures are available on our Aptech GitHub page. 

Testing for structural breaks

A complete time series analysis should consider the possibility that structural breaks have occurred. In the case that structural breaks have occurred, standard tests for cointegration are invalid.

Therefore, it is important to:

• Test whether structural breaks occur in the individual series.
• In the case that there is evidence of structural breaks, employ cointegration tests that allow for structural breaks.

The GAUSS sbreak procedure, available in TSMT, is an easy-to-use tool for identifying multiple, unknown structural breaks. 

Cointegration Tests

In order to test for cointegration, we must test that a long-run equilibrium exists for a group of data. There are a number of things that need to be considered:

• Are there multiple cointegrating vectors or just one?
• Is the cointegrating vector known or does it need to be estimated?
• What deterministic components are included in the cointegrating relationship?
• Do we suspect structural breaks in the cointegrating relationship?

In this section, we will show how to use these questions to guide cointegration testing without structural breaks.

The Engle-Granger Cointegration Test

The Engle-Granger cointegration test considers the case that there is a single cointegrating vector. The test follows the very simple intuition that if variables are cointegrated, then the residual of the cointegrating regression should be stationary.

Forming the cointegrating residual
How to form the cointegrating residual depends on if the cointegrating vector is known or must be estimated:

If the cointegrating vector is known, the cointegrating residuals are directly computed using $u_t = \beta Y_t$. The residuals should be stationary and:

• Any standard unit root tests, such as the ADF or PP test, can be used to test the residuals. The test statistics follow the standard distributions.
• The test compares the null hypothesis of no cointegration against the alternative of cointegration.
• The cointegrating residuals should be examined for the presence of a constant or trend, and the appropriate unit root test should be utilized.

If the cointegrating vector is unknown, OLS is used to estimate the normalized cointegrating vector from the regression $$y_{1t} = c + \beta y_{2t} + u_{t}$$

• The residuals from the cointegrating regression are estimated $$\hat{u_t} = y_{1t} - \hat{c} - \hat{\beta_2}y_{2t}$$
• Any standard unit root test, such as the ADF or PP test, can be used to test the residuals. The test statistics follow the nonstandard Phillips-Ouliaris (PO) distributions.
• The PO distribution depends on the trend behavior of the data.

The Johansen Tests

There are two Johansen cointegrating tests for the VECM context, the trace test and the maximal eigenvalue test. These tests hinge on the intuition that in the VECM, the rank of the long-run impact matrix, $\Pi$, determines if the VAR(p) variables are cointegrated.

Since the rank of the long-run impact matrix equals the number of cointegrating relationships:

• A likelihood ratio statistic for determining the rank of $\Pi$ can be used to establish the number of cointegrating relationships.
• Sequential testing can be used to test the number, $k$, of the cointegrating relationships.

The Johansen testing process has two general steps:

1. Estimate the VECM model using maximum likelihood under various assumptions:
   • With and without trend.
   • With and without constant.
   • With varying number, $k$, of cointegrating vectors.
2. Compare the models using likelihood ratio tests.

The Johansen Trace Statistics
The Johansen trace statistic:

• Is a likelihood ratio test of an unrestricted VECM against the restricted VECM with $k$ cointegrating vectors, where $k = m-1, \ldots, 0$.
• Is formed from the trace of a diagonal matrix of generalized eigenvalues from $\Pi$.
• As the $LR_{trace}(k)$ statistic gets closer to zero, we are less likely to reject the null hypothesis.
• If the $LR_{trace}(k)>CV$, then the null hypothesis is rejected.

The Johansen testing procedure sequentially tests the null hypothesis that the number of cointegrating vectors, $k = m$ against the alternative that $k > m$.

The test statistic follows a nonstandard distribution and depends on the dimension and the specified deterministic trend.

The Johansen Maximum Eigenvalue Statistic
The maximal eigenvalue statistic:

• Considers the null hypothesis that the cointegrating rank is $k$ against the alternative hypothesis that the cointegrating rank is $k + 1$.
• The statistic follows a nonstandard distribution.

Cointegration Test with Structural Breaks

In the case that there are structural breaks in the cointegrating relationship, the cointegration tests in the previous station should not be used. In this section we look at three tests for cointegration with structural breaks:

• The Gregory and Hansen (1996) test for cointegration with a single structural break.
• The Hatemi-J test (2009) for cointegration with two structural breaks.
• The Maki test for cointegration with multiple structural breaks.

The Gregory and Hansen Cointegration Test

The Gregory and Hansen (1996) cointegration test is a residual-based cointegration test that tests the null hypothesis of no cointegration against the alternative of cointegration in the presence of a single regime shift.

The Gregory and Hansen (1996) test:

• Is an extension of the ADF and PP residual tests for cointegration.
• Allows for unknown regimes shifts in either the intercept or the coefficient vector.
• Is valid for three different model cases: level shift with trend, regime shifts (changes in coefficients), regime shift with a shift in trend.

Because the structural break date is unknown, the test computes the cointegration test statistic for each possible breakpoint, and the smallest test statistics are used.

Gregory and Hansen (1996) suggest running their tests in combination with the standard cointegration tests:

• If the standard ADF test and the Gregory and Hansen ADF test both reject the null hypothesis of no cointegration, there is evidence in support of cointegration.
• If the standard ADF test does not reject the null hypothesis but the Gregory and Hansen ADF does, structural change in the cointegrating vector may be important.
• If the standard ADF test and the Gregory and Hansen ADF both reject the null hypothesis, there is no evidence from this test that structural change has occurred.

The Hatemi-J Cointegration Test with Two Structural Breaks

The Hatemi-J cointegration test is an extension of the Gregory and Hansen cointegration test. It allows for two possible structural breaks with unknown timing.

The Maki Cointegration Test

The Maki cointegration test builds on the Gregory and Hansen and the Hatemi-J cointegration tests to allow for an unknown number of structural breaks.

Where to Find Cointegration Tests for GAUSS

GAUSS tools for performing cointegration tests and estimating VECM models are available in a number of libraries, including the Time Series MT (TSMT) library, TSPDLIB, and the coint libraries.  All of these can be directly located and installed using the GAUSS package manager. 

How to Test for Cointegration using GAUSS

In this section, we will test for cointegration between monthly gold and silver prices, using historic monthly price date starting in 1915. Specifically, we will work through several stages of analysis:

1. Graphing the data and checking deterministic behavior.
2. Testing each series for unit roots.
3. Testing for cointegration without structural breaks.
4. Testing for cointegration with structural breaks.

Graphing the Data

As a first step, we will create a time series graph of our data. This allows us to visually examine the deterministic trends in our data.

From our graphs, we can draw some preliminary conclusions about the dynamics of gold and silver prices over our time period:

• There appears to be some foundation for the comovement of silver and gold prices.
• Neither gold nor silver prices appear to have a time trend.

Testing Each Series for Unit Roots

Before testing if silver and gold prices are cointegrated, we should test if the series have unit roots. We can do this using the unit roots tests available in the TSMT and TSPDLIB libraries.

These results provide evidence that gold prices are nonstationary but suggest that the silver prices are stationary. At this point, we would not likely proceed with cointegration testing or we may wish to perform additional unit root testing. For example, we may want to perform unit root tests that allow for structural breaks.

The GAUSS code for the tests in this section is available here.

Testing for Cointegration

Now, let's test for cointegration without structural breaks using two different tests, the Johansen tests and the Engle-Granger test.

The Johansen Tests
We will use the vmsjmt procedure from the TSMT library. This procedure should be used with the vmc_sjamt and vmc_sjtmt procedures, which find the critical values for the Maximum Eigenvalue and Trace statistics, respectively.

The vmsjmt procedure requires four inputs:

y

Matrix, contains the data to be tested for cointegration.

p

Scalar, the order of the time polynomial in the fitted regression. Set to $p=-1$ for no deterministic component, $p=0$ for a constant only, $p=1$ for a constant and trend.

k

Scalar, the number of lagged differences to use when computing the estimator.

no_det

Scalar, set $no\_det = 1$ to suppress the constant term from the fitted regression and include it in the cointegrating regression.

---

The vmsjmt procedure returns both the Johansen Trace and the Johansen Maximum Eigenvalue statistic. In addition, it returns the associated eigenvalues and eigenvectors.

new;

// Load tsmt library
library tsmt;

// Set filename (with path) for loading
fname2 = __FILE_DIR $+ "commodity_mon.dat";

// Load real prices data
y_test_real = loadd(fname2, "P_gold_real + P_silver_real");

// No deterministic component 
// the fitted regression
p = -1;

// Set number of lagged differences
// for computing estimator
k = 2;

// No determinant
no_det = 0;

{ ev, evec, trace_stat, max_ev }  = vmsjmt(y_test_real, p, k, no_det);
cv_lr2 = vmc_sjamt(cols(y), p);
cv_lr1 = vmc_sjtmt(cols(y), p);

Both trace_stat and max_ev will contain statistics for all possible ranks of $\Pi$.

For example, since we are testing for cointegration of just two time series, there will be at most one cointegrating vector. This means trace_stat and max_ev will be 2 x 1 matrices, testing both null hypotheses that $r=0$ and $r=1$.

These results indicate that there is no cointegration between monthly gold and silver prices. This should not be a surprise, given the results of our unit root testing.

The Engle-Granger
Since there is only one possible cointegrating vector for this system, we could have also used the Engle-Granger test for cointegration. This test can be implemented using the coint_egranger procedure from the TSPDLIB library.

The coint_egranger procedure requires five inputs:

y

Vector, independent variable in the testing regression. This is the variable the cointegrating variable is normalized to.

X

Matrix, dependent variable(s) in the testing regression. This should contain all other variables.

model

Scalar, specifies which deterministic components to include in the model. Set equal to 0 to include no deterministic components, 1 to include a constant, and 2 to include a constant and trend.

pmax

Scalar, the maximum number of lags to include in the cointegrating vector.

ic

Scalar, which information criteria to use to select the lags included in the ADF regression. Set equal to 1 for the AIC, 2 for the SIC.

---

The coint_egranger procedure returns the test statistic along with the 1%, 5% and 10% critical values.

Using the data already loaded in the previous example:

 /*
** Information Criterion:
** 1=Akaike;
** 2=Schwarz;
** 3=t-stat sign.
*/
ic = 2;

// Maximum number of lags
pmax = 12;

// No constant or trend
model = 0
{ tau0, cvADF0 } = coint_egranger(y_test_real[., 1], y_test_real[., 2], model, pmax, ic);

// Constant
model = 1
{ tau1, cvADF1 } = coint_egranger(y_test_real[., 1], y_test_real[., 2], model, pmax, ic);

// Constant and trend
model = 2
{ tau2, cvADF2 } = coint_egranger(y_test_real[., 1], y_test_real[., 2], model, pmax, ic);

These results provide evidence for our conclusion that there is no cointegration between gold and silver prices. Note, however, that these results are not conclusive and depend on whether we include a constant. This sheds light on the importance of including the correct deterministic components in our model.

Testing for Cointegration with Structural Breaks

To be thorough we should also test for cointegration using tests that allow for a structural break. As an example, let's use the Gregory-Hansen test to compare the null hypothesis of no cointegration against the alternative that there is cointegration with one structural break.

This test can be implemented using the coint_ghansen procedure from the TSPDLIB.

The coint_ghansen procedure requires eight inputs:

y

Vector, dependent variable in the testing regression. This is the variable the cointegrating variable is normalized to.

X

Matrix, independent variable(s) in the testing regression. This should contain all other variables.

model

Scalar, specified what type of regime shifts to include. Set equal to 1 for a level shift (C model), 2 for level shift with trend (C/T model), 3 for regime shift (C/S model), and 4 for regime and trend shifts.

bwl

Scalar, Bandwidth for kernel estimator for Phillips-Perron type test.

pmax

Scalar, the maximum number of lags to include in the cointegrating vector.

ic

Scalar, which information criteria to use to select the lags included in the ADF regression. Set equal to 1 for the AIC, 2 for the SIC.

varm

Scalar, long-run consistent variance type to use for the Phillips-Perron type test: 1 = iid, 2 = Bartlett, 3 = Quadratic Spectral (QS), 4 = SPC with Bartlett /see (Sul, Phillips & Choi, 2005), 5 = SPC with QS, 6 = Kurozumi with Bartlett, 7 = Kurozumi with QS.

trimm

Scalar, amount to trim from consideration as break date.

---

/*
** Information Criterion:
** 1=Akaike;
** 2=Schwarz;
** 3=t-stat sign.
*/
ic = 2;

//Maximum number of lags
pmax = 12;

// Trimming rate
trimm= 0.15;

// Long-run consistent variance estimation method
varm = 3;

// Bandwidth for kernel estimator
T = rows(y_test_real);
bwl = round(4 * (T/100)^(2/9));

// Level shift
model = 1;
{ ADF_min1, TBadf1, Zt_min1, TBzt1, Za_min1, TBza1, cvADFZt1, cvZa1 }=
    coint_ghansen(y_test_real[., 1], y_test_real[., 2], model, bwl, ic, pmax, varm, trimm);

// Level shift with trend
model = 2;
{ ADF_min2, TBadf2, Zt_min2, TBzt2, Za_min2, TBza2, cvADFZt2, cvZa2 }=
    coint_ghansen(y_test_real[., 1], y_test_real[., 2], model, bwl, ic, pmax, varm, trimm);

// Regime shift
model = 3;
{ ADF_min3, TBadf3, Zt_min3, TBzt3, Za_min3, TBza3, cvADFZt3, cvZa3 }=
    coint_ghansen(y_test_real[., 1], y_test_real[., 2], model, bwl, ic, pmax, varm, trimm);

// Regime shift with trend
model = 4;
{ ADF_min4, TBadf4, Zt_min4, TBzt4, Za_min4, TBza4, cvADFZt4, cvZa4 }=
    coint_ghansen(y_test_real[., 1], y_test_real[., 2], model, bwl, ic, pmax, varm, trimm);

The coint_ghansen has eight returns:

ADFmin

Scalar, the minimum $ADF$ test statistic across all breakpoints.

TBadf

Scalar, the breakpoint associated with the minimum $ADF$ statistic.

Ztmin

Scalar, the minimum $Z_t$ test statistic across all breakpoints.

TBzt

Scalar, the breakpoint associated with the minimum $Z_t$ statistic.

Zamin

Scalar, the minimum $Z_{\alpha}$ test statistic across all breakpoints.

TBza

Scalar, the breakpoint associated with the minimum $Z_{\alpha}$ statistic.

cvADFZt

Vector, the 1%, 5%, and 10% critical values for the $ADF$ and $Z_t$ statistics.

cvZa

Vector, the 1%, 5%, and 10% critical values for the $Z_{\alpha}$ statistic.

---

Note that our test for cointegration with one structural break is inconsistent and depends on which type of structural breaks we include in our model. This provides some indication that further exploration of structural breaks is needed.

Some examples of additional steps that we could take:

1. Perform more complete structural breaks testing to inform if structural breaks are valid, how many structural breaks should be included, and which structural break model is most appropriate.
2. Perform cointegration tests that are most consistent with the structural breaks analysis.

Conclusion

Congratulations! You now have an established guide for cointegration and the background you need to perform cointegration testing.

In particular, today's blog covered:

• The fundamentals of cointegration.
• The error correction model.
• How to prepare for cointegration testing.
• What cointegration tests to use with and without structural breaks.
• How to interpret cointegration tests.
• How to perform cointegration tests in GAUSS.

This week's blog brings you the second video in the series examining running publicly available GAUSS code. This video runs the popular code by Hatemi-J for testing cointegration with multiple structural breaks. In this video you will learn how to:

• Substitute your own dataset.
• Modify the indexing commands for your data.
• Remove missing values.
• Preview your data after loading with the Ctrl+E keyboard shortcut.

Previous: Running Public GAUSS Code: Part 1

Script

Introduction

Hello and welcome to the second part of our series on running publicly available GAUSS code. Last time we showed how to set up a project folder, run a program and resolve the library not found and file not found errors.

Today we will run the code which implements the tests for cointegration with two unknown structural breaks from Dr. Hatemi’s 2008 paper in Empirical Economics, using a couple of variables from the famous Nelson-Plosser dataset.

Starting point

We have saved the program and data in a folder named Hatemi under the GAUSS-Projects folder which we created in the first video in this series. If you are not sure how to do that, go back and take a look at the first video.

Code layout

Let’s start by looking at how this file is laid out. It is split into two main sections. The first part of the file, up to line 22, is responsible for loading data and calling the main procedure, which is in this case literally called main. This is the section that we will need to modify.

This second section of the code contains all of the procedures that Dr. Hatemi wrote to compute the algorithm from his paper.

The end command on line 22 is the line of demarcation between these two sections.

GAUSS will not run any commands located after end, but it will still find the procedures so they will be available for use by the code in the first section.

Data loading code

Let’s look at this first section to see what it is doing. The action starts on line 9 with the load command.

This statement is going to:

1. Look for a file named b22.txt in your current working directory.
2. Load the data it finds in that fil.
3. Reshape the data to be a matrix with obs rows and var columns.

We’re going to have to change this line because our data is not in b22.txt and we don’t want to have to specify the data size ahead of time, as we see here with obs and var.

Our dataset

Our data is in a Stata dataset named nelsonplosser.dta. The loadd command allows us to load data from many different types of datasets, including Stata datasets and to specify the model variables by name. So we will use loadd.

Dataset preview

Before we load our data, let’s get a preview of our dataset by double-clicking it in the Project Folder’s Window. Let’s scroll to the right to see all of the variables.

The yellow cells with dots contain missing values. We will deal with those after loading the data.

For this video our dependent variable will be bond yield which is the bnd variable and our independent variable will be the money supply, which is just m.

Load, preview and index our data

Let’s use the ‘loadd’ command to load our two variables into ‘z’. (add call-out showing viewers where to get more information about ‘loadd’.)

Now we see that lines 10 and 11 are splitting up the variables that we loaded from our dataset.

The intention of line 10 is to select all observations from the first column of z. However, we have a problem because obs has not yet been given a value. We could add a line setting ‘obs’ to be equal to the rows of z. That would be correct.

However, we can replace 1:obs with the dot operator. This is shorter and makes it clear that our intention is to load all the rows.

We see the same problem in line 11 with the row range and also with the column range. For now, we can just change the column index to two, because z will only have two columns.

The remaining lines create two variables, obs and n which do not seem to be used and then there is the call to main. We see that the only variables passed into main are y and x which we have created.

Let’s add an end command just before the call to main and then run our code so we can verify that our data is loaded correctly.

We’ll open z, y and x in floating symbol editors by clicking on them and using the Ctrl+E hotkey.

Remove missing values

As we mentioned earlier, the dots represent missing values. The code won’t work if the data contains missing values, so we will have to remove them.

The packr command removes all rows in which any element contains a missing value. If we add packr right after we load the data, the first 40 rows should be trimmed off, leaving us with z as a 71x2 matrix.

Run the code and view output

Now that we have confirmed that our data is correct, let’s remove the ‘end’ command that we added and run the full code.

We have successfully run the code. Here is our output.

Conclusion

Thank you for watching! I hope this has helped you to become more familiar with GAUSS. Let us know what content you would like to see. Please post your comments and questions below!

References

Abdulnasser Hatemi-J, (2008), Tests for cointegration with two unknown regime shifts with an application to financial market integration, Empirical Economics, Springer, vol. 35(3), p. 497-505.

Nelson, Charles and Plosser, Charles, (1982),Trends and random walks in macroeconmic time series: Some evidence and implications, Journal of Monetary Economics, vol. 10(2), p. 139-162.