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

v4 preprocessor: removed unused bits of code 

git-svn-id: https://www.dynare.org/svn/dynare/dynare_v4@1811 ac1d8469-bf42-47a9-8791-bf33cf982152
time-shift
sebastien 2008-04-29 15:15:35 +00:00
parent e6a060d64e
commit f120c49dde
10 changed files with 8 additions and 1246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

332
preprocessor/BlockTriangular.cc
View File

@ -42,14 +42,6 @@ BlockTriangular::BlockTriangular(const SymbolTable &symbol_table_arg) :
periods = 0;
}
//------------------------------------------------------------------------------
BlockTriangular::~BlockTriangular()
{
// Empty
}
//------------------------------------------------------------------------------
//For a lead or a lag build the Incidence Matrix structures
List_IM*
@ -121,23 +113,6 @@ BlockTriangular::Get_IM(int lead_lag)
return (Cur_IM);
}
bool*
BlockTriangular::bGet_IM(int lead_lag)
{
List_IM* Cur_IM;
Cur_IM = First_IM;
while ((Cur_IM != NULL) && (Cur_IM->lead_lag != lead_lag))
{
Cur_IM = Cur_IM->pNext;
}
if((Cur_IM->lead_lag != lead_lag) || (Cur_IM==NULL))
{
cout << "the incidence matrix with lag " << lead_lag << " does not exist !!";
exit(-1);
}
return (Cur_IM->IM);
}
bool*
BlockTriangular::bGet_IM(int lead_lag) const
{
@ -325,64 +300,6 @@ BlockTriangular::Prologue_Epilogue(bool* IM, int* prologue, int* epilogue, int n
}
void
BlockTriangular::getMax_Lead_Lag(int var, int equ, int *lead, int *lag)
{
List_IM* Cur_IM;
Cur_IM = First_IM->pNext;
(*lead) = (*lag) = 0;
while(Cur_IM)
{
if(Cur_IM->IM[equ*endo_nbr + var])
{
if(Cur_IM->lead_lag > 0)
{
if ((*lead) < Cur_IM->lead_lag)
*lead = Cur_IM->lead_lag;
}
else
{
if ((*lag) < abs(Cur_IM->lead_lag))
*lag = abs(Cur_IM->lead_lag);
}
}
Cur_IM = Cur_IM->pNext;
}
}
void
BlockTriangular::getMax_Lead_Lag_B(int size, int* Equation, int *Variable, int *lead, int *lag)
{
List_IM* Cur_IM;
int i, j;
Cur_IM = First_IM->pNext;
(*lead) = (*lag) = 0;
while(Cur_IM)
{
for(i = 0;i < size;i++)
{
for(j = 0;j < size;j++)
{
if(Cur_IM->IM[Equation[i]*endo_nbr + Variable[j]])
{
if(Cur_IM->lead_lag > 0)
{
if ((*lead) < Cur_IM->lead_lag)
*lead = Cur_IM->lead_lag;
}
else
{
if ((*lag) < abs(Cur_IM->lead_lag))
*lag = abs(Cur_IM->lead_lag);
}
}
}
}
Cur_IM = Cur_IM->pNext;
}
}
void
BlockTriangular::Allocate_Block(int size, int *count_Equ, int *count_Block, int type, Model_Block * ModelBlock)
{
@ -746,12 +663,6 @@ BlockTriangular::Free_Block(Model_Block* ModelBlock)
free(ModelBlock);
}
string
BlockTriangular::getnamebyID(Type type, int id)
{
return symbol_table.getNameByID(type,id);
}
//------------------------------------------------------------------------------
// Normalize each equation of the model (endgenous_i = f_i(endogenous_1, ..., endogenous_n) - in order to apply strong connex components search algorithm -
// and find the optimal blocks triangular decomposition
@ -895,249 +806,6 @@ BlockTriangular::Normalize_and_BlockDecompose(bool* IM, Model_Block* ModelBlock,
return 0;
}
//------------------------------------------------------------------------------
// Normalize each equation of the model (endgenous_i = f_i(endogenous_1, ..., endogenous_n) - in order to apply strong connex components search algorithm -
// and find the optimal blocks triangular decomposition
bool
BlockTriangular::Normalize_and_BlockDecompose(bool* IM, Model_Block* ModelBlock, int n, int* prologue, int* epilogue, simple* Index_Var_IM, simple* Index_Equ_IM, bool Do_Normalization, bool mixing, bool* IM_0)
{
int i, j, Nb_TotalBlocks, Nb_RecursBlocks;
int count_Block, count_Equ;
block_result_t* res;
List_IM * p_First_IM, *p_Cur_IM, *Cur_IM;
Equation_set* Equation_gr = (Equation_set*) malloc(sizeof(Equation_set));
p_First_IM = (List_IM*)malloc(sizeof(*p_First_IM));
p_Cur_IM = p_First_IM;
Cur_IM = First_IM;
i = endo_nbr * endo_nbr;
while(Cur_IM)
{
p_Cur_IM->lead_lag = Cur_IM->lead_lag;
p_Cur_IM->IM = (bool*)malloc(i * sizeof(bool));
memcpy ( p_Cur_IM->IM, Cur_IM->IM, i);
Cur_IM = Cur_IM->pNext;
if(Cur_IM)
{
p_Cur_IM->pNext = (List_IM*)malloc(sizeof(*p_Cur_IM));
p_Cur_IM = p_Cur_IM->pNext;
}
else
p_Cur_IM->pNext = NULL;
}
Prologue_Epilogue(IM, prologue, epilogue, n, Index_Var_IM, Index_Equ_IM);
if(bt_verbose)
{
cout << "prologue : " << *prologue << " epilogue : " << *epilogue << "\n";
Print_SIM(IM, n);
for(i = 0;i < n;i++)
cout << "Index_Var_IM[" << i << "]=" << Index_Var_IM[i].index << " Index_Equ_IM[" << i << "]=" << Index_Equ_IM[i].index << "\n";
}
if(Do_Normalization)
{
cout << "Normalizing the model ...\n";
if(mixing)
{
bool* SIM0;
SIM0 = (bool*)malloc(n * n * sizeof(bool));
for(i = 0;i < n*n;i++)
SIM0[i] = IM_0[i];
for(i = 0;i < n;i++)
for(j = 0;j < n;j++)
IM_0[i*n + j] = SIM0[Index_Equ_IM[i].index * n + Index_Var_IM[j].index];
free(SIM0);
normalization.Normalize(n, *prologue, *epilogue, IM_0, Index_Equ_IM, Equation_gr, 1, IM);
}
else
normalization.Normalize(n, *prologue, *epilogue, IM, Index_Equ_IM, Equation_gr, 0, 0);
}
else
normalization.Gr_to_IM_basic(n, *prologue, *epilogue, IM, Equation_gr, false);
cout << "Finding the optimal block decomposition of the model ...\n";
if(bt_verbose)
blocks.Print_Equation_gr(Equation_gr);
res = blocks.sc(Equation_gr);
if(bt_verbose)
blocks.block_result_print(res);
if ((*prologue) || (*epilogue))
j = 1;
else
j = 0;
for(i = 0;i < res->n_sets;i++)
if ((res->sets_f[i] - res->sets_s[i] + 1) > j)
j = res->sets_f[i] - res->sets_s[i] + 1;
Nb_RecursBlocks = *prologue + *epilogue;
Nb_TotalBlocks = res->n_sets + Nb_RecursBlocks;
cout << Nb_TotalBlocks << " block(s) found:\n";
cout << " " << Nb_RecursBlocks << " recursive block(s) and " << res->n_sets << " simultaneous block(s). \n";
cout << " the largest simultaneous block has " << j << " equation(s). \n";
ModelBlock->Size = Nb_TotalBlocks;
ModelBlock->Periods = periods;
ModelBlock->in_Block_Equ = (int*)malloc(n * sizeof(int));
ModelBlock->in_Block_Var = (int*)malloc(n * sizeof(int));
ModelBlock->in_Equ_of_Block = (int*)malloc(n * sizeof(int));
ModelBlock->in_Var_of_Block = (int*)malloc(n * sizeof(int));
ModelBlock->Block_List = (Block*)malloc(sizeof(ModelBlock->Block_List[0]) * Nb_TotalBlocks);
blocks.block_result_to_IM(res, IM, *prologue, endo_nbr, Index_Equ_IM, Index_Var_IM);
Free_IM(p_First_IM);
count_Equ = count_Block = 0;
if (*prologue)
Allocate_Block(*prologue, &count_Equ, &count_Block, PROLOGUE, ModelBlock);
for(j = 0;j < res->n_sets;j++)
{
if(res->sets_f[res->ordered[j]] == res->sets_s[res->ordered[j]])
Allocate_Block(res->sets_f[res->ordered[j]] - res->sets_s[res->ordered[j]] + 1, &count_Equ, &count_Block, PROLOGUE, ModelBlock);
else
Allocate_Block(res->sets_f[res->ordered[j]] - res->sets_s[res->ordered[j]] + 1, &count_Equ, &count_Block, SIMULTANS, ModelBlock);
}
if (*epilogue)
Allocate_Block(*epilogue, &count_Equ, &count_Block, EPILOGUE, ModelBlock);
return 0;
}
//------------------------------------------------------------------------------
// For the contemparenous simultaneities
// normalize each equation of the model
// and find the optimal block triangular decomposition
void
BlockTriangular::Normalize_and_BlockDecompose_0()
{
int i;
List_IM* Cur_IM;
#ifdef DEBUG
cout << "Normalize_and_BlockDecompose_0 \n";
#endif
Index_Equ_IM = (simple*)malloc(endo_nbr * sizeof(*Index_Equ_IM));
for(i = 0;i < endo_nbr;i++)
{
Index_Equ_IM[i].index = i;
Index_Equ_IM[i].available = 1;
}
Index_Var_IM = (simple*)malloc(endo_nbr * sizeof(*Index_Var_IM));
for(i = 0;i < endo_nbr;i++)
{
Index_Var_IM[i].index = i;
Index_Var_IM[i].available = 1;
}
Cur_IM = Get_IM(0);
Normalize_and_BlockDecompose(Cur_IM->IM, ModelBlock, endo_nbr, &prologue, &epilogue, Index_Var_IM, Index_Equ_IM, 1, 0, NULL);
}
//------------------------------------------------------------------------------
// normalize each equation of the statitic model
// and find the optimal block triangular decomposition
void
BlockTriangular::Normalize_and_BlockDecompose_Inside_Earth()
{
bool *SIM, *SIM1;
int i, j, blk, Size, Nb_blk, k, k1, k2, n0, n, k1_block;
int prologue, epilogue;
bool OK;
simple *Index_Equ_IM, *Index_Var_IM;
Model_Block *ModelBlock_Earth;
//First create a the incidence matrix of each stack block
n0 = endo_nbr;
for(blk = 0;blk < ModelBlock->Size;blk++)
{
if(ModelBlock->Block_List[blk].Type == SIMULTANS)
{
Size = (n = ModelBlock->Block_List[blk].Size) * (Nb_blk = (max(ModelBlock->Block_List[blk].Max_Lag, ModelBlock->Block_List[blk].Max_Lead)) + 1);
SIM = (bool*)malloc(Size * Size * sizeof(*SIM));
memset (SIM, 0, Size*Size*sizeof(*SIM));
k1_block = n * n * Nb_blk;
for(k1 = 0;k1 < Nb_blk;k1++)
{
for(k2 = 0;k2 < Nb_blk;k2++)
{
k = k2 - k1;
OK = 1;
if(k < 0)
if( -k > ModelBlock->Block_List[blk].Max_Lag)
OK = 0;
if(k > 0)
if(k > ModelBlock->Block_List[blk].Max_Lead)
OK = 0;
if(OK)
{
SIM1 = Get_IM(k)->IM;
for(i = 0;i < n;i++)
for(j = 0;j < n;j++)
SIM[i*Size + k1*k1_block + j + k2*n] = SIM1[ModelBlock->Block_List[blk].Equation[i] * n0 + ModelBlock->Block_List[blk].Variable[j]];
}
}
}
if(bt_verbose)
cout << "incidence matrix for the static model (unsorted) \n";
Index_Equ_IM = (simple*)malloc(Size * sizeof(*Index_Equ_IM));
for(i = 0;i < Size;i++)
{
Index_Equ_IM[i].index = i;
Index_Equ_IM[i].available = 1;
}
Index_Var_IM = (simple*)malloc(Size * sizeof(*Index_Var_IM));
for(i = 0;i < Size;i++)
{
Index_Var_IM[i].index = i;
Index_Var_IM[i].available = 1;
}
ModelBlock_Earth = (Model_Block*)malloc(sizeof(Model_Block));
Normalize_and_BlockDecompose(SIM, ModelBlock_Earth, Size, &prologue, &epilogue, Index_Var_IM, Index_Equ_IM, 0, 0, NULL);
}
}
}
//------------------------------------------------------------------------------
// normalize each equation of the statitic model
// and find the optimal block triangular decomposition
void
BlockTriangular::Normalize_and_BlockDecompose_Static_Model()
{
bool* SIM;
List_IM* Cur_IM;
int i;
//First create a static model incidence matrix
SIM = (bool*)malloc(endo_nbr * endo_nbr * sizeof(*SIM));
for(i = 0;i < endo_nbr*endo_nbr;i++)
{
SIM[i] = 0;
Cur_IM = First_IM;
while(Cur_IM)
{
SIM[i] = (SIM[i]) || (Cur_IM->IM[i]);
Cur_IM = Cur_IM->pNext;
}
}
if(bt_verbose)
{
cout << "incidence matrix for the static model (unsorted) \n";
Print_SIM(SIM, endo_nbr);
}
Index_Equ_IM = (simple*)malloc(endo_nbr * sizeof(*Index_Equ_IM));
for(i = 0;i < endo_nbr;i++)
{
Index_Equ_IM[i].index = i;
Index_Equ_IM[i].available = 1;
}
Index_Var_IM = (simple*)malloc(endo_nbr * sizeof(*Index_Var_IM));
for(i = 0;i < endo_nbr;i++)
{
Index_Var_IM[i].index = i;
Index_Var_IM[i].available = 1;
}
if(ModelBlock != NULL)
Free_Block(ModelBlock);
ModelBlock = (Model_Block*)malloc(sizeof(*ModelBlock));
Normalize_and_BlockDecompose(SIM, ModelBlock, endo_nbr, &prologue, &epilogue, Index_Var_IM, Index_Equ_IM, 1, 0, NULL);
}
//------------------------------------------------------------------------------
// normalize each equation of the dynamic model
// and find the optimal block triangular decomposition of the static model

43
preprocessor/ModelBlocks.cc
View File

@ -33,11 +33,6 @@ Blocks::Blocks()
//Empty
}
Blocks::~Blocks()
{
//Empty
}
int n_sc_set=0;
void
@ -291,44 +286,6 @@ Blocks::block_result_to_IM(block_result_t *r,bool* IM,int prologue, int n,simple
free(SIM);
}
Equation_set*
Blocks::Equation_gr_IM( int n , bool* IM)
{
Equation_set *g;
Equation_vertex *vertices;
Edge *edge_ptr;
int i,j;
g = (Equation_set*)malloc(sizeof(Equation_set));
vertices = g->Number = (Equation_vertex*)malloc(n*sizeof(Equation_vertex));
g->size = n;
for(i = 0; i < n; i++)
{
vertices[i].First_Edge = NULL;
for(j=0; j<n;j++)
{
if (IM[j*n+i])
{
if (vertices[i].First_Edge==NULL)
{
vertices[i].First_Edge=(Edge*)malloc(sizeof(Edge));
edge_ptr=vertices[i].First_Edge;
edge_ptr->Vertex_Index=j;
edge_ptr->next= NULL;
}
else
{
edge_ptr=(Edge*)malloc(sizeof(Edge));
edge_ptr->Vertex_Index=j;
edge_ptr->next= NULL;
}
}
}
}
return g;
}
void
Blocks::Print_Equation_gr(Equation_set* Equation)
{

37
preprocessor/ModelNormalization.cc
View File

@ -30,16 +30,9 @@ using namespace std;
Normalization::Normalization(const SymbolTable &symbol_table_arg) :
symbol_table(symbol_table_arg)
symbol_table(symbol_table_arg), fp_verbose(false)
{
//Empty
fp_verbose=false;
};
Normalization::~Normalization()
{
//Empty
};
}
void
Normalization::IM_to_Gr(int n0, int prologue, int epilogue, bool* IM, Equation_set *Equation, Variable_set *Variable )
@ -484,32 +477,6 @@ Normalization::Free_All(int n, Equation_set* Equation, Variable_set* Variable)
Free_Other(Variable);
}
void
Normalization::ErrorHandling(int n, bool* IM, simple* Index_Equ_IM)
{
int i, j, k, k1, k2;
for(i = 0;i < n;i++)
{
k = 0;
for(j = 0;j < n;j++)
k += (int)IM[j * n + Index_Equ_IM[i].index];
if(k == 0)
cout << " the variable " << getnamebyID(eEndogenous, Index_Equ_IM[i].index) << " does not appear in any equation \n";
for(j = i + 1;j < n;j++)
{
k1 = k2 = 0;
for(k = 0;k < n;k++)
{
k1 = k1 + (int)(IM[Index_Equ_IM[i].index * n + k] != IM[Index_Equ_IM[j].index * n + k]);
k2 = k2 + (int)IM[Index_Equ_IM[i].index * n + k];
}
if ((k1 == 0)&(k2 == 1))
cout << " the variable " << getnamebyID(eEndogenous, Index_Equ_IM[i].index) << " is the only endogenous variable in equations " << Index_Equ_IM[i].index + 1 << " and " << Index_Equ_IM[j].index + 1 << "\n";
}
}
}
void
Normalization::Set_fp_verbose(bool ok)
{

602
preprocessor/Model_Graph.cc
View File

@ -132,34 +132,6 @@ void Check_Graph(t_model_graph* model_graph)
}
}
void
copy_model_graph(t_model_graph* model_graph, t_model_graph* saved_model_graph, int nb_endo, int y_kmax)
{
int i, j;
saved_model_graph->nb_vertices = model_graph->nb_vertices;
saved_model_graph->vertex = (t_vertex*)malloc(model_graph->nb_vertices * sizeof(*model_graph->vertex));
for(i = 0;i < model_graph->nb_vertices;i++)
{
saved_model_graph->vertex[i].index = model_graph->vertex[i].index;
saved_model_graph->vertex[i].nb_in_degree_edges = model_graph->vertex[i].nb_in_degree_edges;
saved_model_graph->vertex[i].in_degree_edge = (t_edge*)malloc((y_kmax + 2) * nb_endo * sizeof(t_edge));
for(j = 0;j < model_graph->vertex[i].nb_in_degree_edges;j++)
{
saved_model_graph->vertex[i].in_degree_edge[j].index = model_graph->vertex[i].in_degree_edge[j].index;
saved_model_graph->vertex[i].in_degree_edge[j].u_count = model_graph->vertex[i].in_degree_edge[j].u_count;
}
saved_model_graph->vertex[i].nb_out_degree_edges = model_graph->vertex[i].nb_out_degree_edges;
saved_model_graph->vertex[i].out_degree_edge = (t_edge*)malloc((y_kmax + 2) * nb_endo * sizeof(t_edge));
for(j = 0;j < model_graph->vertex[i].nb_out_degree_edges;j++)
{
saved_model_graph->vertex[i].out_degree_edge[j].index = model_graph->vertex[i].out_degree_edge[j].index;
saved_model_graph->vertex[i].out_degree_edge[j].u_count = model_graph->vertex[i].out_degree_edge[j].u_count;
}
}
}
int
ModelBlock_Graph(Model_Block *ModelBlock, int Blck_num, bool dynamic, t_model_graph* model_graph, int nb_endo, int* block_u_count, int *starting_vertex, int *periods, int *nb_table_y, int *mean_var_in_equ)
{
@ -504,577 +476,3 @@ ModelBlock_Graph(Model_Block *ModelBlock, int Blck_num, bool dynamic, t_model_gr
return (u_count);
}
}
void
IM_to_model_graph(List_IM* First_IM, int Time, int endo, int *y_kmin, int *y_kmax, t_model_graph* model_graph, int *nb_endo, int *stacked_time, double** u1, int *u_count
#ifdef VERIF
, Matrix *B, Matrix *D
#endif
)
{
int i, j, t, n, k, l=0, k_k_in = 0, m;
t_pList* Endo;
List_IM* Curr_IM;
int nb_IM = 0;
int Max_edge = 0;
#ifdef STACKED
int k_block = 0;
#endif
bool OK;
*nb_endo = endo;
Curr_IM = First_IM;
while(Curr_IM)
{
if(Curr_IM->lead_lag > *y_kmax)
*y_kmax = Curr_IM->lead_lag;
if( -Curr_IM->lead_lag > *y_kmin)
*y_kmin = -Curr_IM->lead_lag;
Curr_IM = Curr_IM->pNext;
nb_IM++;
}
Endo = (t_pList*)malloc(endo * sizeof(t_pList));
for(i = 0;i < endo;i++)
{
Endo[i].Lag_in = (int*)malloc((*y_kmin + *y_kmax + 1) * sizeof(int));
Endo[i].Lag_out = (int*)malloc((*y_kmin + *y_kmax + 1) * sizeof(int));
memset(Endo[i].Lag_in, 0, (*y_kmin + *y_kmax + 1)*sizeof(int));
memset(Endo[i].Lag_out, 0, (*y_kmin + *y_kmax + 1)*sizeof(int));
Endo[i].CurrNb_in = Endo[i].CurrNb_out = 0;
}
Curr_IM = First_IM;
while(Curr_IM)
{
k = Curr_IM->lead_lag + *y_kmin;
for(i = 0;i < endo;i++)
for(j = 0;j < endo;j++)
if(Curr_IM->IM[i*endo + j])
{
Endo[i].Lag_in[k]++;
Endo[j].Lag_out[k]++;
}
Curr_IM = Curr_IM->pNext;
}
for(i = 0;i < endo;i++)
{
for(j = 0;j < *y_kmax + *y_kmin + 1;j++)
{
Endo[i].CurrNb_in += Endo[i].Lag_in[j];
Endo[i].CurrNb_out += Endo[i].Lag_out[j];
}
if(Endo[i].CurrNb_in + 2 > Max_edge)
Max_edge = Endo[i].CurrNb_in + 2;
if(Endo[i].CurrNb_out + 2 > Max_edge)
Max_edge = Endo[i].CurrNb_out + 2;
}
*stacked_time = Time;
Max_edge = Max_edge * Max_edge;
#ifdef VERIF
B->resize(Time*endo, Time*endo);
D->resize(Time*endo, 1);
*B = B->zeros();
*D = D->zeros();
#endif
int size_c_in, size_c_out, total_edge = 0;
model_graph->nb_vertices = endo * (*stacked_time) + 1;
model_graph->vertex = (t_vertex*)malloc(model_graph->nb_vertices * sizeof(*model_graph->vertex));
for(t = 0;t < *stacked_time;t++)
{
if(t > 0)
{
if(t <= *y_kmin)
for(i = 0;i < endo;i++)
Endo[i].CurrNb_in += Endo[i].Lag_in[*y_kmin - t];
if(t <= *y_kmax)
for(i = 0;i < endo;i++)
Endo[i].CurrNb_out += Endo[i].Lag_out[*y_kmin + t];
}
if(t >= (*stacked_time - *y_kmax))
{
for(i = 0;i < endo;i++)
Endo[i].CurrNb_in -= Endo[i].Lag_in[*y_kmin + (*stacked_time - t)];
}
if(t >= (*stacked_time - *y_kmin))
{
for(i = 0;i < endo;i++)
Endo[i].CurrNb_out -= Endo[i].Lag_out[*y_kmin - (*stacked_time - t)];
}
for(j = 0;j < endo;j++)
{
size_c_in = endo * (*y_kmin + *y_kmax + 1) + 2;
size_c_out = endo * (*y_kmin + *y_kmax + 1) + 2;
total_edge += size_c_out - 1;
l = t * endo + j;
#ifdef STACKED
if(t - *y_kmax - *y_kmin - 2 > 0)
model_graph->vertex[l].index = l + (Time - *y_kmax - *y_kmin - 2) * endo;
else
model_graph->vertex[l].index = l;
#else
model_graph->vertex[l].index = l;
#endif
model_graph->vertex[l].in_degree_edge = (t_edge*)malloc(size_c_in * sizeof(t_edge));
model_graph->vertex[l].out_degree_edge = (t_edge*)malloc(size_c_out * sizeof(t_edge));
model_graph->vertex[l].nb_in_degree_edges = 0;
model_graph->vertex[l].nb_out_degree_edges = 0;
}
}
total_edge += *stacked_time * endo;
for(i = 0;i < endo;i++)
{
free(Endo[i].Lag_in);
free(Endo[i].Lag_out);
}
free(Endo);
*u1 = (double*)malloc((total_edge) * sizeof(double));
model_graph->vertex[l + 1].in_degree_edge = (t_edge*)malloc(0 * sizeof(t_edge));
model_graph->vertex[l + 1].out_degree_edge = (t_edge*)malloc((*stacked_time * endo) * sizeof(t_edge));
model_graph->vertex[l + 1].index = l + 1;
model_graph->vertex[l + 1].nb_in_degree_edges = 0;
model_graph->vertex[l + 1].nb_out_degree_edges = 0;
for(t = 0;t < *stacked_time;t++)
{
Curr_IM = First_IM;
while(Curr_IM)
{
if(Curr_IM->lead_lag < 0)
{
if(t >= abs(Curr_IM->lead_lag))
OK = 1;
else
OK = 0;
}
else
{
if(*stacked_time - t > Curr_IM->lead_lag)
OK = 1;
else
OK = 0;
}
if(OK)
{
l = (t + Curr_IM->lead_lag) * endo;
for(j = 0;j < endo;j++)
{
n = t * endo + j;
for(k = 0;k < endo;k++)
{
if(Curr_IM->IM[j*endo + k])
{
model_graph->vertex[n].in_degree_edge[model_graph->vertex[n].nb_in_degree_edges].index = l + k;
model_graph->vertex[n].in_degree_edge[model_graph->vertex[n].nb_in_degree_edges].u_count =
*u_count;
(*u1)[*u_count] = (double)rand() / RAND_MAX;
#ifdef VERIF
(*B)[n][l + k] = -(*u1)[*u_count];
#endif
(*u_count)++;
model_graph->vertex[n].nb_in_degree_edges++;
}
}
if(Curr_IM->lead_lag == 0)
{
model_graph->vertex[n].in_degree_edge[model_graph->vertex[n].nb_in_degree_edges].index =
endo * (*stacked_time);
model_graph->vertex[n].in_degree_edge[model_graph->vertex[n].nb_in_degree_edges].u_count =
*u_count;
(*u1)[*u_count] = (double)rand() / RAND_MAX;
#ifdef VERIF
(*D)[n][0] = (*u1)[*u_count];
#endif
(*u_count)++;
model_graph->vertex[n].nb_in_degree_edges++;
}
k_k_in += model_graph->vertex[n].nb_in_degree_edges;
}
n = t * endo;
for(j = 0;j < endo;j++)
{
l = (t + Curr_IM->lead_lag) * endo + j;
for(k = 0;k < endo;k++)
{
if(Curr_IM->IM[k*endo + j])
{
model_graph->vertex[l].out_degree_edge[model_graph->vertex[l].nb_out_degree_edges].index = n + k;
for(m = 0;m < model_graph->vertex[n + k].nb_in_degree_edges;m++)
if(model_graph->vertex[n + k].in_degree_edge[m].index == l)
{
model_graph->vertex[l].out_degree_edge[model_graph->vertex[l].nb_out_degree_edges].u_count =
model_graph->vertex[n + k].in_degree_edge[m].u_count;
}
model_graph->vertex[l].nb_out_degree_edges++;
}
}
}
}
Curr_IM = Curr_IM->pNext;
}
}
l = endo * (*stacked_time);
for(j = 0;j < l;j++)
{
model_graph->vertex[l].out_degree_edge[model_graph->vertex[l].nb_out_degree_edges].index = j;
for(m = 0;m < model_graph->vertex[j].nb_in_degree_edges;m++)
if(model_graph->vertex[j].in_degree_edge[m].index == l)
{
model_graph->vertex[l].out_degree_edge[model_graph->vertex[l].nb_out_degree_edges].u_count =
model_graph->vertex[j].in_degree_edge[m].u_count;
}
model_graph->vertex[l].nb_out_degree_edges++;
}
cout << "mean element by equation : " << (double)(k_k_in) / ((*stacked_time)*endo) << "\n";
}
void
IM_to_model_graph_new(List_IM* First_IM, int Time, int endo, int *y_kmin, int *y_kmax, t_model_graph* model_graph, int * nb_endo, int *stacked_time, double** u1, int* u_count
#ifdef VERIF
, Matrix* B, Matrix* D
#endif
)
{
int i, j, t, n, k, l=0, k_k_in = 0, m, u_count_per_period, s_u_count, bi;
t_pList* Endo;
List_IM* Curr_IM;
int nb_IM = 0;
int Max_edge = 0;
#ifdef STACKED
int k_block = 0;
#endif
bool OK;
*nb_endo = endo;
Curr_IM = First_IM;
while(Curr_IM)
{
if(Curr_IM->lead_lag > *y_kmax)
*y_kmax = Curr_IM->lead_lag;
if( -Curr_IM->lead_lag > *y_kmin)
*y_kmin = -Curr_IM->lead_lag;
Curr_IM = Curr_IM->pNext;
nb_IM++;
}
Endo = (t_pList*)malloc(endo * sizeof(t_pList));
for(i = 0;i < endo;i++)
{
Endo[i].Lag_in = (int*)malloc((*y_kmin + *y_kmax + 1) * sizeof(int));
Endo[i].Lag_out = (int*)malloc((*y_kmin + *y_kmax + 1) * sizeof(int));
memset(Endo[i].Lag_in, 0, (*y_kmin + *y_kmax + 1)*sizeof(int));
memset(Endo[i].Lag_out, 0, (*y_kmin + *y_kmax + 1)*sizeof(int));
Endo[i].CurrNb_in = Endo[i].CurrNb_out = 0;
}
Curr_IM = First_IM;
while(Curr_IM)
{
k = Curr_IM->lead_lag + *y_kmin;
for(i = 0;i < endo;i++)
for(j = 0;j < endo;j++)
if(Curr_IM->IM[i*endo + j])
{
Endo[i].Lag_in[k]++;
Endo[j].Lag_out[k]++;
}
Curr_IM = Curr_IM->pNext;
}
for(i = 0;i < endo;i++)
{
for(j = 0;j < *y_kmax + *y_kmin + 1;j++)
{
Endo[i].CurrNb_in += Endo[i].Lag_in[j];
Endo[i].CurrNb_out += Endo[i].Lag_out[j];
}
if(Endo[i].CurrNb_in + 2 > Max_edge)
Max_edge = Endo[i].CurrNb_in + 2;
if(Endo[i].CurrNb_out + 2 > Max_edge)
Max_edge = Endo[i].CurrNb_out + 2;
}
*stacked_time = Time;
Max_edge = Max_edge * Max_edge;
cout << "Max_edge=" << Max_edge << "\n";
#ifdef VERIF
B->resize(Time*endo, Time*endo);
D->resize(Time*endo, 1);
*B = B->zeros();
*D = D->zeros();
#endif
int size_c_in, size_c_out, total_edge = 0;
model_graph->nb_vertices = endo * (*stacked_time) + 1;
model_graph->vertex = (t_vertex*)malloc(model_graph->nb_vertices * sizeof(*model_graph->vertex));
bi = (*y_kmin) + /*6*/20;
for(t = 0;t < *stacked_time;t++)
{
if(t > 0)
{
if(t <= *y_kmin)
for(i = 0;i < endo;i++)
Endo[i].CurrNb_in += Endo[i].Lag_in[*y_kmin - t];
if(t <= *y_kmax)
for(i = 0;i < endo;i++)
Endo[i].CurrNb_out += Endo[i].Lag_out[*y_kmin + t];
}
if(t >= (*stacked_time - *y_kmax))
{
for(i = 0;i < endo;i++)
Endo[i].CurrNb_in -= Endo[i].Lag_in[*y_kmin + (*stacked_time - t)];
}
if(t >= (*stacked_time - *y_kmin))
{
for(i = 0;i < endo;i++)
Endo[i].CurrNb_out -= Endo[i].Lag_out[*y_kmin - (*stacked_time - t)];
}
for(j = 0;j < endo;j++)
{
size_c_in = endo * (*y_kmin + *y_kmax + 1) + 2;
size_c_out = endo * (*y_kmin + *y_kmax + 1) + 2;
total_edge += size_c_out - 1;
l = t * endo + j;
#ifdef STACKED
if(t - *y_kmax - *y_kmin - 2 > 0)
model_graph->vertex[l].index = l + (Time - *y_kmax - *y_kmin - 2) * endo;
else
model_graph->vertex[l].index = l;
#else
model_graph->vertex[l].index = l;
#endif
if((t < bi + 1 ) || (t > *stacked_time - *y_kmax - 5))
{
model_graph->vertex[l].in_degree_edge = (t_edge*)malloc(size_c_in * sizeof(t_edge));
model_graph->vertex[l].out_degree_edge = (t_edge*)malloc(size_c_out * sizeof(t_edge));
}
else
{
#ifdef PRINT_OUT
cout << "nothing allocated for l=" << l << "\n";
#endif
model_graph->vertex[l].in_degree_edge = (t_edge*)malloc(0 * sizeof(t_edge));
model_graph->vertex[l].out_degree_edge = (t_edge*)malloc(0 * sizeof(t_edge));
}
model_graph->vertex[l].nb_in_degree_edges = 0;
model_graph->vertex[l].nb_out_degree_edges = 0;
}
}
total_edge += *stacked_time * endo;
for(i = 0;i < endo;i++)
{
free(Endo[i].Lag_in);
free(Endo[i].Lag_out);
}
free(Endo);
*u1 = (double*)malloc((total_edge) * sizeof(double));
model_graph->vertex[l + 1].in_degree_edge = (t_edge*)malloc(0 * sizeof(t_edge));
model_graph->vertex[l + 1].out_degree_edge = (t_edge*)malloc((*stacked_time * endo) * sizeof(t_edge));
model_graph->vertex[l + 1].index = l + 1;
model_graph->vertex[l + 1].nb_in_degree_edges = 0;
model_graph->vertex[l + 1].nb_out_degree_edges = 0;
s_u_count = *u_count;
for(t = 0;t < *stacked_time;t++)
{
if((t < bi) || (t > *stacked_time - *y_kmax - 4))
{
u_count_per_period = *u_count;
Curr_IM = First_IM;
while(Curr_IM)
{
if(Curr_IM->lead_lag < 0)
{
if(t >= abs(Curr_IM->lead_lag))
OK = 1;
else
OK = 0;
}
else
{
if(*stacked_time - t > Curr_IM->lead_lag)
OK = 1;
else
OK = 0;
}
if(OK)
{
l = (t + Curr_IM->lead_lag) * endo;
for(j = 0;j < endo;j++)
{
n = t * endo + j;
for(k = 0;k < endo;k++)
{
if(Curr_IM->IM[j*endo + k])
{
model_graph->vertex[n].in_degree_edge[model_graph->vertex[n].nb_in_degree_edges].index = l + k;
model_graph->vertex[n].in_degree_edge[model_graph->vertex[n].nb_in_degree_edges].u_count =
*u_count;
(*u1)[*u_count] = (double)rand() / RAND_MAX;
#ifdef VERIF
(*B)[n][l + k] = -(*u1)[*u_count];
#endif
(*u_count)++;
model_graph->vertex[n].nb_in_degree_edges++;
}
}
if(Curr_IM->lead_lag == 0)
{
model_graph->vertex[n].in_degree_edge[model_graph->vertex[n].nb_in_degree_edges].index =
endo * (*stacked_time);
model_graph->vertex[n].in_degree_edge[model_graph->vertex[n].nb_in_degree_edges].u_count =
*u_count;
(*u1)[*u_count] = (double)rand() / RAND_MAX;
#ifdef VERIF
(*D)[n][0] = (*u1)[*u_count];
#endif
(*u_count)++;
model_graph->vertex[n].nb_in_degree_edges++;
}
k_k_in += model_graph->vertex[n].nb_in_degree_edges;
}
n = t * endo;
for(j = 0;j < endo;j++)
{
l = (t + Curr_IM->lead_lag) * endo + j;
for(k = 0;k < endo;k++)
{
if(Curr_IM->IM[k*endo + j])
{
cout << "l=" << l << " (*stacked_time*endo)=" << (*stacked_time*endo) << " model_graph->vertex[l].nb_out_degree_edges= " << model_graph->vertex[l].nb_out_degree_edges << "\n";
model_graph->vertex[l].out_degree_edge[model_graph->vertex[l].nb_out_degree_edges].index = n + k;
for(m = 0;m < model_graph->vertex[n + k].nb_in_degree_edges;m++)
if(model_graph->vertex[n + k].in_degree_edge[m].index == l)
{
model_graph->vertex[l].out_degree_edge[model_graph->vertex[l].nb_out_degree_edges].u_count =
model_graph->vertex[n + k].in_degree_edge[m].u_count;
}
model_graph->vertex[l].nb_out_degree_edges++;
}
}
}
}
Curr_IM = Curr_IM->pNext;
}
u_count_per_period = *u_count - u_count_per_period;
}
else
{
for(j = 0;j < u_count_per_period;j++)
(*u1)[*u_count + j] = (double)rand() / RAND_MAX;
*u_count += u_count_per_period;
}
}
#ifdef VERIF
*u_count = s_u_count;
for(t = 0;t < *stacked_time;t++)
{
Curr_IM = First_IM;
while(Curr_IM)
{
if(Curr_IM->lead_lag < 0)
{
if(t >= abs(Curr_IM->lead_lag))
OK = 1;
else
OK = 0;
}
else
{
if(*stacked_time - t > Curr_IM->lead_lag)
OK = 1;
else
OK = 0;
}
if(OK)
{
l = (t + Curr_IM->lead_lag) * endo;
for(j = 0;j < endo;j++)
{
n = t * endo + j;
for(k = 0;k < endo;k++)
{
if(Curr_IM->IM[j*endo + k])
{
(*B)[n][l + k] = -(*u1)[*u_count];
(*u_count)++;
}
}
if(Curr_IM->lead_lag == 0)
{
(*D)[n][0] = (*u1)[*u_count];
(*u_count)++;
}
}
}
Curr_IM = Curr_IM->pNext;
}
}
#endif
l = endo * (*stacked_time);
for(j = 0;j < l;j++)
{
model_graph->vertex[l].out_degree_edge[model_graph->vertex[l].nb_out_degree_edges].index = j;
model_graph->vertex[l].out_degree_edge[model_graph->vertex[l].nb_out_degree_edges].u_count = -1;
for(m = 0;m < model_graph->vertex[j].nb_in_degree_edges;m++)
if(model_graph->vertex[j].in_degree_edge[m].index == l)
{
model_graph->vertex[l].out_degree_edge[model_graph->vertex[l].nb_out_degree_edges].u_count =
model_graph->vertex[j].in_degree_edge[m].u_count;
}
model_graph->vertex[l].nb_out_degree_edges++;
}
}
void
reduce_model_graph(t_model_graph* model_graph, int pos)
{
int i, j, k;
if(pos > 0)
{
for(i = 0;i < pos;i++)
{
free(model_graph->vertex[i].in_degree_edge);
free(model_graph->vertex[i].out_degree_edge);
}
for(i = pos;i < model_graph->nb_vertices;i++)
model_graph->vertex[i - pos] = model_graph->vertex[i];
model_graph->nb_vertices -= pos;
for(i = 0;i < model_graph->nb_vertices;i++)
{
for(j = 0;j < model_graph->vertex[i].nb_in_degree_edges;j++)
if(model_graph->vertex[i].in_degree_edge[j].index < pos)
{
for(k = j + 1;k < model_graph->vertex[i].nb_in_degree_edges;k++)
{
model_graph->vertex[i].in_degree_edge[k - 1].index = model_graph->vertex[i].in_degree_edge[k].index;
model_graph->vertex[i].in_degree_edge[k - 1].u_count = model_graph->vertex[i].in_degree_edge[k].u_count;
}
j--;
model_graph->vertex[i].nb_in_degree_edges--;
}
else
model_graph->vertex[i].in_degree_edge[j].index -= pos;
for(j = 0;j < model_graph->vertex[i].nb_out_degree_edges;j++)
if(model_graph->vertex[i].out_degree_edge[j].index < pos)
{
for(k = j + 1;k < model_graph->vertex[i].nb_out_degree_edges;k++)
{
model_graph->vertex[i].out_degree_edge[k - 1].index = model_graph->vertex[i].out_degree_edge[k].index;
model_graph->vertex[i].out_degree_edge[k - 1].u_count = model_graph->vertex[i].out_degree_edge[k].u_count;
}
j--;
model_graph->vertex[i].nb_out_degree_edges--;
}
else
model_graph->vertex[i].out_degree_edge[j].index -= pos;
}
}
}

