stepan
/
dynare
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
dynare/matlab/perfect-foresight-models/perfect_foresight_with_expe...

115 lines
5.5 KiB
Matlab
Raw Normal View History

New perfect_foresight_with_expectation_errors_{setup,solver} commands These command solve the problem where agents think they know perfectly the future (they behave as in perfect foresight), but make expectation errors. Hence they can potentially be surprised in every period, and their expectations about the future (incl. the final steady state) may change. Currently the sequence of information sets needs to be passed through a CSV file. Another interface may be added in the future. The algorithm uses a sequence of (true) perfect foresight simulations (not necessarily as many as there are periods, because if the information set does not change between two periods, there is no need to do a new computation). There are two possibilities for guess values: — the default is to use the initial steady state for the simulation using the first-period information set; then use previously simulated values as guess values — alternatively, with the terminal_steady_state_as_guess_value option, use the terminal steady state as guess value for all future periods (this is actually what the “true” perfect foresight solver does by default)
2021-07-09 18:12:10 +02:00
function perfect_foresight_with_expectation_errors_solver
perfect_foresight_with_expectation_errors_{setup,solver}: fix bugs with several exogenous Closes: #1883
2023-01-24 14:58:30 +01:00
% Copyright © 2021-2023 Dynare Team
New perfect_foresight_with_expectation_errors_{setup,solver} commands These command solve the problem where agents think they know perfectly the future (they behave as in perfect foresight), but make expectation errors. Hence they can potentially be surprised in every period, and their expectations about the future (incl. the final steady state) may change. Currently the sequence of information sets needs to be passed through a CSV file. Another interface may be added in the future. The algorithm uses a sequence of (true) perfect foresight simulations (not necessarily as many as there are periods, because if the information set does not change between two periods, there is no need to do a new computation). There are two possibilities for guess values: — the default is to use the initial steady state for the simulation using the first-period information set; then use previously simulated values as guess values — alternatively, with the terminal_steady_state_as_guess_value option, use the terminal steady state as guess value for all future periods (this is actually what the “true” perfect foresight solver does by default)
2021-07-09 18:12:10 +02:00
%
% This file is part of Dynare.
%
% Dynare is free software: you can redistribute it and/or modify
% it under the terms of the GNU General Public License as published by
% the Free Software Foundation, either version 3 of the License, or
% (at your option) any later version.
%
% Dynare is distributed in the hope that it will be useful,
% but WITHOUT ANY WARRANTY; without even the implied warranty of
% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
% GNU General Public License for more details.
%
% You should have received a copy of the GNU General Public License
% along with Dynare. If not, see <https://www.gnu.org/licenses/>.
Rename ys0_ into oo_.initial_steady_state and ex0_ into oo_.initial_exo_steady_state Also document these variables.
2023-10-23 19:07:26 +02:00
global M_ oo_ options_
New perfect_foresight_with_expectation_errors_{setup,solver} commands These command solve the problem where agents think they know perfectly the future (they behave as in perfect foresight), but make expectation errors. Hence they can potentially be surprised in every period, and their expectations about the future (incl. the final steady state) may change. Currently the sequence of information sets needs to be passed through a CSV file. Another interface may be added in the future. The algorithm uses a sequence of (true) perfect foresight simulations (not necessarily as many as there are periods, because if the information set does not change between two periods, there is no need to do a new computation). There are two possibilities for guess values: — the default is to use the initial steady state for the simulation using the first-period information set; then use previously simulated values as guess values — alternatively, with the terminal_steady_state_as_guess_value option, use the terminal steady state as guess value for all future periods (this is actually what the “true” perfect foresight solver does by default)
2021-07-09 18:12:10 +02:00
New option “constant_simulation_length” to “perfect_foresight_with_simulation_errors_solver” command
2022-04-12 15:45:50 +02:00
% Same for periods (it will be modified before calling perfect_foresight_solver if constants_simulation_length option is false)
periods = options_.periods;
New perfect_foresight_with_expectation_errors_{setup,solver} commands These command solve the problem where agents think they know perfectly the future (they behave as in perfect foresight), but make expectation errors. Hence they can potentially be surprised in every period, and their expectations about the future (incl. the final steady state) may change. Currently the sequence of information sets needs to be passed through a CSV file. Another interface may be added in the future. The algorithm uses a sequence of (true) perfect foresight simulations (not necessarily as many as there are periods, because if the information set does not change between two periods, there is no need to do a new computation). There are two possibilities for guess values: — the default is to use the initial steady state for the simulation using the first-period information set; then use previously simulated values as guess values — alternatively, with the terminal_steady_state_as_guess_value option, use the terminal steady state as guess value for all future periods (this is actually what the “true” perfect foresight solver does by default)
2021-07-09 18:12:10 +02:00
Various improvements to perfect foresight homotopy – new option “endval_steady” to pf_setup command to recompute terminal steady state in the homotopy loop – new options “homotopy_linearization_fallback” and “homotopy_marginal_linearization_fallback” to pf_solver and pfwee_solver commands, to get an approximate solution when homotopy fails to go to 100% – new options “homotopy_initial_step_size”, “homotopy_min_step_size”, “homotopy_step_size_increase_success_count” and “homotopy_max_completion_share” to pf_solver and pfwee_solver commands to fine tune the homotopy behaviour – removed option “homotopy_alt_starting_point” to pf_solver command, not really useful – new options “steady_solve_algo”, “steady_tolf”, “steady_tolx”, “steady_maxit”, “steady_markowitz” to pf_solver and pfwee_solver commands, to control the computation of the terminal steady state (and remove the equivalent options which previously had different names in pfwee_solver command)
2023-06-15 16:59:37 +02:00
% Save some options
orig_homotopy_max_completion_share = options_.simul.homotopy_max_completion_share;
orig_endval_steady = options_.simul.endval_steady;
New perfect_foresight_with_expectation_errors_{setup,solver} commands These command solve the problem where agents think they know perfectly the future (they behave as in perfect foresight), but make expectation errors. Hence they can potentially be surprised in every period, and their expectations about the future (incl. the final steady state) may change. Currently the sequence of information sets needs to be passed through a CSV file. Another interface may be added in the future. The algorithm uses a sequence of (true) perfect foresight simulations (not necessarily as many as there are periods, because if the information set does not change between two periods, there is no need to do a new computation). There are two possibilities for guess values: — the default is to use the initial steady state for the simulation using the first-period information set; then use previously simulated values as guess values — alternatively, with the terminal_steady_state_as_guess_value option, use the terminal steady state as guess value for all future periods (this is actually what the “true” perfect foresight solver does by default)
2021-07-09 18:12:10 +02:00
% Retrieve initial paths built by pfwee_setup
% (the versions in oo_ will be truncated before calling perfect_foresight_solver)
endo_simul = oo_.endo_simul;
exo_simul = oo_.exo_simul;
Various improvements to perfect foresight homotopy – new option “endval_steady” to pf_setup command to recompute terminal steady state in the homotopy loop – new options “homotopy_linearization_fallback” and “homotopy_marginal_linearization_fallback” to pf_solver and pfwee_solver commands, to get an approximate solution when homotopy fails to go to 100% – new options “homotopy_initial_step_size”, “homotopy_min_step_size”, “homotopy_step_size_increase_success_count” and “homotopy_max_completion_share” to pf_solver and pfwee_solver commands to fine tune the homotopy behaviour – removed option “homotopy_alt_starting_point” to pf_solver command, not really useful – new options “steady_solve_algo”, “steady_tolf”, “steady_tolx”, “steady_maxit”, “steady_markowitz” to pf_solver and pfwee_solver commands, to control the computation of the terminal steady state (and remove the equivalent options which previously had different names in pfwee_solver command)
2023-06-15 16:59:37 +02:00
% Enforce the endval steady option in pf_solver
if M_.maximum_lead > 0
options_.simul.endval_steady = true;
end
New perfect_foresight_with_expectation_errors_{setup,solver} commands These command solve the problem where agents think they know perfectly the future (they behave as in perfect foresight), but make expectation errors. Hence they can potentially be surprised in every period, and their expectations about the future (incl. the final steady state) may change. Currently the sequence of information sets needs to be passed through a CSV file. Another interface may be added in the future. The algorithm uses a sequence of (true) perfect foresight simulations (not necessarily as many as there are periods, because if the information set does not change between two periods, there is no need to do a new computation). There are two possibilities for guess values: — the default is to use the initial steady state for the simulation using the first-period information set; then use previously simulated values as guess values — alternatively, with the terminal_steady_state_as_guess_value option, use the terminal steady state as guess value for all future periods (this is actually what the “true” perfect foresight solver does by default)
2021-07-09 18:12:10 +02:00
% Start main loop around informational periods
info_period = 1;
New option “constant_simulation_length” to “perfect_foresight_with_simulation_errors_solver” command
2022-04-12 15:45:50 +02:00
increment = 0;
New perfect_foresight_with_expectation_errors_{setup,solver} commands These command solve the problem where agents think they know perfectly the future (they behave as in perfect foresight), but make expectation errors. Hence they can potentially be surprised in every period, and their expectations about the future (incl. the final steady state) may change. Currently the sequence of information sets needs to be passed through a CSV file. Another interface may be added in the future. The algorithm uses a sequence of (true) perfect foresight simulations (not necessarily as many as there are periods, because if the information set does not change between two periods, there is no need to do a new computation). There are two possibilities for guess values: — the default is to use the initial steady state for the simulation using the first-period information set; then use previously simulated values as guess values — alternatively, with the terminal_steady_state_as_guess_value option, use the terminal steady state as guess value for all future periods (this is actually what the “true” perfect foresight solver does by default)
2021-07-09 18:12:10 +02:00
while info_period <= periods
perfect_foresight_with_expectation_errors_solver: check convergence of informational iterations Error out if an iteration failed. Also display an informative message about those iterations.
2023-06-15 16:57:59 +02:00
if ~options_.noprint
fprintf('perfect_foresight_with_expectations_errors_solver: computing solution for information available at period %d\n', info_period)
end
New perfect_foresight_with_expectation_errors_{setup,solver} commands These command solve the problem where agents think they know perfectly the future (they behave as in perfect foresight), but make expectation errors. Hence they can potentially be surprised in every period, and their expectations about the future (incl. the final steady state) may change. Currently the sequence of information sets needs to be passed through a CSV file. Another interface may be added in the future. The algorithm uses a sequence of (true) perfect foresight simulations (not necessarily as many as there are periods, because if the information set does not change between two periods, there is no need to do a new computation). There are two possibilities for guess values: — the default is to use the initial steady state for the simulation using the first-period information set; then use previously simulated values as guess values — alternatively, with the terminal_steady_state_as_guess_value option, use the terminal steady state as guess value for all future periods (this is actually what the “true” perfect foresight solver does by default)
2021-07-09 18:12:10 +02:00
% Compute terminal steady state as anticipated
oo_.exo_steady_state = oo_.pfwee.terminal_info(:, info_period);
Various improvements to perfect foresight homotopy – new option “endval_steady” to pf_setup command to recompute terminal steady state in the homotopy loop – new options “homotopy_linearization_fallback” and “homotopy_marginal_linearization_fallback” to pf_solver and pfwee_solver commands, to get an approximate solution when homotopy fails to go to 100% – new options “homotopy_initial_step_size”, “homotopy_min_step_size”, “homotopy_step_size_increase_success_count” and “homotopy_max_completion_share” to pf_solver and pfwee_solver commands to fine tune the homotopy behaviour – removed option “homotopy_alt_starting_point” to pf_solver command, not really useful – new options “steady_solve_algo”, “steady_tolf”, “steady_tolx”, “steady_maxit”, “steady_markowitz” to pf_solver and pfwee_solver commands, to control the computation of the terminal steady state (and remove the equivalent options which previously had different names in pfwee_solver command)
2023-06-15 16:59:37 +02:00
% oo_.steady_state will be updated by pf_solver (since endval_steady=true)
New perfect_foresight_with_expectation_errors_{setup,solver} commands These command solve the problem where agents think they know perfectly the future (they behave as in perfect foresight), but make expectation errors. Hence they can potentially be surprised in every period, and their expectations about the future (incl. the final steady state) may change. Currently the sequence of information sets needs to be passed through a CSV file. Another interface may be added in the future. The algorithm uses a sequence of (true) perfect foresight simulations (not necessarily as many as there are periods, because if the information set does not change between two periods, there is no need to do a new computation). There are two possibilities for guess values: — the default is to use the initial steady state for the simulation using the first-period information set; then use previously simulated values as guess values — alternatively, with the terminal_steady_state_as_guess_value option, use the terminal steady state as guess value for all future periods (this is actually what the “true” perfect foresight solver does by default)
2021-07-09 18:12:10 +02:00
New option “constant_simulation_length” to “perfect_foresight_with_simulation_errors_solver” command
2022-04-12 15:45:50 +02:00
if options_.pfwee.constant_simulation_length && increment > 0
Various improvements to perfect foresight homotopy – new option “endval_steady” to pf_setup command to recompute terminal steady state in the homotopy loop – new options “homotopy_linearization_fallback” and “homotopy_marginal_linearization_fallback” to pf_solver and pfwee_solver commands, to get an approximate solution when homotopy fails to go to 100% – new options “homotopy_initial_step_size”, “homotopy_min_step_size”, “homotopy_step_size_increase_success_count” and “homotopy_max_completion_share” to pf_solver and pfwee_solver commands to fine tune the homotopy behaviour – removed option “homotopy_alt_starting_point” to pf_solver command, not really useful – new options “steady_solve_algo”, “steady_tolf”, “steady_tolx”, “steady_maxit”, “steady_markowitz” to pf_solver and pfwee_solver commands, to control the computation of the terminal steady state (and remove the equivalent options which previously had different names in pfwee_solver command)
2023-06-15 16:59:37 +02:00
% Use previous terminal steady state as guess value for: simulation periods that don’t yet have an initial guess (i.e. are NaNs at this point); and also for the terminal steady state
endo_simul = [ endo_simul repmat(oo_.steady_state, 1, increment)];
New option “constant_simulation_length” to “perfect_foresight_with_simulation_errors_solver” command
2022-04-12 15:45:50 +02:00
exo_simul = [ exo_simul; NaN(increment, M_.exo_nbr)];
end
New perfect_foresight_with_expectation_errors_{setup,solver} commands These command solve the problem where agents think they know perfectly the future (they behave as in perfect foresight), but make expectation errors. Hence they can potentially be surprised in every period, and their expectations about the future (incl. the final steady state) may change. Currently the sequence of information sets needs to be passed through a CSV file. Another interface may be added in the future. The algorithm uses a sequence of (true) perfect foresight simulations (not necessarily as many as there are periods, because if the information set does not change between two periods, there is no need to do a new computation). There are two possibilities for guess values: — the default is to use the initial steady state for the simulation using the first-period information set; then use previously simulated values as guess values — alternatively, with the terminal_steady_state_as_guess_value option, use the terminal steady state as guess value for all future periods (this is actually what the “true” perfect foresight solver does by default)
2021-07-09 18:12:10 +02:00
oo_.endo_simul = endo_simul(:, info_period:end); % Take initial conditions + guess values from previous simulation
New option “constant_simulation_length” to “perfect_foresight_with_simulation_errors_solver” command
2022-04-12 15:45:50 +02:00
if options_.pfwee.constant_simulation_length
sim_length = periods;
else
sim_length = periods - info_period + 1;
end
Various improvements to perfect foresight homotopy – new option “endval_steady” to pf_setup command to recompute terminal steady state in the homotopy loop – new options “homotopy_linearization_fallback” and “homotopy_marginal_linearization_fallback” to pf_solver and pfwee_solver commands, to get an approximate solution when homotopy fails to go to 100% – new options “homotopy_initial_step_size”, “homotopy_min_step_size”, “homotopy_step_size_increase_success_count” and “homotopy_max_completion_share” to pf_solver and pfwee_solver commands to fine tune the homotopy behaviour – removed option “homotopy_alt_starting_point” to pf_solver command, not really useful – new options “steady_solve_algo”, “steady_tolf”, “steady_tolx”, “steady_maxit”, “steady_markowitz” to pf_solver and pfwee_solver commands, to control the computation of the terminal steady state (and remove the equivalent options which previously had different names in pfwee_solver command)
2023-06-15 16:59:37 +02:00
New perfect_foresight_with_expectation_errors_{setup,solver} commands These command solve the problem where agents think they know perfectly the future (they behave as in perfect foresight), but make expectation errors. Hence they can potentially be surprised in every period, and their expectations about the future (incl. the final steady state) may change. Currently the sequence of information sets needs to be passed through a CSV file. Another interface may be added in the future. The algorithm uses a sequence of (true) perfect foresight simulations (not necessarily as many as there are periods, because if the information set does not change between two periods, there is no need to do a new computation). There are two possibilities for guess values: — the default is to use the initial steady state for the simulation using the first-period information set; then use previously simulated values as guess values — alternatively, with the terminal_steady_state_as_guess_value option, use the terminal steady state as guess value for all future periods (this is actually what the “true” perfect foresight solver does by default)
2021-07-09 18:12:10 +02:00
oo_.exo_simul = exo_simul(info_period:end, :);
oo_.exo_simul(M_.maximum_lag+(1:periods-info_period+1), :) = oo_.pfwee.shocks_info(:, info_period:end, info_period)';
perfect_foresight_with_expectation_errors_{setup,solver}: fix bugs with several exogenous Closes: #1883
2023-01-24 14:58:30 +01:00
oo_.exo_simul(M_.maximum_lag+periods-info_period+2:end, :) = repmat(oo_.exo_steady_state', sim_length+M_.maximum_lead-(periods-info_period+1), 1);
New option “constant_simulation_length” to “perfect_foresight_with_simulation_errors_solver” command
2022-04-12 15:45:50 +02:00
options_.periods = sim_length;
New perfect_foresight_with_expectation_errors_{setup,solver} commands These command solve the problem where agents think they know perfectly the future (they behave as in perfect foresight), but make expectation errors. Hence they can potentially be surprised in every period, and their expectations about the future (incl. the final steady state) may change. Currently the sequence of information sets needs to be passed through a CSV file. Another interface may be added in the future. The algorithm uses a sequence of (true) perfect foresight simulations (not necessarily as many as there are periods, because if the information set does not change between two periods, there is no need to do a new computation). There are two possibilities for guess values: — the default is to use the initial steady state for the simulation using the first-period information set; then use previously simulated values as guess values — alternatively, with the terminal_steady_state_as_guess_value option, use the terminal steady state as guess value for all future periods (this is actually what the “true” perfect foresight solver does by default)
2021-07-09 18:12:10 +02:00
Fix marginal linearization in the context of perfect_foresight_with_expectation_errors_solver with homotopy If a solution corresponding to 100% of the shock can’t be found in the first informational period, marginal linearization will be performed to extrapolate a solution. However, in subsequent informational periods, this extrapolated solution cannot be used for the initial conditions of endogenous variables, because the initial conditions are not a true solution of the nonlinear model. For those subsequent informational periods, the correct approach is to compute the two solutions needed for marginal linearization using as initial conditions the values obtained in the same two solutions for the previous informational periods (stored as oo_.deterministic_simulation.{sim1,sim2}).
2023-11-21 18:39:33 +01:00
if info_period > 1 && homotopy_completion_share < 1 && options_.simul.homotopy_marginal_linearization_fallback > 0
marginal_linearization_previous_raw_sims.sim1.endo_simul = oo_.deterministic_simulation.sim1.endo_simul(:, info_period:end);
marginal_linearization_previous_raw_sims.sim1.exo_simul = oo_.deterministic_simulation.sim1.exo_simul(info_period:end, :);
marginal_linearization_previous_raw_sims.sim1.homotopy_completion_share = oo_.deterministic_simulation.sim1.homotopy_completion_share;
marginal_linearization_previous_raw_sims.sim2.endo_simul = oo_.deterministic_simulation.sim2.endo_simul(:, info_period:end);
marginal_linearization_previous_raw_sims.sim2.exo_simul = oo_.deterministic_simulation.sim2.exo_simul(info_period:end, :);
marginal_linearization_previous_raw_sims.sim2.homotopy_completion_share = oo_.deterministic_simulation.sim2.homotopy_completion_share;
else
marginal_linearization_previous_raw_sims = [];
end
perfect_foresight_solver(true, marginal_linearization_previous_raw_sims);
New perfect_foresight_with_expectation_errors_{setup,solver} commands These command solve the problem where agents think they know perfectly the future (they behave as in perfect foresight), but make expectation errors. Hence they can potentially be surprised in every period, and their expectations about the future (incl. the final steady state) may change. Currently the sequence of information sets needs to be passed through a CSV file. Another interface may be added in the future. The algorithm uses a sequence of (true) perfect foresight simulations (not necessarily as many as there are periods, because if the information set does not change between two periods, there is no need to do a new computation). There are two possibilities for guess values: — the default is to use the initial steady state for the simulation using the first-period information set; then use previously simulated values as guess values — alternatively, with the terminal_steady_state_as_guess_value option, use the terminal steady state as guess value for all future periods (this is actually what the “true” perfect foresight solver does by default)
2021-07-09 18:12:10 +02:00
perfect_foresight_with_expectation_errors_solver: check convergence of informational iterations Error out if an iteration failed. Also display an informative message about those iterations.
2023-06-15 16:57:59 +02:00
if ~oo_.deterministic_simulation.status
error('perfect_foresight_with_expectation_errors_solver: failed to compute solution for information available at period %d\n', info_period)
end
Various improvements to perfect foresight homotopy – new option “endval_steady” to pf_setup command to recompute terminal steady state in the homotopy loop – new options “homotopy_linearization_fallback” and “homotopy_marginal_linearization_fallback” to pf_solver and pfwee_solver commands, to get an approximate solution when homotopy fails to go to 100% – new options “homotopy_initial_step_size”, “homotopy_min_step_size”, “homotopy_step_size_increase_success_count” and “homotopy_max_completion_share” to pf_solver and pfwee_solver commands to fine tune the homotopy behaviour – removed option “homotopy_alt_starting_point” to pf_solver command, not really useful – new options “steady_solve_algo”, “steady_tolf”, “steady_tolx”, “steady_maxit”, “steady_markowitz” to pf_solver and pfwee_solver commands, to control the computation of the terminal steady state (and remove the equivalent options which previously had different names in pfwee_solver command)
2023-06-15 16:59:37 +02:00
if info_period == 1
homotopy_completion_share = oo_.deterministic_simulation.homotopy_completion_share;
options_.simul.homotopy_max_completion_share = homotopy_completion_share;
elseif oo_.deterministic_simulation.homotopy_completion_share ~= homotopy_completion_share
error('perfect_foresight_solver_with_expectation_errors: could not find a solution for information available at period %d with the same homotopy completion share as period 1\n', info_period)
end
New perfect_foresight_with_expectation_errors_{setup,solver} commands These command solve the problem where agents think they know perfectly the future (they behave as in perfect foresight), but make expectation errors. Hence they can potentially be surprised in every period, and their expectations about the future (incl. the final steady state) may change. Currently the sequence of information sets needs to be passed through a CSV file. Another interface may be added in the future. The algorithm uses a sequence of (true) perfect foresight simulations (not necessarily as many as there are periods, because if the information set does not change between two periods, there is no need to do a new computation). There are two possibilities for guess values: — the default is to use the initial steady state for the simulation using the first-period information set; then use previously simulated values as guess values — alternatively, with the terminal_steady_state_as_guess_value option, use the terminal steady state as guess value for all future periods (this is actually what the “true” perfect foresight solver does by default)
2021-07-09 18:12:10 +02:00
endo_simul(:, info_period:end) = oo_.endo_simul;
exo_simul(info_period:end, :) = oo_.exo_simul;
% Increment info_period (as much as possible, if information set does not change for some time)
increment = 1;
while info_period+increment <= periods && ...
all(oo_.pfwee.terminal_info(:, info_period) == oo_.pfwee.terminal_info(:, info_period+increment)) && ...
all(all(oo_.pfwee.shocks_info(:, info_period+increment:end, info_period) == oo_.pfwee.shocks_info(:, info_period+increment:end, info_period+increment)))
increment = increment + 1;
end
info_period = info_period + increment;
end
% Set final paths
oo_.endo_simul = endo_simul;
oo_.exo_simul = exo_simul;
Various improvements to perfect foresight homotopy – new option “endval_steady” to pf_setup command to recompute terminal steady state in the homotopy loop – new options “homotopy_linearization_fallback” and “homotopy_marginal_linearization_fallback” to pf_solver and pfwee_solver commands, to get an approximate solution when homotopy fails to go to 100% – new options “homotopy_initial_step_size”, “homotopy_min_step_size”, “homotopy_step_size_increase_success_count” and “homotopy_max_completion_share” to pf_solver and pfwee_solver commands to fine tune the homotopy behaviour – removed option “homotopy_alt_starting_point” to pf_solver command, not really useful – new options “steady_solve_algo”, “steady_tolf”, “steady_tolx”, “steady_maxit”, “steady_markowitz” to pf_solver and pfwee_solver commands, to control the computation of the terminal steady state (and remove the equivalent options which previously had different names in pfwee_solver command)
2023-06-15 16:59:37 +02:00
% Restore some options
New perfect_foresight_with_expectation_errors_{setup,solver} commands These command solve the problem where agents think they know perfectly the future (they behave as in perfect foresight), but make expectation errors. Hence they can potentially be surprised in every period, and their expectations about the future (incl. the final steady state) may change. Currently the sequence of information sets needs to be passed through a CSV file. Another interface may be added in the future. The algorithm uses a sequence of (true) perfect foresight simulations (not necessarily as many as there are periods, because if the information set does not change between two periods, there is no need to do a new computation). There are two possibilities for guess values: — the default is to use the initial steady state for the simulation using the first-period information set; then use previously simulated values as guess values — alternatively, with the terminal_steady_state_as_guess_value option, use the terminal steady state as guess value for all future periods (this is actually what the “true” perfect foresight solver does by default)
2021-07-09 18:12:10 +02:00
options_.periods = periods;
Various improvements to perfect foresight homotopy – new option “endval_steady” to pf_setup command to recompute terminal steady state in the homotopy loop – new options “homotopy_linearization_fallback” and “homotopy_marginal_linearization_fallback” to pf_solver and pfwee_solver commands, to get an approximate solution when homotopy fails to go to 100% – new options “homotopy_initial_step_size”, “homotopy_min_step_size”, “homotopy_step_size_increase_success_count” and “homotopy_max_completion_share” to pf_solver and pfwee_solver commands to fine tune the homotopy behaviour – removed option “homotopy_alt_starting_point” to pf_solver command, not really useful – new options “steady_solve_algo”, “steady_tolf”, “steady_tolx”, “steady_maxit”, “steady_markowitz” to pf_solver and pfwee_solver commands, to control the computation of the terminal steady state (and remove the equivalent options which previously had different names in pfwee_solver command)
2023-06-15 16:59:37 +02:00
options_.simul.homotopy_max_completion_share = orig_homotopy_max_completion_share;
options_.simul.endval_steady = orig_endval_steady;