In addition to the basic assignment statements described in the previous section, EViews provides you with a large set of tools for copying data to and from matrix objects.

At times, you may wish to move data between different types of matrix objects. For example, you may wish to take the data from a vector and put it in a matrix. EViews has a number of built-in rules which make these conversions automatically.

At other times, you may wish to move data between a matrix object and an EViews series or group object. There are a separate set of tools which allow you to convert data across a variety of object types.

Data may be moved between different types of matrix objects using assignment statements. If possible, EViews will resize the target object so that it contains the same information as the object on the right side of the equation.

The basic rules governing expressions of the form “Y=X” may be summarized as follows:

Specific exceptions to the rules given above are:

Here are some simple examples illustrating the rules for matrix assignment:

Here are some further examples where automatic resizing is allowed:

Lastly, consider the commands:

Y will be a rowvector of length 3, containing the original contents of Z, and Z will be a column vector of length 20 containing the contents of BETA.

will result in an error. EViews cannot change Y from a vector to a matrix and there is no way to assign directly the 4 elements of the matrix X to the vector Y. Other examples of invalid assignment statements involve assigning matrix objects to scalars or sym objects to vector objects.

It may be possible, however, to use the @vec, @vech, @unvec, and @unvech functions to reshape matrices and vectors into forms that permit assignment.

The best way to extract data from a matrix object is to use matrix object member functions.

The relevant functions for all matrix objects are:

For symmetric matrices, we also have the functions

where

For cases where args are numeric (integers, scalars, vectors), the arg values act as row or column indices. Focusing on column functions, for example,

where X is a matrix and CID is a vector of column indices, and the two lines return the vector V1 and matrix M1 containing the 3rd column of X, and the columns of X referenced in CID, respectively. Note that the elements of CID must be integers from 1 to the number of columns of X.

For cases where args are strings (string literal, string object, svector), the arg values are examined to find matches in the corresponding row or column labels . For example, the commands

where SCID is a svector of strings, produce the vector V2 and matrix M2 containing the 3rd column of X, and the columns of X with labels that match the elements of SCID, respectively. Note that all of the elements of SCID must be strings that match the column names previously assigned to X.

You may mix the types of arg1 and arg2 in data member functions that take two arguments so that, for example,

returns M3 containing the element of X in row 3 and column with label “apple”.

Similarly, the commands

return the matrix objects

The special symmetric matrix versions of these functions return syms:

return the sym objects

Combining matrix utility functions ( “Initialize Using Creation Functions”) with the matrix extraction data members offers flexible methods for obtaining data from matrices.

Consider, for example, the extraction of multiple columns from the matrix X using the @col data member function:

extracts columns {1, 3, 5, 9} from the matrix X.

Since the args in the member data extraction functions may themselves be expressions, we may combine the two lines into a single expression:

Similarly, extracting or dropping the 7 through 9th columns of X may be done using

We can perform the same compound extractions in 2-dimensions, as in

which create XSUB4 containing rows 3 to 6 and columns with labels matching “apple” and “orange” of X, and XSUB5 containing X after dropping row 4 and the columns with matching labels.

Data from a matrix may be assigned to part of another matrix object using the commands colplace, rowplace, and matplace. Consider the commands:

The matplace command places M2 in M1 beginning at row 1 and column 3. V1 is placed in column 3 of M1, while V2 is placed in row 80 of M1.

You may combine matplace with @fill and the @row, @col, @droprow, or @dropcol data members to perform complex subsetting and filling

puts rows 1, 3, and 4 of the matrix X into the upper-left hand corner of Z. Note that Z must be large enough to hold the X subset.

The previous sections described techniques for copying data between matrix objects such as vectors, matrices and scalars. In this section, we describe techniques for copying data between matrix objects and workfile-based EViews objects such as series and groups.

Keep in mind that there are two primary differences between the ordinary series or group objects and the matrix objects. First, operations involving series and groups use information about the current workfile sample, while matrix objects do not. Second, there are important differences in the handling of missing values (NAs) between the two types of objects.

The easiest method to copy data from series or group objects to a matrix object is to use direct assignment. Place the destination matrix object on the left side of an equal sign, and place the series or group to be converted on the right.

If you use a series object on the right-hand side and a vector on the left, EViews will only use observations from the current sample to make the vector. If you place a group object on the right and a matrix on the left, EViews will create a rectangular matrix out of the group using observations from the current sample.

While direct assignment is straightforward and convenient, there are two principal limitations to the approach. First, EViews uses only the observations in the current sample when copying the data. Second, observations containing missing data (NAs) for a series, or for any series in the group, are dropped. Thus, if the current sample contains 20 observations, but the series or group contains missing data, the dimension of the output vector or matrix will be less than 20. (Below, we describe methods which allow you to override the current sample and to retain missing values.)

Examples:

These statements create the vector XVEC and the two column matrix XMAT containing the non-missing series and group data from 1963M03 to 1993M06. Note that if GMPYQ has a missing value in 1970M01, and HSF contains a missing value in 1980M01, both observations for both series will be excluded from XMAT.

When performing matrix assignment, you may refer to an element of a series, just as you would refer to an element of a vector, by placing an index value in parentheses after the name. An index value i refers to the i-th element of the series from the beginning of the workfile range, not the current sample. For example, if the range of the current annual workfile is 1961 to 1980, the expression GNP(6) refers to the 1966 value of GNP. These series element expressions may be used in assigning specific series values to matrix elements, or to assign matrix values to a specific series element. For example:

assigns the fourth value of the series YSER to X(1,1), and assigns to the fifth and sixth values of YSER, the X(2,3) value and the scalar value “4000.2”, respectively.

While matrix assignments allow you to refer to elements of series as though they were elements of vectors, you cannot generally use series in place of vectors. Most vector and matrix operations will error if you use a series in place of a vector. For example, you cannot perform a rowplace command using a series name.

Furthermore, note that when you are not performing matrix assignment, a series name followed by a number in parentheses will indicate that the lag/lead operator be applied to the entire series. Thus, when used in generating series or in an equation, system, or model specification, GNP(6) refers to the sixth lead of the GNP series. To refer to specific elements of the GNP series in these settings, you should use the @elem function.

The @convert function takes a series or group object and, optionally, a sample object, and returns a vector or rectangular matrix. If no sample is provided, @convert will use the workfile sample. The sample determines which series elements are included in the matrix. Example:

There are two primary advantages of using @convert over direct assignment. First, since @convert is a function, it may be used in the middle of a matrix expression. Second, an optional second argument allows you to specify a sample to be used in conversion. For example:

performs the conversion using the sample defined in S1.

EViews also provides three useful commands that perform explicit conversions between series and matrices with control over both the sample and the handling of NAs.

stom (Series TO Matrix) takes a series or group object and copies its data to a vector or matrix using either the current workfile sample, or the optionally specified sample. As with direct assignment, the stom command excludes observations for which the series or any of the series in the group contain missing data.

Example:

While the operation of stom is similar to @convert, stom is a command and cannot be included in a matrix expression. Furthermore, unlike @convert, the destination matrix or vector must already exist and have the proper dimension.

stomna (Series TO Matrix with NAs) works identically to stom, but does not exclude observations for which there are missing values. The elements of the series for the relevant sample will map directly into the target vector or matrix. Thus,

will always create a 50 element vector GVECTOR that contains the values of GDP from 1951 to 2000, including observations with NAs.

mtos (Matrix TO Series) takes a matrix or vector and copies its data into an existing series or group, using the current workfile sample or a sample that you provide.

Example:

As with stom the destination dimension given by the sample must match that of the source vector or matrix.