[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

6.2 dseries class

The Matlab/Octave dseries class handles time series data. As any Matlab/Octave statements, this class can be used in a Dynare’s mod file. A dseries object has eight members:

nobs

A scalar integer, the number of observations.

vobs

A scalar integer, the number of variables.

name

A cell of strings, the names of the variables.

tex

A cell of strings, the tex names of the variables.

freq

A scalar integer equal to 1, 4, 12 or 52, the frequency of the dataset.

init

A single element dates object, the initial date of the sample.

dates

A dates object with nobs element, the dates of the sample.

data

A nobs by vobs array of doubles, the data.

freq, nobs, vobs, data, name, tex are private members. The following constructors are available:

dseries: dseries ()
dseries: dseries (INITIAL_DATE)

Instantiates an empty dseries object, with, if defined, an initial date given by the single element dates object INITIAL_DATE (the frequency is then set accordingly).


dseries: dseries (FILENAME)

Instantiates and populates a dseries object with a data file specified by FILENAME, a string passed as input. Valid file types are ‘.m’ file, ‘.mat’ file, ‘.csv’ file, and ‘.xls’ file. A typical ‘.m’ file will have the following form:

 
INIT__ = '1994Q3';
NAMES__ = {'azert';'yuiop'};
TEX__ = {'azert';'yuiop'};

azert = randn(100,1);
yuiop = randn(100,1);

If a ‘.mat’ file is used instead, it should provide the same informations. Note that the INIT__ variable can be either a dates object or a string which could be used to instantiate the same dates object.


dseries: dseries (DATA_MATRIX[, INITIAL_DATE[, LIST_OF_NAMES[, LIST_OF_TEX_NAMES]]])

If the data is not read from a file, it can be provided via a $T$x$N$ matrix as the first argument to dseries’ constructor, with $T$ representing the number of observations on $N$ variables. The optional second argument, INITIAL_DATE, can be either a dates object representing the period of the first observation or a string which would be used to instantiate a dates object. Its default value is dates('1Y'). The optional third argument, LIST_OF_NAMES, is a $N$ by $1$ cell of strings with one entry for each variable name. The default name associated with column i of DATA_MATRIX is Variable_i. The final argument, LIST_OF_TEX_NAMES, is a $N$ by $1$ cell of strings composed of the LaTeX names associated with the variables. The default LaTeX name associated with column i of DATA_MATRIX is Variable\_i.


Examples

Various ways to create a dseries object:


 
 In a mod file:
do1 = dseries(1999Q3);
do2 = dseries('filename.csv');
do3 = dseries([1; 2; 3], 1999Q3, {'var123'}, {'var_{123}'});

 
 In a Matlab/Octave script:
>> do1 = dseries(dates('1999Q3'));
>> do2 = dseries('filename.csv');
>> do3 = dseries([1; 2; 3], dates('1999Q3'), {'var123'}, {'var_{123}'});

One can easily create subsamples from a dseries object using the overloaded parenthesis operator. If ds is a dseries object with $T$ observations and d is a dates object with $S<T$ elements, such that $min(d)$ is not smaller than the date associated to the first observation in ds and $max(d)$ is not greater than the date associated to the last observation, then ds(d) instantiates a new dseries object containing the subsample defined by d.

A list of the available methods, by alphabetical order, is given below.

dseries: [A, B] = align (A, B)

If dseries objects A and B are defined on different time ranges, this function extends A and/or B with NaNs so that they are defined on the same time range. Note that both dseries objects must have the same frequency.

Example

 
>> ts0 = dseries(rand(5,1),dates('2000Q1')); % 2000Q1 -> 2001Q1
>> ts1 = dseries(rand(3,1),dates('2000Q4')); % 2000Q4 -> 2001Q2
>> [ts0, ts1] = align(ts0, ts1);             % 2000Q1 -> 2001Q2
>> ts0

ts0 is a dseries object:

       | Variable_1
2000Q1 | 0.81472
2000Q2 | 0.90579
2000Q3 | 0.12699
2000Q4 | 0.91338
2001Q1 | 0.63236
2001Q2 | NaN

>> ts1

ts1 is a dseries object:

       | Variable_1
2000Q1 | NaN
2000Q2 | NaN
2000Q3 | NaN
2000Q4 | 0.66653
2001Q1 | 0.17813
2001Q2 | 0.12801

dseries: B = baxter_king_filter (A, hf, lf, K)

Implementation of the Baxter and King (1999) band pass filter for dseries objects. This filter isolates business cycle fluctuations with a period of length ranging between hf (high frequency) to lf (low frequency) using a symmetric moving average smoother with $2K+1$ points, so that K observations at the beginning and at the end of the sample are lost in the computation of the filter. The default value for hf is $6$, for lf is $32$, and for K is 12.

Example

 
% Simulate a component model (stochastic trend, deterministic trend, and a
% stationary autoregressive process).
e = .2*randn(200,1);
u = randn(200,1);
stochastic_trend = cumsum(e);
deterministic_trend = .1*transpose(1:200);
x = zeros(200,1);
for i=2:200
    x(i) = .75*x(i-1) + e(i);
end
y = x + stochastic_trend + deterministic_trend;

% Instantiates time series objects.
ts0 = dseries(y,'1950Q1');
ts1 = dseries(x,'1950Q1'); % stationary component.

% Apply the Baxter-King filter.
ts2 = ts0.baxter_king_filter();

% Plot the filtered time series.
plot(ts1(ts2.dates).data,'-k'); % Plot of the stationary component.
hold on
plot(ts2.data,'--r');           % Plot of the filtered y.
hold off
axis tight
id = get(gca,'XTick');
set(gca,'XTickLabel',strings(ts.dates(id)));

dseries: [error_flag, message ] = check (A)

Sanity check of dseries object A. Returns $1$ if there is an error, $0$ otherwise. The second output argument is a string giving brief informations about the error.


dseries: B = cumsum (A[, d[, v]])

Overloads the Matlab/Octave cumsum function for dseries objects. The cumulated sum cannot be computed if the variables in dseries object A has NaNs. If a dates object d is provided as a second argument, then the method computes the cumulated sum with the additional constraint that the variables in the dseries object B are zero in period d. If a single observation dseries object v is provided as a third argument, the cumulated sum in B is such that B(d) matches v (dseries objects A and v must have the same number of variables).

Example

 
>> ts1 = dseries(ones(10,1));
>> ts2 = ts1.cumsum();
>> ts2

ts2 is a dseries object:

    | cumsum(Variable_1)
1Y  | 1
2Y  | 2
3Y  | 3
4Y  | 4
5Y  | 5
6Y  | 6
7Y  | 7
8Y  | 8
9Y  | 9
10Y | 10

>> ts3 = cumsum(dates('3Y'));
>> ts3

ts3 is a dseries object:

    | cumsum(Variable_1)
1Y  | -2
2Y  | -1
3Y  | 0
4Y  | 1
5Y  | 2
6Y  | 3
7Y  | 4
8Y  | 5
9Y  | 6
10Y | 7

>> ts4 = ts1.cumsum(dates('3Y'),dseries(pi));
>> ts4

ts4 is a dseries object:

    | cumsum(Variable_1)
1Y  | 1.1416
2Y  | 2.1416
3Y  | 3.1416
4Y  | 4.1416
5Y  | 5.1416
6Y  | 6.1416
7Y  | 7.1416
8Y  | 8.1416
9Y  | 9.1416
10Y | 10.1416

dseries: C = eq (A, B)

Overloads the Matlab/Octave eq (equal, ==) operator. dseries objects A and B must have the same number of observations (say, $T$) and variables ($N$). The returned argument is a $T$ by $N$ matrix of zeros and ones. Element $(i,j)$ of C is equal to 1 if and only if observation $i$ for variable $j$ in A and B are the same.

Example

 
>> ts0 = dseries(2*ones(3,1));
>> ts1 = dseries([2; 0; 2]);
>> ts0==ts1

ans =

     1
     0
     1

dseries: B = exp (A)

Overloads the Matlab/Octave exp function for dseries objects. Example

 
>> ts0 = dseries(rand(10,1));
>> ts1 = ts0.exp();

dseries: C = extract (A, B[, ...])

Extracts some variables from a dseries object A and returns a dseries object C. The input arguments following A are strings representing the variables to be selected in the new dseries object C. To simplify the creation of sub-objects, the dseries class overloads the curly braces (D = extract (A, B, C) is equivalent to D = A{B,C}) and allows implicit loops (defined between a pair of @ symbol, see examples below) or Matlab/Octave’s regular expressions (introduced by square brackets).

Examples

The following selections are equivalent:

 
>> ts0 = dseries(ones(100,10));
>> ts1 = ts0{'Variable_1','Variable_2','Variable_3'};
>> ts2 = ts0{'Variable_@1,2,3@'}
>> ts3 = ts0{'Variable_[1-3]$'}
>> isequal(ts1,ts2) && isequal(ts1,ts3)

ans =

     1

It is possible to use up to two implicit loops to select variables:

 
names = {'GDP_1';'GDP_2';'GDP_3'; 'GDP_4'; 'GDP_5'; 'GDP_6'; 'GDP_7'; 'GDP_8'; ...
      'GDP_9'; 'GDP_10'; 'GDP_11'; 'GDP_12'; ...
      'HICP_1';'HICP_2';'HICP_3'; 'HICP_4'; 'HICP_5'; 'HICP_6'; 'HICP_7'; 'HICP_8'; ...
      'HICP_9'; 'HICP_10'; 'HICP_11'; 'HICP_12'};

ts0 = dseries(randn(4,24),dates('1973Q1'),names);
ts0{'@GDP,HICP@_@1,3,5@'}

ans is a dseries object:

       | GDP_1    | GDP_3     | GDP_5     | HICP_1   | HICP_3   | HICP_5
1973Q1 | 1.7906   | -1.6606   | -0.57716  | 0.60963  | -0.52335 | 0.26172
1973Q2 | 2.1624   | 3.0125    | 0.52563   | 0.70912  | -1.7158  | 1.7792
1973Q3 | -0.81928 | 1.5008    | 1.152     | 0.2798   | 0.88568  | 1.8927
1973Q4 | -0.03705 | -0.35899  | 0.85838   | -1.4675  | -2.1666  | -0.62032

dseries: D = horzcat (A, B[, ...])

Overloads the horzcat Matlab/Octave’s method for dseries objects. Returns a dseries object D containing the variables in dseries objects passed as inputs: A, B, ... If the inputs are not defined on the same time ranges, the method adds NaNs to the variables so that the variables are redefined on the smallest common time range. Note that the names in the dseries objects passed as inputs must be different and these objects must have common frequency.

Example

 
>> ts0 = dseries(rand(5,2),'1950Q1',{'nifnif';'noufnouf'});
>> ts1 = dseries(rand(7,1),'1950Q3',{'nafnaf'});
>> ts2 = [ts0, ts1];
>> ts2

ts2 is a dseries object:

       | nifnif  | noufnouf | nafnaf
1950Q1 | 0.17404 | 0.71431  | NaN
1950Q2 | 0.62741 | 0.90704  | NaN
1950Q3 | 0.84189 | 0.21854  | 0.83666
1950Q4 | 0.51008 | 0.87096  | 0.8593
1951Q1 | 0.16576 | 0.21184  | 0.52338
1951Q2 | NaN     | NaN      | 0.47736
1951Q3 | NaN     | NaN      | 0.88988
1951Q4 | NaN     | NaN      | 0.065076
1952Q1 | NaN     | NaN      | 0.50946

dseries: B = hpcycle (A[, lambda])

Extracts the cycle component from a dseries A object using Hodrick Prescott (1997) filter and returns a dseries object, B. The default value for lambda, the smoothing parameter, is $1600$.

Example

 
% Simulate a component model (stochastic trend, deterministic trend, and a
% stationary autoregressive process).
e = .2*randn(200,1);
u = randn(200,1);
stochastic_trend = cumsum(e);
deterministic_trend = .1*transpose(1:200);
x = zeros(200,1);
for i=2:200
    x(i) = .75*x(i-1) + e(i);
end
y = x + stochastic_trend + deterministic_trend;

% Instantiates time series objects.
ts0 = dseries(y,'1950Q1');
ts1 = dseries(x,'1950Q1'); % stationary component.

% Apply the HP filter.
ts2 = ts0.hpcycle();

% Plot the filtered time series.
plot(ts1(ts2.dates).data,'-k'); % Plot of the stationary component.
hold on
plot(ts2.data,'--r');           % Plot of the filtered y.
hold off
axis tight
id = get(gca,'XTick');
set(gca,'XTickLabel',strings(ts.dates(id)));

dseries: B = hptrend (A[, lambda])

Extracts the trend component from a dseries A object using Hodrick Prescott (1997) filter and returns a dseries object, B. Default value for lambda, the smoothing parameter, is $1600$.

Example Using the same generating data process as in the previous example:

 
ts1 = dseries(stochastic_trend + deterministic_trend,'1950Q1');
% Apply the HP filter.
ts2 = ts0.hptrend();

% Plot the filtered time series.
plot(ts1.data,'-k'); % Plot of the nonstationary components.
hold on
plot(ts2.data,'--r');           % Plot of the estimated trend.
hold off
axis tight
id = get(gca,'XTick');
set(gca,'XTickLabel',strings(ts0.dates(id)));

dseries: C = insert (A, B, I)

Inserts variables contained in dseries object B in dseries object A at positions specified by integer scalars in vector I, returns augmented dseries object C. The integer scalars in I must take values between 1 and A.length()+1 and refers to A’s column numbers. The dseries objects A and B need not to be defined over the same time ranges, but it is assumed that they have common frequency.

Example

 
>> ts0 = dseries(ones(2,4),'1950Q1',{'Sly'; 'Gobbo'; 'Sneaky'; 'Stealthy'});
>> ts1 = dseries(pi*ones(2,1),'1950Q1',{'Noddy'});
>> ts2 = ts0.insert(ts1,3)

ts2 is a dseries object:

       | Sly | Gobbo | Noddy  | Sneaky | Stealthy
1950Q1 | 1   | 1     | 3.1416 | 1      | 1
1950Q2 | 1   | 1     | 3.1416 | 1      | 1

>> ts3 = dseries([pi*ones(2,1) sqrt(pi)*ones(2,1)],'1950Q1',{'Noddy';'Tessie Bear'});
>> ts4 = ts0.insert(ts1,[3, 4])

ts4 is a dseries object:

       | Sly | Gobbo | Noddy  | Sneaky | Tessie Bear | Stealthy
1950Q1 | 1   | 1     | 3.1416 | 1      | 1.7725      | 1
1950Q2 | 1   | 1     | 3.1416 | 1      | 1.7725      | 1

dseries: B = isempty (A)

Overloads the Matlab/octave’s isempty function. Returns 1 if dseries object A is empty, 0 otherwise.


dseries: C = isequal (A,B)

Overloads the Matlab/octave’s isequal function. Returns 1 if dseries objects A and B are identical, 0 otherwise.


dseries: B = lag (A[, p])

Returns lagged time series. Default value of p, the number of lags, is 1.

Examples

 
>> ts0 = dseries(transpose(1:4),'1950Q1')

ts0 is a dseries object:

       | Variable_1
1950Q1 | 1
1950Q2 | 2
1950Q3 | 3
1950Q4 | 4

>> ts1 = ts0.lag()

ts1 is a dseries object:

       | lag(Variable_1,1)
1950Q1 | NaN
1950Q2 | 1
1950Q3 | 2
1950Q4 | 3

>> ts2 = ts0.lag(2)

ts2 is a dseries object:

       | lag(Variable_1,2)
1950Q1 | NaN
1950Q2 | NaN
1950Q3 | 1
1950Q4 | 2

dseries class overloads the parenthesis so that ts.lag(p) can be written more compactly as ts(-p). For instance:

 
>> ts0.lag(1)

ans is a dseries object:

       | lag(Variable_1,1)
1950Q1 | NaN
1950Q2 | 1
1950Q3 | 2
1950Q4 | 3

or alternatively:

 
>> ts0(-1)

ans is a dseries object:

       | lag(Variable_1,1)
1950Q1 | NaN
1950Q2 | 1
1950Q3 | 2
1950Q4 | 3

dseries: B = lead (A[, p])

Returns leaded time series. Default value of p, the number of leads, is 1. As for the lag method, the dseries class overloads the parenthesis so that ts.lead(p) is equivalent to ts(p).

Example

 
>> ts0 = dseries(transpose(1:4),'1950Q1');
>> ts1 = ts0.lead()

ts1 is a dseries object:

       | lead(Variable_1,1)
1950Q1 | 2
1950Q2 | 3
1950Q3 | 4
1950Q4 | NaN

>> ts2 = ts0(2)

ts2 is a dseries object:

       | lead(Variable_1,2)
1950Q1 | 3
1950Q2 | 4
1950Q3 | NaN
1950Q4 | NaN

Remark

The overloading of the parenthesis for dseries objects, allows to easily create new dseries objects by copying/pasting equations declared in the model block. For instance, if an Euler equation is defined in the model block:

 
model;
    ...
    1/C - beta/C(1)*(exp(A(1))*K^(alpha-1)+1-delta) ;
    ...
end;

and if variables C, A and K are defined as dseries objects, then by writting:

 
Residuals = 1/C - beta/C(1)*(exp(A(1))*K^(alpha-1)+1-delta) ;

outside of the model block, we create a new dseries object, called Residuals, for the residuals of the Euler equation (the conditional expectation of the equation defined in the model block is zero, but the residuals are non zero).


dseries: B = log (A)

Overloads the Matlab/Octave log function for dseries objects. Example

 
>> ts0 = dseries(rand(10,1));
>> ts1 = ts0.log();

dseries: C = merge (A, B)

Merges two dseries objects A and B in dseries object C. Objects A and B need to have common frequency but can be defined on different time ranges. If a variable, say x, is defined both in dseries objects A and B, then the merge will select the variable x as defined in the second input argument, B.

Example

 
>> ts0 = dseries(rand(3,2),'1950Q1',{'A1';'A2'})

ts0 is a dseries object:

       | A1       | A2
1950Q1 | 0.42448  | 0.92477
1950Q2 | 0.60726  | 0.64208
1950Q3 | 0.070764 | 0.1045

>> ts1 = dseries(rand(3,1),'1950Q2',{'A1'})

ts1 is a dseries object:

       | A1
1950Q2 | 0.70023
1950Q3 | 0.3958
1950Q4 | 0.084905

>> merge(ts0,ts1)

ans is a dseries object:

       | A1       | A2
1950Q1 | NaN      | 0.92477
1950Q2 | 0.70023  | 0.64208
1950Q3 | 0.3958   | 0.1045
1950Q4 | 0.084905 | NaN

>> merge(ts1,ts0)

ans is a dseries object:

       | A1       | A2
1950Q1 | 0.42448  | 0.92477
1950Q2 | 0.60726  | 0.64208
1950Q3 | 0.070764 | 0.1045
1950Q4 | NaN      | NaN

dseries: C = minus (A, B)

Overloads the minus (-) operator for dseries objects, element by element subtraction. If both A and B are dseries objects, they do not need to be defined over the same time ranges. If A and B are dseries objects with $T_A$ and $T_B$ observations and $N_A$ and $N_B$ variables, then $N_A$ must be equal to $N_B$ or $1$ and $N_B$ must be equal to $N_A$ or $1$. If $T_A=T_B$, isequal(A.init,B.init) returns 1 and $N_A=N_B$, then the minus operator will compute for each couple $(t,n)$, with $1\le t\le T_A$ and $1\le n\le N_A$, C.data(t,n)=A.data(t,n)-B.data(t,n). If $N_B$ is equal to $1$ and $N_A>1$, the smaller dseries object (B) is “broadcast” across the larger dseries (A) so that they have compatible shapes, the minus operator will subtract the variable defined in B from each variable in A. If B is a double scalar, then the method minus will subtract B from all the observations/variables in A. If B is a row vector of length $N_A$, then the minus method will subtract B(i) from all the observations of variable i, for $i=1,...,N_A$. If B is a column vector of length $T_A$, then the minus method will subtract B from all the variables.

Example

 
>> ts0 = dseries(rand(3,2));
>> ts1 = ts0{'Variable_2'};
>> ts0-ts1

ans is a dseries object:

   | minus(Variable_1,Variable_2) | minus(Variable_2,Variable_2)
1Y | -0.48853                     | 0
2Y | -0.50535                     | 0
3Y | -0.32063                     | 0

>> ts1

ts1 is a dseries object:

   | Variable_2
1Y | 0.703
2Y | 0.75415
3Y | 0.54729

>> ts1-ts1.data(1)

ans is a dseries object:

   | minus(Variable_2,0.703)
1Y | 0
2Y | 0.051148
3Y | -0.15572

>> ts1.data(1)-ts1

ans is a dseries object:

   | minus(0.703,Variable_2)
1Y | 0
2Y | -0.051148
3Y | 0.15572

dseries: C = mpower (A, B)

Overloads the mpower (^) operator for dseries objects and computes element-by-element power. A is a dseries object with N variables and T observations. If B is a real scalar, then mpower(A,B) returns a dseries object C with C.data(t,n)=A.data(t,n)^C. If B is a dseries object with N variables and T observations then mpower(A,B) returns a dseries object C with C.data(t,n)=A.data(t,n)^C.data(t,n).

Example

 
>> ts0 = dseries(transpose(1:3));
>> ts1 = ts0^2

ts1 is a dseries object:

   | power(Variable_1,2)
1Y | 1
2Y | 4
3Y | 9

>> ts2 = ts0^ts0

ts2 is a dseries object:

   | power(Variable_1,Variable_1)
1Y | 1
2Y | 4
3Y | 27

dseries: C = mrdivide (A, B)

Overloads the mrdivide (/) operator for dseries objects, element by element division (like the ./ Matlab/Octave operator). If both A and B are dseries objects, they do not need to be defined over the same time ranges. If A and B are dseries objects with $T_A$ and $T_B$ observations and $N_A$ and $N_B$ variables, then $N_A$ must be equal to $N_B$ or $1$ and $N_B$ must be equal to $N_A$ or $1$. If $T_A=T_B$, isequal(A.init,B.init) returns 1 and $N_A=N_B$, then the mrdivide operator will compute for each couple $(t,n)$, with $1\le t\le T_A$ and $1\le n\le N_A$, C.data(t,n)=A.data(t,n)/B.data(t,n). If $N_B$ is equal to $1$ and $N_A>1$, the smaller dseries object (B) is “broadcast” across the larger dseries (A) so that they have compatible shapes. In this case the mrdivides operator will divide each variable defined in A by the variable in B, observation per observation. If B is a double scalar, then mrdivide will divide all the observations/variables in A by B. If B is a row vector of length $N_A$, then mrdivide will divide all the observations of variable i by B(i), for $i=1,...,N_A$. If B is a column vector of length $T_A$, then mrdivide will perform a division of all the variables by B, element by element.

Example

 
>> ts0 = dseries(rand(3,2))

ts0 is a dseries object:

   | Variable_1 | Variable_2
1Y | 0.72918    | 0.90307
2Y | 0.93756    | 0.21819
3Y | 0.51725    | 0.87322

>> ts1 = ts0{'Variable_2'};
>> ts0/ts1

ans is a dseries object:

   | divide(Variable_1,Variable_2) | divide(Variable_2,Variable_2)
1Y | 0.80745                       | 1
2Y | 4.2969                        | 1
3Y | 0.59235                       | 1

dseries: C = mtimes (A, B)

Overloads the mtimes (*) operator for dseries objects and the Hadammard product (the .* Matlab/Octave operator). If both A and B are dseries objects, they do not need to be defined over the same time ranges. If A and B are dseries objects with $T_A$ and $T_B$ observations and $N_A$ and $N_B$ variables, then $N_A$ must be equal to $N_B$ or $1$ and $N_B$ must be equal to $N_A$ or $1$. If $T_A=T_B$, isequal(A.init,B.init) returns 1 and $N_A=N_B$, then the mtimes operator will compute for each couple $(t,n)$, with $1\le t\le T_A$ and $1\le n\le N_A$, C.data(t,n)=A.data(t,n)*B.data(t,n). If $N_B$ is equal to $1$ and $N_A>1$, the smaller dseries object (B) is “broadcast” across the larger dseries (A) so that they have compatible shapes, mtimes operator will multiply each variable defined in A by the variable in B, observation per observation. If B is a double scalar, then the method mtimes will multiply all the observations/variables in A by B. If B is a row vector of length $N_A$, then the mtimes method will multiply all the observations of variable i by B(i), for $i=1,...,N_A$. If B is a column vector of length $T_A$, then the mtimes method will perform a multiplication of all the variables by B, element by element.


dseries: C = ne (A, B)

Overloads the Matlab/Octave ne (equal, ~=) operator. dseries objects A and B must have the same number of observations (say, $T$) and variables ($N$). The returned argument is a $T$ by $N$ matrix of zeros and ones. Element $(i,j)$ of C is equal to 1 if and only if observation $i$ for variable $j$ in A and B are not equal.

Example

 
>> ts0 = dseries(2*ones(3,1));
>> ts1 = dseries([2; 0; 2]);
>> ts0~=ts1

ans =

     0
     1
     0

dseries: h = plot (A)
dseries: h = plot (A, B)
dseries: h = plot (A[, ...])
dseries: h = plot (A, B[, ...])

Overloads Matlab/Octave’s plot function for dseries objects. Returns a Matlab/Octave plot handle, that can be used to modify the properties of the plotted time series. If only one dseries object, A, is passed as argument, then the plot function will put the associated dates on the x-abscissa. If this dseries object contains only one variable, additional arguments can be passed to modify the properties of the plot (as one would do with the Matlab/Octave’s version of the plot function). If dseries object A contains more than one variable, it is not possible to pass these additional arguments and the properties of the plotted time series must be modify using the returned plot handle and the Matlab/Octave set function (see example below). If two dseries objects, A and B, are passed as input arguments, the plot function will plot the variables in A against the variables in B (the number of variables in each object must be the same otherwise an error is issued). Again, if each object contains only one variable additional arguments can be passed to modify the properties of the plotted time series, otherwise the Matlab/Octave set command has to be used.

Examples

Define a dseries object with two variables (named by default Variable_1 and Variable_2):

 
>> ts = dseries(randn(100,2),'1950Q1');

The following command will plot the first variable in ts

 
>> plot(ts{'Variable_1'},'-k','linewidth',2);

The next command will draw all the variables in ts on the same figure:

 
>> h = plot(ts);

If one wants to modify the properties of the plotted time series (line style, colours, ...), the set function can be used (see Matlab’s documentation):

 
>> set(h(1),'-k','linewidth',2);
>> set(h(2),'--r');

The follwing command will plot Variable_1 against exp(Variable_1):

 
>> plot(ts{'Variable_1'},ts{'Variable_1'}.exp(),'ok');

Again, the properties can also be modified using the returned plot handle and the set function:

 
>> h = plot(ts, ts.exp());
>> set(h(1),'ok');
>> set(h(2),'+r');

dseries: C = plus (A, B)

Overloads the plus (+) operator for dseries objects, element by element addition. If both A and B are dseries objects, they do not need to be defined over the same time ranges. If A and B are dseries objects with $T_A$ and $T_B$ observations and $N_A$ and $N_B$ variables, then $N_A$ must be equal to $N_B$ or $1$ and $N_B$ must be equal to $N_A$ or $1$. If $T_A=T_B$, isequal(A.init,B.init) returns 1 and $N_A=N_B$, then the plus operator will compute for each couple $(t,n)$, with $1\le t\le T_A$ and $1\le n\le N_A$, C.data(t,n)=A.data(t,n)+B.data(t,n). If $N_B$ is equal to $1$ and $N_A>1$, the smaller dseries object (B) is “broadcast” across the larger dseries (A) so that they have compatible shapes, the plus operator will add the variable defined in B to each variable in A. If B is a double scalar, then the method plus will add B to all the observations/variables in A. If B is a row vector of length $N_A$, then the plus method will add B(i) to all the observations of variable i, for $i=1,...,N_A$. If B is a column vector of length $T_A$, then the plus method will add B to all the variables.


dseries: C = pop (A[, B])

Removes variable B from dseries object A. By default, if the second argument is not provided, the last variable is removed.

Example

 
>> ts0 = dseries(ones(3,3));
>> ts1 = ts0.pop('Variable_2');

ts1 is a dseries object:

   | Variable_1 | Variable_3
1Y | 1          | 1
2Y | 1          | 1
3Y | 1          | 1

dseries: B = qdiff (A)
dseries: B = qgrowth (A)

Computes quarterly differences or growth rates.

Example

 
>> ts0 = dseries(transpose(1:4),'1950Q1');
>> ts1 = ts0.qdiff()

ts1 is a dseries object:

       | qdiff(Variable_1)
1950Q1 | NaN
1950Q2 | 1
1950Q3 | 1
1950Q4 | 1

>> ts0 = dseries(transpose(1:6),'1950M1');
>> ts1 = ts0.qdiff()

ts1 is a dseries object:

        | qdiff(Variable_1)
1950M1  | NaN
1950M2  | NaN
1950M3  | NaN
1950M4  | 3
1950M5  | 3
1950M6  | 3

dseries: B = rename (A,oldname,newname)

Rename variable oldname to newname in dseries object A. Returns a dseries object.

Example

 
>> ts0 = dseries(ones(2,2));
>> ts1 = ts0.rename('Variable_1','Stinkly')

ts1 is a dseries object:

   | Stinkly | Variable_2
1Y | 1       | 1
2Y | 1       | 1

dseries: save (A, basename[, format])

Overloads the Matlab/Octave save function and saves dseries object A to disk. Possible formats are csv (this is the default), m (Matlab/Octave script), and mat (Matlab binary data file). The name of the file without extension is specified by basename.

Example

 
>> ts0 = dseries(ones(2,2));
>> ts0.save('ts0');

The last command will create a file ts0.csv with the following content:

 
,Variable_1,Variable_2
1Y,               1,               1
2Y,               1,               1

To create a Matlab/octave script, the following command:

 
>> ts0.save('ts0','m');

will produce a file ts0.m with the following content:

 
% File created on 14-Nov-2013 12:08:52.

FREQ__ = 1;
INIT__ = ' 1Y';

NAMES__ = {'Variable_1'; 'Variable_2'};
TEX__ = {'Variable_{1}'; 'Variable_{2}'};

Variable_1 = [
              1
              1];

Variable_2 = [
              1
              1];

The generated (csv, m, or mat) files can be loaded when instantiating a dseries object as explained above.


dseries: B = set_names (A, s1, s2, ...)

Renames variables in dseries object A and returns a dseries object B with new names s1, s2, s3, ... The number of input arguments after the first one (dseries object A) must be equal to A.vobs (the number of variables in A). s1 will be the name of the first variable in B, s2 the name of the second variable in B, and so on.

Example

 
>> ts0 = dseries(ones(1,3));
>> ts1 = ts0.set_names('Barbibul',[],'Barbouille')

ts1 is a dseries object:

   | Barbibul | Variable_2 | Barbouille
1Y | 1        | 1          | 1

dseries: [T, N ] = size (A[, dim])

Overloads the Matlab/Octave’s size function. Returns the number of observations in dseries object A (ie A.nobs) and the number of variables (ie A.vobs). If a second input argument is passed, the size function returns the number of observations if dim=1 or the number of variables if dim=2 (for all other values of dim an error is issued).

Example

 
>> ts0 = dseries(ones(1,3));
>> ts0.size()

ans =

     1     3

dseries: B = tex_rename (A, name, newtexname)

Redefines the tex name of variable name to newtexname in dseries object A. Returns a dseries object.


dseries: B = uminus (A)

Overloads uminus (-, unary minus) for dseries object.

Example

 
>> ts0 = dseries(1)

ts0 is a dseries object:

   | Variable_1
1Y | 1

>> ts1 = -ts0

ts1 is a dseries object:

   | -Variable_1
1Y | -1

dseries: D = vertcat (A, B[, ...])

Overloads the vertcat Matlab/Octave method for dseries objects. This method is used to append more observations to a dseries object. Returns a dseries object D containing the variables in dseries objects passed as inputs. All the input arguments must be dseries objects with the same variables defined on different time ranges.

Example

 
>> ts0 = dseries(rand(2,2),'1950Q1',{'nifnif';'noufnouf'});
>> ts1 = dseries(rand(2,2),'1950Q3',{'nifnif';'noufnouf'});
>> ts2 = [ts0; ts1]

ts2 is a dseries object:

       | nifnif   | noufnouf
1950Q1 | 0.82558  | 0.31852
1950Q2 | 0.78996  | 0.53406
1950Q3 | 0.089951 | 0.13629
1950Q4 | 0.11171  | 0.67865
dseries: B = ydiff (A)
dseries: B = ygrowth (A)

Computes yearly differences or growth rates.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]

This document was generated on December 6, 2015 using texi2html 1.82.