130
preprocessor/SymbolGaussElim.cc
View File

@ -43,38 +43,7 @@ SymbolicGaussElimination::SymbolicGaussElimination()
}
#ifdef SIMPLIFY
void
SymbolicGaussElimination::list_table_u(int pos)
{
int i;
t_table_u *table_u;
table_u = First_table_u->pNext;
i = 0;
while(table_u)
{
if((table_u->type > 7) || (table_u->type < 1))
{
cout << "Error : table_u->type=" << int(table_u->type) << " i=" << i << " pos=" << pos << "\n";
system("pause");
exit( -1);
}
i++;
table_u = table_u->pNext;
}
}
//==================================================================================
void
SymbolicGaussElimination::print_free_u_list()
{
int i;
cout << "nb_free_u_list : " << nb_free_u_list << " \n";
cout << "-----------------------------------------------\n";
for(i = 0;i < nb_free_u_list;i++)
cout << i << " " << free_u_list[i] << "\n";
}
//==================================================================================
void
SymbolicGaussElimination::set_free_u_list(int index)
{
@ -223,99 +192,6 @@ SymbolicGaussElimination::write_to_file_table_y( t_table_y *save_table_y, t_tabl
}
}
void
SymbolicGaussElimination::write_to_file_table_u(t_table_u *save_table_u, t_table_u *save_i_table_u, int nb_save_table_u)
{
t_table_u *table_u;
SaveCode.write(reinterpret_cast<char *>(&nb_save_table_u), sizeof(nb_save_table_u));
#ifdef PRINT_OUT
cout << "**nb_save_table_u=" << nb_save_table_u << "\n";
#endif
#ifdef PRINT_OUT
cout << "**save_table_u=" << save_table_u << "\n";
#endif
while(save_table_u)
{
#ifdef PRINT_OUT
cout << "**save_table_u->type=" << int(save_table_u->type) << "\n";
#endif
switch (save_table_u->type)
{
case 3:
case 7:
SaveCode.write(reinterpret_cast<char *>(&save_table_u->type), sizeof(save_table_u->type));
SaveCode.write(reinterpret_cast<char *>(&save_table_u->index), sizeof(save_table_u->index));
SaveCode.write(reinterpret_cast<char *>(&save_table_u->op1), sizeof(save_table_u->op1));
#ifdef PRINT_OUT
if(save_table_u->type == 3)
cout << "+u[" << save_table_u->index << "]=1/(1-u[" << save_table_u->op1 << "])\n";
else
cout << "+u[" << save_table_u->index << "]*=u[" << save_table_u->op1 << "]\n";
#endif /**PRINT_OUT**/
break;
case 1:
case 2:
case 6:
SaveCode.write(reinterpret_cast<char *>(&save_table_u->type), sizeof(save_table_u->type));
SaveCode.write(reinterpret_cast<char *>(&save_table_u->index), sizeof(save_table_u->index));
SaveCode.write(reinterpret_cast<char *>(&save_table_u->op1), sizeof(save_table_u->op1));
SaveCode.write(reinterpret_cast<char *>(&save_table_u->op2), sizeof(save_table_u->op2));
#ifdef PRINT_OUT
if(save_table_u->type == 1)
cout << "+u[" << save_table_u->index << "]=" << "u[" << save_table_u->op1 << "]*u[" << save_table_u->op2 << "]\n";
else if(save_table_u->type == 2)
cout << "+u[" << save_table_u->index << "]+=u[" << save_table_u->op1 << "]*u[" << save_table_u->op2 << "]\n";
else
cout << "+u[" << save_table_u->index << "]=1/(1-u[" << save_table_u->op1 << "]*u[" << save_table_u->op2 << "])\n";
#endif /**PRINT_OUT**/
break;
case 5:
SaveCode.write(reinterpret_cast<char *>(&save_table_u->type), sizeof(save_table_u->type));
SaveCode.write(reinterpret_cast<char *>(&save_table_u->index), sizeof(save_table_u->index));
#ifdef PRINT_OUT
cout << "+push(u[" << save_table_u->index << "])\n";
#endif /**PRINT_OUT**/
break;
}
table_u = save_table_u->pNext;
free(save_table_u);
save_table_u = table_u;
}
#ifdef PRINT_OUT
cout << "save_i_table_u=" << save_i_table_u << "\n";
#endif
while(save_i_table_u)
{
switch (save_i_table_u->type)
{
case 3:
case 7:
SaveCode.write(reinterpret_cast<char *>(&save_i_table_u->type), sizeof(save_i_table_u->type));
SaveCode.write(reinterpret_cast<char *>(&save_i_table_u->index), sizeof(save_i_table_u->index));
SaveCode.write(reinterpret_cast<char *>(&save_i_table_u->op1), sizeof(save_i_table_u->op1));
break;
case 1:
case 2:
case 6:
SaveCode.write(reinterpret_cast<char *>(&save_i_table_u->type), sizeof(save_i_table_u->type));
SaveCode.write(reinterpret_cast<char *>(&save_i_table_u->index), sizeof(save_i_table_u->index));
SaveCode.write(reinterpret_cast<char *>(&save_i_table_u->op1), sizeof(save_i_table_u->op1));
SaveCode.write(reinterpret_cast<char *>(&save_i_table_u->op2), sizeof(save_i_table_u->op2));
break;
case 5:
SaveCode.write(reinterpret_cast<char *>(&save_i_table_u->type), sizeof(save_i_table_u->type));
SaveCode.write(reinterpret_cast<char *>(&save_i_table_u->index), sizeof(save_i_table_u->index));
break;
}
table_u = save_i_table_u->pNext;
free(save_i_table_u);
save_i_table_u = table_u;
}
#ifdef PRINT_OUT
cout << "nb_save_table_u=" << nb_save_table_u << "\n";
#endif
}
void
SymbolicGaussElimination::write_to_file_table_u_b(t_table_u *save_table_u, t_table_u *last_table_u, int *nb_save_table_u, bool chk)
{
@ -1871,12 +1747,6 @@ SymbolicGaussElimination::Gaussian_Elimination(t_model_graph* model_graph
free(s_j2);
}
void
SymbolicGaussElimination::file_is_open1()
{
file_open=true;
}
void
SymbolicGaussElimination::file_is_open()
{

59
preprocessor/include/BlockTriangular.hh
View File

@ -40,52 +40,31 @@ typedef struct List_IM
bool* IM;
};
typedef struct vari
{
int Size;
int* arc;
int used_arc;
int available;
};
typedef map<pair<int ,int >,double> jacob_map;
class BlockTriangular
{
public:
BlockTriangular(const SymbolTable &symbol_table_arg);
~BlockTriangular();
/*! The incidence matrix for each lead and lags */
const SymbolTable &symbol_table;
Blocks blocks;
Normalization normalization;
List_IM* Build_IM(int lead_lag);
List_IM* Get_IM(int lead_lag);
bool* bGet_IM(int lead_lag);
bool* bGet_IM(int lead_lag) const;
void fill_IM(int equation, int variable_endo, int lead_lag);
void fill_IM(int equation, int variable_endo, int lead_lag);
void unfill_IM(int equation, int variable_endo, int lead_lag);
void incidence_matrix() const;
void init_incidence_matrix(int nb_endo);
void Print_IM(int n) const;
void Free_IM(List_IM* First_IM);
void Print_SIM(bool* IM, int n) const;
void Normalize_and_BlockDecompose_Static_Model();
void Normalize_and_BlockDecompose_Static_0_Model(const jacob_map &j_m);
bool Normalize_and_BlockDecompose(bool* IM, Model_Block* ModelBlock, int n, int* prologue, int* epilogue, simple* Index_Var_IM, simple* Index_Equ_IM, bool Do_Normalization, bool mixing, bool* IM_0 );
bool Normalize_and_BlockDecompose(bool* IM, Model_Block* ModelBlock, int n, int* prologue, int* epilogue, simple* Index_Var_IM, simple* Index_Equ_IM, bool Do_Normalization, bool mixing, bool* IM_0 , jacob_map j_m);
void Normalize_and_BlockDecompose_0();
void Normalize_and_BlockDecompose_Inside_Earth();
void Prologue_Epilogue(bool* IM, int* prologue, int* epilogue, int n, simple* Index_Var_IM, simple* Index_Equ_IM);
void Sort_By_Cols(bool* IM, int d, int f);
void getMax_Lead_Lag(int var, int equ, int *lead, int *lag);
void getMax_Lead_Lag_B(int size, int* Equation, int *Variable, int *lead, int *lag);
void swap_IM_c(bool *SIM, int pos1, int pos2, int pos3, simple* Index_Var_IM, simple* Index_Equ_IM, int n);
void Allocate_Block(int size, int *count_Equ, int *count_Block, int type, Model_Block * ModelBlock);
void Free_Block(Model_Block* ModelBlock);
string getnamebyID(Type type, int id);
List_IM *First_IM ;
List_IM *Last_IM ;
simple *Index_Equ_IM;
@ -151,42 +130,6 @@ public:
break;
}
};
inline static std::string BlockSim_d(int type)
{
switch (type)
{
case EVALUATE_FOREWARD:
case EVALUATE_FOREWARD_R:
return ("EVALUATE_FOREWARD ");
break;
case EVALUATE_BACKWARD:
case EVALUATE_BACKWARD_R:
return ("EVALUATE_BACKWARD ");
break;
case SOLVE_FOREWARD_SIMPLE:
return ("SOLVE_FOREWARD_SIMPLE ");
break;
case SOLVE_BACKWARD_SIMPLE:
return ("SOLVE_BACKWARD_SIMPLE ");
break;
case SOLVE_TWO_BOUNDARIES_SIMPLE:
return ("SOLVE_TWO_BOUNDARIES_SIMPLE ");
break;
case SOLVE_FOREWARD_COMPLETE:
return ("SOLVE_FOREWARD_COMPLETE ");
break;
case SOLVE_BACKWARD_COMPLETE:
return ("SOLVE_BACKWARD_COMPLETE ");
break;
case SOLVE_TWO_BOUNDARIES_COMPLETE:
return ("SOLVE_TWO_BOUNDARIES_COMPLETE");
break;
default:
return ("UNKNOWN ");
break;
}
};
};
//------------------------------------------------------------------------------
#endif

