An alphanumeric string is a set of characters containing alphabetic (“alpha”) and numeric characters, and in some cases symbols, found on a standard keyboard. Strings in EViews may include spaces and dashes, as well as single or double quote characters. Note also that EViews does not support unicode characters.

Strings are used in EViews in a variety of places. “Using Strings in EViews” offers a brief overview.

When entering alphanumeric values into EViews, you generally should enclose your characters in double quotes. The following are all examples of valid string input:

You should use the double quote character as an escape character for double quotes in a string. Simply enter two double quote characters to include the single double quote in the string:

Bear in mind that strings are simply sequences of characters with no special interpretation. The string values “3.14159” and “11/27/2002” might, for example, be used to represent a number and a date, but as strings they have no such intrinsic interpretation. To provide such an interpretation, you must use the EViews tools for translating string values into numeric or date values (see “String Information Functions” and “Translating between Date Strings and Date Numbers”).

Lastly, we note that the empty, or null, string (“”) has multiple interpretations in EViews. In settings where we employ strings as a building block for other strings, the null string is interpreted as a blank string with no additional meaning. If, for example, we concatenate two strings, one of which is empty, the resulting string will simply be the non-empty string.

In other settings, the null string is interpreted as a missing value. In settings where we use string values as a category, for example when performing categorizations, the null string is interpreted as both a blank string and a missing value. You may then choose to exclude or not exclude the missing value as a category when computing a tabulation using the string values. This designation of the null string as a missing value is recognized by a variety of views and procedures in EViews and may prove useful.

Likewise, when performing string comparisons using blank strings, EViews generally treats the blank string as a missing value. As with numeric comparisons involving missing values, comparisons involving missing values will often generate a missing value. We discuss this behavior in greater detail in our discussion of “String Comparison (with empty strings)”.

The following operators are supported for strings: (1) concatenation—plus (“+”), and (2) relational—equal to (“=”), not equal to (“<>”), greater than (“>”), greater than or equal to (“>=”), less than (“<“), less than or equal to (“<=”).

Given two strings, concatenation creates a new string which contains the first string followed immediately by the second string. You may concatenate strings in EViews using the concatenation operator, “+”. For example,

returns the strings

Bear in mind that string concatenation is a simple operation that does not involve interpretation of strings as numbers or dates. Note in particular that the latter entry yields the concatenated string, “3.14159”, not the sum of the two numeric values, “162.14”. To obtain numeric results, you will first have to convert your strings into a number (see “String Information Functions”).

Lastly, we note that when concatenating strings, the empty string is interpreted as a blank string, not as a missing value. Thus, the expression

yields

since the middle string is interpreted as a blank.

The relational operators return a 1 if the comparison is true, and 0 if the comparison is false. In some cases, relational comparisons involving null strings will return a NA.

To determine the ordering of strings, EViews employs the region-specific collation order as supplied by the Windows operating system using the user’s regional settings. Central to the tasks of sorting or alphabetizing, the collation order is the culturally influenced order of characters in a particular language.

While we cannot possibly describe all of the region-specific collation order rules, we note a few basic concepts. First, all punctuation marks and other non alphanumeric characters, except for the hyphen and the apostrophe precede the alphanumeric symbols. The apostrophe and hyphen characters are treated distinctly, so that “were” and “we’re” remain close in a sorted list. Second, the collation order is case specific, so that the character “a” precedes “A”. In addition, similar characters are kept close so that strings beginning with “a” are followed by strings beginning with “A”, ahead of strings beginning with “b” and “B”.

Typically, we determine the order of two strings by evaluating strings character-by-character, comparing pairs of corresponding characters in turn, until we find the first pair for which the strings differ. If, using the collation order, we determine the first character precedes the second character, we say that the first string is less than the second string and the second string is greater than the first. Two strings are said to be equal if they have the same number of identical characters.

If the two strings are identical in every character, but one of them is shorter than the other, then a comparison will indicate that the longer string is greater. A corollary of this statement is that the null string is less than or equal to all other strings.

The multi-character elements that arise in many languages are treated as single characters for purposes of comparison, and ordered using region-specific rules. For example, the “CH” and “LL” in Traditional Spanish are treated as unique characters that come between “C” and “L” and “M”, respectively.

