stepan
/
dynare
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

trunk: {load,save}_params_and_steady_state now use a text file for communicating (instead of a MAT-file) 

git-svn-id: https://www.dynare.org/svn/dynare/trunk@2517 ac1d8469-bf42-47a9-8791-bf33cf982152
time-shift
sebastien 2009-03-24 16:29:58 +00:00
parent 7d854cec94
commit 5ee346e4fd
8 changed files with 80 additions and 1613 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
matlab/load_params_and_steady_state.m
View File

@ -1,65 +0,0 @@
function load_params_and_steady_state(filename)
% function load_params_and_steady_state(filename)
%
% For all parameters, endogenous and exogenous variables, loads
% their value from a file created with save_params_and_steady_state.
% * for parameters, their value will be initialized as if they
% had been calibrated in the .mod file
% * for endogenous and exogenous, their value will be initialized
% as they would have been from an initval block
%
% INPUTS
% filename: where to load from the saved values
%
% OUTPUTS
% none
%
% SPECIAL REQUIREMENTS
% none
% Copyright (C) 2008 Dynare Team
%
% This file is part of Dynare.
%
% Dynare 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.
%
% Dynare 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.
%
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global M_ oo_
load(filename);
if ~exist('stored_values')
error('LOAD_PARAMS_AND_INITVAL: filename provided was probably not created by save_params_and_initval')
end
names = fieldnames(stored_values);
for i = 1:size(names,1)
field = names{i};
j = strmatch(field, M_.param_names, 'exact');
if ~isempty(j)
M_.params(j) = stored_values.(field);
else
j = strmatch(field, M_.endo_names, 'exact');
if ~isempty(j)
oo_.steady_state(j) = stored_values.(field);
else
j = strmatch(field, M_.exo_names, 'exact');
if ~isempty(j)
oo_.exo_steady_state(j) = stored_values.(field);
else
warning(['LOAD_PARAMS_AND_INITVAL: Unknown symbol name: ', field])
end
end
end
end

22
matlab/save_params_and_steady_state.m
View File

@ -2,7 +2,7 @@ function save_params_and_steady_state(filename)
% function save_params_and_steady_state(filename)
%
% For all parameters, endogenous and exogenous variables, stores
% their value in a file, using a simple name/value associative array.
% their value in a text file.
% * for parameters, the value is taken from the last parameter
% initialization
% * for exogenous, the value is taken from the last initval block
@ -22,7 +22,7 @@ function save_params_and_steady_state(filename)
% SPECIAL REQUIREMENTS
% none
% Copyright (C) 2008 Dynare Team
% Copyright (C) 2008-2009 Dynare Team
%
% This file is part of Dynare.
%
@ -41,15 +41,25 @@ function save_params_and_steady_state(filename)
global M_ oo_
fid = fopen(filename, 'w');
if fid < 0
error([ 'SAVE_PARAMS_AND_STEADY_STATE: Can''t open ' filename ]);
end
for i = 1:M_.param_nbr
stored_values.(deblank(M_.param_names(i,:))) = M_.params(i);
fprintf(fid, '%s %.16g\n', M_.param_names(i,:), M_.params(i));
end
for i = 1:M_.endo_nbr
stored_values.(deblank(M_.endo_names(i,:))) = oo_.steady_state(i);
fprintf(fid, '%s %.16g\n', M_.endo_names(i,:), oo_.steady_state(i));
end
for i = 1:M_.exo_nbr
stored_values.(deblank(M_.exo_names(i,:))) = oo_.exo_steady_state(i);
fprintf(fid, '%s %.16g\n', M_.exo_names(i,:), oo_.exo_steady_state(i));
end
save('-v6',filename, 'stored_values');
for i = 1:M_.exo_det_nbr
fprintf(fid, '%s %.16g\n', M_.exo_det_names(i,:), oo_.exo_det_steady_state(i));
end
fclose(fid);

1
preprocessor/Makefile
View File

@ -48,7 +48,6 @@ MAIN_OBJS = \
ParsingDriver.o \
DataTree.o \
ModFile.o \
MatlabFile.o \
Statement.o \
ExprNode.o \
ModelNormalization.o \

1077
preprocessor/MatlabFile.cc
View File

File diff suppressed because it is too large Load Diff

426
preprocessor/MatlabFile.hh
View File