2
preprocessor/include/ModelBlocks.hh
View File

@ -37,12 +37,10 @@ class Blocks
{
public:
Blocks();
~Blocks();
void block_depth_search(int v);
block_result_t* sc(Equation_set *g);
void block_result_free(block_result_t *r);
void block_result_print(block_result_t *r);
Equation_set* Equation_gr_IM( int n , bool* IM);
void Print_Equation_gr(Equation_set* Equation);
void block_result_to_IM(block_result_t *r,bool* IM,int prologue, int n,simple* Index_Equ_IM,simple* Index_Var_IM);
Equation_vertex *vertices;

7
preprocessor/include/ModelNormalization.hh
View File

@ -33,7 +33,7 @@ typedef struct Equation_vertex
{
Edge *First_Edge;
Edge *Next_Edge;
int matched,index;
int matched;
};
typedef struct Equation_set
@ -49,8 +49,6 @@ typedef struct simple
bool available;
};
typedef std::string (*t_getNameByID)(Type type, int id);
class Normalization
{
private:
@ -71,10 +69,8 @@ private:
};
public:
Normalization(const SymbolTable &symbol_table_arg);
~Normalization();
bool Normalize(int n, int prologue, int epilogue, bool* IM, simple* Index_Var_IM, Equation_set* Equation,bool mixing, bool* IM_s);
void Gr_to_IM_basic(int n0, int prologue, int epilogue, bool* IM, Equation_set *Equation,bool transpose);
t_getNameByID getnamebyID;
const SymbolTable &symbol_table;
void Set_fp_verbose(bool ok);
private:
@ -90,7 +86,6 @@ private:
void Free_Equation(int n, Equation_set* Equation);
void Free_Other(Variable_set* Variable);
void Free_All(int n, Equation_set* Equation, Variable_set* Variable);
void ErrorHandling(int n, bool* IM, simple* Index_Equ_IM);
int eq, eex;
int IndexUnmatched;
bool fp_verbose;

