v4 preprocessor: removed unused bits of code
git-svn-id: https://www.dynare.org/svn/dynare/dynare_v4@1811 ac1d8469-bf42-47a9-8791-bf33cf982152time-shift
parent
e6a060d64e
commit
f120c49dde
|
@ -42,14 +42,6 @@ BlockTriangular::BlockTriangular(const SymbolTable &symbol_table_arg) :
|
||||||
periods = 0;
|
periods = 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
//------------------------------------------------------------------------------
|
|
||||||
BlockTriangular::~BlockTriangular()
|
|
||||||
{
|
|
||||||
// Empty
|
|
||||||
}
|
|
||||||
|
|
||||||
//------------------------------------------------------------------------------
|
//------------------------------------------------------------------------------
|
||||||
//For a lead or a lag build the Incidence Matrix structures
|
//For a lead or a lag build the Incidence Matrix structures
|
||||||
List_IM*
|
List_IM*
|
||||||
|
@ -121,23 +113,6 @@ BlockTriangular::Get_IM(int lead_lag)
|
||||||
return (Cur_IM);
|
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*
|
bool*
|
||||||
BlockTriangular::bGet_IM(int lead_lag) const
|
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
|
void
|
||||||
BlockTriangular::Allocate_Block(int size, int *count_Equ, int *count_Block, int type, Model_Block * ModelBlock)
|
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);
|
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 -
|
// 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
|
// and find the optimal blocks triangular decomposition
|
||||||
|
@ -895,249 +806,6 @@ BlockTriangular::Normalize_and_BlockDecompose(bool* IM, Model_Block* ModelBlock,
|
||||||
return 0;
|
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
|
// normalize each equation of the dynamic model
|
||||||
// and find the optimal block triangular decomposition of the static model
|
// and find the optimal block triangular decomposition of the static model
|
||||||
|
|
|
@ -33,11 +33,6 @@ Blocks::Blocks()
|
||||||
//Empty
|
//Empty
|
||||||
}
|
}
|
||||||
|
|
||||||
Blocks::~Blocks()
|
|
||||||
{
|
|
||||||
//Empty
|
|
||||||
}
|
|
||||||
|
|
||||||
int n_sc_set=0;
|
int n_sc_set=0;
|
||||||
|
|
||||||
void
|
void
|
||||||
|
@ -291,44 +286,6 @@ Blocks::block_result_to_IM(block_result_t *r,bool* IM,int prologue, int n,simple
|
||||||
free(SIM);
|
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
|
void
|
||||||
Blocks::Print_Equation_gr(Equation_set* Equation)
|
Blocks::Print_Equation_gr(Equation_set* Equation)
|
||||||
{
|
{
|
||||||
|
|
|
@ -30,16 +30,9 @@ using namespace std;
|
||||||
|
|
||||||
|
|
||||||
Normalization::Normalization(const SymbolTable &symbol_table_arg) :
|
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
|
void
|
||||||
Normalization::IM_to_Gr(int n0, int prologue, int epilogue, bool* IM, Equation_set *Equation, Variable_set *Variable )
|
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);
|
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
|
void
|
||||||
Normalization::Set_fp_verbose(bool ok)
|
Normalization::Set_fp_verbose(bool ok)
|
||||||
{
|
{
|
||||||
|
|
|
@ -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
|
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)
|
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);
|
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;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
|
@ -43,38 +43,7 @@ SymbolicGaussElimination::SymbolicGaussElimination()
|
||||||
}
|
}
|
||||||
|
|
||||||
#ifdef SIMPLIFY
|
#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
|
void
|
||||||
SymbolicGaussElimination::set_free_u_list(int index)
|
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
|
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)
|
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);
|
free(s_j2);
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
|
||||||
SymbolicGaussElimination::file_is_open1()
|
|
||||||
{
|
|
||||||
file_open=true;
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
void
|
||||||
SymbolicGaussElimination::file_is_open()
|
SymbolicGaussElimination::file_is_open()
|
||||||
{
|
{
|
||||||
|
|
|
@ -40,52 +40,31 @@ typedef struct List_IM
|
||||||
bool* IM;
|
bool* IM;
|
||||||
};
|
};
|
||||||
|
|
||||||
|
|
||||||
typedef struct vari
|
|
||||||
{
|
|
||||||
int Size;
|
|
||||||
int* arc;
|
|
||||||
int used_arc;
|
|
||||||
int available;
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
typedef map<pair<int ,int >,double> jacob_map;
|
typedef map<pair<int ,int >,double> jacob_map;
|
||||||
|
|
||||||
class BlockTriangular
|
class BlockTriangular
|
||||||
{
|
{
|
||||||
public:
|
public:
|
||||||
BlockTriangular(const SymbolTable &symbol_table_arg);
|
BlockTriangular(const SymbolTable &symbol_table_arg);
|
||||||
~BlockTriangular();
|
|
||||||
/*! The incidence matrix for each lead and lags */
|
/*! The incidence matrix for each lead and lags */
|
||||||
const SymbolTable &symbol_table;
|
const SymbolTable &symbol_table;
|
||||||
Blocks blocks;
|
Blocks blocks;
|
||||||
Normalization normalization;
|
Normalization normalization;
|
||||||
List_IM* Build_IM(int lead_lag);
|
List_IM* Build_IM(int lead_lag);
|
||||||
List_IM* Get_IM(int lead_lag);
|
List_IM* Get_IM(int lead_lag);
|
||||||
bool* bGet_IM(int lead_lag);
|
|
||||||
bool* bGet_IM(int lead_lag) const;
|
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 unfill_IM(int equation, int variable_endo, int lead_lag);
|
||||||
void incidence_matrix() const;
|
|
||||||
void init_incidence_matrix(int nb_endo);
|
void init_incidence_matrix(int nb_endo);
|
||||||
void Print_IM(int n) const;
|
void Print_IM(int n) const;
|
||||||
void Free_IM(List_IM* First_IM);
|
void Free_IM(List_IM* First_IM);
|
||||||
void Print_SIM(bool* IM, int n) const;
|
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);
|
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);
|
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 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 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 Allocate_Block(int size, int *count_Equ, int *count_Block, int type, Model_Block * ModelBlock);
|
||||||
void Free_Block(Model_Block* ModelBlock);
|
void Free_Block(Model_Block* ModelBlock);
|
||||||
string getnamebyID(Type type, int id);
|
|
||||||
List_IM *First_IM ;
|
List_IM *First_IM ;
|
||||||
List_IM *Last_IM ;
|
List_IM *Last_IM ;
|
||||||
simple *Index_Equ_IM;
|
simple *Index_Equ_IM;
|
||||||
|
@ -151,42 +130,6 @@ public:
|
||||||
break;
|
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
|
#endif
|
||||||
|
|
|
@ -37,12 +37,10 @@ class Blocks
|
||||||
{
|
{
|
||||||
public:
|
public:
|
||||||
Blocks();
|
Blocks();
|
||||||
~Blocks();
|
|
||||||
void block_depth_search(int v);
|
void block_depth_search(int v);
|
||||||
block_result_t* sc(Equation_set *g);
|
block_result_t* sc(Equation_set *g);
|
||||||
void block_result_free(block_result_t *r);
|
void block_result_free(block_result_t *r);
|
||||||
void block_result_print(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 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);
|
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;
|
Equation_vertex *vertices;
|
||||||
|
|
|
@ -33,7 +33,7 @@ typedef struct Equation_vertex
|
||||||
{
|
{
|
||||||
Edge *First_Edge;
|
Edge *First_Edge;
|
||||||
Edge *Next_Edge;
|
Edge *Next_Edge;
|
||||||
int matched,index;
|
int matched;
|
||||||
};
|
};
|
||||||
|
|
||||||
typedef struct Equation_set
|
typedef struct Equation_set
|
||||||
|
@ -49,8 +49,6 @@ typedef struct simple
|
||||||
bool available;
|
bool available;
|
||||||
};
|
};
|
||||||
|
|
||||||
typedef std::string (*t_getNameByID)(Type type, int id);
|
|
||||||
|
|
||||||
class Normalization
|
class Normalization
|
||||||
{
|
{
|
||||||
private:
|
private:
|
||||||
|
@ -71,10 +69,8 @@ private:
|
||||||
};
|
};
|
||||||
public:
|
public:
|
||||||
Normalization(const SymbolTable &symbol_table_arg);
|
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);
|
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);
|
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;
|
const SymbolTable &symbol_table;
|
||||||
void Set_fp_verbose(bool ok);
|
void Set_fp_verbose(bool ok);
|
||||||
private:
|
private:
|
||||||
|
@ -90,7 +86,6 @@ private:
|
||||||
void Free_Equation(int n, Equation_set* Equation);
|
void Free_Equation(int n, Equation_set* Equation);
|
||||||
void Free_Other(Variable_set* Variable);
|
void Free_Other(Variable_set* Variable);
|
||||||
void Free_All(int n, Equation_set* Equation, 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 eq, eex;
|
||||||
int IndexUnmatched;
|
int IndexUnmatched;
|
||||||
bool fp_verbose;
|
bool fp_verbose;
|
||||||
|
|
|
@ -50,34 +50,8 @@ typedef struct t_model_graph
|
||||||
t_vertex* vertex;
|
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 free_model_graph(t_model_graph* model_graph);
|
||||||
void print_Graph(t_model_graph* model_graph);
|
void print_Graph(t_model_graph* model_graph);
|
||||||
void Check_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);
|
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
|
#endif
|
||||||
|
|
|
@ -45,8 +45,7 @@ typedef struct t_table_u
|
||||||
class SymbolicGaussElimination
|
class SymbolicGaussElimination
|
||||||
{
|
{
|
||||||
public:
|
public:
|
||||||
int y_kmin, y_kmax, nb_endo, Time, stacked_time, u_count, periods;
|
int y_kmin, y_kmax, nb_endo, Time, u_count, periods;
|
||||||
double* u1;
|
|
||||||
int *s_i1, *s_i2, *s_j2;
|
int *s_i1, *s_i2, *s_j2;
|
||||||
bool nstacked, save_direct;
|
bool nstacked, save_direct;
|
||||||
int nb_loop_table;
|
int nb_loop_table;
|
||||||
|
@ -58,14 +57,13 @@ public:
|
||||||
int vertex_count;
|
int vertex_count;
|
||||||
t_table_u* table_u;
|
t_table_u* table_u;
|
||||||
int nb_table_u;
|
int nb_table_u;
|
||||||
t_table_u *get_table_u;
|
|
||||||
t_table_u* First_table_u;
|
t_table_u* First_table_u;
|
||||||
#endif /**DIRECT_COMPUTE**/
|
#endif /**DIRECT_COMPUTE**/
|
||||||
int starting_vertex;
|
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;
|
int first_y_blck, second_y_blck, third_y_blck;
|
||||||
#ifdef SAVE
|
#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;
|
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_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;
|
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 MAX_FREE_U_LIST;
|
||||||
int nb_free_u_list,nb_free_u_list1,max_nb_free_u_list1,max_nb_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;
|
bool simplification_allowed;
|
||||||
void print_free_u_list();
|
|
||||||
void set_free_u_list(int index);
|
void set_free_u_list(int index);
|
||||||
int get_free_u_list(bool dynamic);
|
int get_free_u_list(bool dynamic);
|
||||||
#endif /**SIMPLIFY**/
|
#endif /**SIMPLIFY**/
|
||||||
SymbolicGaussElimination();
|
SymbolicGaussElimination();
|
||||||
void list_table_u(int pos);
|
|
||||||
void init_glb();
|
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_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);
|
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);
|
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);
|
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
|
, string file_name
|
||||||
#endif
|
#endif
|
||||||
, bool dynamic);
|
, 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 SGE_compute(Model_Block *ModelBlock, int blck, bool dynamic, string file_name, int endo_nbr);
|
||||||
void file_is_open();
|
void file_is_open();
|
||||||
void file_is_open1();
|
|
||||||
|
|
||||||
};
|
};
|
||||||
//------------------------------------------------------------------------------
|
|
||||||
#endif
|
#endif
|
||||||
|
|
Loading…
Reference in New Issue