\documentclass{beamer}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{lmodern}
\usepackage{amsmath}
\usepackage[copyright]{ccicons}

\usetheme{Boadilla}

\titlegraphic{\includegraphics{../logos/dlogo.png}}

\title{The Dynare Macro Processor}

\author[S. Villemot, H.Bastani]{Sébastien Villemot \and Houtan Bastani}

\institute[CEPREMAP]{\includegraphics[scale=0.15]{../logos/cepremap.jpg}}

\date{28 June 2019}


\setbeamertemplate{title page}
{
  \vbox{}
  \begingroup
    \centering
    {\usebeamercolor[fg]{titlegraphic}\inserttitlegraphic\par}\vskip1em
    \begin{beamercolorbox}[sep=8pt,center]{title}
      \usebeamerfont{title}\inserttitle\par%
      \ifx\insertsubtitle\@empty%
      \else%
        \vskip0.25em%
        {\usebeamerfont{subtitle}\usebeamercolor[fg]{subtitle}\insertsubtitle\par}%
      \fi%
    \end{beamercolorbox}%
    \vskip1em\par
    \begin{beamercolorbox}[sep=8pt,center]{author}
      \usebeamerfont{author}\insertauthor
    \end{beamercolorbox}
    \begin{beamercolorbox}[sep=8pt,center]{institute}
      \usebeamerfont{institute}\insertinstitute
    \end{beamercolorbox}
    \begin{beamercolorbox}[sep=8pt,center]{date}
      \usebeamerfont{date}\insertdate
    \end{beamercolorbox}
  \endgroup
  \vfill
}

\AtBeginSection[]
{
  \begin{frame}
    \frametitle{Outline}
    \tableofcontents[currentsection]
  \end{frame}
}

\begin{document}

\begin{frame}
  \titlepage

  \begin{columns}[T]
    \column{0.2\textwidth}
    \column{0.09\textwidth}

    \ccbysa
    \column{0.71\textwidth}
    \tiny
    Copyright © 2008--2019 Dynare Team \\
    Licence: \href{http://creativecommons.org/licenses/by-sa/4.0/}{Creative
      Commons Attribution-ShareAlike 4.0}
  \end{columns}
\end{frame}

\begin{frame}
  \frametitle{Outline}
  \tableofcontents
\end{frame}

\section{Overview}