26
preprocessor/include/Model_Graph.hh
View File

@ -50,34 +50,8 @@ typedef struct t_model_graph
t_vertex* vertex;
};
typedef struct t_pList
{
int* Lag_in, * Lag_out;
int CurrNb_in, CurrNb_out;
};
void free_model_graph(t_model_graph* model_graph);
void print_Graph(t_model_graph* model_graph);
void Check_Graph(t_model_graph* model_graph);
void copy_model_graph(t_model_graph* model_graph, t_model_graph* saved_model_graph, int nb_endo, int y_kmax);
int ModelBlock_Graph(Model_Block *ModelBlock, int Blck_num,bool dynamic, t_model_graph* model_graph, int nb_endo, int *block_u_count, int *starting_vertex, int* periods, int *nb_table_y, int *mean_var_in_equ);
void IM_to_model_graph(List_IM* First_IM,int Time, int endo, int* y_kmin, int* y_kmax, t_model_graph* model_graph, int* nb_endo, int *stacked_time, double** u1, int* u_count
#ifdef VERIF
, Matrix *B, Matrix *D
#endif
);
void IM_to_model_graph_new(List_IM* First_IM,int Time, int endo, int* y_kmin, int* y_kmax, t_model_graph* model_graph, int* nb_endo, int *stacked_time, double** u1, int* u_count
#ifdef VERIF
, Matrix *B, Matrix *D
#endif
);
void IM_to_model_graph_new_new(List_IM* First_IM,int Time, int endo, int* y_kmin, int* y_kmax, t_model_graph* model_graph, int* nb_endo, int *stacked_time, double** u1, int* u_count
#ifdef VERIF
, Matrix *B, Matrix *D
#endif
);
void reduce_model_graph(t_model_graph* model_graph,int pos);
#endif