@ -1,426 +0,0 @@
/*
* Copyright (C) 2009 Dynare Team
*
* This file is part of Dynare.
*
* Dynare 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.
*
* Dynare 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.
*
* You should have received a copy of the GNU General Public License
* along with Dynare. If not, see <http://www.gnu.org/licenses/>.
*/
/*
Usefull documentation: Matlab 7 Mat-File Format
-----------------------------------------------
revision: October 2008 PDF only Rereleased for Version 7.7 (Release 2008b)
available at: http://www.mathworks.com/access/helpdesk/help/pdf_doc/matlab/matfile_format.pdf
*/
#ifndef _MAT_FILE_HH
#define _MAT_FILE_HH
#include <cstdio>
#include <cstdlib>
#include <string>
#include <fstream>
#include <cstring>
#include <iostream>
#include <map>
#include <vector>
#include <math.h>
//! zlib needed to uncompress the mat-file. It is available with GCC 4.3.2 but it needs a dll !!
//! => to avoid compress MatFile, save is used with option '-v6' in save_params_and_strady_state.m
//#include "zlib.h"
using namespace std;
enum Data_Type
{
miINT8 = 1, //8 bit, signed
miUINT8 = 2, //8 bit, unsigned
miINT16 = 3, //16-bit, signed
miUINT16 = 4, //16-bit, unsigned
miINT32 = 5, //32-bit, signed
miUINT32 = 6, //32-bit, unsigned
miSINGLE = 7, //IEEE® 754 single format
miDOUBLE = 9, //IEEE 754 double format
miINT64 = 12, //64-bit, signed
miUINT64 = 13, //64-bit, unsigned
miMATRIX = 14, //MATLAB array
miCOMPRESSED = 15, //Compressed Data
miUTF8 = 16, //Unicode UTF-8 Encoded Character Data
miUTF16 = 17, //Unicode UTF-16 Encoded Character Data
miUTF32 = 18 //Unicode UTF-32 Encoded Character Data
};
enum Array_Type
{
Cell_array = 1,
Structure_ = 2,
Object_ = 3,
Character_array = 4,
Sparse_array = 5,
Double_precision_array = 6,
Single_precision_array = 7,
Signed_integer_8_bit = 8,
Unsigned_integer_8_bit = 9,
Signed_integer_16_bit = 10,
Unsigned_integer_16_bit = 11,
Signed_integer_32_bit = 12,
Unsigned_integer_32_bit = 13
};
enum Function_Returned_Type
{
Numerical =1,
AlphaNumeric =2,
Matrix =3,
Compressed =4,
Unknown =5
};
class ArrayElem;
class SimpleElem;
typedef long long LongLongInt;
typedef long int LongInt;
typedef short int Int;
//typedef char ShortInt;
typedef unsigned long int uLongInt ;
typedef unsigned short int uShortInt ;
typedef short int ShortInt ;
typedef class SimpleElem *PSimpleElem;
//!Header of MatFile
typedef struct Header
{
char Theader[124];
short int Version;
char Edian_Indicator[2];
}
Header_t;
typedef struct Data_Header
{
ShortInt S_Number_of_Bytes;
ShortInt DataType;
uLongInt Number_of_Bytes;
}
Data_Header_t;
typedef struct Array_Flag
{
Data_Header_t tag;
unsigned char classe;
unsigned char flag;
char undef1[2];
uLongInt nzmax;
}
Array_Flag_t;
typedef struct returned_ReadData
{
SimpleElem* Simple;
Function_Returned_Type Type;
} returned_ReadData_t;
typedef struct FlagStructure
{
bool no_name;
bool character;
} FlagStructure_t;
typedef struct CollectStruct
{
/*vector<string> variable_name;
vector< vector<double> > variable_double;
vector< vector<string> > variable_string;*/
string tmp_name;
map<string,vector<string> > variable_string_name;
map<string,vector<double> > variable_double_name;
}
CollectStruct;
typedef vector<int> Array_Dimensions_t;
//! Base class for simple elements in Mat-File
class SimpleElem
{
public:
bool verbose;
vector<double> VNumeric;
vector<string> Vstr;
ArrayElem *array_elem;
int Type;
SimpleElem();
virtual ~SimpleElem();
virtual double ReadNum(char* InBuff, int* pBuff) const{return(0);};
virtual string ReadAlph(char* InBuff, int* pBuff, int Size) const{return(NULL);};
virtual Data_Header_t ReadDataHeader(char* InBuff, int* pBuff) const;
virtual int size() const{cout << "oups\n";return(0);};
void Print() const;
void Delete() const;
void Collect(const string &name, bool found, CollectStruct &collect_struct) const;
returned_ReadData_t ReadData(char* InBuff, int* pBuff) const;
returned_ReadData_t Get_Data_Class(Data_Header_t data_header) const;
void DataProceed(Data_Header data_header, char* InBuff, int* pBuff, FlagStructure flag);
};
class UTF8 : public SimpleElem
{
public:
virtual int size() const {return(1);};
virtual double ReadNum(char* InBuff, int* pBuff) const {return(0.0);};
virtual string ReadAlph(char* InBuff, int* pBuff, int Size) const;
};
class UTF16 : public SimpleElem
{
public:
virtual int size() const {return(2);};
virtual double ReadNum(char* InBuff, int* pBuff) const {return(0.0);};
virtual string ReadAlph(char* InBuff, int* pBuff, int Size) const;
};
class UTF32 : public SimpleElem
{
public:
virtual int size() const {return(4);};
virtual double ReadNum(char* InBuff, int* pBuff) const {return(0.0);};
virtual string ReadAlph(char* InBuff, int* pBuff, int Size) const;
};
class INT8 : public SimpleElem
{
public:
virtual int size() const {return(1);};
virtual double ReadNum(char* InBuff, int* pBuff) const;
virtual string ReadAlph(char* InBuff, int* pBuff, int Size) const {return(string(""));};
};
class INT16 : public SimpleElem
{
public:
virtual int size() const {return(2);};
virtual double ReadNum(char* InBuff, int* pBuff) const;
virtual string ReadAlph(char* InBuff, int* pBuff, int Size) const {return(string(""));};
};
class INT32 : public SimpleElem
{
public:
virtual int size() const {return(4);};
virtual double ReadNum(char* InBuff, int* pBuff) const;
virtual string ReadAlph(char* InBuff, int* pBuff, int Size) const {return(string(""));};
};
class INT64 : public SimpleElem
{
public:
virtual int size() const {return(8);};
virtual double ReadNum(char* InBuff, int* pBuff) const;
virtual string ReadAlph(char* InBuff, int* pBuff, int Size) const {return(string(""));};
};
class Single : public SimpleElem
{
public:
virtual int size() const {return(4);};
virtual double ReadNum(char* InBuff, int* pBuff) const;
virtual string ReadAlph(char* InBuff, int* pBuff, int Size) const {return(string(""));};
};
class Double : public SimpleElem
{
public:
virtual int size() const {return(8);};
virtual double ReadNum(char* InBuff, int* pBuff) const;
virtual string ReadAlph(char* InBuff, int* pBuff, int Size) const {return(string(""));};
};
//! Base class for Array Element in Mat-File
class ArrayElem : public SimpleElem
{
private:
protected:
public:
int Cell_number, Structure_number, Matrix_Elem_number;
Array_Type Type;
vector<PSimpleElem> VCell;
vector<string> Structure_Elem_name;
bool array_complex, array_global, array_logical;
string variable_name;
int array_nzmax;
int number_of_dimensions;
vector<int> dimension;
vector<double> Double_value;
vector<string> String_value;
Array_Type type;
ArrayElem();
virtual LongInt ReadINT32(char* InBuff, int* pBuff) const;
virtual Array_Flag_t ReadArrayFlag(char* InBuff, int* pBuff) /*const*/;
virtual void ReadArrayDimension(char* InBuff, int* pBuff) /*const*/;
virtual void ReadArrayName(char* InBuff, int* pBuff) /*const*/;
virtual void ReadStructureNames(char* InBuff, int* pBuff);
virtual ArrayElem* ReadArray_class(char* InBuff, int* pBuff) const;
virtual void ReadArray(char* InBuff, int* pBuff, FlagStructure_t flag) /*const*/ {cout << "oups..\n";};
virtual void Collect(const string &name, bool found, CollectStruct &collect_struct) const;
virtual void Print() const;
virtual void Delete() const;
virtual ~ArrayElem();
};
class CellArray : public ArrayElem
{
public:
virtual void Collect(const string &name, bool found, CollectStruct &collect_struct) const;
virtual void Print() const;
virtual void Delete() const;
virtual void ReadArray(char* InBuff, int* pBuff, FlagStructure_t flag);
};
class Structure : public ArrayElem
{
public:
virtual void Collect(const string &name, bool found, CollectStruct &collect_struct) const;
virtual void Print() const;
virtual void Delete() const;
virtual void ReadArray(char* InBuff, int* pBuff, FlagStructure_t flag);
};
class Object : public ArrayElem
{
public:
virtual void Collect(const string &name, bool found, CollectStruct &collect_struct) const;
virtual void Print() const;
virtual void Delete() const;
virtual void ReadArray(char* InBuff, int* pBuff, FlagStructure_t flag);
};
class CharacterArray : public ArrayElem
{
public:
virtual void Collect(const string &name, bool found, CollectStruct &collect_struct) const;
virtual void Print() const;
virtual void Delete() const;
virtual void ReadArray(char* InBuff, int* pBuff, FlagStructure_t flag);
};
class SparseArray : public ArrayElem
{
public:
virtual void Collect(const string &name, bool found, CollectStruct &collect_struct) const;
virtual void Print() const;
virtual void Delete() const;
virtual void ReadArray(char* InBuff, int* pBuff, FlagStructure_t flag);
};
class DoublePrecisionArray : public ArrayElem
{
public:
virtual void Collect(const string &name, bool found, CollectStruct &collect_struct) const;
virtual void Print() const;
virtual void Delete() const;
virtual void ReadArray(char* InBuff, int* pBuff, FlagStructure_t flag);
};
class SinglePrecisionArray : public ArrayElem
{
public:
virtual void Collect(const string &name, bool found, CollectStruct &collect_struct) const;
virtual void Print() const;
virtual void Delete() const;
virtual void ReadArray(char* InBuff, int* pBuff, FlagStructure_t flag);
};
class Bit8SignedInteger : public ArrayElem
{
public:
virtual void Collect(const string &name, bool found, CollectStruct &collect_struct) const;
virtual void Print() const;
virtual void Delete() const;
virtual void ReadArray(char* InBuff, int* pBuff, FlagStructure_t flag);
};
class Bit8UnsignedInteger : public ArrayElem
{
public:
virtual void Collect(const string &name, bool found, CollectStruct &collect_struct) const;
virtual void Print() const;
virtual void Delete() const;
virtual void ReadArray(char* InBuff, int* pBuff, FlagStructure_t flag);
};
class Bit16SignedInteger : public ArrayElem
{
public:
virtual void Collect(const string &name, bool found, CollectStruct &collect_struct) const;
virtual void Print() const;
virtual void Delete() const;
virtual void ReadArray(char* InBuff, int* pBuff, FlagStructure_t flag);
};
class Bit16UnsignedInteger : public ArrayElem
{
public:
virtual void Collect(const string &name, bool found, CollectStruct &collect_struct) const;
virtual void Print() const;
virtual void Delete() const;
virtual void ReadArray(char* InBuff, int* pBuff, FlagStructure_t flag);
};
class Bit32SignedInteger : public ArrayElem
{
public:
virtual void Collect(const string &name, bool found, CollectStruct &collect_struct) const;
virtual void Print() const;
virtual void Delete() const;
virtual void ReadArray(char* InBuff, int* pBuff, FlagStructure_t flag);
};
class Bit32UnsignedInteger : public ArrayElem
{
public:
virtual void Collect(const string &name, bool found, CollectStruct &collect_struct) const;
virtual void Print() const;
virtual void Delete() const;
virtual void ReadArray(char* InBuff, int* pBuff, FlagStructure_t flag);
};
class MatlabFile
{
public:
Header_t header;
vector<PSimpleElem> VSimpl;
MatlabFile();
~MatlabFile();
void MatFileRead(string filename);
void MatFilePrint();
void Delete();
bool Collect(const string &name, CollectStruct &collect_struct) const;
Data_Header_t ReadDataHeader(ifstream &MatFile);
};
#endif