Having defined the notion of string ordering, we may readily describe the behavior of the relational operators for non-empty (non-missing) strings. The “=” (equal), “>=” (greater than or equal), and “<=” (less than or equal), “<>” (not equal), “>” (greater than), and “<” (less than) comparison operators return a 1 or a 0, depending on the result of the string comparison. To illustrate, the following (non region-specific) comparisons return the value 1,

while the following return a 0,

To compare portions of strings, you may use the functions @left, @right, and @mid to extract the relevant part of the string (see “String Manipulation Functions”). The relational comparisons,

all return 1.

In normal settings, EViews will employ case-sensitive comparisons (see “Case-Sensitive String Comparison” for settings that enable caseless element comparisons in programs). To perform a caseless comparison, you should convert the expressions to all uppercase, or all lowercase using the @upper, or @lower functions. The comparisons,

both return 1.

To ignore leading and trailing spaces, you should use the @ltrim, @rtrim, and @trim functions remove the spaces prior to using the operator. The relational comparisons,

all return 1.

Generally speaking, the relational operators treat the empty string as a missing value and return the numeric missing value NA when applied to such a string. Suppose, for example that an observation in the alpha series X contains the string “Apple”, and the corresponding observation in the alpha series Y contains a blank string. All comparisons (“X=Y”, “X>Y”, “X>=Y”, “X<Y”, “X<=Y”, and “X<>Y”) will generate an NA for that observation since the Y value is treated as a missing value.

Note that this behavior differs from EViews 4 and earlier in which empty strings were treated as ordinary blank strings and not as a missing value. In these versions of EViews, the comparison operators always returned a 0 or a 1. The change in behavior, while regrettable, was necessary to support the use of string missing values.

It is still possible to perform comparisons using the previous behavior. One approach is to use the special functions @eqna and @neqna for equality and strict inequality comparisons without propagating NAs (see “String Information Functions”). For example, you may use the expressions

so that blanks in string X or Y are treated as ordinary string values. Using these two functions, the observation where X contains “Apple” and Y contains the “” will evaluate to 0 and 1, respectively instead of NA.

Similarly, if you specify a relational expression involving a literal blank string, EViews will perform the test treating empty strings as ordinary string values. If, for example, you test

or

all of the string values in X will be tested against the string literal “”. You should contrast this behavior with the behavior for the non-literal tests “X=Y” and “X<Y” where blank values of X or Y result in an NA comparison.

Lastly, EViews provides a function for the strict purpose of testing whether a string value is an empty string. The @isempty function tests whether a string is empty. The relational equality test against the blank string literal “” is equivalent to this function.

A string list is an ordinary string that is interpreted as a space delimited list of string elements. For example, the string

may be interpreted as containing three elements, the words “Here”, “I” and “stand”. Double quotes may be used to include multiword elements in a list. Bearing in mind that the quote is used as an escape character for including quotes in strings, the list

contains three elements, the expressions “Chicken Marsala”, “Beef Stew”, and “Hamburger”. Notice how the escaped double quotes are used to group words into single list elements.

Interpreting a string as a list of elements allows us to make use of functions which operate on each element in the string, rather than on each character. These methods can be useful for string manipulation and pattern searching. For example, we may find the intersection, union, or cross of two string lists. Additionally, we may manipulate the elements of a string list and find the elements that match or do not match a given pattern. For example, the string list function

uses the pattern “?B*” to filter the string list “ABC ABCC AABC”. Elements with a single character, followed by the character “B”, then followed by any number of other characters are kept, returning: “ABC ABCC”.

EViews provides a number of functions that may either be used with strings, or return string values.

Functions that treat a string as a string list begin with a “w”. Some string functions have corresponding list functions with the same name, preceded by a “w”. For instance, @left returns the leftmost characters of a string, while @wleft returns the leftmost elements of a string list.

The following is a brief summary of the basic functions that take strings as an argument and return a number. ( “String and Date Function Reference” offers a more detailed description.)

The following is a brief summary of the basic functions that take strings as an argument and return a string.

The following functions convert between numbers or date numbers and strings:

