2006-11-05 00:31:17 +01:00
|
|
|
#include <iostream>
|
|
|
|
#include <algorithm>
|
2006-12-14 23:19:39 +01:00
|
|
|
|
2006-11-05 00:31:17 +01:00
|
|
|
#include "VariableTable.hh"
|
2006-11-28 12:56:02 +01:00
|
|
|
|
2006-12-18 12:29:10 +01:00
|
|
|
VariableTable::VariableTable(const SymbolTable &symbol_table_arg) :
|
2006-11-28 12:56:02 +01:00
|
|
|
symbol_table(symbol_table_arg),
|
2006-12-18 12:29:10 +01:00
|
|
|
var_endo_nbr(0), var_exo_nbr(0), var_exo_det_nbr(0),
|
|
|
|
max_lag(0), max_lead(0),
|
|
|
|
max_endo_lag(0), max_endo_lead(0),
|
|
|
|
max_exo_lag(0), max_exo_lead(0),
|
|
|
|
max_exo_det_lag(0), max_exo_det_lead(0),
|
|
|
|
max_recur_lag(0), max_recur_lead(0)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2006-12-14 23:19:39 +01:00
|
|
|
int
|
|
|
|
VariableTable::AddVariable(const string &iName, int iLag)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-14 23:19:39 +01:00
|
|
|
// Testing if variable exists in VariableTable
|
|
|
|
int lVariableID = getID(iName,iLag);
|
2006-11-05 00:31:17 +01:00
|
|
|
if (lVariableID != -1)
|
2006-12-14 23:19:39 +01:00
|
|
|
return lVariableID;
|
|
|
|
|
2006-11-05 00:31:17 +01:00
|
|
|
lVariableID = mVariableIndex.size();
|
|
|
|
// Making variable struct and key
|
2006-12-14 23:19:39 +01:00
|
|
|
varKey key = make_pair(iName, iLag);
|
2006-11-05 00:31:17 +01:00
|
|
|
// Pushing variable on VariableTable
|
|
|
|
mVariableTable[key] = lVariableID;
|
|
|
|
mVariableIndex.push_back(key);
|
2006-12-14 23:19:39 +01:00
|
|
|
|
|
|
|
// Setting dynamic variables numbers
|
2006-11-05 00:31:17 +01:00
|
|
|
Type type = getType(lVariableID);
|
2006-11-05 01:19:43 +01:00
|
|
|
if (type == eEndogenous)
|
2006-12-18 12:29:10 +01:00
|
|
|
var_endo_nbr++;
|
2006-11-05 01:19:43 +01:00
|
|
|
if (type == eExogenous)
|
2006-12-18 12:29:10 +01:00
|
|
|
var_exo_nbr++;
|
2006-11-05 01:19:43 +01:00
|
|
|
if (type == eExogenousDet)
|
2006-12-18 12:29:10 +01:00
|
|
|
var_exo_det_nbr++;
|
2006-12-14 23:19:39 +01:00
|
|
|
|
|
|
|
// Setting maximum and minimum lags
|
2006-12-18 12:29:10 +01:00
|
|
|
if (max_lead < iLag)
|
|
|
|
max_lead = iLag;
|
|
|
|
else if (-max_lag > iLag)
|
|
|
|
max_lag = -iLag;
|
2006-11-28 12:56:02 +01:00
|
|
|
|
2006-11-05 00:31:17 +01:00
|
|
|
switch(type)
|
|
|
|
{
|
|
|
|
case eEndogenous:
|
2006-12-18 12:29:10 +01:00
|
|
|
if (max_endo_lead < iLag)
|
|
|
|
max_endo_lead = iLag;
|
|
|
|
else if (-max_endo_lag > iLag)
|
|
|
|
max_endo_lag = -iLag;
|
2006-11-05 00:31:17 +01:00
|
|
|
break;
|
|
|
|
case eExogenous:
|
2006-12-18 12:29:10 +01:00
|
|
|
if (max_exo_lead < iLag)
|
|
|
|
max_exo_lead = iLag;
|
|
|
|
else if (-max_exo_lag > iLag)
|
|
|
|
max_exo_lag = -iLag;
|
2006-11-05 00:31:17 +01:00
|
|
|
break;
|
|
|
|
case eExogenousDet:
|
2006-12-18 12:29:10 +01:00
|
|
|
if (max_exo_det_lead < iLag)
|
|
|
|
max_exo_det_lead = iLag;
|
|
|
|
else if (-max_exo_det_lag > iLag)
|
|
|
|
max_exo_det_lag = -iLag;
|
2006-11-05 00:31:17 +01:00
|
|
|
break;
|
|
|
|
case eRecursiveVariable:
|
2006-12-18 12:29:10 +01:00
|
|
|
if (max_recur_lead < iLag)
|
|
|
|
max_recur_lead = iLag;
|
|
|
|
else if (-max_recur_lag > iLag)
|
|
|
|
max_recur_lag = -iLag;
|
2006-11-05 00:31:17 +01:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
;
|
|
|
|
}
|
2006-12-14 23:19:39 +01:00
|
|
|
return lVariableID;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-12-14 23:19:39 +01:00
|
|
|
void
|
|
|
|
VariableTable::Sort()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-14 23:19:39 +01:00
|
|
|
// Trivial case where no ordering is necessary
|
2006-11-05 00:31:17 +01:00
|
|
|
if (mVariableIndex.size() == 1)
|
|
|
|
{
|
|
|
|
mSortedVariableID.push_back(0);
|
|
|
|
mPrintFormatIndex.push_back(0);
|
|
|
|
return;
|
|
|
|
}
|
2006-12-14 23:19:39 +01:00
|
|
|
|
|
|
|
/* The type of key for lexicographic ordering over variables:
|
|
|
|
the key is equal to (type, lag, symbol_id) */
|
|
|
|
typedef pair<Type, pair<int, int> > lexicographic_key_type;
|
|
|
|
|
|
|
|
// Construct the vector matching keys to their varIDs
|
|
|
|
vector<pair<lexicographic_key_type, int> > VarToSort;
|
|
|
|
for (unsigned int varID = 0; varID < mVariableIndex.size(); varID++)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-14 23:19:39 +01:00
|
|
|
Type type = getType(varID);
|
|
|
|
int symbolID = getSymbolID(varID);
|
|
|
|
int lag = mVariableIndex[varID].second;
|
|
|
|
VarToSort.push_back(make_pair(make_pair(type, make_pair(lag, symbolID)), varID));
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
2006-12-14 23:19:39 +01:00
|
|
|
|
|
|
|
// Sort variables using the lexicographic ordering
|
2006-11-05 00:31:17 +01:00
|
|
|
sort(VarToSort.begin(), VarToSort.end());
|
2006-12-14 23:19:39 +01:00
|
|
|
|
|
|
|
// Fill mSortedVariableID and mPrintFormatIndex
|
2006-11-05 00:31:17 +01:00
|
|
|
mSortedVariableID.resize(VarToSort.size());
|
|
|
|
mPrintFormatIndex.resize(VarToSort.size());
|
2006-12-14 23:19:39 +01:00
|
|
|
Type type = getType(VarToSort[0].second);
|
2006-11-05 00:31:17 +01:00
|
|
|
int index = 0;
|
2006-12-14 23:19:39 +01:00
|
|
|
for (unsigned int sortedID = 0; sortedID < VarToSort.size(); sortedID++)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-14 23:19:39 +01:00
|
|
|
int varID = VarToSort[sortedID].second;
|
|
|
|
mSortedVariableID[varID] = sortedID;
|
|
|
|
if (type == getType(varID))
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-14 23:19:39 +01:00
|
|
|
mPrintFormatIndex[varID] = index;
|
2006-11-05 00:31:17 +01:00
|
|
|
index++;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2006-12-14 23:19:39 +01:00
|
|
|
mPrintFormatIndex[varID] = 0;
|
|
|
|
type = getType(varID);
|
2006-11-05 00:31:17 +01:00
|
|
|
index = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2007-02-22 00:28:16 +01:00
|
|
|
|
|
|
|
int*
|
|
|
|
VariableTable::GetVariableTable(int* Size, int* HSize)
|
|
|
|
{
|
|
|
|
int* Table;
|
|
|
|
varKey key;
|
|
|
|
int variable,id, ind;
|
|
|
|
(*Size)=0;
|
|
|
|
for (id=0; id < (int) mVariableIndex.size(); id++)
|
|
|
|
{
|
|
|
|
key = mVariableIndex[id];
|
|
|
|
variable = mVariableTable[key];
|
|
|
|
if(getType(variable)==eEndogenous)
|
|
|
|
(*Size)++;
|
|
|
|
}
|
|
|
|
(*HSize)=4;
|
|
|
|
Table=(int*)malloc((*Size)*(*HSize)*sizeof(*Table));
|
|
|
|
ind=0;
|
|
|
|
for (id=0; id < (int) mVariableIndex.size(); id++)
|
|
|
|
{
|
|
|
|
key = mVariableIndex[id];
|
|
|
|
variable = mVariableTable[key];
|
|
|
|
if (getType(variable)==eEndogenous)
|
|
|
|
{
|
|
|
|
Table[ind*(*HSize)]= getSymbolID(id);
|
|
|
|
Table[ind*(*HSize)+1]= key.second;
|
|
|
|
Table[ind*(*HSize)+2]= mPrintFormatIndex[id];
|
|
|
|
Table[ind*(*HSize)+3]= mSortedVariableID[id];
|
|
|
|
ind++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return(Table);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
VariableTable::getIDS(int id, int lead_lag) const
|
|
|
|
{
|
|
|
|
varKey key;
|
|
|
|
key=mVariableIndex[id];
|
|
|
|
map<varKey, int>::const_iterator it = mVariableTable.find(key);
|
|
|
|
return(it->second);
|
|
|
|
}
|