2008-07-04 16:30:46 +02:00
\documentclass { beamer}
\usepackage [utf8] { inputenc}
\usepackage { amsmath}
\mode <handout>
{
\usepackage { pgfpages}
\pgfpagesuselayout { 4 on 1} [a4paper,border shrink=3mm,landscape]
\usetheme { Madrid}
\usecolortheme { seagull}
}
\mode <beamer>
{
\usetheme { Madrid}
}
\title { The Dynare Macro-processor}
\author { Sébastien Villemot}
\institute [BoFrance - PSE] { Bank of France - Paris School of Economics}
2009-03-13 17:34:56 +01:00
\date { February 2, 2009}
2008-07-04 16:30:46 +02:00
\AtBeginSection []
{
\begin { frame}
\frametitle { Outline}
\tableofcontents [currentsection]
\end { frame}
}
\begin { document}
\begin { frame}
\titlepage
\end { frame}
\begin { frame}
\frametitle { Outline}
\tableofcontents
\end { frame}
\section { Overview}
\begin { frame}
\frametitle { Motivation}
\begin { itemize}
\item The \textbf { Dynare language} (used in MOD files) is well suited for describing economic models
\item However, it lacks some useful features, such as:
\begin { itemize}
\item a loop mechanism for automatically repeating similar blocks of equations (such as in multi-country models)
\item an operator for indexed sums or products inside equations
\item a mechanism for splitting large MOD-files in smaller modular files
\item the possibility of conditionally including some equations or some runtime commands
\end { itemize}
\item The \textbf { Dynare Macro-language} was specifically designed to address these issues
\item Being flexible and fairly general, it can also be helpful in other situations
\end { itemize}
\end { frame}
\begin { frame}
\frametitle { Design of the macro-language}
\begin { itemize}
\item The Dynare Macro-language provides a new set of \textbf { macro-commands} which can be inserted inside MOD-files
\item Language features include:
\begin { itemize}
\item file inclusion
\item loops
\item conditional inclusion (if/then/else structures)
\item expression substitution
\end { itemize}
2009-03-13 17:34:56 +01:00
\item Implemented in Dynare starting from 4.0 version
2008-07-04 16:30:46 +02:00
\item The macro-processor transforms a MOD file with macro-commands into a MOD file without macro-commands (doing text expansions/inclusions) and then feeds it to the Dynare parser
\item The key point to understand is that the macro-processor only does \textbf { text substitution} (like the C preprocessor or the PHP language)
\end { itemize}
\end { frame}
\begin { frame}
\frametitle { Old Dynare design}
\includegraphics [width=0.95\linewidth] { old-design.pdf}
\end { frame}
\begin { frame}
\frametitle { New Dynare design}
\includegraphics [width=0.95\linewidth] { new-design.pdf}
\end { frame}
\section { Syntax}
\begin { frame} [fragile=singleslide]
\frametitle { Macro Directives}
\begin { itemize}
\item Directives begin with an at-sign followed by a pound sign (\verb +@#+) and occupy exactly one line
\item However, a directive can be continued on next line by adding two anti-slashes (\verb +\\ +) at the end of the line to be continued
\item A directive produces no output, but serves to give instructions to the macro processor
\end { itemize}
\end { frame}
\begin { frame} [fragile=singleslide]
\frametitle { Inclusion directive}
This directive simply includes the content of another file at the place where it is inserted.
\begin { block} { Syntax}
\verb +@#include "+\textit { filename} \verb +"+
\end { block}
\begin { block} { Example}
\begin { verbatim}
@#include "modelcomponent.mod"
\end { verbatim}
\end { block}
Note that it is possible to include a file from an included file (nested includes).
\end { frame}
\begin { frame}
\frametitle { Variables}
\begin { itemize}
\item The macro processor maintains its own list of variables (distinct of model variables and of Matlab variables)
\item Variables can be of four types:
\begin { itemize}
\item integer
\item character string (declared between \textit { double} quotes)
\item array of integers
\item array of strings
\end { itemize}
\item No boolean type:
\begin { itemize}
\item false is represented by integer zero
\item true is any non-null integer
\end { itemize}
\end { itemize}
\end { frame}
\begin { frame} [fragile=singleslide]
\frametitle { Macro-expressions (1/2)}
It is possible to construct macro-expressions, using standard operators.
\begin { block} { Operators on integers}
\begin { itemize}
\item arithmetic operators: \texttt { +,-,*,/}
\item comparison operators: \texttt { <,>,<=,>=,==,!=}
\item logical operators: \verb +& & ,||,!+
\item integer ranges: \texttt { 1:4} is equivalent to integer array \texttt { [1,2,3,4]}
\end { itemize}
\end { block}
\begin { block} { Operators on character strings}
\begin { itemize}
\item comparison operators: \texttt { ==,!=}
\item concatenation: \texttt { +}
\item extraction of substrings: if \texttt { s} is a string, then one can write \texttt { s[3]} or \texttt { s[4:6]}
\end { itemize}
\end { block}
\end { frame}
\begin { frame} [fragile=singleslide]
\frametitle { Macro-expressions (2/2)}
\begin { block} { Operators on arrays}
\begin { itemize}
\item dereferencing: if \texttt { v} is an array, then \texttt { v[2]} is its $ 2 ^ { \textrm { nd } } $ element
\item concatenation: \texttt { +}
\item difference \texttt { -} : returns the first operand from which the elements of the second operand have been removed
\item extraction of sub-arrays: \textit { e.g.} \texttt { v[4:6]}
2009-03-13 17:34:56 +01:00
\item testing membership of an array: \texttt { in} operator (only in unstable version of Dynare)
2008-07-04 16:30:46 +02:00
\end { itemize}
\end { block}
Macro-expressions can be used at two places:
\begin { itemize}
\item inside macro directives, directly
\item in the body of the MOD-file, between an at-sign and curly braces (like \verb +@{ expr} +): the macro processor will substitute the expression with its value
\end { itemize}
\end { frame}
\begin { frame} [fragile=singleslide]
\frametitle { Define directive}
The value of a macro-variable can be defined with the \verb +@#define+ directive.
\begin { block} { Syntax}
\verb +@#define +\textit { variable\_ name} \verb + = +\textit { expression}
\end { block}
\begin { block} { Examples}
\begin { verbatim}
@#define x = 5
@#define y = "foo"
@#define v = [ 1, 2, 4 ]
@#define w = [ "foo", "bar" ]
@#define z = 3+v[2]
\end { verbatim}
\end { block}
\end { frame}
\begin { frame} [fragile=singleslide]
\frametitle { Expression substitution}
\framesubtitle { Dummy example}
\begin { block} { Before macro-processing}
\begin { verbatim}
@#define x = [ "B", "C" ]
@#define i = 2
model;
A = @{ x[i]} ;
end;
\end { verbatim}
\end { block}
\begin { block} { After macro-processing}
\begin { verbatim}
model;
A = C;
end;
\end { verbatim}
\end { block}
\end { frame}
\begin { frame} [fragile=singleslide]
\frametitle { Loop directive}
\begin { block} { Syntax}
\verb +@#for +\textit { variable\_ name} \verb + in +\textit { array\_ expr} \\
\verb + +\textit { loop\_ body} \\
\verb +@#endfor+
\end { block}
\begin { block} { Example: before macro-processing}
\small
\begin { verbatim}
model;
@#for country in [ "home", "foreign" ]
2009-04-27 15:39:52 +02:00
GDP_ @{ country} = K_ @{ country} ^ a * L_ @{ country} ^ (1-a);
2008-07-04 16:30:46 +02:00
@#endfor
end;
\end { verbatim}
\normalsize
\end { block}
\begin { block} { Example: after macro-processing}
\small
\begin { verbatim}
model;
GDP_ home = K_ home^ a * L_ home^ (1-a);
GDP_ foreign = K_ foreign^ a * L_ foreign^ (1-a);
end;
\end { verbatim}
\normalsize
\end { block}
\end { frame}
\begin { frame} [fragile=singleslide]
\frametitle { Conditional inclusion directive}
\begin { columns} [T]
\column { 0.47\linewidth }
\begin { block} { Syntax 1}
\verb +@#if +\textit { integer\_ expr} \\
\verb + +\textit { body included if expr != 0} \\
\verb +@#endif+
\end { block}
\column { 0.47\linewidth }
\begin { block} { Syntax 2}
\verb +@#if +\textit { integer\_ expr} \\
\verb + +\textit { body included if expr != 0} \\
\verb +@#else+ \\
\verb + +\textit { body included if expr == 0} \\
\verb +@#endif+
\end { block}
\end { columns}
\begin { block} { Example: alternative monetary policy rules}
\scriptsize
\begin { verbatim}
@#define linear_ mon_ pol = ...
...
model;
@#if linear_ mon_ pol
2009-04-27 15:39:52 +02:00
i = w*i(-1) + (1-w)*i_ ss + w2*(pie-piestar);
2008-07-04 16:30:46 +02:00
@#else
2009-04-27 15:39:52 +02:00
i = i(-1)^ w * i_ ss^ (1-w) * (pie/piestar)^ w2;
2008-07-04 16:30:46 +02:00
@#endif
...
end;
\end { verbatim}
\scriptsize
\end { block}
\end { frame}
\begin { frame} [fragile=singleslide]
\frametitle { Echo and error directives}
\begin { itemize}
\item The echo directive will simply display a message on standard output
\item The error directive will display the message and make Dynare stop (only makes sense inside a conditional inclusion directive)
\end { itemize}
\begin { block} { Syntax}
\verb +@#echo +\textit { string\_ expr} \\
\verb +@#error +\textit { string\_ expr}
\end { block}
\begin { block} { Examples}
\begin { verbatim}
@#echo "Information message."
@#error "Error message!"
\end { verbatim}
\end { block}
\end { frame}
\begin { frame}
\frametitle { Saving the macro-expanded MOD file}
\begin { itemize}
\item For \textbf { debugging or learning} purposes, it is possible to save the output of the macro-processor
\item This output is a valid MOD-file, obtained after processing the macro-commands of the original MOD-file
% \item Useful to understand how the macro-processor works
\item Just add the \texttt { savemacro} option on the Dynare command line (after the name of your MOD-file)
\item If MOD file is \texttt { filename.mod} , then the macro-expanded version will be saved in \texttt { filename-macroexp.mod}
2009-03-13 17:34:56 +01:00
\item With the unstable version of Dynare, you can specify the filename for the macro-expanded version with the syntax \texttt { savemacro=mymacroexp.mod}
2008-07-04 16:30:46 +02:00
\end { itemize}
\end { frame}
% \begin{frame}
% \frametitle{Note on error messages}
% \end{frame}
\section { Typical usages}
\begin { frame} [fragile=singleslide]
\frametitle { Modularization}
\begin { itemize}
\item The \verb +@#include+ directive can be used to split MOD-files into several modular components
\item Example setup:
\begin { itemize}
\item \texttt { modeldesc.mod} : contains variable declarations, model equations and shocks declarations
\item \texttt { simul.mod} : includes \texttt { modeldesc.mod} , calibrates parameters and runs stochastic simulations
\item \texttt { estim.mod} : includes \texttt { modeldesc.mod} , declares priors on parameters and runs bayesian estimation
\item Dynare can be called on \texttt { simul.mod} and \texttt { estim.mod} (but it makes no sense to run it on \texttt { modeldesc.mod} )
\end { itemize}
\end { itemize}
\end { frame}
\begin { frame} [fragile=singleslide]
\frametitle { Indexed sums or products}
\framesubtitle { Example: moving average}
\begin { columns} [T]
\column { 0.47\linewidth }
\begin { block} { Before macro-processing}
\begin { verbatim}
@#define window = 2
var x MA_ x;
...
model;
...
MA_ x = 1/@{ 2*window+1} *(
@#for i in -window:window
+x(@{ i} )
@#endfor
);
...
end;
\end { verbatim}
\end { block}
\column { 0.47\linewidth }
\begin { block} { After macro-processing}
\begin { verbatim}
var x MA_ x;
...
model;
...
MA_ x = 1/5*(
+x(-2)
+x(-1)
+x(0)
+x(1)
+x(2)
);
...
end;
\end { verbatim}
\end { block}
\end { columns}
\end { frame}
\begin { frame} [fragile=singleslide]
\frametitle { Multi-country models}
\framesubtitle { MOD-file skeleton example}
\scriptsize
\begin { verbatim}
@#define countries = [ "US", "EU", "AS", "JP", "RC" ]
@#define nth_ co = "US"
@#for co in countries
var Y_ @{ co} K_ @{ co} L_ @{ co} i_ @{ co} E_ @{ co} ...;
parameters a_ @{ co} ...;
varexo ...;
@#endfor
model;
@#for co in countries
Y_ @{ co} = K_ @{ co} ^ a_ @{ co} * L_ @{ co} ^ (1-a_ @{ co} );
...
@# if co != nth_ co
(1+i_ @{ co} ) = (1+i_ @{ nth_ co} ) * E_ @{ co} (+1) / E_ @{ co} ; // UIP relation
@# else
E_ @{ co} = 1;
@# endif
@#endfor
end;
\end { verbatim}
\normalsize
\end { frame}
\begin { frame}
2009-03-13 17:34:56 +01:00
\frametitle { Endogeneizing parameters (1/4)}
2008-07-04 16:30:46 +02:00
\begin { itemize}
\item When doing the steady-state calibration of the model, it may be useful to consider a parameter as an endogenous (and vice-versa)
\item Example:
\begin { gather*}
y = \left (\alpha ^ { \frac { 1} { \xi } } \ell ^ { 1-\frac { 1} { \xi } } + (1-\alpha )^ { \frac { 1} { \xi } } k^ { 1-\frac { 1} { \xi } } \right )^ { \frac { \xi } { \xi - 1} } \\
lab\_ rat = \frac { w \ell } { p y}
\end { gather*}
2009-03-13 17:34:56 +01:00
\item In the model, $ \alpha $ is a (share) parameter, and $ lab \_ rat $ is an endogenous variable
\item We observe that:
\begin { itemize}
\item calibrating $ \alpha $ is not straigthforward!
\item on the contrary, we have real world data for $ lab \_ rat $
\item it is clear that these two variables are economically linked
\end { itemize}
\end { itemize}
\end { frame}
\begin { frame} [fragile=singleslide]
\frametitle { Endogeneizing parameters (2/4)}
\begin { itemize}
\item Therefore, when computing the steady state:
\begin { itemize}
\item we make $ \alpha $ an endogenous variable and $ lab \_ rat $ a parameter
\item we impose an economically relevant value for $ lab \_ rat $
\item the solution algorithm deduces the implied value for $ \alpha $
\end { itemize}
\item We call this method ``variable flipping''
2008-07-04 16:30:46 +02:00
\end { itemize}
\end { frame}
\begin { frame} [fragile=singleslide]
2009-03-13 17:34:56 +01:00
\frametitle { Endogeneizing parameters (3/4)}
\framesubtitle { Example implementation}
2008-07-04 16:30:46 +02:00
\begin { itemize}
2009-03-13 17:34:56 +01:00
\item File \texttt { modeqs.mod} :
\begin { itemize}
\item contains variable declarations and model equations
\item For declaration of \texttt { alpha} and \texttt { lab\_ rat} :
2008-07-04 16:30:46 +02:00
\footnotesize
\begin { verbatim}
@#if steady
var alpha;
parameter lab_ rat;
@#else
parameter alpha;
var lab_ rat;
@#endif
\end { verbatim}
\normalsize
\end { itemize}
2009-03-13 17:34:56 +01:00
2008-07-04 16:30:46 +02:00
\end { itemize}
\end { frame}
\begin { frame} [fragile=singleslide]
2009-03-13 17:34:56 +01:00
\frametitle { Endogeneizing parameters (4/4)}
\framesubtitle { Example implementation}
2008-07-04 16:30:46 +02:00
\begin { itemize}
2009-03-13 17:34:56 +01:00
\item File \texttt { steady.mod} :
\begin { itemize}
\item begins with \verb +@#define steady = 1+
\item then with \verb +@#include "modeqs.mod"+
\item initializes parameters (including \texttt { lab\_ rat} , excluding \texttt { alpha} )
\item computes steady state (using guess values for endogenous, including \texttt { alpha} )
\item saves values of parameters and endogenous at steady-state in a file, using the \texttt { load\_ params\_ and\_ steady\_ state} command
\end { itemize}
\item File \texttt { simul.mod} :
2008-07-04 16:30:46 +02:00
\begin { itemize}
\item begins with \verb +@#define steady = 0+
\item then with \verb +@#include "modeqs.mod"+
2009-03-13 17:34:56 +01:00
\item loads values of parameters and endogenous at steady-state from file, using the \texttt { save\_ params\_ and\_ steady\_ state} command
2008-07-04 16:30:46 +02:00
\item computes simulations
\end { itemize}
\end { itemize}
\end { frame}
% \begin{frame}
% \frametitle{Matlab loops vs macro-processor loops}
% \end{frame}
\section { Conclusion}
\begin { frame} [fragile=singleslide]
\frametitle { Possible future developments}
\begin { itemize}
\item Find a nicer syntax for indexed sums/products
\item Implement other control structures: \texttt { elsif} , \texttt { switch/case} , \texttt { while/until} loops
\item Implement macro-functions (or templates), with a syntax like:
\small
\verb +@define QUADRATIC_ COST(x, x_ ss, phi) = phi/2*(x/x_ ss-1)^ 2+
\normalsize
\end { itemize}
\end { frame}
\begin { frame}
\frametitle { Dynare for Octave (1/2)}
\begin { itemize}
\item GNU Octave (or simply Octave) is a high-level language, primarily intended for numerical computations
\item Basically, it is a free clone of Matlab
\item Runs on MS Windows, Linux and MacOS
\item Advantages:
\begin { itemize}
\item mostly compatible with Matlab: same syntax, almost same set of functions
\item free software, no license needed
\item source code available
\item software under constant development
\item dynamic and responsive community of developers
\end { itemize}
\item Inconvenients:
\begin { itemize}
\item slower than Matlab
\item less user-friendly (no fancy graphical user interface)
\end { itemize}
\end { itemize}
\end { frame}
\begin { frame}
\frametitle { Dynare for Octave (2/2)}
\begin { itemize}
\item Small adjustments have been made in recent versions of Dynare to make it run on Octave
\item This makes Dynare 100\% free software
\item If you're interested in using Dynare for Octave, go to: \\
2009-03-13 17:34:56 +01:00
\url { http://www.dynare.org/DynareWiki/DynareOctave}
2008-07-04 16:30:46 +02:00
\item Adapting Dynare for Octave is still a work in progress \\
$ \Rightarrow $ feedback is welcome
\end { itemize}
\end { frame}
\end { document}