16
preprocessor/include/SymbolGaussElim.hh
View File

@ -45,8 +45,7 @@ typedef struct t_table_u
class SymbolicGaussElimination
{
public:
int y_kmin, y_kmax, nb_endo, Time, stacked_time, u_count, periods;
double* u1;
int y_kmin, y_kmax, nb_endo, Time, u_count, periods;
int *s_i1, *s_i2, *s_j2;
bool nstacked, save_direct;
int nb_loop_table;
@ -58,14 +57,13 @@ public:
int vertex_count;
t_table_u* table_u;
int nb_table_u;
t_table_u *get_table_u;
t_table_u* First_table_u;
#endif /**DIRECT_COMPUTE**/
int starting_vertex;
t_table_u *first_u_blck, *second_u_blck, *third_u_blck, *stop_table_u, *forth_u_blck;
t_table_u *first_u_blck, *second_u_blck, *third_u_blck;
int first_y_blck, second_y_blck, third_y_blck;
#ifdef SAVE
t_table_u *prologue_save_table_u, *first_save_table_u, *first_save_i_table_u, *middle_save_table_u, *middle_save_i_table_u, *last_save_table_u, *save_table_u, *save_i_table_u;
t_table_u *prologue_save_table_u, *first_save_table_u, *first_save_i_table_u, *middle_save_table_u, *middle_save_i_table_u, *last_save_table_u, *save_table_u;
t_table_y *prologue_save_table_y, *first_save_table_y, *first_save_i_table_y, *middle_save_table_y, *middle_save_i_table_y, *last_save_table_y;
int nb_prologue_save_table_y, nb_first_save_table_y, nb_middle_save_table_y, nb_last_save_table_y;
int nb_prologue_save_table_u, nb_first_save_table_u, nb_middle_save_table_u, nb_last_save_table_u, middle_count_loop;
@ -79,15 +77,12 @@ public:
int MAX_FREE_U_LIST;
int nb_free_u_list,nb_free_u_list1,max_nb_free_u_list1,max_nb_free_u_list;
bool simplification_allowed;
void print_free_u_list();
void set_free_u_list(int index);
int get_free_u_list(bool dynamic);
#endif /**SIMPLIFY**/
SymbolicGaussElimination();
void list_table_u(int pos);
void init_glb();
void write_to_file_table_y( t_table_y *save_table_y, t_table_y *save_i_table_y, int nb_save_table_y, int nb_save_i_table_y);
void write_to_file_table_u(t_table_u *save_table_u,t_table_u *save_i_table_u, int nb_save_table_u);
void write_to_file_table_u_b(t_table_u *save_table_u, t_table_u *last_table_u, int *nb_save_table_u, bool chk);
bool Check_Regularity(t_table_u *first_u_blck, t_table_u *second_u_blck, t_table_u *third_u_blck);
t_table_u* interpolation(t_model_graph* model_graph,t_table_y* table_y, int to_add, bool middle,int per);
@ -98,11 +93,8 @@ public:
, string file_name
#endif
, bool dynamic);
int SGE_all(int endo,int Time, List_IM *First_IM);
void SGE_compute(Model_Block *ModelBlock, int blck, bool dynamic, string file_name, int endo_nbr);
void file_is_open();
void file_is_open1();
};
//------------------------------------------------------------------------------
#endif