diff --git a/cpp/ms_dsge_c_driver.cc b/cpp/ms_dsge_c_driver.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4fdcc184273f6973763c1f9991445f2769cb8afc
--- /dev/null
+++ b/cpp/ms_dsge_c_driver.cc
@@ -0,0 +1,381 @@
+/*
+ * Copyright (C) 2011-2012 Houtan Bastani, Daniel Waggoner, Tao Zha
+ *
+ * This is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This code is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * More information is available at <http://www.gnu.org/licenses/>.
+ */
+
+#include <cstdlib>
+#include <vector>
+#include <string>
+#include <iostream>
+#include <assert.h>
+
+using namespace std;
+
+#include "ms_dsge_c_driver.hh"
+
+MsDsgeInfo::MsDsgeInfo(map<string, int > exo_names_arg,
+ map<string, int > exo_det_names_arg,
+ map<string, int > endo_names_arg,
+ map<string, int > param_names_arg,
+ map<int, double > params_arg,
+ vector<aux_vars_t> aux_vars_arg,
+ vector<int> predetermined_variables_arg,
+ vector<int> varobs_arg,
+ vector<vector<int > > lead_lag_incidence_arg,
+ vector<double> NNZDerivatives_arg) :
+ exo_names(exo_names_arg),
+ exo_det_names(exo_det_names_arg),
+ endo_names(endo_names_arg),
+ param_names(param_names_arg),
+ params(params_arg),
+ aux_vars(aux_vars_arg),
+ predetermined_variables(predetermined_variables_arg),
+ varobs(varobs_arg),
+ lead_lag_incidence(lead_lag_incidence_arg),
+ NNZDerivatives(NNZDerivatives_arg)
+{
+}
+
+MsDsgeInfo::~MsDsgeInfo()
+{
+ for (vector<MarkovSwitching *>::iterator it = markov_switching_vector.begin();
+ it < markov_switching_vector.end(); it++ )
+ delete *it;
+
+ for (vector<ModFilePrior *>::iterator it = prior_vector.begin();
+ it < prior_vector.end(); it++ )
+ delete *it;
+
+ for (vector<ModFileStructuralInnovationPrior *>::iterator it = structural_innovation_prior_vector.begin();
+ it < structural_innovation_prior_vector.end(); it++ )
+ delete *it;
+
+ for (vector<ModFileMeasurementErrorPrior *>::iterator it = measurement_error_prior_vector.begin();
+ it < measurement_error_prior_vector.end(); it++ )
+ delete *it;
+
+ for (vector<ModFileStructuralInnovationCorrPrior *>::iterator it = structural_innovation_corr_prior_vector.begin();
+ it < structural_innovation_corr_prior_vector.end(); it++ )
+ delete *it;
+
+ for (vector<ModFileMeasurementErrorCorrPrior *>::iterator it = measurement_error_corr_prior_vector.begin();
+ it < measurement_error_corr_prior_vector.end(); it++ )
+ delete *it;
+
+ markov_switching_vector.clear();
+ prior_vector.clear();
+ structural_innovation_prior_vector.clear();
+ measurement_error_prior_vector.clear();
+ structural_innovation_corr_prior_vector.clear();
+ measurement_error_corr_prior_vector.clear();
+ exo_names.clear();
+ exo_det_names.clear();
+ endo_names.clear();
+ param_names.clear();
+ params.clear();
+ aux_vars.clear();
+ predetermined_variables.clear();
+ varobs.clear();
+ lead_lag_incidence.clear();
+ NNZDerivatives.clear();
+}
+
+string
+MsDsgeInfo::get_exo_name_by_index(int index) throw (ValueNotSetException)
+{
+ for (map<string, int >::iterator it = exo_names.begin();
+ it != exo_names.end(); it++)
+ if (it->second == index)
+ return it->first;
+ throw ValueNotSetException("get_exo_name_by_index" + index);
+}
+
+int
+MsDsgeInfo::get_exo_index_by_name(string name) throw (ValueNotSetException)
+{
+ map<string, int >::iterator it = exo_names.find(name);
+ if (it != exo_names.end())
+ return it->second;
+ throw ValueNotSetException("get_exo_name_by_name" + name);
+}
+
+string
+MsDsgeInfo::get_exo_det_name_by_index(int index) throw (ValueNotSetException)
+{
+ for (map<string, int >::iterator it = exo_det_names.begin();
+ it != exo_det_names.end(); it++)
+ if (it->second == index)
+ return it->first;
+ throw ValueNotSetException("get_exo_det_name_by_index" + index);
+}
+
+int
+MsDsgeInfo::get_exo_det_index_by_name(string name) throw (ValueNotSetException)
+{
+ map<string, int >::iterator it = exo_det_names.find(name);
+ if (it != exo_det_names.end())
+ return it->second;
+ throw ValueNotSetException("get_exo_det_name_by_name" + name);
+}
+
+string
+MsDsgeInfo::get_endo_name_by_index(int index) throw (ValueNotSetException)
+{
+ for (map<string, int >::iterator it = endo_names.begin();
+ it != endo_names.end(); it++)
+ if (it->second == index)
+ return it->first;
+ throw ValueNotSetException("get_endo_name_by_index" + index);
+}
+
+int
+MsDsgeInfo::get_endo_index_by_name(string name) throw (ValueNotSetException)
+{
+ map<string, int >::iterator it = endo_names.find(name);
+ if (it != endo_names.end())
+ return it->second;
+ throw ValueNotSetException("get_endo_name_by_name" + name);
+}
+
+string
+MsDsgeInfo::get_param_name_by_index(int index) throw (ValueNotSetException)
+{
+ for (map<string, int >::iterator it = param_names.begin();
+ it != param_names.end(); it++)
+ if (it->second == index)
+ return it->first;
+ throw ValueNotSetException("get_param_name_by_index" + index);
+}
+
+int
+MsDsgeInfo::get_param_index_by_name(string name) throw (ValueNotSetException)
+{
+ map<string, int >::iterator it = param_names.find(name);
+ if (it != param_names.end())
+ return it->second;
+ throw ValueNotSetException("get_param_name_by_name" + name);
+}
+
+double
+MsDsgeInfo::get_param_value_by_index(int index) throw (ValueNotSetException)
+{
+ map<int, double >::iterator it = params.find(index);
+ if (it != params.end())
+ return it->second;
+ throw ValueNotSetException("get_param_value_by_index" + index);
+}
+
+vector<int >
+MsDsgeInfo::get_lead_lag_incidence_for_endo_var_by_index(int index) throw (ValueNotSetException)
+{
+ if (index < lead_lag_incidence.size())
+ return lead_lag_incidence.at(index);
+ throw ValueNotSetException("get_lead_lag_incidence_for_endo_var_by_index" + index);
+}
+
+MarkovSwitching::MarkovSwitching(const int chain_arg,
+ const int number_of_regimes_arg,
+ const int number_of_lags_arg,
+ const bool number_of_lags_was_passed_arg,
+ const vector<int> parameters_arg,
+ const vector<double> duration_arg,
+ const restriction_map_t restriction_map_arg) :
+ chain(chain_arg),
+ number_of_regimes(number_of_regimes_arg),
+ number_of_lags(number_of_lags_arg),
+ number_of_lags_was_passed(number_of_lags_was_passed_arg),
+ parameters(parameters_arg),
+ duration(duration_arg),
+ restriction_map(restriction_map_arg)
+{
+ assert(chain >= 1);
+ assert(number_of_regimes > 0);
+ if (number_of_lags_was_passed)
+ assert(number_of_lags > 0);
+ assert(!parameters.empty());
+ assert(!duration.empty());
+}
+
+int
+MarkovSwitching::get_number_of_lags() throw (ValueNotSetException)
+{
+ if (number_of_lags_has_val())
+ return number_of_lags;
+ throw ValueNotSetException("number_of_lags");
+}
+
+restriction_map_t
+MarkovSwitching::get_restriction_map() throw (ValueNotSetException)
+{
+ if (restriction_map_has_val())
+ return restriction_map;
+ throw ValueNotSetException("restriction_map");
+}
+
+BasicModFilePrior::BasicModFilePrior(const int index_arg,
+ const string shape_arg,
+ const double mean_arg,
+ const double mode_arg,
+ const double stdev_arg,
+ const double variance_arg,
+ const vector <double> domain_arg) :
+ index(index_arg),
+ shape(shape_arg),
+ mean(mean_arg),
+ mode(mode_arg),
+ stdev(stdev_arg),
+ variance(variance_arg),
+ domain(domain_arg)
+{
+ assert(index >= 0);
+ assert(!shape.empty());
+ if (stdev_has_val())
+ assert(stdev >= 0);
+ if (variance_has_val())
+ assert(variance >= 0);
+ if (domain_has_val())
+ assert(domain.size() == 2);
+}
+
+double
+BasicModFilePrior::get_mean() throw (ValueNotSetException)
+{
+ if (mean_has_val())
+ return mean;
+ throw ValueNotSetException("mean");
+};
+
+double
+BasicModFilePrior::get_mode() throw (ValueNotSetException)
+{
+ if (mode_has_val())
+ return mode;
+ throw ValueNotSetException("mode");
+};
+
+double
+BasicModFilePrior::get_stdev() throw (ValueNotSetException)
+{
+ if (stdev_has_val())
+ return stdev;
+ throw ValueNotSetException("stdev");
+};
+
+double
+BasicModFilePrior::get_variance() throw (ValueNotSetException)
+{
+ if (variance_has_val())
+ return variance;
+ throw ValueNotSetException("variance");
+};
+
+vector<double>
+BasicModFilePrior::get_domain() throw (ValueNotSetException)
+{
+ if (domain_has_val())
+ return domain;
+ throw ValueNotSetException("domain");
+};
+
+ModFilePrior::ModFilePrior(const int index_arg,
+ const string shape_arg,
+ const double mean_arg,
+ const double mode_arg,
+ const double stdev_arg,
+ const double variance_arg,
+ const vector <double> domain_arg) :
+ BasicModFilePrior(index_arg,
+ shape_arg,
+ mean_arg,
+ mode_arg,
+ stdev_arg,
+ variance_arg,
+ domain_arg)
+{
+}
+
+ModFileStructuralInnovationPrior::ModFileStructuralInnovationPrior(const int index_arg,
+ const string shape_arg,
+ const double mean_arg,
+ const double stdev_arg,
+ const double variance_arg,
+ const double mode_arg,
+ const vector <double> domain_arg) :
+ BasicModFilePrior(index_arg,
+ shape_arg,
+ mean_arg,
+ mode_arg,
+ stdev_arg,
+ variance_arg,
+ domain_arg)
+{
+}
+
+ModFileMeasurementErrorPrior::ModFileMeasurementErrorPrior(const int index_arg,
+ const string shape_arg,
+ const double mean_arg,
+ const double stdev_arg,
+ const double variance_arg,
+ const double mode_arg,
+ const vector <double> domain_arg) :
+ BasicModFilePrior(index_arg,
+ shape_arg,
+ mean_arg,
+ mode_arg,
+ stdev_arg,
+ variance_arg,
+ domain_arg)
+{
+}
+
+ModFileStructuralInnovationCorrPrior::ModFileStructuralInnovationCorrPrior(const int index1_arg,
+ const int index2_arg,
+ const string shape_arg,
+ const double mean_arg,
+ const double stdev_arg,
+ const double variance_arg,
+ const double mode_arg,
+ const vector <double> domain_arg) :
+ BasicModFilePrior(index1_arg,
+ shape_arg,
+ mean_arg,
+ mode_arg,
+ stdev_arg,
+ variance_arg,
+ domain_arg),
+ index2(index2_arg)
+{
+ assert(index2 >= 0);
+}
+
+ModFileMeasurementErrorCorrPrior::ModFileMeasurementErrorCorrPrior(const int index1_arg,
+ const int index2_arg,
+ const string shape_arg,
+ const double mean_arg,
+ const double stdev_arg,
+ const double variance_arg,
+ const double mode_arg,
+ const vector <double> domain_arg) :
+ BasicModFilePrior(index1_arg,
+ shape_arg,
+ mean_arg,
+ mode_arg,
+ stdev_arg,
+ variance_arg,
+ domain_arg),
+ index2(index2_arg)
+{
+ assert(index2 >= 0);
+}
+
diff --git a/cpp/ms_dsge_c_driver.hh b/cpp/ms_dsge_c_driver.hh
new file mode 100644
index 0000000000000000000000000000000000000000..325255e95b7b9a65ed6ffb1a5dff04f7c7391db9
--- /dev/null
+++ b/cpp/ms_dsge_c_driver.hh
@@ -0,0 +1,242 @@
+/*
+ * Copyright (C) 2011-2012 Houtan Bastani, Daniel Waggoner, Tao Zha
+ *
+ * This is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This code is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * More information is available at <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _MS_DSGE_C_DRIVER_HH
+#define _MS_DSGE_C_DRIVER_HH
+
+#include <cstdlib>
+#include <vector>
+#include <string>
+#include <map>
+#include <limits>
+
+using namespace std;
+
+struct aux_vars_t {
+ int endo_index, type, orig_index, orig_lead_lag;
+} ;
+
+typedef map<pair<int, int >, double> restriction_map_t ;
+
+class ValueNotSetException
+{
+public:
+ string name;
+ ValueNotSetException(const string &name_arg) : name(name_arg)
+ {
+ }
+};
+
+class MarkovSwitching
+{
+private:
+ const int chain, number_of_regimes, number_of_lags;
+ const bool number_of_lags_was_passed;
+ const vector<int> parameters;
+ const vector<double> duration;
+ const restriction_map_t restriction_map;
+public:
+ MarkovSwitching(const int chain_arg,
+ const int number_of_regimes_arg,
+ const int number_of_lags_arg,
+ const bool number_of_lags_was_passed_arg,
+ const vector<int> parameters_arg,
+ const vector<double> duration_arg,
+ const restriction_map_t restriction_map_arg);
+
+ inline bool number_of_lags_has_val() const { return number_of_lags_was_passed; };
+ inline bool restriction_map_has_val() const { return !restriction_map.empty(); };
+
+ inline int get_chain() const { return chain; };
+ inline int get_number_of_regimes() const { return number_of_regimes; };
+ int get_number_of_lags() throw (ValueNotSetException);
+ inline vector<int> get_parameters() { return parameters; };
+ inline vector<double> get_duration() { return duration; };
+ restriction_map_t get_restriction_map() throw (ValueNotSetException);
+};
+
+class BasicModFilePrior
+{
+private:
+ inline bool isnan(double x) const { return (x!=x); };
+protected:
+ const int index;
+ const string shape;
+ const double mean, mode, stdev, variance;
+ const vector <double> domain;
+
+ BasicModFilePrior(const int index_arg,
+ const string shape_arg,
+ const double mean_arg,
+ const double mode_arg,
+ const double stdev_arg,
+ const double variance_arg,
+ const vector <double> domain_arg);
+public:
+ inline bool mean_has_val() const { return !isnan(mean); };
+ inline bool mode_has_val() const { return !isnan(mode); };
+ inline bool stdev_has_val() const { return !isnan(stdev); };
+ inline bool variance_has_val() const { return !isnan(variance); };
+ inline bool domain_has_val() const { return (domain.size() == 2); };
+
+ inline int get_index() const { return index; };
+ inline string get_shape() const { return shape; };
+ double get_mean() throw (ValueNotSetException);
+ double get_mode() throw (ValueNotSetException);
+ double get_stdev() throw (ValueNotSetException);
+ double get_variance() throw (ValueNotSetException);
+ vector<double> get_domain() throw (ValueNotSetException);
+};
+
+class ModFilePrior : public BasicModFilePrior
+{
+public:
+ ModFilePrior(const int index_arg,
+ const string shape_arg,
+ const double mean_arg,
+ const double mode_arg,
+ const double stdev_arg,
+ const double variance_arg,
+ const vector <double> domain_arg);
+};
+
+class ModFileStructuralInnovationPrior: public BasicModFilePrior
+{
+public:
+ ModFileStructuralInnovationPrior(const int index_arg,
+ const string shape_arg,
+ const double mean_arg,
+ const double mode_arg,
+ const double stdev_arg,
+ const double variance_arg,
+ const vector <double> domain_arg);
+};
+
+class ModFileMeasurementErrorPrior : public BasicModFilePrior
+{
+public:
+ ModFileMeasurementErrorPrior(const int index_arg,
+ const string shape_arg,
+ const double mean_arg,
+ const double stdev_arg,
+ const double variance_arg,
+ const double mode_arg,
+ const vector <double> domain_arg);
+};
+
+class ModFileStructuralInnovationCorrPrior : public BasicModFilePrior
+{
+private:
+ const int index2;
+public:
+ ModFileStructuralInnovationCorrPrior(const int index1_arg,
+ const int index2_arg,
+ const string shape_arg,
+ const double mean_arg,
+ const double stdev_arg,
+ const double variance_arg,
+ const double mode_arg,
+ const vector <double> domain_arg);
+};
+
+class ModFileMeasurementErrorCorrPrior : public BasicModFilePrior
+{
+private:
+ const int index2;
+public:
+ ModFileMeasurementErrorCorrPrior(const int index1_arg,
+ const int index2_arg,
+ const string shape_arg,
+ const double mean_arg,
+ const double stdev_arg,
+ const double variance_arg,
+ const double mode_arg,
+ const vector <double> domain_arg);
+};
+
+class MsDsgeInfo
+{
+private:
+ vector<MarkovSwitching *> markov_switching_vector;
+ vector<ModFilePrior *> prior_vector;
+ vector<ModFileStructuralInnovationPrior *> structural_innovation_prior_vector;
+ vector<ModFileMeasurementErrorPrior *> measurement_error_prior_vector;
+ vector<ModFileStructuralInnovationCorrPrior *> structural_innovation_corr_prior_vector;
+ vector<ModFileMeasurementErrorCorrPrior *> measurement_error_corr_prior_vector;
+ map<string, int > exo_names, exo_det_names, endo_names, param_names;
+ map<int, double > params;
+ vector<aux_vars_t> aux_vars;
+ vector<int> predetermined_variables;
+ vector<int> varobs;
+ vector<vector<int > >lead_lag_incidence;
+ vector<double> NNZDerivatives;
+public:
+ MsDsgeInfo(map<string, int > exo_names_arg,
+ map<string, int > exo_det_names_arg,
+ map<string, int > endo_names_arg,
+ map<string, int > param_names_arg,
+ map<int, double > params_arg,
+ vector<aux_vars_t> aux_vars_arg,
+ vector<int> predetermined_variables_arg,
+ vector<int> varobs_arg,
+ vector<vector<int > > lead_lag_incidence_arg,
+ vector<double> NNZDerivatives_arg);
+ ~MsDsgeInfo();
+
+ inline void addMarkovSwitching(MarkovSwitching *ms) { markov_switching_vector.push_back(ms); };
+ inline void addPrior(ModFilePrior *p) { prior_vector.push_back(p); };
+ inline void addStructuralInnovationPrior(ModFileStructuralInnovationPrior *sip) { structural_innovation_prior_vector.push_back(sip); };
+ inline void addMeasurementErrorPrior(ModFileMeasurementErrorPrior *mep) { measurement_error_prior_vector.push_back(mep); };
+ inline void addStructuralInnovationCorrPrior(ModFileStructuralInnovationCorrPrior *sicp) { structural_innovation_corr_prior_vector.push_back(sicp); };
+ inline void addMeasurementErrorCorrPrior(ModFileMeasurementErrorCorrPrior *mecp) { measurement_error_corr_prior_vector.push_back(mecp); };
+
+ inline bool markov_switching_has_val() { return !markov_switching_vector.empty(); };
+ inline bool prior_has_val() { return !prior_vector.empty(); };
+ inline bool structural_innovation_prior_has_val() { return !structural_innovation_prior_vector.empty(); };
+ inline bool measurement_error_prior_has_val() { return !measurement_error_prior_vector.empty(); };
+ inline bool structural_innovation_corr_prior_has_val() { return !structural_innovation_corr_prior_vector.empty(); };
+ inline bool measurement_error_corr_prior_has_val() { return !measurement_error_corr_prior_vector.empty(); };
+
+ inline vector<MarkovSwitching *>get_markov_switching() { return markov_switching_vector; };
+ inline vector<ModFilePrior *> get_prior() { return prior_vector; };
+ inline vector<ModFileStructuralInnovationPrior *> get_structural_innovation_prior() { return structural_innovation_prior_vector; };
+ inline vector<ModFileMeasurementErrorPrior *> get_measurement_error_prior() { return measurement_error_prior_vector; };
+ inline vector<ModFileStructuralInnovationCorrPrior *> get_structural_innovation_corr_prior() { return structural_innovation_corr_prior_vector; };
+ inline vector<ModFileMeasurementErrorCorrPrior *> get_measurement_error_corr_prior() { return measurement_error_corr_prior_vector; };
+ inline map<string, int > get_exo_names() { return exo_names; };
+ inline map<string, int > get_exo_det_names() { return exo_det_names; };
+ inline map<string, int > get_endo_names() { return endo_names; };
+ inline map<string, int > get_param_names() { return param_names; };
+ inline map<int, double > get_params() { return params; };
+ inline vector <aux_vars_t> get_aux_vars() { return aux_vars; };
+ inline vector <int> get_predetermined_variables() { return predetermined_variables; };
+ inline vector <int> get_varobs() { return varobs; };
+ inline vector<vector<int > > get_lead_lag_incidence() { return lead_lag_incidence; };
+ inline vector<double> get_NNZDerivatives() { return NNZDerivatives; };
+
+ string get_exo_name_by_index(int index) throw (ValueNotSetException);
+ int get_exo_index_by_name(string name) throw (ValueNotSetException);
+ string get_exo_det_name_by_index(int index) throw (ValueNotSetException);
+ int get_exo_det_index_by_name(string name) throw (ValueNotSetException);
+ string get_endo_name_by_index(int index) throw (ValueNotSetException);
+ int get_endo_index_by_name(string name) throw (ValueNotSetException);
+ string get_param_name_by_index(int index) throw (ValueNotSetException);
+ int get_param_index_by_name(string name) throw (ValueNotSetException);
+ double get_param_value_by_index(int index) throw (ValueNotSetException);
+ vector<int >get_lead_lag_incidence_for_endo_var_by_index(int index) throw (ValueNotSetException);
+};
+
+#endif // ! _MS_DSGE_C_DRIVER_HH