\begin{frame}
  \frametitle{Motivation}
  \begin{itemize}
  \item The \textbf{Dynare language} (used in \texttt{.mod} files) is well suited for many economic models
    \begin{itemize}
    \item It's a markup language that defines models
    \item Lacks a programmatic element
    \end{itemize}
  \item The \textbf{Dynare macro language} adds a programmatic element to Dynare
    \begin{itemize}
    \item Introduces conditionals, loops, and other simple programmatic directives
    \item Used to speed model development
    \item Useful in various situations
      \begin{itemize}
      \item Multi-country models
      \item Creation of modular \texttt{.mod} files
      \item Variable flipping
      \item Conditional inclusion of equations
      \item ...among others
      \end{itemize}
    \end{itemize}
  \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} that can be used in \texttt{.mod} files
  \item The macro processor transforms a \texttt{.mod} file with macro commands into a \texttt{.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{Dynare Flowchart}
  \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:\verb+@#+
  \item A directive gives instructions to the macro processor
  \item Main directives are:
    \begin{itemize}
    \item file inclusion: \verb+@#include+
    \item definition of a macro processor variable: \verb+@#define+
    \item conditional statements: \verb+@#if/@#ifdef/@#ifndef/@#else/@#endif+
    \item loop statements: \verb+@#for/@#endfor+
    \end{itemize}
  \item Most directives fit on one line. If needed however, two backslashes (i.e. \verb+\\+) at the end of a line indicate that the directive is continued on the next line.
  \end{itemize}
\end{frame}


\begin{frame}
\frametitle{Variables}
\begin{itemize}
\item The macro processor has its own list of variables which are different than model variables and MATLAB/Octave variables
\item There are 6 types of macro-variables:
  \begin{itemize}
  \item boolean
  \item real
  \item string
  \item tuple
  \item array
  \item function
  \end{itemize}
\item Variables/literals of the types listed above can be cast to other types
  \begin{itemize}
  \item \texttt{(bool) -1 \&\& (bool) 2} $\rightarrow$ \texttt{true}
  \item \texttt{(real) ``3.1''} $\rightarrow$ \texttt{3.1}
  \item \texttt{(array) 4} $\rightarrow$ \texttt{[4]}
  \item \texttt{(real) [5]} $\rightarrow$ \texttt{5}
  \item \texttt{(real) [6, 7]} $\rightarrow$ \texttt{error}
  \end{itemize}
\end{itemize}
\end{frame}

\begin{frame}[fragile=singleslide]
  \frametitle{Macro-expressions (1/8)}
  \begin{itemize}
    \item Macro-expressions are constructed using literals of the 6 basic types
      described above, macro-variables, comprehensions, and standard operators.
    \item Macro-expressions can be used in two places:
      \begin{itemize}
      \item inside macro directives; no special markup is required
      \item in the body of the \texttt{.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{itemize}
\end{frame}


\begin{frame}[fragile=singleslide]
  \frametitle{Macro-expressions (2/8): Boolean}
  It is possible to construct macro-expressions using standard operators.
  \begin{block}{Operators on booleans}
    \begin{itemize}
    \item comparison operators: \texttt{== !=}
    \item logical operators: \verb+&& || !+
    \end{itemize}
  \end{block}
\end{frame}

\begin{frame}[fragile=singleslide]
  \frametitle{Macro-expressions (3/8): Real}
  \begin{block}{Operators on reals}
    \begin{itemize}
    \item arithmetic operators: \texttt{+ - * / \^{}}
    \item comparison operators: \texttt{< > <= >= == !=}
    \item logical operators: \verb+&& || !+
    \item range with increment of \texttt{1}: \texttt{1:4} is equivalent to real array \texttt{[1, 2, 3, 4]}. NB \texttt{[1:4]} is equivalent to an array containing an array of reals \texttt{[[1, 2, 3, 4]]}
    \item range with user-defined increment: \texttt{4:-1.1:-1} is equivalent to real array \texttt{[4, 2.9, 1.8, 0.7, -0.4]}.
    \end{itemize}
  \end{block}

  \begin{block}{Functions for reals}
    \begin{itemize}
    \item \texttt{min, max, exp, ln (or log), log10}
    \item \texttt{sin, cos, tan, asin, acos, atan}
    \item \texttt{sqrt, cbrt, sign, floor, ceil, trunc, mod}
    \item \texttt{erf, erfc, normpdf, normcdf, gamma, lgamma, round}
    \end{itemize}
  \end{block}
\end{frame}

\begin{frame}[fragile=singleslide]
  \frametitle{Macro-expressions (4/8): String}
  String literals have to be declared between \textit{double} quotes, e.g. \texttt{``string''}
  \begin{block}{Operators on character strings}
    \begin{itemize}
    \item comparison operators: \texttt{< > <= >= == !=}
    \item concatenation: \texttt{+}
    \item string length: \texttt{length()}
    \item string emptiness: \texttt{isempty()}
    \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 (5/8): Tuple}
  Tuples are enclosed by parenthesis and elements separated by commas (like
  \texttt{(a,b,c)} or \texttt{(1,2.2,c)}).
  \begin{block}{Operators on tuples}
    \begin{itemize}
    \item comparison operators: \texttt{== !=}
    \item functions: \texttt{length, isempty}
    \item testing membership in tuple: \texttt{in} operator \\ (example:
      \texttt{"b" in ("a", "b", "c")} returns \texttt{1})
    \end{itemize}
  \end{block}
\end{frame}

\begin{frame}[fragile=singleslide]
  \frametitle{Macro-expressions (6/8): Array}
  Arrays are enclosed by brackets, and their elements are separated by commas
  (like \texttt{[1,[2,3],4]} or \texttt{[``US'', ``EA'']}).
  \begin{block}{Operators on arrays}
    \begin{itemize}
    \item comparison operators: \texttt{== !=}
    \item dereferencing: if \texttt{v} is an array, then \texttt{v[2]} is its $2^{\textrm{nd}}$ element
    \item concatenation: \texttt{+}
    \item functions: \texttt{sum, length, isempty}
    \item difference \texttt{-}: returns the first operand from which the elements of the second operand have been removed
    \item Cartesian product of two arrays: \texttt{*}
    \item Cartesian product of one array \texttt{N} times: \texttt{\^{}N}
    \item extraction of sub-arrays: \textit{e.g.} \texttt{v[4:6]}
    \item testing membership of an array: \texttt{in} operator \\ (example:
      \texttt{"b" in ["a", "b", "c"]} returns \texttt{1})
    \end{itemize}
  \end{block}
\end{frame}

\begin{frame}[fragile=singleslide]
  \frametitle{Macro-expressions (7/8): Comprehension (1/3)}
  Comprehensions are a shorthand way of creating arrays from other arrays. This is done by filtering, mapping, or filtering and mapping
  \begin{block}{Filtering}
    \begin{itemize}
    \item Allows one to choose those elements from an array for which a condition holds
    \item Syntax: \texttt{[variable/tuple IN array WHEN condition]}
    \item Example: Choose even numbers from array
      \begin{itemize}
      \item Code: \texttt{@\{[ i in 1:5 when mod(i,2) == 0 ]\}}
      \item Result: \texttt{[2, 4]}
      \end{itemize}
    \end{itemize}
  \end{block}
\end{frame}

\begin{frame}[fragile=singleslide]
  \frametitle{Macro-expressions (7/8): Comprehension (2/3)}
  \begin{block}{Mapping}
    \begin{itemize}
    \item Allows one to apply a transformation to every element of an array
    \item Syntax: \texttt{[expr for variable/tuple IN array]}
    \item Example: Square elements in array
      \begin{itemize}
      \item Code: \texttt{@\{[ i\^{}2 for i in 1:5 ]\}}
      \item Result: \texttt{[1, 4, 9, 16, 25]}
      \end{itemize}
    \item Example: Reverse order of elements in array
      \begin{itemize}
      \item Code: \texttt{@\{[ (j,i) for (i,j) in (1:2)\^{}2 ]\}}
      \item Result: \texttt{[(1, 1), (2, 1), (1, 2), (2, 2)]}
      \end{itemize}
    \end{itemize}
  \end{block}
\end{frame}

\begin{frame}[fragile=singleslide]
  \frametitle{Macro-expressions (7/8): Comprehension (3/3)}
  \begin{block}{Mapping and Filtering}
    \begin{itemize}
    \item Allows one to apply a transformation to the elements selected from an array
    \item Syntax: \texttt{[expr for variable/tuple IN array WHEN condition]}
    \item Example: Square odd numbers from array
      \begin{itemize}
      \item Code: \texttt{@\{[ i\^{}2 for i in 1:5 when mod(i,2) == 1 ]\}}
      \item Result: \texttt{[1, 9, 25]}
      \end{itemize}
    \end{itemize}
  \end{block}
\end{frame}

\begin{frame}[fragile=singleslide]
  \frametitle{Macro-expressions (8/8): Functions}
  \begin{itemize}
  \item Can take any number of arguments
  \item Dynamic binding: is evaluated when invoked, not when defined
  \item Can be included in expressions; valid operators depend on return type
  \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              // Real
@#define y = "US"           // String
@#define v = [ 1, 2, 4 ]    // Real array
@#define w = [ "US", "EA" ] // String array
@#define z = 3 + v[2]       // Equals 5
@#define t = ("US" in w)    // Equals 1 (true)
@#define f(x) = " " + x + y // Function f with argument x
\end{verbatim}
  \end{block}
  NB: You can define macro variables on the dynare command line by using the \texttt{-D} option
\end{frame}

\begin{frame}[fragile=singleslide]
  \frametitle{Expression substitution}
  \framesubtitle{Dummy example}
  \begin{block}{Before macro processing}
\begin{verbatim}
@#define x = 1
@#define y = [ "B", "C" ]
@#define i = 2
@#define f(x) = x + " + " + y[i]
@#define i = 1

model;
  A = @{y[i] + f("D")};
end;
\end{verbatim}
  \end{block}
  \begin{block}{After macro processing}
\begin{verbatim}
model;
  A = BD + B;
end;
\end{verbatim}
  \end{block}
\end{frame}

\begin{frame}[fragile=singleslide]
  \frametitle{Include directive (1/2)}
  \begin{itemize}
  \item This directive simply inserts the text of another file in its place
    \begin{block}{Syntax}
      \verb+@#include "+\textit{filename}\verb+"+
    \end{block}
    \begin{block}{Example}
\begin{verbatim}
@#include "modelcomponent.mod"
\end{verbatim}
    \end{block}
  \item Equivalent to a copy/paste of the content of the included file
  \item Note that it is possible to nest includes (\textit{i.e.} to include a
    file with an included file)
  \end{itemize}
\end{frame}

\begin{frame}[fragile=singleslide]
  \frametitle{Include directive (2/2)}
  \begin{itemize}
\item The filename can be given by a macro-variable (useful in loops):
    \begin{block}{Example with variable}
\begin{verbatim}
@#define fname = "modelcomponent.mod"
@#include fname
\end{verbatim}
    \end{block}
  \item Files to include are searched for in the current directory. Other directories can
    be added with the
    \verb+@#includepath+ directive, the \texttt{-I} command line option, or the
    \texttt{[paths]} section in config file.
  \end{itemize}
\end{frame}

\begin{frame}[fragile=singleslide]
  \frametitle{Loop directive (1/2)}
  \begin{block}{Syntax 1}
\verb+@#for +\textit{variable\_name}\verb+ in +\textit{array\_expr} \\
\verb+   +\textit{loop\_body} \\
\verb+@#endfor+
  \end{block}
  \begin{block}{Syntax 2}
\verb+@#for +\textit{tuple}\verb+ in +\textit{array\_expr} \\
\verb+   +\textit{loop\_body} \\
\verb+@#endfor+
  \end{block}
  \begin{block}{Syntax 3}
\verb+@#for +\textit{tuple\_or\_variable}\verb+ in +\textit{array\_expr} \verb+ when +\textit{expr}\\
\verb+   +\textit{loop\_body} \\
\verb+@#endfor+
  \end{block}
\end{frame}

\begin{frame}[fragile=singleslide]
  \frametitle{Loop directive (2/2)}
  \begin{block}{Example: before macro processing}
    \small
\begin{verbatim}
model;
@#for country in [ "home", "foreign" ]
  GDP_@{country} = A * K_@{country}^a * L_@{country}^(1-a);
@#endfor
end;
\end{verbatim}
    \normalsize
  \end{block}

  \begin{block}{Example: after macro processing}
    \small
\begin{verbatim}
model;
  GDP_home = A * K_home^a * L_home^(1-a);
  GDP_foreign = A * K_foreign^a * L_foreign^(1-a);
end;
\end{verbatim}
    \normalsize
  \end{block}
\end{frame}

\begin{frame}[fragile=singleslide]
  \frametitle{Conditional directives (1/3)}

  \begin{columns}[T]
    \column{0.47\linewidth}
    \begin{block}{Syntax 1}
\verb+@#if +\textit{bool\_or\_real\_expr} \\
\verb+   +\textit{body included if expr is true (or != 0)} \\
\verb+@#endif+
    \end{block}

    \column{0.47\linewidth}
    \begin{block}{Syntax 2}
\verb+@#if +\textit{bool\_or\_real\_expr} \\
\verb+   +\textit{body included if expr is true (or != 0)} \\
\verb+@#else+ \\
\verb+   +\textit{body included if expr is false (or 0)} \\
\verb+@#endif+
    \end{block}
  \end{columns}
\end{frame}

\begin{frame}[fragile=singleslide]
  \frametitle{Conditional directives (2/3)}
  \begin{block}{Syntax 3}
    \verb+@#if +\textit{bool\_or\_real\_expr1} \\
    \verb+   +\textit{body included if expr1 is true (or != 0)} \\
    \verb+@#elseif +\textit{bool\_or\_real\_expr2} \\
    \verb+   +\textit{body included if expr2 is true (or != 0)} \\
    \verb+@#else+ \\
    \verb+   +\textit{body included if expr1 and expr2 are false (or 0)} \\
    \verb+@#endif+
  \end{block}

  \begin{block}{Example: alternative monetary policy rules}
    \scriptsize
\begin{verbatim}
@#define linear_mon_pol = false // or 0
...
model;
@#if linear_mon_pol
  i = w*i(-1) + (1-w)*i_ss + w2*(pie-piestar);
@#else
  i = i(-1)^w * i_ss^(1-w) * (pie/piestar)^w2;
@#endif
...
end;
\end{verbatim}
    \scriptsize
  \end{block}
\end{frame}

\begin{frame}[fragile=singleslide]
  \frametitle{Conditional directives (3/3)}

  \begin{columns}[T]
    \column{0.47\linewidth}
    \begin{block}{Syntax 1}
\verb+@#ifdef +\textit{variable\_name} \\
\verb+   +\textit{body included if variable defined} \\
\verb+@#endif+
    \end{block}

    \column{0.47\linewidth}
    \begin{block}{Syntax 2}
\verb+@#ifdef +\textit{variable\_name} \\
\verb+   +\textit{body included if variable defined} \\
\verb+@#else+ \\
\verb+   +\textit{body included if variable not defined} \\
\verb+@#endif+
    \end{block}
  \end{columns}

\bigskip

There is also \verb+@#ifndef+, which is the opposite of \verb+@#ifdef+
(\textit{i.e.} it tests whether a variable is \emph{not} defined). NB: There is
\emph{no} \verb+@#elseifdef+ or \verb+@#elseifndef+ directive; use
\verb+elseif defined(variable_name)+ to achieve the desired objective.
\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 directive)
  \item The echomacrovars directive will display all of the macro variables (or
    those specified) and their values, optionally saving them
  \end{itemize}

  \begin{block}{Syntax}
