Commit d32dd992 authored by ferhat's avatar ferhat
Browse files

- extension of normalization of equations to nonlinear equations

- mfs: new option for 'steady' and 'model' commands. Determines the equation belonging to the set of feedback variables.
  mfs = 0 => all variables are considered as feedback variables (default value)
  mfs = 1 => using only naturally normalized equation as potential recursive equations (all variables assigned to unnormalized equations are considered as feedback variable)
  mfs = 2 => adding to the set of potential recursive equation with mfs = 1 the linear equation in endogenous variable normalized (all variables assigned to nonlinear unnormalized equations are considered as feedback variable)
  mfs = 3 => adding to the set of potential recursive equation with mfs = 2 the non linear equation in endogenous variable normalized
- correction of few buggs in simulate.dll
- block_mfs_dll: new option for 'steady' command. Use simulate.dll to solve the steady state model (speedup the computation of the steady-state and the homotopy)

git-svn-id: https://www.dynare.org/svn/dynare/trunk@2866 ac1d8469-bf42-47a9-8791-bf33cf982152
parent 5d1fdab1
......@@ -224,4 +224,7 @@ function global_initialization()
% block decomposition + minimum feedback set for steady state computation
options_.block_mfs = 0;
\ No newline at end of file
% block decomposition + minimum feedback set for steady state computation
% using simulate.dll
options_.block_mfs_dll = 0;
......@@ -24,23 +24,23 @@ function model_info;
if(isfield(M_,'block_structure'))
nb_blocks=length(M_.block_structure.block);
fprintf('The model has %d equations and is decomposed in %d blocks as follow:\n',M_.endo_nbr,nb_blocks);
fprintf('==============================================================================================================\n');
fprintf('| %10s | %10s | %30s | %14s | %30s |\n','Block n','Size','Block Type','Equation','Dependent variable');
fprintf('|============|============|================================|================|================================|\n');
fprintf('===============================================================================================================\n');
fprintf('| %10s | %10s | %30s | %14s | %31s |\n','Block n','Size','Block Type','E quation','Dependent variable');
fprintf('|============|============|================================|================|=================================|\n');
for i=1:nb_blocks
size_block=length(M_.block_structure.block(i).equation);
if(i>1)
fprintf('|------------|------------|--------------------------------|----------------|--------------------------------|\n');
fprintf('|------------|------------|--------------------------------|----------------|---------------------------------|\n');
end;
for j=1:size_block
if(j==1)
fprintf('| %3d (%4d) | %10d | %30s | %14d | %30s |\n',i,M_.block_structure.block(i).num,size_block,Sym_type(M_.block_structure.block(i).Simulation_Type),M_.block_structure.block(i).equation(j),M_.endo_names(M_.block_structure.block(i).variable(j),:));
fprintf('| %3d (%4d) | %10d | %30s | %14d | %-6d %24s |\n',i,M_.block_structure.block(i).num,size_block,Sym_type(M_.block_structure.block(i).Simulation_Type),M_.block_structure.block(i).equation(j),M_.block_structure.block(i).variable(j),M_.endo_names(M_.block_structure.block(i).variable(j),:));
else
fprintf('| %10s | %10s | %30s | %14d | %30s |\n','','','',M_.block_structure.block(i).equation(j),M_.endo_names(M_.block_structure.block(i).variable(j),:));
fprintf('| %10s | %10s | %30s | %14d | %-6d %24s |\n','','','',M_.block_structure.block(i).equation(j),M_.block_structure.block(i).variable(j),M_.endo_names(M_.block_structure.block(i).variable(j),:));
end;
end;
end;
fprintf('==============================================================================================================\n');
fprintf('===============================================================================================================\n');
fprintf('\n');
for k=1:M_.maximum_endo_lag+M_.maximum_endo_lead+1
if(k==M_.maximum_endo_lag+1)
......
......@@ -53,12 +53,12 @@ function resid(period)
addpath(M_.fname);
end;
for it_=M_.maximum_lag+1:period+M_.maximum_lag
if(options_.model_mode == 1 || options_.model_mode == 3)
z(:,it_-M_.maximum_lag) = feval(fh,oo_.endo_simul',oo_.exo_simul, M_.params, it_);
else
%if(options_.model_mode == 1 || options_.model_mode == 3)
% z(:,it_-M_.maximum_lag) = feval(fh,oo_.endo_simul',oo_.exo_simul, M_.params, it_);
%else
z(:,it_-M_.maximum_lag) = feval(fh,y(iyr0),oo_.exo_simul, M_.params, it_);
iyr0 = iyr0 + n;
end;
%end;
end
if(options_.model_mode == 1 || options_.model_mode == 3)
rmpath(M_.fname);
......
......@@ -100,8 +100,42 @@ function [y, info] = solve_one_boundary(fname, y, x, params, y_index_eq, nze, pe
max_res=max(max(abs(r)));
end;
%['max_res=' num2str(max_res) ' Block_Num=' int2str(Block_Num) ' it_=' int2str(it_)]
disp(['iteration : ' int2str(iter+1) ' => ' num2str(max_res) ' time = ' int2str(it_)]);
% fjac = zeros(Blck_size, Blck_size);
% disp(['Blck_size=' int2str(Blck_size) ' it_=' int2str(it_)]);
% dh = max(abs(y(it_, y_index_eq)),options_.gstep*ones(1, Blck_size))*eps^(1/3);
% fvec = r;
% for j = 1:Blck_size
% ydh = y ;
% ydh(it_, y_index_eq(j)) = ydh(it_, y_index_eq(j)) + dh(j) ;
% [t, y1, g11, g21, g31]=feval(fname, ydh, x, params, it_, 0);
% fjac(:,j) = (t - fvec)./dh(j) ;
% end;
% diff = g1 -fjac;
% diff
% disp('g1');
% disp([num2str(g1,'%4.5f')]);
% disp('fjac');
% disp([num2str(fjac,'%4.5f')]);
% [c_max, i_c_max] = max(abs(diff));
% [l_c_max, i_r_max] = max(c_max);
% disp(['maximum element row=' int2str(i_c_max(i_r_max)) ' and column=' int2str(i_r_max) ' value = ' num2str(l_c_max)]);
% equation = i_c_max(i_r_max);
% variable = i_r_max;
% variable
% mod(variable, Blck_size)
% disp(['equation ' int2str(equation) ' and variable ' int2str(y_index_eq(variable)) ' ' M_.endo_names(y_index_eq(variable), :)]);
% disp(['g1(' int2str(equation) ', ' int2str(variable) ')=' num2str(g1(equation, variable),'%3.10f') ' fjac(' int2str(equation) ', ' int2str(variable) ')=' num2str(fjac(equation, variable), '%3.10f') ' y(' int2str(it_) ', ' int2str(variable) ')=' num2str(y(it_, variable))]);
% %return;
% %g1 = fjac;
if(verbose==1)
disp(['iteration : ' int2str(iter) ' => ' num2str(max_res) ' time = ' int2str(it_)]);
disp(['iteration : ' int2str(iter+1) ' => ' num2str(max_res) ' time = ' int2str(it_)]);
if(is_dynamic)
disp([M_.endo_names(y_index_eq,:) num2str([y(it_,y_index_eq)' r g1])]);
else
......@@ -118,7 +152,7 @@ function [y, info] = solve_one_boundary(fname, y, x, params, y_index_eq, nze, pe
if(~cvg)
if(iter>0)
if(~isreal(max_res) | isnan(max_res) | (max_resa<max_res && iter>1))
if(isnan(max_res))
if(isnan(max_res)| (max_resa<max_res && iter>0))
detJ=det(g1a);
if(abs(detJ)<1e-7)
max_factor=max(max(abs(g1a)));
......@@ -198,15 +232,23 @@ function [y, info] = solve_one_boundary(fname, y, x, params, y_index_eq, nze, pe
else
info = -Block_Num*10;
end
elseif(~is_dynamic & options_.solve_algo==2)
elseif((~is_dynamic & options_.solve_algo==2) || (is_dynamic & options_.solve_algo==4))
lambda=1;
stpmx = 100 ;
stpmax = stpmx*max([sqrt(y'*y);size(y_index_eq,2)]);
if (is_dynamic)
stpmax = stpmx*max([sqrt(y*y');size(y_index_eq,2)]);
else
stpmax = stpmx*max([sqrt(y'*y);size(y_index_eq,2)]);
end;
nn=1:size(y_index_eq,2);
g = (r'*g1)';
f = 0.5*r'*r;
p = -g1\r ;
[y,f,r,check]=lnsrch1(y,f,g,p,stpmax,fname,nn,y_index_eq,x, params, 0);
if (is_dynamic)
[y,f,r,check]=lnsrch1(y,f,g,p,stpmax,fname,nn,y_index_eq,x, params, it_, 0);
else
[y,f,r,check]=lnsrch1(y,f,g,p,stpmax,fname,nn,y_index_eq,x, params, 0);
end;
dx = ya - y(y_index_eq);
elseif(~is_dynamic & options_.solve_algo==3)
[yn,info] = csolve(@local_fname, y(y_index_eq),@local_fname,1e-6,500, x, params, y, y_index_eq, fname, 1);
......@@ -283,6 +325,7 @@ function [y, info] = solve_one_boundary(fname, y, x, params, y_index_eq, nze, pe
return;
end;
iter=iter+1;
max_resa = max_res;
end
end
if cvg==0
......
......@@ -58,7 +58,7 @@ function y = solve_two_boundaries(fname, y, x, params, y_index, nze, periods, y_
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <http://www.gnu.org/licenses/>.
global oo_ M_ T9025 T1149 T11905;
global options_ oo_ M_ T9025 T1149 T11905;
cvg=0;
iter=0;
Per_u_=0;
......@@ -73,11 +73,48 @@ function y = solve_two_boundaries(fname, y, x, params, y_index, nze, periods, y_
reduced = 0;
while ~(cvg==1 | iter>maxit_),
[r, y, g1, g2, g3, b]=feval(fname, y, x, params, periods, 0, y_kmin, Blck_size);
% fjac = zeros(Blck_size, Blck_size*(y_kmin_l+1+y_kmax_l));
% disp(['Blck_size=' int2str(Blck_size) ' size(y_index)=' int2str(size(y_index,2))]);
% dh = max(abs(y(y_kmin+1-y_kmin_l:y_kmin+1+y_kmax_l, y_index)),options_.gstep*ones(y_kmin_l+1+y_kmax_l, Blck_size))*eps^(1/3);
% fvec = r;
% %for i = y_kmin+1-y_kmin_l:y_kmin+1+y_kmax_l
% i = y_kmin+1;
% i
% for j = 1:Blck_size
% ydh = y ;
% ydh(i, y_index(j)) = ydh(i, y_index(j)) + dh(i, j) ;
% if(j==11 && i==2)
% disp(['y(i,y_index(11)=' int2str(y_index(11)) ')= ' num2str(y(i,y_index(11))) ' ydh(i, y_index(j))=' num2str(ydh(i, y_index(j))) ' dh(i,j)= ' num2str(dh(i,j))]);
% end;
% [t, y1, g11, g21, g31, b1]=feval(fname, ydh, x, params, periods, 0, y_kmin, Blck_size);
% fjac(:,j+(i-(y_kmin+1-y_kmin_l))*Blck_size) = (t(:, 1+y_kmin) - fvec(:, 1+y_kmin))./dh(i, j) ;
% if(j==11 && i==2)
% disp(['fjac(:,' int2str(j+(i-(y_kmin+1-y_kmin_l))*Blck_size) ')=']);
% disp([num2str(fjac(:,j+(i-(y_kmin+1-y_kmin_l))*Blck_size))]);
% end;
% end;
% % end
% %diff = g1(1:Blck_size, 1:Blck_size*(y_kmin_l+1+y_kmax_l)) -fjac;
% diff = g1(1:Blck_size, y_kmin_l*Blck_size+1:(y_kmin_l+1)*Blck_size) -fjac(1:Blck_size, y_kmin_l*Blck_size+1:(y_kmin_l+1)*Blck_size);
% disp(diff);
% [c_max, i_c_max] = max(abs(diff));
% [l_c_max, i_r_max] = max(c_max);
% disp(['maximum element row=' int2str(i_c_max(i_r_max)) ' and column=' int2str(i_r_max) ' value = ' num2str(l_c_max)]);
% equation = i_c_max(i_r_max);
% variable = i_r_max;
% variable
% disp(['equation ' int2str(equation) ' and variable ' int2str(y_index(mod(variable, Blck_size))) ' ' M_.endo_names(y_index(mod(variable, Blck_size)), :)]);
% disp(['g1(' int2str(equation) ', ' int2str(variable) ')=' num2str(g1(equation, y_kmin_l*Blck_size+variable),'%3.10f') ' fjac(' int2str(equation) ', ' int2str(variable) ')=' num2str(fjac(equation, y_kmin_l*Blck_size+variable), '%3.10f')]);
% return;
% for i=1:periods;
% disp([sprintf('%5.14f ',[T9025(i) T1149(i) T11905(i)])]);
% end;
% return;
residual = r(:,y_kmin+1:y_kmin+1+y_kmax_l);
%residual = r(:,y_kmin+1:y_kmin+1+y_kmax_l);
%num2str(residual,' %1.6f')
%jac_ = g1(1:(y_kmin)*Blck_size, 1:(y_kmin+1+y_kmax_l)*Blck_size);
%jac_
......@@ -87,15 +124,15 @@ function y = solve_two_boundaries(fname, y, x, params, y_index, nze, periods, y_
term2 = g1(:, (periods+y_kmin_l)*Blck_size+1:(periods+y_kmin_l+y_kmax_l)*Blck_size)*reshape(y(periods+y_kmin+1:periods+y_kmin+y_kmax_l,y_index)',1,y_kmax_l*Blck_size)';
b = b - term1 - term2;
% fid = fopen(['result' num2str(iter)],'w');
% fg1a = full(g1a);
% fprintf(fid,'%d\n',size(fg1a,1));
% fprintf(fid,'%d\n',size(fg1a,2));
% fprintf(fid,'%5.14f\n',fg1a);
% fprintf(fid,'%d\n',size(b,1));
% fprintf(fid,'%5.14f\n',b);
% fclose(fid);
% return;
% fid = fopen(['result' num2str(iter)],'w');
% fg1a = full(g1a);
% fprintf(fid,'%d\n',size(fg1a,1));
% fprintf(fid,'%d\n',size(fg1a,2));
% fprintf(fid,'%5.14f\n',fg1a);
% fprintf(fid,'%d\n',size(b,1));
% fprintf(fid,'%5.14f\n',b);
% fclose(fid);
% return;
%ipconfigb_ = b(1:(1+y_kmin)*Blck_size);
%b_
......
......@@ -79,6 +79,8 @@ function steady_()
[oo_.exo_steady_state; ...
oo_.exo_det_steady_state], M_.params);
end
elseif options_.block_mfs_dll
[oo_.steady_state,check] = simulate('steady_state');
else
[oo_.steady_state,check] = dynare_solve([M_.fname '_static'],...
oo_.steady_state,...
......
......@@ -16,9 +16,13 @@
* You should have received a copy of the GNU General Public License
* along with Dynare. If not, see <http://www.gnu.org/licenses/>.
*/
//#define DEBUGC
#include <cstring>
#include <sstream>
#include "Interpreter.hh"
#define BIG 1.0e+8;
#define SMALL 1.0e-5;
//#define DEBUG
Interpreter::Interpreter(double *params_arg, double *y_arg, double *ya_arg, double *x_arg, double *direction_arg, int y_size_arg,
int nb_row_x_arg, int nb_row_xd_arg, int periods_arg, int y_kmin_arg, int y_kmax_arg,
......@@ -45,202 +49,249 @@ Interpreter::Interpreter(double *params_arg, double *y_arg, double *ya_arg, doub
markowitz_c=markowitz_c_arg;
filename=filename_arg;
T=NULL;
//GaussSeidel=true;
error_not_printed = true;
}
double
Interpreter::pow1(double a, double b)
{
double r=pow_(a,b);
/*double r;
if(a>=0)
r=pow_(a,b);
else
{
//r=0;
//max_res=res1=res2=BIG;
if(error_not_printed)
{
mexPrintf("Error: X^a with X<0\n");
error_not_printed = false;
}
//r = BIG;
//r = -pow_(-a, b);
//r = 0;
//r = SMALL;
//r = pow_(-a, b);
}*/
double r = pow_(a, b);
if (isnan(r) || isinf(r))
{
//mexPrintf("pow(%f, %f)=%f\n",a, b, r);
max_res=res1=res2=r;
if(a<0 && error_not_printed)
{
mexPrintf("Error: X^a with X=%5.25f\n",a);
error_not_printed = false;
r = 0.0000000000000000000000001;
}
//res1=NAN;
return(r);
}
else
return r;
}
double
Interpreter::log1(double a)
{
/*double r;
if(a>=0)
r=pow_(a,b);
else
{
//r=0;
//max_res=res1=res2=BIG;
if(error_not_printed)
{
mexPrintf("Error: X^a with X<0\n");
error_not_printed = false;
}
//r = BIG;
//r = -pow_(-a, b);
//r = 0;
//r = SMALL;
//r = pow_(-a, b);
}*/
double r = log(a);
if (isnan(r) || isinf(r))
{
if(a<=0 && error_not_printed)
{
mexPrintf("Error: log(X) with X<=0\n");
error_not_printed = false;
}
res1=NAN;
return(r);
}
else
return r;
}
void
Interpreter::compute_block_time(int Per_u_) /*throw(EvalException)*/
{
int var, lag, op;
ostringstream tmp_out;
double v1, v2;
char/*uint8_t*/ cc;
bool go_on=true;
double *ll;
while (go_on)
{
//mexPrintf("it_=%d",it_);
switch (cc=get_code_char)
{
case FLDV :
//load a variable in the processor
#ifdef DEBUGC
if(Block_Count==2)
{
mexPrintf("FLDV\n");
mexEvalString("drawnow;");
}
#endif
switch (get_code_char)
{
case eParameter :
var=get_code_int;
#ifdef DEBUGC
if(Block_Count==2)
{
mexPrintf(" params[%d]=%f\n",var,params[var]);
mexEvalString("drawnow;");
}
#endif
Stack.push(params[var]);
#ifdef DEBUG
tmp_out << " params[" << var << "](" << params[var] << ")";
#endif
break;
case eEndogenous :
var=get_code_int;
lag=get_code_int;
#ifdef DEBUGC
if(Block_Count==2)
{
mexPrintf("y[%d, %d]=%f\n",it_+lag, var+1, y[(it_+lag)*y_size+var]);
}
#endif
Stack.push(y[(it_+lag)*y_size+var]);
#ifdef DEBUG
tmp_out << " y[" << it_+lag << ", " << var << "](" << y[(it_+lag)*y_size+var] << ")";
#endif
break;
case eExogenous :
#ifdef DEBUGC
mexPrintf("Exogenous\n");
#endif
var=get_code_int;
lag=get_code_int;
#ifdef DEBUGC
if(Block_Count==2)
{
mexPrintf("x[%d, %d]\n",it_+lag, var+1);
}
#endif
Stack.push(x[it_+lag+var*nb_row_x]);
#ifdef DEBUG
tmp_out << " x[" << it_+lag << ", " << var << "](" << x[it_+lag+var*nb_row_x] << ")";
#endif
break;
case eExogenousDet :
#ifdef DEBUGC
mexPrintf("ExogenousDet\n");
#endif
var=get_code_int;
lag=get_code_int;
#ifdef DEBUGC
mexPrintf(" x(det)[%d]=%f\n",it_+lag+var*nb_row_xd,x[it_+lag+var*nb_row_xd]);
mexEvalString("drawnow;");
#endif
Stack.push(x[it_+lag+var*nb_row_xd]);
break;
default:
mexPrintf("Unknown variable type\n");
}
break;
case FLDSV :
//load a variable in the processor
switch (get_code_char)
{
case eParameter :
var=get_code_int;
Stack.push(params[var]);
#ifdef DEBUG
tmp_out << " params[" << var << "](" << params[var] << ")";
#endif
break;
case eEndogenous :
var=get_code_int;
Stack.push(y[var]);
#ifdef DEBUG
tmp_out << " y[" << var << "](" << y[var] << ")";
#endif
break;
case eExogenous :
var=get_code_int;
Stack.push(x[var]);
#ifdef DEBUG
tmp_out << " x[" << var << "](" << x[var] << ")";
#endif
break;
case eExogenousDet :
var=get_code_int;
Stack.push(x[var]);
break;
default:
mexPrintf("Unknown variable type\n");
}
break;
case FLDT :
//load a temporary variable in the processor
var=get_code_int;
#ifdef DEBUGC
mexPrintf("FLDT %d [%d]=%f Stack.size()=%d\n",var,var*(periods+y_kmin+y_kmax)+it_,T[var*(periods+y_kmin+y_kmax)+it_], Stack.size());
mexEvalString("drawnow;");
#ifdef DEBUG
tmp_out << " T[" << it_ << ", " << var << "](" << T[var*(periods+y_kmin+y_kmax)+it_] << ")";
#endif
Stack.push(T[var*(periods+y_kmin+y_kmax)+it_]);
break;
case FLDST :
//load a temporary variable in the processor
var=get_code_int;
#ifdef DEBUG
tmp_out << " T[" << var << "](" << T[var] << ")";
#endif
Stack.push(T[var]);
break;
case FLDU :
//load u variable in the processor
#ifdef DEBUGC
mexPrintf("FLDU\n");
mexEvalString("drawnow;");
#endif
var=get_code_int;
var+=Per_u_;
#ifdef DEBUG
tmp_out << " u[" << var << "](" << u[var] << ")";
#endif
Stack.push(u[var]);
break;
case FLDR :
case FLDSU :
//load u variable in the processor
var=get_code_int;
#ifdef DEBUGC
mexPrintf("FLDR r[%d]=%f\n",var, r[var] );
mexEvalString("drawnow;");
#ifdef DEBUG
tmp_out << " u[" << var << "](" << u[var] << ")";
#endif
Stack.push(u[var]);
break;
case FLDR :
//load u variable in the processor
var=get_code_int;
Stack.push(r[var]);
break;
case FLDZ :
//load 0 in the processor
#ifdef DEBUGC
mexPrintf("FLDZ\n");
mexEvalString("drawnow;");
#endif
Stack.push(0);
#ifdef DEBUG
tmp_out << " 0";
#endif
break;
case FLDC :
//load a numerical constant in the processor
/*asm("fld\n\t"
"fstp %%st" : "=t" (ll) : "0" ((double)(*Code)));*/
ll=get_code_pdouble;
#ifdef DEBUGC
mexPrintf("FLDC %f\n",*ll);
mexEvalString("drawnow;");
#ifdef DEBUG
tmp_out << " " << *ll;
#endif
Stack.push(*ll);
break;
case FSTPV :
//load a variable in the processor
#ifdef DEBUGC
mexPrintf("FSTPV\n");
mexEvalString("drawnow;");
#endif
switch (get_code_char)
{
case eParameter :
var=get_code_int;
params[var] = Stack.top();
#ifdef DEBUGC
mexPrintf("FSTP params[%d]=%f\n", var, params[var]);
mexEvalString("drawnow;");
#endif
Stack.pop();
break;
case eEndogenous :
#ifdef DEBUGC
mexPrintf("FSTP Endogenous\n");
#endif
var=get_code_int;
lag=get_code_int;
#ifdef DEBUGC
//mexPrintf("y[%d(it_=%d, lag=%d, y_size=%d, var=%d)](%d)=",(it_+lag)*y_size+var,it_, lag, y_size, var, Stack.size());
mexPrintf("FSTP y[it_=%d, lag=%d, y_size=%d, var=%d, block=%d)]=",it_, lag, y_size, var+1, Block_Count+1);
mexEvalString("drawnow;");
#endif
y[(it_+lag)*y_size+var] = Stack.top();
#ifdef DEBUGC
mexPrintf("%f\n",y[(it_+lag)*y_size+var]);
mexEvalString("drawnow;");
#ifdef DEBUG
tmp_out << "=>";
//mexPrintf(" y[%d, %d](%f)=%s\n", it_+lag, var, y[(it_+lag)*y_size+var], tmp_out.str().c_str());
tmp_out.str("");
#endif
Stack.pop();
break;
case eExogenous :
#ifdef DEBUGC
mexPrintf("Exogenous\n");
#endif
//var=get_code_int;
var=get_code_int;
lag=get_code_int;
/*mexPrintf("FSTP x[it_=%d, lag=%d, y_size=%d, var=%d, block=%d)]=",it_, lag, y_size, var+1, Block_Count+1);
mexEvalString("drawnow;");*/
x[it_+lag+var*nb_row_x] = Stack.top();
Stack.pop();
/*mexPrintf("%f\n",x[it_+lag+var*nb_row_x]);
mexEvalString("drawnow;");*/
break;
case eExogenousDet :
#ifdef DEBUGC
mexPrintf("ExogenousDet\n");
#endif
var=get_code_int;
var=get_code_int;
lag=get_code_int;
x[it_+lag+var*nb_row_xd] = Stack.top();
......@@ -249,69 +300,110 @@ Interpreter::compute_block_time(int Per_u_) /*throw(EvalException)*/
default:
mexPrintf("Unknown vraibale type\n");
}
break;
case FSTPSV :