The following functions either take a string vector as an argument, or return a string vector:

EViews provides a special, workfile-based function that uses the structure of the active workfile page and returns a set of string values representing the date identifiers associated with the observations.

In addition, EViews provides two special functions that return a string representations of the date associated with a specific observation in the workfile, or with the current time.

You may also ask EViews to report information about objects in the current workfile or database, or a directory on your computer, in a form suitable for list processing:

Lastly, all EViews objects have data members which return information about themselves in the form of a string. For example:

returns the last update time for the series SER1

returns the full command line form of the estimation command.

For lists of the relevant data members see the individual object descriptions in “Object View and Procedure Reference”.

Strings in EViews are primarily used in four distinct contexts: string variables, string objects, string vectors, or Alpha series.

A string variable is a temporary variable used in a program whose value is a string. String variables, which only exist during the time that your EViews program is executing, have names that begin with a “%” symbol. For example,

are string variables declarations that may be used in program files.

See “String Variables” for extensive discussion of the role that these variables play in programming.

A string object is an EViews workfile object that holds a string of text:

creates the string objects LUNCH and DINNER, each containing the corresponding string literal. Note that we have used the double quote character as an escape character for double quotes.

Since a string object is an EViews workfile object, we may open and display its views. A string object’s view may be switched between String and Word list views. The String view for DINNER displays the text as a single string,

while the Word list view breaks up the text by element,

with each element on a separate line.

We emphasize the important distinction that string objects are named objects in the workfile that may be saved with the workfile, while string variables are temporary variables that only exist while an EViews program is running. Thus, string objects have the advantage that they may be used interactively, while string variables may not be used outside of programs. String objects can, however, go out of scope when the active workfile page changes, while string variables are always in scope.

In all other respects, strings objects and string variables may be used interchangeably in programs. Either string object or string variables can be passed into subroutines for arguments declared as type string.

An svector, or string vector, is an EViews object that holds a string in each row of the vector. A string vector can be created by specifying the number of rows in the vector and providing a name:

If a length is not specified, a one row svector will be created.

An svector can be populated by assigning a string or string literal to each row:

fills the first row of SVEC with the string “gdp cost total”. To assign the same string to all rows, omit the row number. The command

will assign the string “invalid” to all rows of SVEC.

A multiple row svector may be populated using the @wsplit command, which creates a string vector from a string list. For example,

creates the string vector SVEC of default length one and a string object ST containing “gdp cost total”. The @wsplit command creates a three element svector from the elements of ST, placing the string “gdp” in the first row of the string vector, the string “cost” in the second row, and the string “total” in the third row, and assigns it to SVEC, which is resized accordingly.

Similarly, an svector will shrink if assigned to a smaller svector. For example,

first creates the three row svector SVEC3, then assigns the strings “First”, “Middle”, and “Last” to the first, second, and third rows, respectively. The third line creates a second ten row svector, SVEC10. When SVEC3 is assigned to SVEC10, its values are copied over and rows four through ten are removed from SVEC10.

An svector may also be filled by concatenating two strings or svectors. For instance,

creates two svectors S1 and S2, each with three rows. S1 contains the characters “A”, “B”, and “C”, while S2 contains “1”, “2”, and “3”. The third command creates the svector SSVEC and fills it with the concatenation of the other two svectors, producing “A1” on the first row, “B2” on the second row, and “C3” on the third row.

More generally, any operation that can be performed on a string may be performed on element of an svector. For example, given an svector whose first element contains the string “Hello World” and whose second element contains “Hi there world”, the element assignment statement

takes the left five characters of the first row (“Hello”), adds a space, concatenates five characters from the second row, starting at the fourth character (“there”), and assigns it to the third element of SV. Element three of SV now contains the string “Hello there”.

The row count of a string vector may be retrieved using the @rows command:

This is especially useful since svectors are dynamically resized when necessary.

EViews has a special series type for holding string data. An alpha series object contains a set of observations on string values. Alpha series should be used when you wish to work with variables that contain alphanumeric data, such as names, addresses, and other text.

Alpha series are distinguished from string vectors primarily in that their length is tied to the length of the workfile.

See “Alpha Series” for discussion.