\verb+@#echo +\textit{string\_expr} \\
\verb+@#error +\textit{string\_expr} \\
\verb+@#echomacrovars +\\
\verb+@#echomacrovars +\textit{list\_of\_variables}\\
\verb+@#echomacrovars (save)+\\
\verb+@#echomacrovars (save)+\textit{list\_of\_variables}\\
  \end{block}

  \begin{block}{Examples}
\begin{verbatim}
@#echo "Information message."
@#error "Error message!"
\end{verbatim}
  \end{block}
\end{frame}

\begin{frame}
  \frametitle{Macro-related command line options}
  \begin{itemize}
  \item \texttt{savemacro}: Useful for debugging or learning purposes, saves the output of the macro processor. If your \texttt{.mod} file is called \texttt{file.mod}, the output is saved to \texttt{file-macroexp.mod}.
  \item \texttt{nolinemacro}: In the output of \texttt{savemacro}, don't print line numbers where the macro directives were placed.
  \item \texttt{noemptylinemacro}: Remove empty lines in the output of \texttt{savemacro}.
  \item \texttt{onlymacro}: Stops processing after the macro processing step.
  \end{itemize}
\end{frame}

\section{Common uses}

\begin{frame}[fragile=singleslide]
  \frametitle{Modularization}
  \begin{itemize}
  \item The \verb+@#include+ directive can be used to split \texttt{.mod} files into several modular components
  \item Example setup:
    \begin{description}
    \item[\texttt{modeldesc.mod}:] contains variable declarations, model equations and shocks declarations
    \item[\texttt{simulate.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
    \end{description}
  \item Dynare can be called on \texttt{simulate.mod} and \texttt{estim.mod}
  \item But it makes no sense to run it on \texttt{modeldesc.mod}
  \item Advantage: no need to manually copy/paste the whole model (at the beginning) or changes to the model (during development)
  \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{\texttt{.mod} file skeleton example}
  \scriptsize
\begin{verbatim}
@#define countries = [ "US", "EA", "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}
  \frametitle{Endogeneizing parameters (1/4)}
  \begin{itemize}
  \item When calibrating 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*}
  \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''
  \end{itemize}
\end{frame}

\begin{frame}[fragile=singleslide]
  \frametitle{Endogeneizing parameters (3/4)}
  \framesubtitle{Example implementation}
  \begin{itemize}
  \item File \texttt{modeqs.mod}:
    \begin{itemize}
    \item contains variable declarations and model equations
    \item For declaration of \texttt{alpha} and \texttt{lab\_rat}:
    \footnotesize
\begin{verbatim}
@#if steady
 var alpha;
 parameter lab_rat;
@#else
 parameter alpha;
 var lab_rat;
@#endif
\end{verbatim}
    \normalsize
    \end{itemize}

  \end{itemize}
\end{frame}

\begin{frame}[fragile=singleslide]
  \frametitle{Endogeneizing parameters (4/4)}
  \framesubtitle{Example implementation}
  \begin{itemize}
  \item File \texttt{steadystate.mod}:
    \begin{itemize}
    \item begins with \verb+@#define steady = true+
    \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{save\_params\_and\_steady\_state} command
    \end{itemize}
  \item File \texttt{simulate.mod}:
    \begin{itemize}
    \item begins with \verb+@#define steady = false+
    \item then with \verb+@#include "modeqs.mod"+
    \item loads values of parameters and endogenous at steady-state from file, using the \texttt{load\_params\_and\_steady\_state} command
    \item computes simulations
    \end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}[fragile=singleslide]
  \frametitle{MATLAB/Octave loops vs macro processor loops (1/3)}
  Suppose you have a model with a parameter $\rho$, and you want to make
  simulations for three values: $\rho = 0.8, 0.9, 1$. There are
  several ways of doing this:
  \begin{block}{With a MATLAB/Octave loop}