94
preprocessor/NumericalInitialization.cc
View File

@ -17,9 +17,9 @@
* along with Dynare. If not, see <http://www.gnu.org/licenses/>.
*/
#include "NumericalInitialization.hh"
#include <cstdlib>
#include "MatlabFile.hh"
#include "NumericalInitialization.hh"
InitParamStatement::InitParamStatement(int symb_id_arg,
const NodeID param_value_arg,
@ -247,49 +247,73 @@ SaveParamsAndSteadyStateStatement::writeOutput(ostream &output, const string &ba
output << "save_params_and_steady_state('" << filename << "');" << endl;
}
LoadParamsAndSteadyStateStatement::LoadParamsAndSteadyStateStatement(const string &filename_arg,
LoadParamsAndSteadyStateStatement::LoadParamsAndSteadyStateStatement(const string &filename,
const SymbolTable &symbol_table_arg) :
filename(filename_arg), symbol_table(symbol_table_arg)
symbol_table(symbol_table_arg)
{
cout << "Reading " << filename << " ...";
ifstream f;
f.open(filename.c_str(), ios::in);
if (f.bad())
{
cerr << "ERROR: Can't open " << filename << endl;
exit(EXIT_FAILURE);
}
while(true)
{
string symb_name, value;
f >> symb_name >> value;
if (f.eof())
break;
try
{
int symb_id = symbol_table.getID(symb_name);
content[symb_id] = value;
}
catch(SymbolTable::UnknownSymbolNameException &e)
{
cerr << "WARNING: Unknown symbol " << symb_name << " in " << filename << endl;
}
}
}
void
LoadParamsAndSteadyStateStatement::writeOutput(ostream &output, const string &basename) const
{
output << "load_params_and_steady_state('" << filename << "');" << endl;
for(map<int, string>::const_iterator it = content.begin();
it != content.end(); it++)
{
switch(symbol_table.getType(it->first))
{
case eParameter:
output << "M_.params";
break;
case eEndogenous:
output << "oo_.steady_state";
break;
case eExogenous:
output << "oo_.exo_steady_state";
break;
case eExogenousDet:
output << "oo_.exo_det_steady_state";
break;
default:
cerr << "ERROR: Unsupported variable type for " << symbol_table.getName(it->first) << " in load_params_and_steady_state" << endl;
exit(EXIT_FAILURE);
}
int tsid = symbol_table.getTypeSpecificID(it->first) + 1;
output << "(" << tsid << ") = " << it->second << ";" << endl;
}
}
void
LoadParamsAndSteadyStateStatement::fillEvalContext(eval_context_type &eval_context) const
{
cout << "Reading " << filename << " ...";
MatlabFile matlab_file;
matlab_file.MatFileRead(filename);
string sname = "stored_values";
CollectStruct collect_struct;
bool tmp_b = matlab_file.Collect(sname, collect_struct);
matlab_file.Delete();
if (!tmp_b)
cout << "The structure " << sname << " was not found in " << filename << endl;
cout << "done\n";
for(map<string, vector<double> >::iterator it = collect_struct.variable_double_name.begin();
it != collect_struct.variable_double_name.end(); it++)
{
const string &symbol_name = it->first;
double val = it->second[0];
try
{
int symb_id = symbol_table.getID(symbol_name);
eval_context[symb_id] = val;
}
catch(SymbolTable::UnknownSymbolNameException &e)
{
cerr << "Warning: unknown symbol " << symbol_name << " in " << filename << endl;
}
}
for(map<int, string>::const_iterator it = content.begin();
it != content.end(); it++)
eval_context[it->first] = atof(it->second.c_str());
}

6
preprocessor/NumericalInitialization.hh
View File

@ -134,10 +134,12 @@ public:
class LoadParamsAndSteadyStateStatement : public Statement
{
private:
const string filename;
const SymbolTable &symbol_table;
//! Content of the file
/*! Maps symbol ID to numeric value (stored as string) */
map<int, string> content;
public:
LoadParamsAndSteadyStateStatement(const string &filename_arg,
LoadParamsAndSteadyStateStatement(const string &filename,
const SymbolTable &symbol_table_arg);
virtual void writeOutput(ostream &output, const string &basename) const;
//! Fill eval context with parameters/variables values

2
preprocessor/Statement.hh
View File

@ -63,7 +63,7 @@ public:
//! Do some internal check, and fill the ModFileStructure class
virtual void checkPass(ModFileStructure &mod_file_struct);
virtual void computingPass();
//! Write Matlab outout code
//! Write Matlab output code
/*!
\param output is the output stream of the main matlab file
\param basename is the name of the modfile (without extension) which can be used to build auxiliary files