\begin{verbatim}
rhos = [ 0.8, 0.9, 1];
for i = 1:length(rhos)
  rho = rhos(i);
  stoch_simul(order=1);
end
\end{verbatim}
  \end{block}
  \begin{itemize}
  \item The loop is not unrolled
  \item MATLAB/Octave manages the iterations
  \end{itemize}
\end{frame}

\begin{frame}[fragile=singleslide]
  \frametitle{MATLAB/Octave loops vs macro processor loops (2/3)}
  \begin{block}{With a macro processor loop (case 1)}
\begin{verbatim}
rhos = [ 0.8, 0.9, 1];
@#for i in 1:3
  rho = rhos(@{i});
  stoch_simul(order=1);
@#endfor
\end{verbatim}
  \end{block}
  \begin{itemize}
  \item Very similar to previous example
  \item Loop is unrolled
  \item Dynare macro processor manages the loop index but not the data array (\texttt{rhos})
  \end{itemize}
\end{frame}

\begin{frame}[fragile=singleslide]
  \frametitle{MATLAB/Octave loops vs macro processor loops (3/3)}
  \begin{block}{With a macro processor loop (case 2)}
\begin{verbatim}
@#for rho_val in [ 0.8, 0.9, 1]
  rho = @{rho_val};
  stoch_simul(order=1);
@#endfor
\end{verbatim}
  \end{block}
  \begin{itemize}
  \item Shorter syntax, since list of values directly given in the loop construct
  \item NB: Array not stored as MATLAB/Octave variable, hence cannot be used in MATLAB/Octave
  \end{itemize}
\end{frame}

% \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}
  \begin{center}
    \vfill {\LARGE Thanks for your attention!} \vfill
    {\LARGE Questions?}
    \vfill
  \end{center}
  \vfill
  \end{frame}


\end{document}