From 439f4b4c083a5051a55222d13cc68415aab9f90c Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Sat, 10 Jan 2026 09:16:30 +1300 Subject: [PATCH 01/67] p_grid --- .../FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m | 6 +++--- .../HeteroAgentStationaryEqm_Case1_FHorz_PType.m | 3 +-- HeterogeneousAgent/HeteroAgentStationaryEqm_Case1.m | 12 ++++++------ .../PType/HeteroAgentStationaryEqm_Case1_PType.m | 3 +-- 4 files changed, 11 insertions(+), 13 deletions(-) diff --git a/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m b/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m index 0a660cdb..9c0f3c46 100644 --- a/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m +++ b/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m @@ -63,8 +63,8 @@ heteroagentoptions.multiGEweights=ones(1,length(fieldnames(GeneralEqmEqns))); end if N_p~=0 - if ~isfield(heteroagentoptions,'pgrid') - error('You have set n_p to a non-zero value, but not declared heteroagentoptions.pgrid') + if ~isfield(heteroagentoptions,'p_grid') + error('You have set n_p to a non-zero value, but not declared heteroagentoptions.p_grid') end end if ~isfield(heteroagentoptions,'toleranceGEprices') @@ -575,4 +575,4 @@ -end \ No newline at end of file +end diff --git a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m index b3eebb9f..f2388289 100644 --- a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m +++ b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m @@ -96,8 +96,7 @@ end if N_p~=0 if ~isfield(heteroagentoptions,'p_grid') - disp('ERROR: you have set n_p to a non-zero value, but not declared heteroagentoptions.pgrid') - dbstack + error('You have set n_p to a non-zero value, but not declared heteroagentoptions.p_grid') end end if ~isfield(heteroagentoptions,'toleranceGEprices') diff --git a/HeterogeneousAgent/HeteroAgentStationaryEqm_Case1.m b/HeterogeneousAgent/HeteroAgentStationaryEqm_Case1.m index a316abff..e5c27633 100644 --- a/HeterogeneousAgent/HeteroAgentStationaryEqm_Case1.m +++ b/HeterogeneousAgent/HeteroAgentStationaryEqm_Case1.m @@ -1,6 +1,6 @@ function varargout=HeteroAgentStationaryEqm_Case1(n_d, n_a, n_z, n_p, pi_z, d_grid, a_grid, z_grid, ReturnFn, FnsToEvaluate, GeneralEqmEqns, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, GeneralEqmEqnParamNames, GEPriceParamNames,heteroagentoptions, simoptions, vfoptions, EntryExitParamNames) % Outputs: [p_eqm, GeneralEqmConditions] -% Unless you use n_p and p_grid (n.b. heteroagentoptions.pgrid), in which case [p_eq, p_eqm_index, GeneralEqmConditions] +% Unless you use n_p and p_grid (n.b. heteroagentoptions.p_grid), in which case [p_eq, p_eqm_index, GeneralEqmConditions] % Input heteroagentoptions and those that appear after it are all optional. @@ -444,13 +444,13 @@ minoptions = optimset('TolX',heteroagentoptions.toleranceGEprices,'TolFun',heteroagentoptions.toleranceGEcondns,'MaxFunEvals',heteroagentoptions.maxiter); p_eqm_index=nan; % If not using p_grid then this is irrelevant/useless if N_p~=0 % Solving on p_grid - GeneralEqmConditions=zeros(size(heteroagentoptions.pgrid)); % - for pp_c=1:size(heteroagentoptions.pgrid,1) - pvec=heteroagentoptions.pgrid(pp_c,:); + GeneralEqmConditions=zeros(size(heteroagentoptions.p_grid)); % + for pp_c=1:size(heteroagentoptions.p_grid,1) + pvec=heteroagentoptions.p_grid(pp_c,:); GeneralEqmConditions(pp_c,:)=GeneralEqmConditionsFnOpt(pvec); end [~,p_eqm_index]=max(sum(GeneralEqmConditions.^2,2)); - p_eqm_vec=heteroagentoptions.pgrid(p_eqm_index,:); % CHECK THAT THIS IS CORRECT! + p_eqm_vec=heteroagentoptions.p_grid(p_eqm_index,:); % CHECK THAT THIS IS CORRECT! elseif heteroagentoptions.fminalgo==0 % fzero, is based on root-finding so it needs just the vector of GEcondns, not the sum-of-squares (it is not a minimization routine) [p_eqm_vec,GeneralEqmConditions]=fzero(GeneralEqmConditionsFnOpt,GEparamsvec0,minoptions); elseif heteroagentoptions.fminalgo==1 @@ -636,4 +636,4 @@ end -end \ No newline at end of file +end diff --git a/HeterogeneousAgent/PType/HeteroAgentStationaryEqm_Case1_PType.m b/HeterogeneousAgent/PType/HeteroAgentStationaryEqm_Case1_PType.m index 78311707..425dcbb9 100644 --- a/HeterogeneousAgent/PType/HeteroAgentStationaryEqm_Case1_PType.m +++ b/HeterogeneousAgent/PType/HeteroAgentStationaryEqm_Case1_PType.m @@ -84,8 +84,7 @@ end if N_p~=0 if isfield(heteroagentoptions,'p_grid')==0 - disp('ERROR: you have set n_p to a non-zero value, but not declared heteroagentoptions.pgrid') - dbstack + error('You have set n_p to a non-zero value, but not declared heteroagentoptions.p_grid') end end if isfield(heteroagentoptions,'toleranceGEprices')==0 From 9b819a147193769363177d71f2ac1d02f00be57d Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Sun, 11 Jan 2026 16:15:50 +1300 Subject: [PATCH 02/67] clean --- .../GeneralEqmConditions_Case1_v3.m | 4 ++-- .../GeneralEqmConditions_Case1_v3_TPath.m | 17 +++++++++++++++++ .../GeneralEqmConditions_Case1_v3g.m | 4 ++-- .../GeneralEqmConditions_Case1_v3g_ptype.m | 4 ++-- 4 files changed, 23 insertions(+), 6 deletions(-) create mode 100644 HeterogeneousAgent/EvaluateGeneralEqmEqns/GeneralEqmConditions_Case1_v3_TPath.m diff --git a/HeterogeneousAgent/EvaluateGeneralEqmEqns/GeneralEqmConditions_Case1_v3.m b/HeterogeneousAgent/EvaluateGeneralEqmEqns/GeneralEqmConditions_Case1_v3.m index bc744ed4..dbc2bdfa 100644 --- a/HeterogeneousAgent/EvaluateGeneralEqmEqns/GeneralEqmConditions_Case1_v3.m +++ b/HeterogeneousAgent/EvaluateGeneralEqmEqns/GeneralEqmConditions_Case1_v3.m @@ -4,8 +4,8 @@ GeneralEqmEqnParamsVec=gather(CreateVectorFromParams(Parameters,GeneralEqmEqnParamNames)); GeneralEqmEqnParamsCell=cell(length(GeneralEqmEqnParamsVec),1); -for jj=1:length(GeneralEqmEqnParamsVec) - GeneralEqmEqnParamsCell(jj,1)={GeneralEqmEqnParamsVec(jj)}; +for pp=1:length(GeneralEqmEqnParamsVec) + GeneralEqmEqnParamsCell(pp,1)={GeneralEqmEqnParamsVec(pp)}; end GeneralEqmConditionsValue=GeneralEqmEqnsCell(GeneralEqmEqnParamsCell{:}); diff --git a/HeterogeneousAgent/EvaluateGeneralEqmEqns/GeneralEqmConditions_Case1_v3_TPath.m b/HeterogeneousAgent/EvaluateGeneralEqmEqns/GeneralEqmConditions_Case1_v3_TPath.m new file mode 100644 index 00000000..f81f4140 --- /dev/null +++ b/HeterogeneousAgent/EvaluateGeneralEqmEqns/GeneralEqmConditions_Case1_v3_TPath.m @@ -0,0 +1,17 @@ +function GeneralEqmConditionsValue=GeneralEqmConditions_Case1_v3_TPath(GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters,T) +% Input should be just one General Eqm Condition, and must be in the cell form (not the structure form) +% This is a CPU based version of _v3g. Identical except this does not use GPU. + +% _TPath is that it does all the periods t=1:1:T at once +GeneralEqmConditionsValue=zeros(1,T); +for tt=1:T + GeneralEqmEqnParamsVec=gather(CreateVectorFromParams(Parameters,GeneralEqmEqnParamNames,tt)); + GeneralEqmEqnParamsCell=cell(length(GeneralEqmEqnParamsVec),1); + for pp=1:length(GeneralEqmEqnParamsVec) + GeneralEqmEqnParamsCell(pp,1)={GeneralEqmEqnParamsVec(pp)}; + end + + GeneralEqmConditionsValue(tt)=GeneralEqmEqnsCell(GeneralEqmEqnParamsCell{:}); +end + +end diff --git a/HeterogeneousAgent/EvaluateGeneralEqmEqns/GeneralEqmConditions_Case1_v3g.m b/HeterogeneousAgent/EvaluateGeneralEqmEqns/GeneralEqmConditions_Case1_v3g.m index c0adc12c..ca335dcf 100644 --- a/HeterogeneousAgent/EvaluateGeneralEqmEqns/GeneralEqmConditions_Case1_v3g.m +++ b/HeterogeneousAgent/EvaluateGeneralEqmEqns/GeneralEqmConditions_Case1_v3g.m @@ -4,8 +4,8 @@ GeneralEqmEqnParamsVec=gpuArray(CreateVectorFromParams(Parameters,GeneralEqmEqnParamNames)); GeneralEqmEqnParamsCell=cell(length(GeneralEqmEqnParamsVec),1); -for jj=1:length(GeneralEqmEqnParamsVec) - GeneralEqmEqnParamsCell(jj,1)={GeneralEqmEqnParamsVec(jj)}; +for pp=1:length(GeneralEqmEqnParamsVec) + GeneralEqmEqnParamsCell(pp,1)={GeneralEqmEqnParamsVec(pp)}; end GeneralEqmConditionsValue=GeneralEqmEqnsCell(GeneralEqmEqnParamsCell{:}); diff --git a/HeterogeneousAgent/EvaluateGeneralEqmEqns/GeneralEqmConditions_Case1_v3g_ptype.m b/HeterogeneousAgent/EvaluateGeneralEqmEqns/GeneralEqmConditions_Case1_v3g_ptype.m index 4d49923e..2dde51e0 100644 --- a/HeterogeneousAgent/EvaluateGeneralEqmEqns/GeneralEqmConditions_Case1_v3g_ptype.m +++ b/HeterogeneousAgent/EvaluateGeneralEqmEqns/GeneralEqmConditions_Case1_v3g_ptype.m @@ -4,8 +4,8 @@ GeneralEqmEqnParamsVec=gpuArray(CreateVectorFromParams(Parameters,GeneralEqmEqnParamNames,1)); % the ,1 is only difference of _ptype GeneralEqmEqnParamsCell=cell(length(GeneralEqmEqnParamsVec),1); -for jj=1:length(GeneralEqmEqnParamsVec) - GeneralEqmEqnParamsCell(jj,1)={GeneralEqmEqnParamsVec(jj)}; +for pp=1:length(GeneralEqmEqnParamsVec) + GeneralEqmEqnParamsCell(pp,1)={GeneralEqmEqnParamsVec(pp)}; end GeneralEqmConditionsValue=GeneralEqmEqnsCell(GeneralEqmEqnParamsCell{:}); From 8b34bbb36fd18f3932c9450beedc0c14b25a1e6b Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Mon, 12 Jan 2026 08:38:08 +1300 Subject: [PATCH 03/67] clean --- .../FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m | 9 +++++---- .../PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m | 9 +++++---- HeterogeneousAgent/HeteroAgentStationaryEqm_Case1.m | 9 +++++---- .../PType/HeteroAgentStationaryEqm_Case1_PType.m | 9 +++++---- 4 files changed, 20 insertions(+), 16 deletions(-) diff --git a/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m b/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m index 9c0f3c46..6f93d5c1 100644 --- a/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m +++ b/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m @@ -375,13 +375,14 @@ minoptions = optimset('TolX',heteroagentoptions.toleranceGEprices,'TolFun',heteroagentoptions.toleranceGEcondns,'MaxFunEvals',heteroagentoptions.maxiter,'MaxIter',heteroagentoptions.maxiter); p_eqm_index=nan; % If not using p_grid then this is irrelevant/useless if N_p~=0 % Solving on p_grid - GeneralEqmConditions=zeros(size(heteroagentoptions.p_grid)); - for pp_c=1:size(heteroagentoptions.p_grid,1) - pvec=heteroagentoptions.p_grid(pp_c,:); + p_gridvals=CreateGridvals(n_p,heteroagentoptions.p_grid,1); + GeneralEqmConditions=zeros(size(p_gridvals)); % + for pp_c=1:N_p + pvec=p_gridvals(pp_c,:); GeneralEqmConditions(pp_c,:)=GeneralEqmConditionsFnOpt(pvec); end [~,p_eqm_index]=max(sum(GeneralEqmConditions.^2,2)); - p_eqm=heteroagentoptions.p_grid(p_eqm_index,:); + p_eqm_vec=p_gridvals(p_eqm_index,:); elseif heteroagentoptions.fminalgo==0 % fzero, is based on root-finding so it needs just the vector of GEcondns, not the sum-of-squares (it is not a minimization routine) [p_eqm_vec,GeneralEqmConditions]=fzero(GeneralEqmConditionsFnOpt,GEparamsvec0,minoptions); elseif heteroagentoptions.fminalgo==1 diff --git a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m index f2388289..2a02ff3c 100644 --- a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m +++ b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m @@ -775,13 +775,14 @@ minoptions = optimset('TolX',heteroagentoptions.toleranceGEprices,'TolFun',heteroagentoptions.toleranceGEcondns,'MaxFunEvals',heteroagentoptions.maxiter); p_eqm_index=nan; % If not using p_grid then this is irrelevant/useless if N_p~=0 % Solving on p_grid - GeneralEqmConditions=zeros(size(heteroagentoptions.p_grid)); - for pp_c=1:size(heteroagentoptions.p_grid,1) - pvec=heteroagentoptions.p_grid(pp_c,:); + p_gridvals=CreateGridvals(n_p,heteroagentoptions.p_grid,1); + GeneralEqmConditions=zeros(size(p_gridvals)); % + for pp_c=1:N_p + pvec=p_gridvals(pp_c,:); GeneralEqmConditions(pp_c,:)=GeneralEqmConditionsFnOpt(pvec); end [~,p_eqm_index]=max(sum(GeneralEqmConditions.^2,2)); - p_eqm=heteroagentoptions.p_grid(p_eqm_index,:); + p_eqm_vec=p_gridvals(p_eqm_index,:); elseif heteroagentoptions.fminalgo==0 % fzero, is based on root-finding so it needs just the vector of GEcondns, not the sum-of-squares (it is not a minimization routine) [p_eqm_vec,GeneralEqmConditions]=fzero(GeneralEqmConditionsFnOpt,GEparamsvec0,minoptions); elseif heteroagentoptions.fminalgo==1 diff --git a/HeterogeneousAgent/HeteroAgentStationaryEqm_Case1.m b/HeterogeneousAgent/HeteroAgentStationaryEqm_Case1.m index e5c27633..6725ffea 100644 --- a/HeterogeneousAgent/HeteroAgentStationaryEqm_Case1.m +++ b/HeterogeneousAgent/HeteroAgentStationaryEqm_Case1.m @@ -444,13 +444,14 @@ minoptions = optimset('TolX',heteroagentoptions.toleranceGEprices,'TolFun',heteroagentoptions.toleranceGEcondns,'MaxFunEvals',heteroagentoptions.maxiter); p_eqm_index=nan; % If not using p_grid then this is irrelevant/useless if N_p~=0 % Solving on p_grid - GeneralEqmConditions=zeros(size(heteroagentoptions.p_grid)); % - for pp_c=1:size(heteroagentoptions.p_grid,1) - pvec=heteroagentoptions.p_grid(pp_c,:); + p_gridvals=CreateGridvals(n_p,heteroagentoptions.p_grid,1); + GeneralEqmConditions=zeros(size(p_gridvals)); % + for pp_c=1:N_p + pvec=p_gridvals(pp_c,:); GeneralEqmConditions(pp_c,:)=GeneralEqmConditionsFnOpt(pvec); end [~,p_eqm_index]=max(sum(GeneralEqmConditions.^2,2)); - p_eqm_vec=heteroagentoptions.p_grid(p_eqm_index,:); % CHECK THAT THIS IS CORRECT! + p_eqm_vec=p_gridvals(p_eqm_index,:); elseif heteroagentoptions.fminalgo==0 % fzero, is based on root-finding so it needs just the vector of GEcondns, not the sum-of-squares (it is not a minimization routine) [p_eqm_vec,GeneralEqmConditions]=fzero(GeneralEqmConditionsFnOpt,GEparamsvec0,minoptions); elseif heteroagentoptions.fminalgo==1 diff --git a/HeterogeneousAgent/PType/HeteroAgentStationaryEqm_Case1_PType.m b/HeterogeneousAgent/PType/HeteroAgentStationaryEqm_Case1_PType.m index 425dcbb9..cd7a7e99 100644 --- a/HeterogeneousAgent/PType/HeteroAgentStationaryEqm_Case1_PType.m +++ b/HeterogeneousAgent/PType/HeteroAgentStationaryEqm_Case1_PType.m @@ -715,13 +715,14 @@ minoptions = optimset('TolX',heteroagentoptions.toleranceGEprices,'TolFun',heteroagentoptions.toleranceGEcondns); p_eqm_index=nan; % If not using p_grid then this is irrelevant/useless if N_p~=0 % Solving on p_grid - GeneralEqmConditions=zeros(size(heteroagentoptions.p_grid)); - for pp_c=1:size(heteroagentoptions.p_grid,1) - pvec=heteroagentoptions.p_grid(pp_c,:); + p_gridvals=CreateGridvals(n_p,heteroagentoptions.p_grid,1); + GeneralEqmConditions=zeros(size(p_gridvals)); % + for pp_c=1:N_p + pvec=p_gridvals(pp_c,:); GeneralEqmConditions(pp_c,:)=GeneralEqmConditionsFnOpt(pvec); end [~,p_eqm_index]=max(sum(GeneralEqmConditions.^2,2)); - p_eqm=heteroagentoptions.p_grid(p_eqm_index,:); + p_eqm_vec=p_gridvals(p_eqm_index,:); elseif heteroagentoptions.fminalgo==0 % fzero, is based on root-finding so it needs just the vector of GEcondns, not the sum-of-squares (it is not a minimization routine) [p_eqm_vec,GeneralEqmConditions]=fzero(GeneralEqmConditionsFnOpt,GEparamsvec0,minoptions); elseif heteroagentoptions.fminalgo==1 From 1be62c09690b7ee0307336d0c268c676c0cf8a71 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Mon, 12 Jan 2026 09:22:20 +1300 Subject: [PATCH 04/67] clean p_grid --- HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m | 1 + .../FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m | 1 + HeterogeneousAgent/HeteroAgentStationaryEqm_Case1.m | 1 + HeterogeneousAgent/PType/HeteroAgentStationaryEqm_Case1_PType.m | 1 + 4 files changed, 4 insertions(+) diff --git a/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m b/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m index 6f93d5c1..bebd868d 100644 --- a/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m +++ b/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m @@ -383,6 +383,7 @@ end [~,p_eqm_index]=max(sum(GeneralEqmConditions.^2,2)); p_eqm_vec=p_gridvals(p_eqm_index,:); + heteroagentoptions.outputGEstruct=0; % Output the GeneralEqmConditions as a matrix elseif heteroagentoptions.fminalgo==0 % fzero, is based on root-finding so it needs just the vector of GEcondns, not the sum-of-squares (it is not a minimization routine) [p_eqm_vec,GeneralEqmConditions]=fzero(GeneralEqmConditionsFnOpt,GEparamsvec0,minoptions); elseif heteroagentoptions.fminalgo==1 diff --git a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m index 2a02ff3c..6445cdb7 100644 --- a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m +++ b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m @@ -783,6 +783,7 @@ end [~,p_eqm_index]=max(sum(GeneralEqmConditions.^2,2)); p_eqm_vec=p_gridvals(p_eqm_index,:); + heteroagentoptions.outputGEstruct=0; % Output the GeneralEqmConditions as a matrix elseif heteroagentoptions.fminalgo==0 % fzero, is based on root-finding so it needs just the vector of GEcondns, not the sum-of-squares (it is not a minimization routine) [p_eqm_vec,GeneralEqmConditions]=fzero(GeneralEqmConditionsFnOpt,GEparamsvec0,minoptions); elseif heteroagentoptions.fminalgo==1 diff --git a/HeterogeneousAgent/HeteroAgentStationaryEqm_Case1.m b/HeterogeneousAgent/HeteroAgentStationaryEqm_Case1.m index 6725ffea..354623b8 100644 --- a/HeterogeneousAgent/HeteroAgentStationaryEqm_Case1.m +++ b/HeterogeneousAgent/HeteroAgentStationaryEqm_Case1.m @@ -452,6 +452,7 @@ end [~,p_eqm_index]=max(sum(GeneralEqmConditions.^2,2)); p_eqm_vec=p_gridvals(p_eqm_index,:); + heteroagentoptions.outputGEstruct=0; % Output the GeneralEqmConditions as a matrix elseif heteroagentoptions.fminalgo==0 % fzero, is based on root-finding so it needs just the vector of GEcondns, not the sum-of-squares (it is not a minimization routine) [p_eqm_vec,GeneralEqmConditions]=fzero(GeneralEqmConditionsFnOpt,GEparamsvec0,minoptions); elseif heteroagentoptions.fminalgo==1 diff --git a/HeterogeneousAgent/PType/HeteroAgentStationaryEqm_Case1_PType.m b/HeterogeneousAgent/PType/HeteroAgentStationaryEqm_Case1_PType.m index cd7a7e99..fa281ff8 100644 --- a/HeterogeneousAgent/PType/HeteroAgentStationaryEqm_Case1_PType.m +++ b/HeterogeneousAgent/PType/HeteroAgentStationaryEqm_Case1_PType.m @@ -723,6 +723,7 @@ end [~,p_eqm_index]=max(sum(GeneralEqmConditions.^2,2)); p_eqm_vec=p_gridvals(p_eqm_index,:); + heteroagentoptions.outputGEstruct=0; % Output the GeneralEqmConditions as a matrix elseif heteroagentoptions.fminalgo==0 % fzero, is based on root-finding so it needs just the vector of GEcondns, not the sum-of-squares (it is not a minimization routine) [p_eqm_vec,GeneralEqmConditions]=fzero(GeneralEqmConditionsFnOpt,GEparamsvec0,minoptions); elseif heteroagentoptions.fminalgo==1 From 79c3e29d9817bfc737178c00ddd80b2b069b35d7 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Mon, 12 Jan 2026 09:32:02 +1300 Subject: [PATCH 05/67] redo https://github.com/vfitoolkit/VFIToolkit-matlab/pull/42/commits/72bdd4ed916b910021c72033397432ccf3f59aae which I accidently overwrote --- .../LifeCycleProfiles_FHorz_Case1_PType.m | 27 +++++++++++-------- 1 file changed, 16 insertions(+), 11 deletions(-) diff --git a/EvaluateFnOnAgentDist/FHorz/PType/LifeCycleProfiles_FHorz_Case1_PType.m b/EvaluateFnOnAgentDist/FHorz/PType/LifeCycleProfiles_FHorz_Case1_PType.m index 39263fde..03711775 100644 --- a/EvaluateFnOnAgentDist/FHorz/PType/LifeCycleProfiles_FHorz_Case1_PType.m +++ b/EvaluateFnOnAgentDist/FHorz/PType/LifeCycleProfiles_FHorz_Case1_PType.m @@ -228,7 +228,7 @@ end end end -elseif length(simoptions.agejshifter)==1 % not using agejshifter +elseif isscalar(simoptions.agejshifter) % not using agejshifter simoptions.agejshifter=zeros(N_i,1); N_j_max2=N_j_max; else % have inputed as a vector @@ -563,7 +563,12 @@ if FnsAndPTypeIndicator_ii(ff)==1 % If this function is relevant to this ptype % Get parameter names for current FnsToEvaluate functions - tempnames=getAnonymousFnInputNames(FnsToEvaluate.(FnsToEvalNames{ff})); + if isstruct(FnsToEvaluate.(FnsToEvalNames{ff})) + tempfn=FnsToEvaluate.(FnsToEvalNames{ff}).(Names_i{ii}); + else + tempfn=FnsToEvaluate.(FnsToEvalNames{ff}); + end + tempnames=getAnonymousFnInputNames(tempfn); if length(tempnames)>(l_daprime_temp+l_a_temp+l_z_temp) FnsToEvaluateParamNames={tempnames{l_daprime_temp+l_a_temp+l_z_temp+1:end}}; % the first inputs will always be (d,aprime,a,z) else @@ -577,7 +582,7 @@ %% We have set up the current PType, now do some calculations for it. simoptions_temp.keepoutputasmatrix=2; - ValuesOnGrid_ffii=EvalFnOnAgentDist_Grid_J(FnsToEvaluate.(FnsToEvalNames{ff}),CellOverAgeOfParamValues,PolicyValuesPermute_temp,l_daprime_temp,n_a_temp,n_z_temp,a_gridvals_temp,z_gridvals_J_temp); + ValuesOnGrid_ffii=EvalFnOnAgentDist_Grid_J(tempfn,CellOverAgeOfParamValues,PolicyValuesPermute_temp,l_daprime_temp,n_a_temp,n_z_temp,a_gridvals_temp,z_gridvals_J_temp); ValuesOnGrid_ffii=reshape(ValuesOnGrid_ffii,[N_a_temp*N_z_temp,N_j_temp]); % StationaryDist_ii=reshape(StationaryDist.(Names_i{ii}),[N_a_temp*N_z_temp,N_j_temp]); % Note: does not impose *StationaryDist.ptweights(ii) @@ -1193,37 +1198,37 @@ % a structure is there a need to take just a specific part and send % only that to the 'non-PType' version of the command. - if isa(n_d,'struct') + if isstruct(n_d) n_d_temp=n_d.(Names_i{ii}); else n_d_temp=n_d; end - if isa(n_a,'struct') + if isstruct(n_a) n_a_temp=n_a.(Names_i{ii}); else n_a_temp=n_a; end - if isa(n_z,'struct') + if isstruct(n_z) n_z_temp=n_z.(Names_i{ii}); else n_z_temp=n_z; end - if isa(N_j,'struct') + if isstruct(N_j) N_j_temp=N_j.(Names_i{ii}); else N_j_temp=N_j; end - if isa(d_grid,'struct') + if isstruct(d_grid) d_grid_temp=d_grid.(Names_i{ii}); else d_grid_temp=d_grid; end - if isa(a_grid,'struct') + if isstruct(a_grid) a_grid_temp=a_grid.(Names_i{ii}); else a_grid_temp=a_grid; end - if isa(z_grid,'struct') + if isstruct(z_grid) z_grid_temp=z_grid.(Names_i{ii}); else z_grid_temp=z_grid; @@ -1236,7 +1241,7 @@ FullParamNames=fieldnames(Parameters); nFields=length(FullParamNames); for kField=1:nFields - if isa(Parameters.(FullParamNames{kField}), 'struct') % Check for permanent type in structure form + if isstruct(Parameters.(FullParamNames{kField})) % Check for permanent type in structure form names=fieldnames(Parameters.(FullParamNames{kField})); for jj=1:length(names) if strcmp(names{jj},Names_i{ii}) From 88d85b8ba8c90a951dc176f5eab52b05db7c8a40 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Mon, 12 Jan 2026 09:55:23 +1300 Subject: [PATCH 06/67] reoorg --- .../EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit.m | 0 .../EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit2.m | 0 .../EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit2_pgrid.m | 0 .../EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit2_subfn.m | 0 .../EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit_pgrid.m | 0 .../EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit_subfn.m | 0 .../HeteroAgentStationaryEqm_Case1_EntryExit_subfn_condlentry.m | 0 HeterogeneousAgent/{ => InfHorz}/HeteroAgentStationaryEqm_Case1.m | 0 .../{ => InfHorz}/HeteroAgentStationaryEqm_Case1_subfn.m | 0 HeterogeneousAgent/{ => InfHorz}/HeteroAgentStationaryEqm_Case2.m | 0 .../{ => InfHorz}/HeteroAgentStationaryEqm_Case2_subfn.m | 0 .../{ => InfHorz}/PType/HeteroAgentStationaryEqm_Case1_PType.m | 0 .../PType/HeteroAgentStationaryEqm_Case1_PType_subfn.m | 0 13 files changed, 0 insertions(+), 0 deletions(-) rename HeterogeneousAgent/{ => InfHorz}/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit.m (100%) rename HeterogeneousAgent/{ => InfHorz}/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit2.m (100%) rename HeterogeneousAgent/{ => InfHorz}/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit2_pgrid.m (100%) rename HeterogeneousAgent/{ => InfHorz}/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit2_subfn.m (100%) rename HeterogeneousAgent/{ => InfHorz}/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit_pgrid.m (100%) rename HeterogeneousAgent/{ => InfHorz}/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit_subfn.m (100%) rename HeterogeneousAgent/{ => InfHorz}/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit_subfn_condlentry.m (100%) rename HeterogeneousAgent/{ => InfHorz}/HeteroAgentStationaryEqm_Case1.m (100%) rename HeterogeneousAgent/{ => InfHorz}/HeteroAgentStationaryEqm_Case1_subfn.m (100%) rename HeterogeneousAgent/{ => InfHorz}/HeteroAgentStationaryEqm_Case2.m (100%) rename HeterogeneousAgent/{ => InfHorz}/HeteroAgentStationaryEqm_Case2_subfn.m (100%) rename HeterogeneousAgent/{ => InfHorz}/PType/HeteroAgentStationaryEqm_Case1_PType.m (100%) rename HeterogeneousAgent/{ => InfHorz}/PType/HeteroAgentStationaryEqm_Case1_PType_subfn.m (100%) diff --git a/HeterogeneousAgent/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit.m b/HeterogeneousAgent/InfHorz/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit.m similarity index 100% rename from HeterogeneousAgent/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit.m rename to HeterogeneousAgent/InfHorz/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit.m diff --git a/HeterogeneousAgent/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit2.m b/HeterogeneousAgent/InfHorz/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit2.m similarity index 100% rename from HeterogeneousAgent/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit2.m rename to HeterogeneousAgent/InfHorz/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit2.m diff --git a/HeterogeneousAgent/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit2_pgrid.m b/HeterogeneousAgent/InfHorz/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit2_pgrid.m similarity index 100% rename from HeterogeneousAgent/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit2_pgrid.m rename to HeterogeneousAgent/InfHorz/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit2_pgrid.m diff --git a/HeterogeneousAgent/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit2_subfn.m b/HeterogeneousAgent/InfHorz/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit2_subfn.m similarity index 100% rename from HeterogeneousAgent/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit2_subfn.m rename to HeterogeneousAgent/InfHorz/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit2_subfn.m diff --git a/HeterogeneousAgent/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit_pgrid.m b/HeterogeneousAgent/InfHorz/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit_pgrid.m similarity index 100% rename from HeterogeneousAgent/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit_pgrid.m rename to HeterogeneousAgent/InfHorz/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit_pgrid.m diff --git a/HeterogeneousAgent/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit_subfn.m b/HeterogeneousAgent/InfHorz/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit_subfn.m similarity index 100% rename from HeterogeneousAgent/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit_subfn.m rename to HeterogeneousAgent/InfHorz/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit_subfn.m diff --git a/HeterogeneousAgent/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit_subfn_condlentry.m b/HeterogeneousAgent/InfHorz/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit_subfn_condlentry.m similarity index 100% rename from HeterogeneousAgent/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit_subfn_condlentry.m rename to HeterogeneousAgent/InfHorz/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit_subfn_condlentry.m diff --git a/HeterogeneousAgent/HeteroAgentStationaryEqm_Case1.m b/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1.m similarity index 100% rename from HeterogeneousAgent/HeteroAgentStationaryEqm_Case1.m rename to HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1.m diff --git a/HeterogeneousAgent/HeteroAgentStationaryEqm_Case1_subfn.m b/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1_subfn.m similarity index 100% rename from HeterogeneousAgent/HeteroAgentStationaryEqm_Case1_subfn.m rename to HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1_subfn.m diff --git a/HeterogeneousAgent/HeteroAgentStationaryEqm_Case2.m b/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case2.m similarity index 100% rename from HeterogeneousAgent/HeteroAgentStationaryEqm_Case2.m rename to HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case2.m diff --git a/HeterogeneousAgent/HeteroAgentStationaryEqm_Case2_subfn.m b/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case2_subfn.m similarity index 100% rename from HeterogeneousAgent/HeteroAgentStationaryEqm_Case2_subfn.m rename to HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case2_subfn.m diff --git a/HeterogeneousAgent/PType/HeteroAgentStationaryEqm_Case1_PType.m b/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m similarity index 100% rename from HeterogeneousAgent/PType/HeteroAgentStationaryEqm_Case1_PType.m rename to HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m diff --git a/HeterogeneousAgent/PType/HeteroAgentStationaryEqm_Case1_PType_subfn.m b/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType_subfn.m similarity index 100% rename from HeterogeneousAgent/PType/HeteroAgentStationaryEqm_Case1_PType_subfn.m rename to HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType_subfn.m From ed3daeffe7621ac80e56eaac4c9a2a50cb1fad86 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Mon, 12 Jan 2026 14:11:07 +1300 Subject: [PATCH 07/67] minor --- .../EvalFnOnAgentDist_AggVars_Case1.m | 2 +- .../PricePathParamPath_StructToMatrix.m | 43 +++++++++++-------- 2 files changed, 25 insertions(+), 20 deletions(-) diff --git a/EvaluateFnOnAgentDist/EvalFnOnAgentDist_AggVars_Case1.m b/EvaluateFnOnAgentDist/EvalFnOnAgentDist_AggVars_Case1.m index 8e5342a3..aa04a855 100644 --- a/EvaluateFnOnAgentDist/EvalFnOnAgentDist_AggVars_Case1.m +++ b/EvaluateFnOnAgentDist/EvalFnOnAgentDist_AggVars_Case1.m @@ -77,7 +77,7 @@ if isfield(simoptions,'outputasstructure') if simoptions.outputasstructure==1 FnsToEvaluateStruct=1; - FnsToEvalNames=simoptions.AggVarNames; + % FnsToEvalNames=simoptions.AggVarNames; elseif simoptions.outputasstructure==0 FnsToEvaluateStruct=0; end diff --git a/TransitionPaths/Subcodes/PricePathParamPath_StructToMatrix.m b/TransitionPaths/Subcodes/PricePathParamPath_StructToMatrix.m index 9aebfb63..447bb36a 100644 --- a/TransitionPaths/Subcodes/PricePathParamPath_StructToMatrix.m +++ b/TransitionPaths/Subcodes/PricePathParamPath_StructToMatrix.m @@ -27,26 +27,31 @@ end ParamPathNames=fieldnames(ParamPathStruct); -ParamPathSizeVec=zeros(1,length(ParamPathNames)); % Allows for a given price param to depend on age (or permanent type) -for pp=1:length(ParamPathNames) - temp=ParamPathStruct.(ParamPathNames{pp}); - tempsize=size(temp); - ParamPathSizeVec(pp)=tempsize(tempsize~=T); % Get the dimension which is not T -end -ParamPathSizeVec=cumsum(ParamPathSizeVec); -if length(ParamPathNames)>1 - ParamPathSizeVec=[[1,ParamPathSizeVec(1:end-1)+1];ParamPathSizeVec]; -else - ParamPathSizeVec=[1;ParamPathSizeVec]; -end -ParamPath=zeros(T,ParamPathSizeVec(2,end));% Do this seperately afterwards so that can preallocate the memory -for pp=1:length(ParamPathNames) - if size(ParamPathStruct.(ParamPathNames{pp}),1)==T - ParamPath(:,ParamPathSizeVec(1,pp):ParamPathSizeVec(2,pp))=ParamPathStruct.(ParamPathNames{pp}); - else % Need to transpose - ParamPath(:,ParamPathSizeVec(1,pp):ParamPathSizeVec(2,pp))=ParamPathStruct.(ParamPathNames{pp})'; +if ~isempty(ParamPathNames) + ParamPathSizeVec=zeros(1,length(ParamPathNames)); % Allows for a given price param to depend on age (or permanent type) + for pp=1:length(ParamPathNames) + temp=ParamPathStruct.(ParamPathNames{pp}); + tempsize=size(temp); + ParamPathSizeVec(pp)=tempsize(tempsize~=T); % Get the dimension which is not T + end + ParamPathSizeVec=cumsum(ParamPathSizeVec); + if length(ParamPathNames)>1 + ParamPathSizeVec=[[1,ParamPathSizeVec(1:end-1)+1];ParamPathSizeVec]; + else + ParamPathSizeVec=[1;ParamPathSizeVec]; end -% ParamPath(:,pp)=ParamPathStruct.(ParamPathNames{pp}); + ParamPath=zeros(T,ParamPathSizeVec(2,end));% Do this seperately afterwards so that can preallocate the memory + for pp=1:length(ParamPathNames) + if size(ParamPathStruct.(ParamPathNames{pp}),1)==T + ParamPath(:,ParamPathSizeVec(1,pp):ParamPathSizeVec(2,pp))=ParamPathStruct.(ParamPathNames{pp}); + else % Need to transpose + ParamPath(:,ParamPathSizeVec(1,pp):ParamPathSizeVec(2,pp))=ParamPathStruct.(ParamPathNames{pp})'; + end + % ParamPath(:,pp)=ParamPathStruct.(ParamPathNames{pp}); + end +else + ParamPathSizeVec=[]; + ParamPath=[]; end From b7030dcc795a2db90281bede07662d31a641dd1e Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Mon, 12 Jan 2026 14:35:06 +1300 Subject: [PATCH 08/67] preEV to prepare for matched expectations path --- .../FHorz/TransitionPath_Case1_FHorz.m | 1 + ...rz_TPath_SingleStep_fastOLG_DC1_GI_e_raw.m | 19 ++++++++++++++----- ...Path_SingleStep_fastOLG_DC1_GI_nod_e_raw.m | 19 ++++++++++++++----- ..._SingleStep_fastOLG_DC1_GI_nod_noz_e_raw.m | 11 +++++++++-- ...th_SingleStep_fastOLG_DC1_GI_nod_noz_raw.m | 11 +++++++++-- ..._TPath_SingleStep_fastOLG_DC1_GI_nod_raw.m | 17 ++++++++++++----- ...Path_SingleStep_fastOLG_DC1_GI_noz_e_raw.m | 11 +++++++++-- ..._TPath_SingleStep_fastOLG_DC1_GI_noz_raw.m | 10 ++++++++-- ...Horz_TPath_SingleStep_fastOLG_DC1_GI_raw.m | 17 ++++++++++++----- ...FHorz_TPath_SingleStep_fastOLG_DC1_e_raw.m | 19 ++++++++++++++----- ...z_TPath_SingleStep_fastOLG_DC1_nod_e_raw.m | 19 ++++++++++++++----- ...ath_SingleStep_fastOLG_DC1_nod_noz_e_raw.m | 10 +++++++--- ...TPath_SingleStep_fastOLG_DC1_nod_noz_raw.m | 18 +++++++++++------- ...orz_TPath_SingleStep_fastOLG_DC1_nod_raw.m | 17 ++++++++++++----- ...z_TPath_SingleStep_fastOLG_DC1_noz_e_raw.m | 8 +++++++- ...orz_TPath_SingleStep_fastOLG_DC1_noz_raw.m | 14 ++++++++++---- ...r_FHorz_TPath_SingleStep_fastOLG_DC1_raw.m | 17 ++++++++++++----- .../ValueFnOnTransPath_Case1_FHorz.m | 3 ++- .../ValueFnOnTransPath_Case1_FHorz_PType.m | 2 ++ 19 files changed, 179 insertions(+), 64 deletions(-) diff --git a/TransitionPaths/FHorz/TransitionPath_Case1_FHorz.m b/TransitionPaths/FHorz/TransitionPath_Case1_FHorz.m index 27d3521e..ee1467e0 100644 --- a/TransitionPaths/FHorz/TransitionPath_Case1_FHorz.m +++ b/TransitionPaths/FHorz/TransitionPath_Case1_FHorz.m @@ -135,6 +135,7 @@ vfoptions.endotype=0; end end +vfoptions.preEV=0; % =1 is used by 'Matched Expecations Path', for TPath we want =0 (this relates to details of fastOLG=1 value fn code) diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_e_raw.m index 73d8414b..b984053a 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_e_raw.m @@ -54,11 +54,20 @@ % Each column will be a specific parameter with the values at every age. ReturnFnParamsAgeMatrix=CreateAgeMatrixFromParams(Parameters, ReturnFnParamNames,N_j); % this will be a matrix, row indexes ages and column indexes the parameters (parameters which are not dependent on age appear as a constant valued column) -EVpre=[sum(V(N_a+1:end,:,:).*pi_e_J(N_a+1:end,:,:),3); zeros(N_a,N_z,'gpuArray')]; % I use zeros in j=N_j so that can just use pi_z_J to create expectations -EVpre=reshape(EVpre,[N_a,1,N_j,N_z]); -EV=EVpre.*shiftdim(pi_z_J,-2); -EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) -EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +if vfoptions.EVpre==0 + EVpre=[sum(V(N_a+1:end,:,:).*pi_e_J(N_a+1:end,:,:),3); zeros(N_a,N_z,'gpuArray')]; % I use zeros in j=N_j so that can just use pi_z_J to create expectations + EVpre=reshape(EVpre,[N_a,1,N_j,N_z]); + EV=EVpre.*shiftdim(pi_z_J,-2); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +elseif vfoptions.EVpre==1 + % This is used for 'Matched Expecations Path' + EVpre=[reshape(V,[N_a*N_j,N_z,N_e].*pi_e_J,3)]; % input V is already of size [N_a,N_j] and we want to use the whole thing + EVpre=reshape(EVpre,[N_a,1,N_j,N_z]); + EV=EVpre.*shiftdim(pi_z_J,-2); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +end % Interpolate EV over aprime_grid EVinterp=interp1(a_grid,EV,aprime_grid); diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_e_raw.m index 4dbc558a..a75377ff 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_e_raw.m @@ -49,11 +49,20 @@ % Each column will be a specific parameter with the values at every age. ReturnFnParamsAgeMatrix=CreateAgeMatrixFromParams(Parameters, ReturnFnParamNames,N_j); % this will be a matrix, row indexes ages and column indexes the parameters (parameters which are not dependent on age appear as a constant valued column) -EVpre=[sum(V(N_a+1:end,:,:).*pi_e_J(N_a+1:end,:,:),3); zeros(N_a,N_z,'gpuArray')]; % I use zeros in j=N_j so that can just use pi_z_J to create expectations -EVpre=reshape(EVpre,[N_a,1,N_j,N_z]); -EV=EVpre.*shiftdim(pi_z_J,-2); -EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) -EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +if vfoptions.EVpre==0 + EVpre=[sum(V(N_a+1:end,:,:).*pi_e_J(N_a+1:end,:,:),3); zeros(N_a,N_z,'gpuArray')]; % I use zeros in j=N_j so that can just use pi_z_J to create expectations + EVpre=reshape(EVpre,[N_a,1,N_j,N_z]); + EV=EVpre.*shiftdim(pi_z_J,-2); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +elseif vfoptions.EVpre==1 + % This is used for 'Matched Expecations Path' + EVpre=[reshape(V,[N_a*N_j,N_z,N_e].*pi_e_J,3)]; % input V is already of size [N_a,N_j] and we want to use the whole thing + EVpre=reshape(EVpre,[N_a,1,N_j,N_z]); + EV=EVpre.*shiftdim(pi_z_J,-2); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +end % Interpolate EV over aprime_grid EVinterp=interp1(a_grid,EV,aprime_grid); diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_noz_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_noz_e_raw.m index 5dea4350..2fc45ba8 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_noz_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_noz_e_raw.m @@ -47,8 +47,15 @@ ReturnFnParamsAgeMatrix=CreateAgeMatrixFromParams(Parameters, ReturnFnParamNames,N_j); % this will be a matrix, row indexes ages and column indexes the parameters (parameters which are not dependent on age appear as a constant valued column) % pi_e_J is (a,j)-by-e -EV=[sum(V(N_a+1:end,:).*pi_e_J(N_a+1:end,:),2); zeros(N_a,1,'gpuArray')]; % I use zeros in j=N_j so that can just use pi_e_J to create expectations -EV=reshape(EV,[N_a,1,N_j]); % (aprime,1,j), 2nd dim will be autofilled with a +if vfoptions.EVpre==0 + % pi_e_J is (a,j)-by-e + EV=[sum(V(N_a+1:end,:).*pi_e_J(N_a+1:end,:),2); zeros(N_a,1,'gpuArray')]; % I use zeros in j=N_j so that can just use pi_z_J to create expectations + EV=reshape(EV,[N_a,1,N_j]); % (aprime,1,j), 2nd dim will be autofilled with a +elseif vfoptions.EVpre==1 + % This is used for 'Matched Expecations Path' + EV=[reshape(V,[N_a*N_j,N_e].*pi_e_J,2)]; % input V is already of size [N_a,N_j] and we want to use the whole thing + EV=reshape(EV,[N_a,1,N_j]); % (aprime,1,j), 2nd dim will be autofilled with a +end % Interpolate EV over aprime_grid EVinterp=interp1(a_grid,EV,aprime_grid); diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_noz_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_noz_raw.m index 51c5f662..d1e7ef34 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_noz_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_noz_raw.m @@ -37,8 +37,15 @@ DiscountFactorParamsVec=prod(DiscountFactorParamsVec,2); DiscountFactorParamsVec=shiftdim(DiscountFactorParamsVec,-2); -EV=zeros(N_a,1,N_j,'gpuArray'); -EV(:,1,1:N_j-1)=V(:,2:end); +if vfoptions.EVpre==0 + EV=zeros(N_a,N_j,'gpuArray'); + EV(:,1:N_j-1)=V(:,2:end); + EV=reshape(EV,[N_a,1,N_j]); +elseif vfoptions.EVpre==1 + % This is used for 'Matched Expecations Path' + EV=reshape(V,[N_a,1,N_j]); % input V is of size [N_a,N_j] and we want to use the whole thing +end + % Interpolate EV over aprime_grid EVinterp=interp1(a_grid,EV,aprime_grid); diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_raw.m index d18fd909..37deccd5 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_raw.m @@ -47,11 +47,18 @@ % Each column will be a specific parameter with the values at every age. ReturnFnParamsAgeMatrix=CreateAgeMatrixFromParams(Parameters, ReturnFnParamNames,N_j); % this will be a matrix, row indexes ages and column indexes the parameters (parameters which are not dependent on age appear as a constant valued column) -EVpre=zeros(N_a,1,N_j,N_z); -EVpre(:,1,1:N_j-1,:)=reshape(V(N_a+1:end,:),[N_a,1,N_j-1,N_z]); % I use zeros in j=N_j so that can just use pi_z_J to create expectations -EV=EVpre.*shiftdim(pi_z_J,-2); -EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) -EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +if vfoptions.EVpre==0 + EVpre=zeros(N_a,1,N_j,N_z); + EVpre(:,1,1:N_j-1,:)=reshape(V(N_a+1:end,:),[N_a,1,N_j-1,N_z]); % I use zeros in j=N_j so that can just use pi_z_J to create expectations + EV=EVpre.*shiftdim(pi_z_J,-2); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +elseif vfoptions.EVpre==1 + % This is used for 'Matched Expecations Path' + EV=reshape(V,[N_a,1,N_j,N_z]).*shiftdim(pi_z_J,-2); % input V is already of size [N_a,N_j,N_z] and we want to use the whole thing + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +end % Interpolate EV over aprime_grid EVinterp=interp1(a_grid,EV,aprime_grid); diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_e_raw.m index df83a9c2..f45768e8 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_e_raw.m @@ -51,8 +51,15 @@ ReturnFnParamsAgeMatrix=CreateAgeMatrixFromParams(Parameters, ReturnFnParamNames,N_j); % this will be a matrix, row indexes ages and column indexes the parameters (parameters which are not dependent on age appear as a constant valued column) % pi_e_J is (a,j)-by-e -EV=[sum(V(N_a+1:end,:).*pi_e_J(N_a+1:end,:),2); zeros(N_a,1,'gpuArray')]; % I use zeros in j=N_j so that can just use pi_e_J to create expectations -EV=reshape(EV,[N_a,1,N_j]); +if vfoptions.EVpre==0 + % pi_e_J is (a,j)-by-e + EV=[sum(V(N_a+1:end,:).*pi_e_J(N_a+1:end,:),2); zeros(N_a,1,'gpuArray')]; % I use zeros in j=N_j so that can just use pi_z_J to create expectations + EV=reshape(EV,[N_a,1,N_j]); % (aprime,1,j), 2nd dim will be autofilled with a +elseif vfoptions.EVpre==1 + % This is used for 'Matched Expecations Path' + EV=[reshape(V,[N_a*N_j,N_e].*pi_e_J,2)]; % input V is already of size [N_a,N_j] and we want to use the whole thing + EV=reshape(EV,[N_a,1,N_j]); % (aprime,1,j), 2nd dim will be autofilled with a +end % Interpolate EV over aprime_grid EVinterp=interp1(a_grid,EV,aprime_grid); diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_raw.m index dcda4420..1e3d88f0 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_raw.m @@ -39,8 +39,14 @@ DiscountFactorParamsVec=prod(DiscountFactorParamsVec,2); DiscountFactorParamsVec=shiftdim(DiscountFactorParamsVec,-2); -EV=zeros(N_a,1,N_j,'gpuArray'); -EV(:,1,1:N_j-1)=V(:,2:end); +if vfoptions.EVpre==0 + EV=zeros(N_a,1,N_j,'gpuArray'); + EV(:,1,1:N_j-1)=V(:,2:end); +elseif vfoptions.EVpre==1 + % This is used for 'Matched Expecations Path' + EV=reshape(V,[N_a,1,N_j]); % input V is of size [N_a,N_j] and we want to use the whole thing +end + % Interpolate EV over aprime_grid EVinterp=interp1(a_grid,EV,aprime_grid); diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_raw.m index 3950820d..22ca5a2b 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_raw.m @@ -51,11 +51,18 @@ % Each column will be a specific parameter with the values at every age. ReturnFnParamsAgeMatrix=CreateAgeMatrixFromParams(Parameters, ReturnFnParamNames,N_j); % this will be a matrix, row indexes ages and column indexes the parameters (parameters which are not dependent on age appear as a constant valued column) -EVpre=zeros(N_a,1,N_j,N_z); -EVpre(:,1,1:N_j-1,:)=reshape(V(N_a+1:end,:),[N_a,1,N_j-1,N_z]); % I use zeros in j=N_j so that can just use pi_z_J to create expectations -EV=EVpre.*shiftdim(pi_z_J,-2); -EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) -EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +if vfoptions.EVpre==0 + EVpre=zeros(N_a,1,N_j,N_z); + EVpre(:,1,1:N_j-1,:)=reshape(V(N_a+1:end,:),[N_a,1,N_j-1,N_z]); % I use zeros in j=N_j so that can just use pi_z_J to create expectations + EV=EVpre.*shiftdim(pi_z_J,-2); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +elseif vfoptions.EVpre==1 + % This is used for 'Matched Expecations Path' + EV=reshape(V,[N_a,1,N_j,N_z]).*shiftdim(pi_z_J,-2); % input V is already of size [N_a,N_j,N_z] and we want to use the whole thing + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +end % Interpolate EV over aprime_grid EVinterp=interp1(a_grid,EV,aprime_grid); diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_e_raw.m index 83b5ba7a..30d625f0 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_e_raw.m @@ -37,11 +37,20 @@ % Each column will be a specific parameter with the values at every age. ReturnFnParamsAgeMatrix=CreateAgeMatrixFromParams(Parameters, ReturnFnParamNames,N_j); % this will be a matrix, row indexes ages and column indexes the parameters (parameters which are not dependent on age appear as a constant valued column) -EVpre=[sum(V(N_a+1:end,:,:).*pi_e_J(N_a+1:end,:,:),3); zeros(N_a,N_z,'gpuArray')]; % I use zeros in j=N_j so that can just use pi_z_J to create expectations -EVpre=reshape(EVpre,[N_a,1,N_j,N_z]); -EV=EVpre.*shiftdim(pi_z_J,-2); -EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) -EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +if vfoptions.EVpre==0 + EVpre=[sum(V(N_a+1:end,:,:).*pi_e_J(N_a+1:end,:,:),3); zeros(N_a,N_z,'gpuArray')]; % I use zeros in j=N_j so that can just use pi_z_J to create expectations + EVpre=reshape(EVpre,[N_a,1,N_j,N_z]); + EV=EVpre.*shiftdim(pi_z_J,-2); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +elseif vfoptions.EVpre==1 + % This is used for 'Matched Expecations Path' + EVpre=[reshape(V,[N_a*N_j,N_z,N_e].*pi_e_J,3)]; % input V is already of size [N_a,N_j] and we want to use the whole thing + EVpre=reshape(EVpre,[N_a,1,N_j,N_z]); + EV=EVpre.*shiftdim(pi_z_J,-2); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +end DiscountedEV=repelem(shiftdim(DiscountFactorParamsVec.*EV,-1),N_d,1,1,1); % [N_d,N_aprime,1,N_j,N_z] diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_e_raw.m index 467e9b34..41e67c56 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_e_raw.m @@ -31,11 +31,20 @@ % Each column will be a specific parameter with the values at every age. ReturnFnParamsAgeMatrix=CreateAgeMatrixFromParams(Parameters, ReturnFnParamNames,N_j); % this will be a matrix, row indexes ages and column indexes the parameters (parameters which are not dependent on age appear as a constant valued column) -EVpre=[sum(V(N_a+1:end,:,:).*pi_e_J(N_a+1:end,:,:),3); zeros(N_a,N_z,'gpuArray')]; % I use zeros in j=N_j so that can just use pi_z_J to create expectations -EVpre=reshape(EVpre,[N_a,1,N_j,N_z]); -EV=EVpre.*shiftdim(pi_z_J,-2); -EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) -EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +if vfoptions.EVpre==0 + EVpre=[sum(V(N_a+1:end,:,:).*pi_e_J(N_a+1:end,:,:),3); zeros(N_a,N_z,'gpuArray')]; % I use zeros in j=N_j so that can just use pi_z_J to create expectations + EVpre=reshape(EVpre,[N_a,1,N_j,N_z]); + EV=EVpre.*shiftdim(pi_z_J,-2); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +elseif vfoptions.EVpre==1 + % This is used for 'Matched Expecations Path' + EVpre=[reshape(V,[N_a*N_j,N_z,N_e].*pi_e_J,3)]; % input V is already of size [N_a,N_j] and we want to use the whole thing + EVpre=reshape(EVpre,[N_a,1,N_j,N_z]); + EV=EVpre.*shiftdim(pi_z_J,-2); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +end DiscountedEV=DiscountFactorParamsVec.*EV; diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_e_raw.m index 3764cdaa..22b3b040 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_e_raw.m @@ -31,9 +31,13 @@ % Each column will be a specific parameter with the values at every age. ReturnFnParamsAgeMatrix=CreateAgeMatrixFromParams(Parameters, ReturnFnParamNames,N_j); % this will be a matrix, row indexes ages and column indexes the parameters (parameters which are not dependent on age appear as a constant valued column) -% pi_e_J is (a,j)-by-e -EV=[sum(V(N_a+1:end,:).*pi_e_J(N_a+1:end,:),2); zeros(N_a,1,'gpuArray')]; % I use zeros in j=N_j so that can just use pi_z_J to create expectations - +if vfoptions.EVpre==0 + % pi_e_J is (a,j)-by-e + EV=[sum(V(N_a+1:end,:).*pi_e_J(N_a+1:end,:),2); zeros(N_a,1,'gpuArray')]; % I use zeros in j=N_j so that can just use pi_z_J to create expectations +elseif vfoptions.EVpre==1 + % This is used for 'Matched Expecations Path' + EV=[reshape(V,[N_a*N_j,N_e].*pi_e_J,2)]; % input V is already of size [N_a,N_j] and we want to use the whole thing +end discountedEV=DiscountFactorParamsVec.*reshape(EV,[N_a,1,N_j]); % [aprime] V=zeros(N_a,N_j,N_e,'gpuArray'); % V is over (a,j) diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_raw.m index 75e506c0..c43d807e 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_raw.m @@ -3,9 +3,6 @@ % fastOLG just means parallelize over "age" (j) N_a=prod(n_a); -VKronNext=zeros(N_a,N_j,'gpuArray'); -VKronNext(:,1:N_j-1)=V(:,2:end); - V=zeros(N_a,N_j,'gpuArray'); % V is over (a,j) Policy=zeros(N_a,N_j,'gpuArray'); % first dim indexes the optimal choice for d and aprime @@ -28,12 +25,19 @@ DiscountFactorParamsVec=prod(DiscountFactorParamsVec,2); DiscountFactorParamsVec=shiftdim(DiscountFactorParamsVec,-2); -entireEV=reshape(VKronNext,[N_a,1,N_j]); % [aprime] +if vfoptions.EVpre==0 + EV=zeros(N_a,N_j,'gpuArray'); + EV(:,1:N_j-1)=V(:,2:end); + EV=reshape(EV,[N_a,1,N_j]); +elseif vfoptions.EVpre==1 + % This is used for 'Matched Expecations Path' + EV=reshape(V,[N_a,1,N_j]); % input V is of size [N_a,N_j] and we want to use the whole thing +end % n-Monotonicity ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_nod_noz_Par2(ReturnFn, N_j, a_grid, a_grid(level1ii), ReturnFnParamsAgeMatrix,1); -entireRHS_ii=ReturnMatrix_ii+DiscountFactorParamsVec.*entireEV; % (aprime,a and j), autofills j for expectation term +entireRHS_ii=ReturnMatrix_ii+DiscountFactorParamsVec.*EV; % (aprime,a and j), autofills j for expectation term %Calc the max and it's index [Vtempii,maxindex1]=max(entireRHS_ii,[],1); @@ -50,7 +54,7 @@ % aprime possibilities are maxgap(ii)+1-by-1-by-N_j ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_nod_noz_Par2(ReturnFn, N_j, a_grid(aprimeindexes), a_grid(level1ii(ii)+1:level1ii(ii+1)-1), ReturnFnParamsAgeMatrix,2); aprime=aprimeindexes+N_a*shiftdim((0:1:N_j-1),-1); % with the current aprimeii(ii):aprimeii(ii+1) - entireRHS_ii=ReturnMatrix_ii+DiscountFactorParamsVec.*entireEV(aprime); + entireRHS_ii=ReturnMatrix_ii+DiscountFactorParamsVec.*EV(aprime); [Vtempii,maxindex]=max(entireRHS_ii,[],1); V(level1ii(ii)+1:level1ii(ii+1)-1,:)=shiftdim(Vtempii,1); % temp=loweredge(maxindex+shiftdim((0:1:N_j-1),-1)); @@ -60,7 +64,7 @@ % Just use aprime(ii) for everything ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_nod_noz_Par2(ReturnFn, N_j, a_grid(loweredge), a_grid(level1ii(ii)+1:level1ii(ii+1)-1), ReturnFnParamsAgeMatrix,2); aprime=loweredge+N_a*shiftdim((0:1:N_j-1),-1); % with the current aprimeii(ii):aprimeii(ii+1) - entireRHS_ii=ReturnMatrix_ii+DiscountFactorParamsVec.*entireEV(aprime); + entireRHS_ii=ReturnMatrix_ii+DiscountFactorParamsVec.*EV(aprime); [Vtempii,maxindex]=max(entireRHS_ii,[],1); V(level1ii(ii)+1:level1ii(ii+1)-1,:)=shiftdim(Vtempii,1); Policy(level1ii(ii)+1:level1ii(ii+1)-1,:)=shiftdim(maxindex+loweredge-1,1); % loweredge diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_raw.m index 45429bc0..18ef6988 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_raw.m @@ -33,11 +33,18 @@ % Each column will be a specific parameter with the values at every age. ReturnFnParamsAgeMatrix=CreateAgeMatrixFromParams(Parameters, ReturnFnParamNames,N_j); % this will be a matrix, row indexes ages and column indexes the parameters (parameters which are not dependent on age appear as a constant valued column) -EVpre=zeros(N_a,1,N_j,N_z); -EVpre(:,1,1:N_j-1,:)=reshape(V(N_a+1:end,:),[N_a,1,N_j-1,N_z]); % I use zeros in j=N_j so that can just use pi_z_J to create expectations -EV=EVpre.*shiftdim(pi_z_J,-2); -EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) -EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +if vfoptions.EVpre==0 + EVpre=zeros(N_a,1,N_j,N_z); + EVpre(:,1,1:N_j-1,:)=reshape(V(N_a+1:end,:),[N_a,1,N_j-1,N_z]); % I use zeros in j=N_j so that can just use pi_z_J to create expectations + EV=EVpre.*shiftdim(pi_z_J,-2); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +elseif vfoptions.EVpre==1 + % This is used for 'Matched Expecations Path' + EV=reshape(V,[N_a,1,N_j,N_z]).*shiftdim(pi_z_J,-2); % input V is already of size [N_a,N_j,N_z] and we want to use the whole thing + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +end DiscountedEV=DiscountFactorParamsVec.*EV; diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_e_raw.m index c5dcd114..a7b27f24 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_e_raw.m @@ -36,7 +36,13 @@ ReturnFnParamsAgeMatrix=CreateAgeMatrixFromParams(Parameters, ReturnFnParamNames,N_j); % this will be a matrix, row indexes ages and column indexes the parameters (parameters which are not dependent on age appear as a constant valued column) % pi_e_J is (a,j)-by-e -EV=[sum(V(N_a+1:end,:).*pi_e_J(N_a+1:end,:),2); zeros(N_a,1,'gpuArray')]; % I use zeros in j=N_j so that can just use pi_z_J to create expectations +if vfoptions.EVpre==0 + EV=[sum(V(N_a+1:end,:).*pi_e_J(N_a+1:end,:),2); zeros(N_a,1,'gpuArray')]; % I use zeros in j=N_j so that can just use pi_z_J to create expectations +elseif vfoptions.EVpre==1 + % This is used for 'Matched Expecations Path' + EV=[reshape(V,[N_a*N_j,N_e].*pi_e_J,2)]; % input V is already of size [N_a,N_j] and we want to use the whole thing +end + discountedEV=repelem(shiftdim(DiscountFactorParamsVec.*reshape(EV,[N_a,1,N_j]),-1),N_d,1); % [N_d,N_aprime,1,N_a,N_j] V=zeros(N_a,N_j,N_e,'gpuArray'); % V is over (a,j) diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_raw.m index 12126812..2be3068d 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_raw.m @@ -4,9 +4,6 @@ N_d=prod(n_d); N_a=prod(n_a); -VKronNext=zeros(N_a,N_j,'gpuArray'); -VKronNext(:,1:N_j-1)=V(:,2:end); - V=zeros(N_a,N_j,'gpuArray'); % V is over (a,j) Policy=zeros(N_a,N_j,'gpuArray'); % first dim indexes the optimal choice for d and aprime @@ -32,7 +29,16 @@ DiscountFactorParamsVec=prod(DiscountFactorParamsVec,2); DiscountFactorParamsVec=shiftdim(DiscountFactorParamsVec,-2); -entireEV=repmat(reshape(VKronNext,[1,N_a,1,N_j]),N_d,1); % [d,aprime] +if vfoptions.EVpre==0 + EV=zeros(N_a,N_j,'gpuArray'); + EV(:,1:N_j-1)=V(:,2:end); + EV=reshape(EV,[1,N_a,1,N_j]); +elseif vfoptions.EVpre==1 + % This is used for 'Matched Expecations Path' + EV=reshape(V,[1,N_a,1,N_j]); % input V is of size [N_a,N_j] and we want to use the whole thing +end + +entireEV=repmat(EV,N_d,1); % [d,aprime] % n-Monotonicity ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_noz_Par2(ReturnFn, n_d, N_j, d_gridvals, a_grid, a_grid(level1ii), ReturnFnParamsAgeMatrix,1); diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_raw.m index edcc8d2b..a43efe85 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_raw.m @@ -38,11 +38,18 @@ % Each column will be a specific parameter with the values at every age. ReturnFnParamsAgeMatrix=CreateAgeMatrixFromParams(Parameters, ReturnFnParamNames,N_j); % this will be a matrix, row indexes ages and column indexes the parameters (parameters which are not dependent on age appear as a constant valued column) -EVpre=zeros(N_a,1,N_j,N_z); -EVpre(:,1,1:N_j-1,:)=reshape(V(N_a+1:end,:),[N_a,1,N_j-1,N_z]); % I use zeros in j=N_j so that can just use pi_z_J to create expectations -EV=EVpre.*shiftdim(pi_z_J,-2); -EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) -EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +if vfoptions.EVpre==0 + EVpre=zeros(N_a,1,N_j,N_z); + EVpre(:,1,1:N_j-1,:)=reshape(V(N_a+1:end,:),[N_a,1,N_j-1,N_z]); % I use zeros in j=N_j so that can just use pi_z_J to create expectations + EV=EVpre.*shiftdim(pi_z_J,-2); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +elseif vfoptions.EVpre==1 + % This is used for 'Matched Expecations Path' + EV=reshape(V,[N_a,1,N_j,N_z]).*shiftdim(pi_z_J,-2); % input V is already of size [N_a,N_j,N_z] and we want to use the whole thing + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +end DiscountedEV=shiftdim(DiscountFactorParamsVec.*EV,-1); % [1,N_a,1,N_j,N_z] 1st dim will autofill d, 3rd dim will autofill a DiscountedEV=repelem(DiscountedEV,N_d,1,1,1,1); diff --git a/ValueFnIter/TransPathFHorz/ValueFnOnTransPath_Case1_FHorz.m b/ValueFnIter/TransPathFHorz/ValueFnOnTransPath_Case1_FHorz.m index 4efbee5b..f3594532 100644 --- a/ValueFnIter/TransPathFHorz/ValueFnOnTransPath_Case1_FHorz.m +++ b/ValueFnIter/TransPathFHorz/ValueFnOnTransPath_Case1_FHorz.m @@ -79,6 +79,7 @@ vfoptions.policy_forceintegertype=0; end end +vfoptions.preEV=0; % =1 is used by 'Matched Expecations Path', for TPath we want =0 (this relates to details of fastOLG=1 value fn code) %% Internally PricePath is matrix of size T-by-'number of prices'. @@ -532,4 +533,4 @@ -end \ No newline at end of file +end diff --git a/ValueFnIter/TransPathFHorz/ValueFnOnTransPath_Case1_FHorz_PType.m b/ValueFnIter/TransPathFHorz/ValueFnOnTransPath_Case1_FHorz_PType.m index 04376b34..f0ae812a 100644 --- a/ValueFnIter/TransPathFHorz/ValueFnOnTransPath_Case1_FHorz_PType.m +++ b/ValueFnIter/TransPathFHorz/ValueFnOnTransPath_Case1_FHorz_PType.m @@ -3,6 +3,8 @@ VPath=struct(); PolicyPath=struct(); +vfoptions.preEV=0; % =1 is used by 'Matched Expecations Path', for TPath we want =0 (this relates to details of fastOLG=1 value fn code) + %% if iscell(Names_i) N_i=length(Names_i); From c66959639978cb5869b256d5ca69cfb1f15b737d Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Tue, 13 Jan 2026 10:14:40 +1300 Subject: [PATCH 09/67] mostly reorg --- .../HeteroAgentStationaryEqm_Case1_subfn.m | 1 - StationaryDist/InfHorz/StationaryDist_Case1.m | 32 ++++++++++++++----- .../TransitionPath_FHorz_shooting_nod_noz.m | 4 +-- ...rz_TPath_SingleStep_fastOLG_DC1_GI_e_raw.m | 0 ...Path_SingleStep_fastOLG_DC1_GI_nod_e_raw.m | 0 ..._SingleStep_fastOLG_DC1_GI_nod_noz_e_raw.m | 0 ...th_SingleStep_fastOLG_DC1_GI_nod_noz_raw.m | 0 ..._TPath_SingleStep_fastOLG_DC1_GI_nod_raw.m | 0 ...Path_SingleStep_fastOLG_DC1_GI_noz_e_raw.m | 0 ..._TPath_SingleStep_fastOLG_DC1_GI_noz_raw.m | 0 ...Horz_TPath_SingleStep_fastOLG_DC1_GI_raw.m | 0 ...FHorz_TPath_SingleStep_fastOLG_DC1_e_raw.m | 0 ...z_TPath_SingleStep_fastOLG_DC1_nod_e_raw.m | 0 ...ath_SingleStep_fastOLG_DC1_nod_noz_e_raw.m | 0 ...TPath_SingleStep_fastOLG_DC1_nod_noz_raw.m | 0 ...orz_TPath_SingleStep_fastOLG_DC1_nod_raw.m | 2 +- ...z_TPath_SingleStep_fastOLG_DC1_noz_e_raw.m | 0 ...orz_TPath_SingleStep_fastOLG_DC1_noz_raw.m | 0 ...r_FHorz_TPath_SingleStep_fastOLG_DC1_raw.m | 0 ..._FHorz_TPath_SingleStep_fastOLG_GI_e_raw.m | 0 ...rz_TPath_SingleStep_fastOLG_GI_nod_e_raw.m | 0 ...Path_SingleStep_fastOLG_GI_nod_noz_e_raw.m | 0 ..._TPath_SingleStep_fastOLG_GI_nod_noz_raw.m | 0 ...Horz_TPath_SingleStep_fastOLG_GI_nod_raw.m | 17 +++++++--- ...rz_TPath_SingleStep_fastOLG_GI_noz_e_raw.m | 0 ...Horz_TPath_SingleStep_fastOLG_GI_noz_raw.m | 0 ...er_FHorz_TPath_SingleStep_fastOLG_GI_raw.m | 17 +++++++--- ...ter_FHorz_TPath_SingleStep_fastOLG_e_raw.m | 0 ...FHorz_TPath_SingleStep_fastOLG_nod_e_raw.m | 0 ...z_TPath_SingleStep_fastOLG_nod_noz_e_raw.m | 0 ...orz_TPath_SingleStep_fastOLG_nod_noz_raw.m | 0 ...r_FHorz_TPath_SingleStep_fastOLG_nod_raw.m | 17 +++++++--- ...ter_FHorz_TPath_SingleStep_fastOLG_noz_e.m | 0 ...FHorz_TPath_SingleStep_fastOLG_noz_e_raw.m | 0 ...r_FHorz_TPath_SingleStep_fastOLG_noz_raw.m | 0 ...nIter_FHorz_TPath_SingleStep_fastOLG_raw.m | 17 +++++++--- ValueFnIter/InfHorz/ValueFnIter_Case1.m | 1 + 37 files changed, 76 insertions(+), 32 deletions(-) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_e_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_e_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_noz_e_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_noz_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_e_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_e_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_e_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_e_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_raw.m (99%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_e_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_e_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_e_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_noz_e_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_noz_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_raw.m (86%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_noz_e_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_noz_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_raw.m (87%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_e_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_e_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_noz_e_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_noz_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_raw.m (74%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_raw.m (100%) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{ => fastOLG}/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_raw.m (77%) diff --git a/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1_subfn.m b/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1_subfn.m index 53472813..7b264009 100644 --- a/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1_subfn.m +++ b/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1_subfn.m @@ -27,7 +27,6 @@ %% [V,Policy]=ValueFnIter_Case1(n_d,n_a,n_z,d_grid,a_grid,z_gridvals, pi_z, ReturnFn, Parameters, DiscountFactorParamNames,ReturnFnParamNames,vfoptions); - %Step 2: Calculate the Steady-state distn (given this price) and use it to assess market clearance StationaryDist=StationaryDist_Case1(Policy,n_d,n_a,n_z,pi_z,simoptions,Parameters); AggVars=EvalFnOnAgentDist_AggVars_Case1(StationaryDist, Policy, FnsToEvaluateCell, Parameters, FnsToEvaluateParamNames, n_d, n_a, n_z, d_grid, a_grid, z_gridvals, simoptions); diff --git a/StationaryDist/InfHorz/StationaryDist_Case1.m b/StationaryDist/InfHorz/StationaryDist_Case1.m index ebed2ce9..7f5f4df9 100644 --- a/StationaryDist/InfHorz/StationaryDist_Case1.m +++ b/StationaryDist/InfHorz/StationaryDist_Case1.m @@ -15,7 +15,6 @@ simoptions.maxit=10^6; % In my experience, after a simulation, if you need more than 10^6 iterations to reach the steady-state it is because something has gone wrong simoptions.tolerance=10^(-6); % I originally had this at 10^(-9) but this seems to have been overly strict as very hard to acheive and not needed for model accuracy, now set to 10^(-6) [note that this is the max of all error across the agent dist, the L-Infinity norm] simoptions.multiiter=50; % How many iteration steps before check tolerance - simoptions.outputkron=0; % Options relating to simulation method simoptions.ncores=1; simoptions.seedpoint=[ceil(N_a/2),ceil(N_z/2)]; @@ -36,6 +35,7 @@ simoptions.n_e=0; simoptions.n_semiz=0; % When calling as a subcommand, the following is used internally + simoptions.outputkron=0; simoptions.alreadygridvals=0; else %Check simoptions for missing fields, if there are some fill them with the defaults @@ -54,9 +54,6 @@ if ~isfield(simoptions, 'multiiter') simoptions.multiiter=50; % How many iteration steps before check tolerance end - if ~isfield(simoptions, 'outputkron') - simoptions.outputkron=0; - end % Options relating to simulation method if ~isfield(simoptions,'ncores') simoptions.ncores=1; @@ -111,6 +108,9 @@ simoptions.n_semiz=0; end % When calling as a subcommand, the following is used internally + if ~isfield(simoptions, 'outputkron') + simoptions.outputkron=0; + end if ~isfield(simoptions,'alreadygridvals') simoptions.alreadygridvals=0; end @@ -309,10 +309,18 @@ if N_z==0 if N_e==0 StationaryDist=StationaryDist_InfHorz_IterationTan_noz_raw(StationaryDist,Policy_aprime,N_a,simoptions); - StationaryDist=reshape(StationaryDist,[n_a,1]); + if simoptions.outputkron==0 + StationaryDist=reshape(StationaryDist,[n_a,1]); + else + StationaryDist=reshape(StationaryDist,[N_a,1]); + end else StationaryDist=StationaryDist_InfHorz_IterationTan_noz_e_raw(StationaryDist,Policy_aprime,N_a,N_e,pi_e,simoptions); - StationaryDist=reshape(StationaryDist,[n_a,n_e]); + if simoptions.outputkron==0 + StationaryDist=reshape(StationaryDist,[n_a,n_e]); + else + StationaryDist=reshape(StationaryDist,[N_a,N_e]); + end end else if N_e==0 @@ -321,10 +329,18 @@ elseif simoptions.tanimprovement==1 % Improvement of Tan (2020) StationaryDist=StationaryDist_InfHorz_IterationTan_raw(StationaryDist,Policy_aprime,N_a,N_z,pi_z,simoptions); end - StationaryDist=reshape(StationaryDist,[n_a,n_z]); + if simoptions.outputkron==0 + StationaryDist=reshape(StationaryDist,[n_a,n_z]); + else + StationaryDist=reshape(StationaryDist,[N_a,N_z]); + end else StationaryDist=StationaryDist_InfHorz_IterationTan_e_raw(StationaryDist,Policy_aprime,N_a,N_z,N_e,pi_z,pi_e,simoptions); - StationaryDist=reshape(StationaryDist,[n_a,n_z,n_e]); + if simoptions.outputkron==0 + StationaryDist=reshape(StationaryDist,[n_a,n_z,n_e]); + else + StationaryDist=reshape(StationaryDist,[N_a,N_z,N_e]); + end end end diff --git a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_nod_noz.m b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_nod_noz.m index 15f5ab5b..e82cd563 100644 --- a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_nod_noz.m +++ b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_nod_noz.m @@ -51,8 +51,8 @@ PolicyPath(1,:,:,T-tt)=Policy; end - - + + %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_e_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_e_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_e_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_e_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_e_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_e_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_noz_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_noz_e_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_noz_e_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_noz_e_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_noz_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_noz_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_noz_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_noz_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_nod_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_e_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_e_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_e_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_e_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_e_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_e_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_e_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_e_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_e_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_e_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_e_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_e_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_raw.m similarity index 99% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_raw.m index 18ef6988..efeb814d 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_raw.m @@ -41,7 +41,7 @@ EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a elseif vfoptions.EVpre==1 % This is used for 'Matched Expecations Path' - EV=reshape(V,[N_a,1,N_j,N_z]).*shiftdim(pi_z_J,-2); % input V is already of size [N_a,N_j,N_z] and we want to use the whole thing + EV=reshape(V,[N_a,1,N_j,N_z]).*shiftdim(pi_z_J,-2); % input V is already of size [N_a*N_j,N_z] and we want to use the whole thing. EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a end diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_e_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_e_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_e_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_e_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_e_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_e_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_e_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_e_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_e_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_noz_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_noz_e_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_noz_e_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_noz_e_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_noz_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_noz_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_noz_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_noz_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_raw.m similarity index 86% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_raw.m index e9cbe969..0288fc5d 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_raw.m @@ -34,11 +34,18 @@ % Each column will be a specific parameter with the values at every age. ReturnFnParamsAgeMatrix=CreateAgeMatrixFromParams(Parameters, ReturnFnParamNames,N_j); % this will be a matrix, row indexes ages and column indexes the parameters (parameters which are not dependent on age appear as a constant valued column) -EVpre=zeros(N_a,1,N_j,N_z); -EVpre(:,1,1:N_j-1,:)=reshape(V(N_a+1:end,:),[N_a,1,N_j-1,N_z]); % I use zeros in j=N_j so that can just use pi_z_J to create expectations -EV=EVpre.*shiftdim(pi_z_J,-2); -EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) -EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +if vfoptions.EVpre==0 + EVpre=zeros(N_a,1,N_j,N_z); + EVpre(:,1,1:N_j-1,:)=reshape(V(N_a+1:end,:),[N_a,1,N_j-1,N_z]); % I use zeros in j=N_j so that can just use pi_z_J to create expectations + EV=EVpre.*shiftdim(pi_z_J,-2); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +elseif vfoptions.EVpre==1 + % This is used for 'Matched Expecations Path' + EV=reshape(V,[N_a,1,N_j,N_z]).*shiftdim(pi_z_J,-2); % input V is already of size [N_a,N_j,N_z] and we want to use the whole thing + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +end % Interpolate EV over aprime_grid EVinterp=interp1(a_grid,EV,aprime_grid); diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_noz_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_noz_e_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_noz_e_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_noz_e_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_noz_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_noz_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_noz_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_noz_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_raw.m similarity index 87% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_raw.m index bf0b44c1..fece536d 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_raw.m @@ -39,11 +39,18 @@ % Each column will be a specific parameter with the values at every age. ReturnFnParamsAgeMatrix=CreateAgeMatrixFromParams(Parameters, ReturnFnParamNames,N_j); % this will be a matrix, row indexes ages and column indexes the parameters (parameters which are not dependent on age appear as a constant valued column) -EVpre=zeros(N_a,1,N_j,N_z); -EVpre(:,1,1:N_j-1,:)=reshape(V(N_a+1:end,:),[N_a,1,N_j-1,N_z]); % I use zeros in j=N_j so that can just use pi_z_J to create expectations -EV=EVpre.*shiftdim(pi_z_J,-2); -EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) -EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +if vfoptions.EVpre==0 + EVpre=zeros(N_a,1,N_j,N_z); + EVpre(:,1,1:N_j-1,:)=reshape(V(N_a+1:end,:),[N_a,1,N_j-1,N_z]); % I use zeros in j=N_j so that can just use pi_z_J to create expectations + EV=EVpre.*shiftdim(pi_z_J,-2); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +elseif vfoptions.EVpre==1 + % This is used for 'Matched Expecations Path' + EV=reshape(V,[N_a,1,N_j,N_z]).*shiftdim(pi_z_J,-2); % input V is already of size [N_a,N_j,N_z] and we want to use the whole thing + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +end % Interpolate EV over aprime_grid EVinterp=interp1(a_grid,EV,aprime_grid); diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_e_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_e_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_e_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_e_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_e_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_e_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_noz_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_noz_e_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_noz_e_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_noz_e_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_noz_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_noz_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_noz_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_noz_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_raw.m similarity index 74% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_raw.m index 3f6bf9ff..14b7352f 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_raw.m @@ -21,11 +21,18 @@ % Each column will be a specific parameter with the values at every age. ReturnFnParamsAgeMatrix=CreateAgeMatrixFromParams(Parameters, ReturnFnParamNames,N_j); % this will be a matrix, row indexes ages and column indexes the parameters (parameters which are not dependent on age appear as a constant valued column) -EVpre=zeros(N_a,1,N_j,N_z); -EVpre(:,1,1:N_j-1,:)=reshape(V(N_a+1:end,:),[N_a,1,N_j-1,N_z]); % I use zeros in j=N_j so that can just use pi_z_J to create expectations -EV=EVpre.*shiftdim(pi_z_J,-2); -EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) -EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +if vfoptions.EVpre==0 + EVpre=zeros(N_a,1,N_j,N_z); + EVpre(:,1,1:N_j-1,:)=reshape(V(N_a+1:end,:),[N_a,1,N_j-1,N_z]); % I use zeros in j=N_j so that can just use pi_z_J to create expectations + EV=EVpre.*shiftdim(pi_z_J,-2); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +elseif vfoptions.EVpre==1 + % This is used for 'Matched Expecations Path' + EV=reshape(V,[N_a,1,N_j,N_z]).*shiftdim(pi_z_J,-2); % input V is already of size [N_a,N_j,N_z] and we want to use the whole thing + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +end DiscountedEV=DiscountFactorParamsVec.*EV; diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_raw.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_raw.m diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_raw.m similarity index 77% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_raw.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_raw.m index a5d98311..64090fde 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_raw.m @@ -24,11 +24,18 @@ % Each column will be a specific parameter with the values at every age. ReturnFnParamsAgeMatrix=CreateAgeMatrixFromParams(Parameters, ReturnFnParamNames,N_j); % this will be a matrix, row indexes ages and column indexes the parameters (parameters which are not dependent on age appear as a constant valued column) -EVpre=zeros(N_a,1,N_j,N_z); -EVpre(:,1,1:N_j-1,:)=reshape(V(N_a+1:end,:),[N_a,1,N_j-1,N_z]); % I use zeros in j=N_j so that can just use pi_z_J to create expectations -EV=EVpre.*shiftdim(pi_z_J,-2); -EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) -EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +if vfoptions.EVpre==0 + EVpre=zeros(N_a,1,N_j,N_z); + EVpre(:,1,1:N_j-1,:)=reshape(V(N_a+1:end,:),[N_a,1,N_j-1,N_z]); % I use zeros in j=N_j so that can just use pi_z_J to create expectations + EV=EVpre.*shiftdim(pi_z_J,-2); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +elseif vfoptions.EVpre==1 + % This is used for 'Matched Expecations Path' + EV=reshape(V,[N_a,1,N_j,N_z]).*shiftdim(pi_z_J,-2); % input V is already of size [N_a,N_j,N_z] and we want to use the whole thing + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a +end DiscountedEV=DiscountFactorParamsVec.*EV; DiscountedEV=repelem(DiscountedEV,N_d,1,1,1); % [d & aprime,1,j,z] diff --git a/ValueFnIter/InfHorz/ValueFnIter_Case1.m b/ValueFnIter/InfHorz/ValueFnIter_Case1.m index abd1510e..dabb09ee 100644 --- a/ValueFnIter/InfHorz/ValueFnIter_Case1.m +++ b/ValueFnIter/InfHorz/ValueFnIter_Case1.m @@ -665,6 +665,7 @@ V=reshape(VKron,[n_a,n_z]); Policy=UnKronPolicyIndexes_Case1(Policy, n_d, n_a, n_z,vfoptions); else + Policy=reshape(Policy,[1,N_a,N_z]); varargout={VKron,Policy}; return end From 39e7ce3bfbdbf565545aafbca99472bb87b38eb6 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Tue, 13 Jan 2026 10:22:18 +1300 Subject: [PATCH 10/67] clean --- .../ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e.m | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename TransitionPaths/FHorz/subcodes/ValueFnSingleStep/{fastOLG => }/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e.m (100%) diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e.m similarity index 100% rename from TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e.m rename to TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e.m From aaa99c75f044e0784219ba1a6d1b481d083cb638 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Fri, 16 Jan 2026 18:23:56 +1300 Subject: [PATCH 11/67] big overhaul of FHorz TPath and also UnKron --- .../EvalFnOnAgentDist_AggVars_FHorz_fastOLG.m | 262 +++++----- ...lFnOnAgentDist_AggVars_FHorz_fastOLG_noz.m | 20 +- .../EvalFnOnTransPath_AggVars_Case1_FHorz.m | 53 +- .../LifeCycleProfiles_TransPath_FHorz_Case1.m | 50 +- .../AgentDistOnTransPath_Case1_FHorz.m | 365 +++++++------ .../AgentDistOnTransPath_Case1_FHorz_noz.m | 63 --- .../AgentDistOnTransPath_Case1_FHorz_raw.m | 72 --- .../ExoShocks/ExogShockSetup_TPath_FHorz.m | 166 ++++-- .../OnCPU/UnKronPolicyIndexes_FHorz_CPU.m | 43 ++ .../OnCPU/UnKronPolicyIndexes_FHorz_noz_CPU.m | 36 ++ .../OnCPU/UnKronPolicyIndexes_InfHorz_CPU.m | 36 ++ .../UnKronPolicyIndexes_Case1.m | 170 ++----- .../UnKronPolicyIndexes_Case1_FHorz.m | 132 ++--- .../UnKronPolicyIndexes_Case1_FHorz_PType.m | 50 -- .../UnKronPolicyIndexes_Case1_FHorz_e.m | 132 ++--- .../UnKronPolicyIndexes_Case1_FHorz_noz.m | 130 ++--- .../UnKronPolicyIndexes_Case1_FHorz_semiz.m | 132 +++-- .../UnKronPolicyIndexes_Case1_FHorz_semiz_e.m | 133 +++-- ...nKronPolicyIndexes_Case1_FHorz_semiz_noz.m | 91 ++++ .../UnKronPolicyIndexes_Case1_PType.m | 45 -- ...UnKronPolicyIndexes_Case1_TransPathFHorz.m | 105 ++-- ...KronPolicyIndexes_Case1_TransPathFHorz_e.m | 102 ++-- ...onPolicyIndexes_Case1_TransPathFHorz_noz.m | 104 ++-- .../UnKronPolicyIndexes_Case1_e.m | 66 +++ .../UnKronPolicyIndexes_Case1_noz.m | 65 +++ .../UnKronPolicyIndexes_Case2.m | 49 +- .../UnKronPolicyIndexes_Case2_FHorz.m | 51 +- .../UnKronPolicyIndexes_Case2_FHorz_PType.m | 27 - .../UnKronPolicyIndexes_Case2_FHorz_e.m | 52 +- .../UnKronPolicyIndexes_Case2_FHorz_noz.m | 48 +- .../UnKronPolicyIndexes_Case2_PType.m | 25 - .../UnKronPolicyIndexes_InfHorz_TransPath.m | 126 +---- ...PolicyIndexes_InfHorz_TransPath_ExpAsset.m | 123 ++--- ...TransitionPath_FHorz_shooting_fastOLG_GI.m | 224 -------- ...ansitionPath_FHorz_shooting_fastOLG_GI_e.m | 237 --------- ...sitionPath_FHorz_shooting_fastOLG_GI_nod.m | 228 --------- ...tionPath_FHorz_shooting_fastOLG_GI_nod_e.m | 237 --------- ...onPath_FHorz_shooting_fastOLG_GI_nod_noz.m | 214 -------- ...Path_FHorz_shooting_fastOLG_GI_nod_noz_e.m | 226 --------- ...sitionPath_FHorz_shooting_fastOLG_GI_noz.m | 215 -------- ...tionPath_FHorz_shooting_fastOLG_GI_noz_e.m | 227 --------- .../FHorz/TransitionPath_Case1_FHorz.m | 479 ++++++++---------- .../FHorz/TransitionPath_FHorz_shooting.m | 127 +++-- .../FHorz/TransitionPath_FHorz_shooting_e.m | 131 +++-- .../TransitionPath_FHorz_shooting_fastOLG.m | 91 +++- .../TransitionPath_FHorz_shooting_fastOLG_e.m | 98 ++-- ...ransitionPath_FHorz_shooting_fastOLG_nod.m | 96 ++-- ...nsitionPath_FHorz_shooting_fastOLG_nod_e.m | 96 ++-- ...itionPath_FHorz_shooting_fastOLG_nod_noz.m | 88 +++- ...ionPath_FHorz_shooting_fastOLG_nod_noz_e.m | 94 +++- ...ransitionPath_FHorz_shooting_fastOLG_noz.m | 92 +++- ...nsitionPath_FHorz_shooting_fastOLG_noz_e.m | 91 +++- .../FHorz/TransitionPath_FHorz_shooting_nod.m | 124 +++-- .../TransitionPath_FHorz_shooting_nod_e.m | 130 +++-- .../TransitionPath_FHorz_shooting_nod_noz.m | 118 +++-- .../TransitionPath_FHorz_shooting_nod_noz_e.m | 131 +++-- .../FHorz/TransitionPath_FHorz_shooting_noz.m | 116 +++-- .../TransitionPath_FHorz_shooting_noz_e.m | 132 +++-- ...h_SingleStep_IterFast_TwoProbs_noz_e_raw.m | 29 -- ...ath_SingleStep_IterFast_TwoProbs_noz_raw.m | 22 - ...st_FHorz_TPath_SingleStep_IterFast_e_raw.m | 20 +- ..._TPath_SingleStep_IterFast_nProbs_e_raw.m} | 20 +- ...ath_SingleStep_IterFast_nProbs_noz_e_raw.m | 31 ++ ...TPath_SingleStep_IterFast_nProbs_noz_raw.m | 22 + ...rz_TPath_SingleStep_IterFast_nProbs_raw.m} | 26 +- ...Horz_TPath_SingleStep_IterFast_noz_e_raw.m | 16 +- ..._FHorz_TPath_SingleStep_IterFast_noz_raw.m | 12 +- ...Dist_FHorz_TPath_SingleStep_IterFast_raw.m | 26 +- ...t_FHorz_TPath_SingleStep_Iteration_e_raw.m | 11 +- ...orz_TPath_SingleStep_Iteration_noz_e_raw.m | 10 +- ...FHorz_TPath_SingleStep_Iteration_noz_raw.m | 10 +- ...ist_FHorz_TPath_SingleStep_Iteration_raw.m | 13 +- .../ValueFnIter_FHorz_TPath_SingleStep.m | 27 +- .../ValueFnIter_FHorz_TPath_SingleStep_e.m | 29 +- ...lueFnIter_FHorz_TPath_SingleStep_fastOLG.m | 16 +- ...eFnIter_FHorz_TPath_SingleStep_fastOLG_e.m | 16 +- ...nIter_FHorz_TPath_SingleStep_fastOLG_noz.m | 12 +- ...ter_FHorz_TPath_SingleStep_fastOLG_noz_e.m | 16 +- .../ValueFnIter_FHorz_TPath_SingleStep_noz.m | 26 +- ...ValueFnIter_FHorz_TPath_SingleStep_noz_e.m | 28 +- ..._TPath_SingleStep_fastOLG_DC1_GI_noz_raw.m | 2 +- ...FHorz_TPath_SingleStep_fastOLG_DC1_e_raw.m | 7 +- ...z_TPath_SingleStep_fastOLG_DC1_nod_e_raw.m | 9 +- ...ath_SingleStep_fastOLG_DC1_nod_noz_e_raw.m | 10 +- ...TPath_SingleStep_fastOLG_DC1_nod_noz_raw.m | 6 +- ...orz_TPath_SingleStep_fastOLG_DC1_nod_raw.m | 8 +- ...z_TPath_SingleStep_fastOLG_DC1_noz_e_raw.m | 4 +- ...orz_TPath_SingleStep_fastOLG_DC1_noz_raw.m | 3 +- ...r_FHorz_TPath_SingleStep_fastOLG_DC1_raw.m | 3 +- ..._TPath_SingleStep_fastOLG_GI_nod_noz_raw.m | 2 - ...er_FHorz_TPath_SingleStep_fastOLG_GI_raw.m | 1 + ...ter_FHorz_TPath_SingleStep_fastOLG_e_raw.m | 1 - ...FHorz_TPath_SingleStep_fastOLG_nod_e_raw.m | 8 +- ...z_TPath_SingleStep_fastOLG_nod_noz_e_raw.m | 8 +- ...orz_TPath_SingleStep_fastOLG_nod_noz_raw.m | 4 +- ...r_FHorz_TPath_SingleStep_fastOLG_nod_raw.m | 5 +- ...FHorz_TPath_SingleStep_fastOLG_noz_e_raw.m | 2 - ...nIter_FHorz_TPath_SingleStep_fastOLG_raw.m | 1 - ...eFnIter_FHorz_TPath_SingleStep_nod_e_raw.m | 5 +- ...ter_FHorz_TPath_SingleStep_nod_noz_e_raw.m | 5 +- ...nIter_FHorz_TPath_SingleStep_nod_noz_raw.m | 6 +- ...lueFnIter_FHorz_TPath_SingleStep_nod_raw.m | 4 +- ...eFnIter_FHorz_TPath_SingleStep_noz_e_raw.m | 1 + ...lueFnIter_FHorz_TPath_SingleStep_noz_raw.m | 1 - .../InfHorz/TransitionPath_InfHorz_shooting.m | 4 +- ...TransitionPath_InfHorz_shooting_ExpAsset.m | 4 +- .../TransitionPath_InfHorz_shooting_nod.m | 3 +- ...Iter_InfHorz_TPath_SingleStep_DC1_GI_raw.m | 1 - ...ter_InfHorz_TPath_SingleStep_DC1_nod_raw.m | 2 +- .../ValueFnIter_InfHorz_TPath_SingleStep.m | 19 +- ...eFnIter_InfHorz_TPath_SingleStep_nod_raw.m | 2 +- .../Subcodes/updatePricePathNew_TPath_tt.m | 3 +- .../DC1/ValueFnIter_FHorz_DC1_nod_noz_raw.m | 3 - .../ValueFnIter_FHorz_DC2B_nod_noz_e_raw.m | 1 - .../DivideConquer/ValueFnIter_FHorz_DC.m | 4 + .../ValueFnIter_Case1_FHorz_Ambiguity.m | 2 + .../ValueFnIter_Case1_FHorz_EpsteinZin.m | 2 + .../ValueFnIter_Case1_FHorz_GulPesendorfer.m | 2 + .../ValueFnIter_Case1_FHorz_QuasiHyperbolic.m | 2 + .../FHorz/OnCPU/ValueFnIter_FHorz_CPU.m | 20 +- .../ValueFnIter_FHorz_SemiExo_DC.m | 41 +- .../FHorz/SemiExo/ValueFnIter_FHorz_SemiExo.m | 26 +- ValueFnIter/FHorz/ValueFnIter_Case1_FHorz.m | 6 + .../FHorz/ValueFnIter_FHorz_nod_noz_e_raw.m | 3 + .../FHorz/ValueFnIter_FHorz_nod_noz_raw.m | 1 + .../InfHorz/CPU/ValueFnIter_nod_Par0_raw.m | 2 +- .../InfHorz/CPU/ValueFnIter_nod_Par1_raw.m | 8 +- .../LowMemory/ValueFnIter_LowMem_nod_raw.m | 8 +- .../ValueFnIter_LowMem_sparse_nod_raw.m | 2 +- ValueFnIter/InfHorz/ValueFnIter_Case1.m | 2 +- .../ValueFnIter_nod_HowardGreedy_raw.m | 2 +- ValueFnIter/InfHorz/ValueFnIter_nod_raw.m | 2 +- .../InfHorz/ValueFnIter_sparse_nod_raw.m | 5 +- .../ValueFnOnTransPath_Case1_FHorz.m | 113 ++--- 134 files changed, 3237 insertions(+), 4768 deletions(-) delete mode 100644 StationaryDist/TransPathFHorz/AgentDistOnTransPath_Case1_FHorz_noz.m delete mode 100644 StationaryDist/TransPathFHorz/AgentDistOnTransPath_Case1_FHorz_raw.m create mode 100644 SubCodes/UnKronPolicyIndexes/OnCPU/UnKronPolicyIndexes_FHorz_CPU.m create mode 100644 SubCodes/UnKronPolicyIndexes/OnCPU/UnKronPolicyIndexes_FHorz_noz_CPU.m create mode 100644 SubCodes/UnKronPolicyIndexes/OnCPU/UnKronPolicyIndexes_InfHorz_CPU.m delete mode 100644 SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_PType.m create mode 100644 SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_semiz_noz.m delete mode 100644 SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_PType.m create mode 100644 SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_e.m create mode 100644 SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_noz.m delete mode 100644 SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2_FHorz_PType.m delete mode 100644 SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2_PType.m delete mode 100644 TransitionPaths/FHorz/Shooting_GI/TransitionPath_FHorz_shooting_fastOLG_GI.m delete mode 100644 TransitionPaths/FHorz/Shooting_GI/TransitionPath_FHorz_shooting_fastOLG_GI_e.m delete mode 100644 TransitionPaths/FHorz/Shooting_GI/TransitionPath_FHorz_shooting_fastOLG_GI_nod.m delete mode 100644 TransitionPaths/FHorz/Shooting_GI/TransitionPath_FHorz_shooting_fastOLG_GI_nod_e.m delete mode 100644 TransitionPaths/FHorz/Shooting_GI/TransitionPath_FHorz_shooting_fastOLG_GI_nod_noz.m delete mode 100644 TransitionPaths/FHorz/Shooting_GI/TransitionPath_FHorz_shooting_fastOLG_GI_nod_noz_e.m delete mode 100644 TransitionPaths/FHorz/Shooting_GI/TransitionPath_FHorz_shooting_fastOLG_GI_noz.m delete mode 100644 TransitionPaths/FHorz/Shooting_GI/TransitionPath_FHorz_shooting_fastOLG_GI_noz_e.m delete mode 100644 TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_noz_e_raw.m delete mode 100644 TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_noz_raw.m rename TransitionPaths/FHorz/subcodes/AgentDistSingleStep/{AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_e_raw.m => AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_e_raw.m} (53%) create mode 100644 TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_e_raw.m create mode 100644 TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_raw.m rename TransitionPaths/FHorz/subcodes/AgentDistSingleStep/{AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_raw.m => AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_raw.m} (51%) diff --git a/EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnAgentDist_AggVars_FHorz_fastOLG.m b/EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnAgentDist_AggVars_FHorz_fastOLG.m index e779e447..2bb7d205 100644 --- a/EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnAgentDist_AggVars_FHorz_fastOLG.m +++ b/EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnAgentDist_AggVars_FHorz_fastOLG.m @@ -1,30 +1,20 @@ -function AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist,Policy_d, Policy_aprime, FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_aprime,l_a,l_z,N_a,N_z,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J,outputasstructure) +function AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist,PolicyValues_d, PolicyValues_aprime, FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_aprime,l_a,l_z,N_a,N_z,a_gridvals,z_gridvals_J_fastOLG,outputasstructure) % fastOLG: so (a,j)-by-z % Policy can be in fastOLG for or not, use fastOLGpolicy=1 or 0 to indicate this % No z is treated elsewhere +% If you have e or semiz, just disguise them as z for this command -% If no d variable, set l_d=0, and then Policy_d=[], d_gridvals=[]. +% If no d variable, set l_d=0, and then PolicyValues_d=[], d_gridvals=[]. -% d_gridvals is [N_d,l_aprime] -% aprime_gridvals is [N_aprime,l_aprime] +% PolicyValues_d is [N_a,N_j,N_z,l_d] +% PolicyValues_aprime is [N_a,N_j,N_z,l_aprime] % a_gridvals is [N_a,l_a] -% z_gridvals_J is [N_j,N_z,l_z] (conver to [1,N_j,N_z,l_z] +% z_gridvals_J_fastOLG is [1,N_j,N_z,l_z] (convert internally to [1,N_j,N_z,l_z]) % parameters that depend on age must be [1,N_j] % Note: FnsToEvaluate is already cell (converted from struct) -% If you have e or semiz, just disguise them as z for this command - -z_gridvals_J=shiftdim(z_gridvals_J,-1); % make it [1,N_j,N_z,l_z]) - -if l_d==0 - PolicyValues_aprime=reshape(aprime_gridvals(Policy_aprime(:),:),[N_a,N_j,N_z,l_aprime]); -else - PolicyValues_d=reshape(d_gridvals(Policy_d(:),:),[N_a,N_j,N_z,l_d]); - PolicyValues_aprime=reshape(aprime_gridvals(Policy_aprime(:),:),[N_a,N_j,N_z,l_aprime]); -end - if l_a~=l_aprime error('cannot yet handle l_a different from l_aprime, need more if-else statements in main body of EvalFnOnAgentDist_AggVars_FHorz_fastOLG command to handle that ') end @@ -62,337 +52,337 @@ if l_z==1 if l_d==0 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); end elseif l_d==1 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); end elseif l_d==2 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); end elseif l_d==3 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); end elseif l_d==4 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); end end elseif l_z==2 if l_d==0 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); end elseif l_d==1 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); end elseif l_d==2 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); end elseif l_d==3 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); end elseif l_d==4 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); end end elseif l_z==3 if l_d==0 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); end elseif l_d==1 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); end elseif l_d==2 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); end elseif l_d==3 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); end elseif l_d==4 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); end end elseif l_z==4 if l_d==0 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); end elseif l_d==1 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); end elseif l_d==2 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); end elseif l_d==3 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); end elseif l_d==4 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); end end elseif l_z==5 if l_d==0 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); end elseif l_d==1 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); end elseif l_d==2 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); end elseif l_d==3 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); end elseif l_d==4 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); end end elseif l_z==6 if l_d==0 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); end elseif l_d==1 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); end elseif l_d==2 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); end elseif l_d==3 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); end elseif l_d==4 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); end end elseif l_z==7 if l_d==0 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); end elseif l_d==1 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); end elseif l_d==2 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); end elseif l_d==3 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); end elseif l_d==4 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); end end elseif l_z==8 if l_d==0 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), z_gridvals_J(1,:,:,8), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), z_gridvals_J(1,:,:,8), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), z_gridvals_J(1,:,:,8), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); end elseif l_d==1 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), z_gridvals_J(1,:,:,8), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), z_gridvals_J(1,:,:,8), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), z_gridvals_J(1,:,:,8), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); end elseif l_d==2 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), z_gridvals_J(1,:,:,8), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), z_gridvals_J(1,:,:,8), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), z_gridvals_J(1,:,:,8), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); end elseif l_d==3 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), z_gridvals_J(1,:,:,8), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), z_gridvals_J(1,:,:,8), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), z_gridvals_J(1,:,:,8), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); end elseif l_d==4 if l_aprime==1 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), z_gridvals_J(1,:,:,8), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); elseif l_aprime==2 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), z_gridvals_J(1,:,:,8), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); elseif l_aprime==3 - Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J(1,:,:,1), z_gridvals_J(1,:,:,2), z_gridvals_J(1,:,:,3), z_gridvals_J(1,:,:,4), z_gridvals_J(1,:,:,5), z_gridvals_J(1,:,:,6), z_gridvals_J(1,:,:,7), z_gridvals_J(1,:,:,8), ParamCell{:}); + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); end end end diff --git a/EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz.m b/EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz.m index 0101371a..d635f10e 100644 --- a/EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz.m +++ b/EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz.m @@ -1,23 +1,23 @@ -function AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz(AgentDist,Policy_d, Policy_aprime, FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_aprime,l_a,N_a,d_gridvals,aprime_gridvals,a_gridvals,outputasstructure) +function AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz(AgentDist,PolicyValues_d, PolicyValues_aprime, FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_aprime,l_a,N_a,a_gridvals,outputasstructure) % fastOLG: so (a,j)-by-1 % Policy is in Kron form -% If no d variable, set l_d=0, and then Policy_d=[], d_gridvals=[]. +% If no d variable, set l_d=0, and then PolicyValues_d=[], d_gridvals=[]. -% d_gridvals is [N_d,l_aprime] -% aprime_gridvals is [N_aprime,l_aprime] +% PolicyValues_d is [N_a,N_j,l_d] +% PolicyValues_aprime is [N_a,N_j,l_aprime] % a_gridals is [N_a,l_a] % parameters that depend on age must be [1,N_j] % Note: FnsToEvaluate is already cell (converted from struct) -if l_d==0 - PolicyValues_aprime=reshape(aprime_gridvals(Policy_aprime(:),:),[N_a,N_j,l_aprime]); -else - PolicyValues_d=reshape(d_gridvals(Policy_d(:),:),[N_a,N_j,l_d]); - PolicyValues_aprime=reshape(aprime_gridvals(Policy_aprime(:),:),[N_a,N_j,l_aprime]); -end +% if l_d==0 +% PolicyValues_aprime=reshape(aprime_gridvals(Policy_aprime(:),:),[N_a,N_j,l_aprime]); +% else +% PolicyValues_d=reshape(d_gridvals(Policy_d(:),:),[N_a,N_j,l_d]); +% PolicyValues_aprime=reshape(aprime_gridvals(Policy_aprime(:),:),[N_a,N_j,l_aprime]); +% end if l_a~=l_aprime error('cannot yet handle l_a different from l_aprime, need more if-else statements in main body of EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz command to handle that ') diff --git a/EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnTransPath_AggVars_Case1_FHorz.m b/EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnTransPath_AggVars_Case1_FHorz.m index f7fc7124..7b78fad9 100644 --- a/EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnTransPath_AggVars_Case1_FHorz.m +++ b/EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnTransPath_AggVars_Case1_FHorz.m @@ -94,54 +94,9 @@ l_ze=l_z+l_e; -%% Note: Internally PricePath is matrix of size T-by-'number of prices'. -% ParamPath is matrix of size T-by-'number of parameters that change over the transition path'. -% Actually, some of those prices are 1-by-N_j, so is more subtle than this. -PricePathNames=fieldnames(PricePath); -PricePathStruct=PricePath; -PricePathSizeVec=zeros(1,length(PricePathNames)); % Allows for a given price param to depend on age (or permanent type) -for ii=1:length(PricePathNames) - temp=PricePathStruct.(PricePathNames{ii}); - tempsize=size(temp); - PricePathSizeVec(ii)=tempsize(tempsize~=T); % Get the dimension which is not T -end -PricePathSizeVec=cumsum(PricePathSizeVec); -if length(PricePathNames)>1 - PricePathSizeVec=[[1,PricePathSizeVec(1:end-1)+1];PricePathSizeVec]; -else - PricePathSizeVec=[1;PricePathSizeVec]; -end -PricePath=zeros(T,PricePathSizeVec(2,end));% Do this seperately afterwards so that can preallocate the memory -for ii=1:length(PricePathNames) - if size(PricePathStruct.(PricePathNames{ii}),1)==T - PricePath(:,PricePathSizeVec(1,ii):PricePathSizeVec(2,ii))=PricePathStruct.(PricePathNames{ii}); - else % Need to transpose - PricePath(:,PricePathSizeVec(1,ii):PricePathSizeVec(2,ii))=PricePathStruct.(PricePathNames{ii})'; - end -end - -ParamPathNames=fieldnames(ParamPath); -ParamPathStruct=ParamPath; -ParamPathSizeVec=zeros(1,length(ParamPathNames)); % Allows for a given price param to depend on age (or permanent type) -for ii=1:length(ParamPathNames) - temp=ParamPathStruct.(ParamPathNames{ii}); - tempsize=size(temp); - ParamPathSizeVec(ii)=tempsize(tempsize~=T); % Get the dimension which is not T -end -ParamPathSizeVec=cumsum(ParamPathSizeVec); -if length(ParamPathNames)>1 - ParamPathSizeVec=[[1,ParamPathSizeVec(1:end-1)+1];ParamPathSizeVec]; -else - ParamPathSizeVec=[1;ParamPathSizeVec]; -end -ParamPath=zeros(T,ParamPathSizeVec(2,end));% Do this seperately afterwards so that can preallocate the memory -for ii=1:length(ParamPathNames) - if size(ParamPathStruct.(ParamPathNames{ii}),1)==T - ParamPath(:,ParamPathSizeVec(1,ii):ParamPathSizeVec(2,ii))=ParamPathStruct.(ParamPathNames{ii}); - else % Need to transpose - ParamPath(:,ParamPathSizeVec(1,ii):ParamPathSizeVec(2,ii))=ParamPathStruct.(ParamPathNames{ii})'; - end -end +%% Internally PricePath is matrix of size T-by-'number of prices'. +% ParamPath is matrix of size T-by-'number of parameters that change over the transition path'. +[PricePath,ParamPath,PricePathNames,ParamPathNames,PricePathSizeVec,ParamPathSizeVec]=PricePathParamPath_FHorz_StructToMatrix(PricePath,ParamPath,N_j,T); %% Check if using _tminus1 and/or _tplus1 variables. if isstruct(FnsToEvaluate) @@ -202,7 +157,7 @@ %% Set up exogenous shock processes -[z_gridvals_J, ~, ~, e_gridvals_J, ~, ~, transpathoptions, simoptions]=ExogShockSetup_TPath_FHorz(n_z,z_grid,[],N_a,N_j,Parameters,PricePathNames,ParamPathNames,transpathoptions,simoptions,1); +[z_gridvals_J, ~, ~, e_gridvals_J, ~, ~, ~, transpathoptions, simoptions]=ExogShockSetup_TPath_FHorz(n_z,z_grid,[],N_a,N_j,Parameters,PricePathNames,ParamPathNames,transpathoptions,simoptions,1); % Convert z and e to age-dependent joint-grids and transtion matrix % output: z_gridvals_J, pi_z_J, e_gridvals_J, pi_e_J, transpathoptions,vfoptions,simoptions diff --git a/EvaluateFnOnAgentDist/TransPathFHorz/LifeCycleProfiles_TransPath_FHorz_Case1.m b/EvaluateFnOnAgentDist/TransPathFHorz/LifeCycleProfiles_TransPath_FHorz_Case1.m index 6333ac1e..c66fd059 100644 --- a/EvaluateFnOnAgentDist/TransPathFHorz/LifeCycleProfiles_TransPath_FHorz_Case1.m +++ b/EvaluateFnOnAgentDist/TransPathFHorz/LifeCycleProfiles_TransPath_FHorz_Case1.m @@ -89,55 +89,9 @@ PolicyPath=KronPolicyIndexes_TransPathFHorz_Case1(PolicyPath, n_d, n_a, n_z, N_j, T); end end - -%% Note: Internally PricePath is matrix of size T-by-'number of prices'. +%% Internally PricePath is matrix of size T-by-'number of prices'. % ParamPath is matrix of size T-by-'number of parameters that change over the transition path'. -% Actually, some of those prices are 1-by-N_j, so is more subtle than this. -PricePathNames=fieldnames(PricePath); -PricePathStruct=PricePath; -PricePathSizeVec=zeros(1,length(PricePathNames)); % Allows for a given price param to depend on age (or permanent type) -for tt=1:length(PricePathNames) - temp=PricePathStruct.(PricePathNames{tt}); - tempsize=size(temp); - PricePathSizeVec(tt)=tempsize(tempsize~=T); % Get the dimension which is not T -end -PricePathSizeVec=cumsum(PricePathSizeVec); -if length(PricePathNames)>1 - PricePathSizeVec=[[1,PricePathSizeVec(1:end-1)+1];PricePathSizeVec]; -else - PricePathSizeVec=[1;PricePathSizeVec]; -end -PricePath=zeros(T,PricePathSizeVec(2,end));% Do this seperately afterwards so that can preallocate the memory -for tt=1:length(PricePathNames) - if size(PricePathStruct.(PricePathNames{tt}),1)==T - PricePath(:,PricePathSizeVec(1,tt):PricePathSizeVec(2,tt))=PricePathStruct.(PricePathNames{tt}); - else % Need to transpose - PricePath(:,PricePathSizeVec(1,tt):PricePathSizeVec(2,tt))=PricePathStruct.(PricePathNames{tt})'; - end -end - -ParamPathNames=fieldnames(ParamPath); -ParamPathStruct=ParamPath; -ParamPathSizeVec=zeros(1,length(ParamPathNames)); % Allows for a given price param to depend on age (or permanent type) -for tt=1:length(ParamPathNames) - temp=ParamPathStruct.(ParamPathNames{tt}); - tempsize=size(temp); - ParamPathSizeVec(tt)=tempsize(tempsize~=T); % Get the dimension which is not T -end -ParamPathSizeVec=cumsum(ParamPathSizeVec); -if length(ParamPathNames)>1 - ParamPathSizeVec=[[1,ParamPathSizeVec(1:end-1)+1];ParamPathSizeVec]; -else - ParamPathSizeVec=[1;ParamPathSizeVec]; -end -ParamPath=zeros(T,ParamPathSizeVec(2,end));% Do this seperately afterwards so that can preallocate the memory -for tt=1:length(ParamPathNames) - if size(ParamPathStruct.(ParamPathNames{tt}),1)==T - ParamPath(:,ParamPathSizeVec(1,tt):ParamPathSizeVec(2,tt))=ParamPathStruct.(ParamPathNames{tt}); - else % Need to transpose - ParamPath(:,ParamPathSizeVec(1,tt):ParamPathSizeVec(2,tt))=ParamPathStruct.(ParamPathNames{tt})'; - end -end +[PricePath,ParamPath,PricePathNames,ParamPathNames,PricePathSizeVec,ParamPathSizeVec]=PricePathParamPath_FHorz_StructToMatrix(PricePath,ParamPath,N_j,T); %% Check if z_grid and/or pi_z depend on prices. If not then create pi_z_J and z_grid_J for the entire transition before we start diff --git a/StationaryDist/TransPathFHorz/AgentDistOnTransPath_Case1_FHorz.m b/StationaryDist/TransPathFHorz/AgentDistOnTransPath_Case1_FHorz.m index 0b489246..f31af557 100644 --- a/StationaryDist/TransPathFHorz/AgentDistOnTransPath_Case1_FHorz.m +++ b/StationaryDist/TransPathFHorz/AgentDistOnTransPath_Case1_FHorz.m @@ -18,6 +18,7 @@ else l_d=length(n_d); end +l_aprime=l_a; %% Check which transpathoptions have been used, set all others to defaults @@ -67,57 +68,9 @@ end end - -%% Note: Internally PricePath is matrix of size T-by-'number of prices', similarly for ParamPath -% PricePath is matrix of size T-by-'number of prices'. -% Actually, some of those prices may be 1-by-N_j, so is more subtle than this. -PricePathNames=fieldnames(PricePath); -PricePathStruct=PricePath; -PricePathSizeVec=zeros(1,length(PricePathNames)); % Allows for a given price param to depend on age (or permanent type) -for ii=1:length(PricePathNames) - temp=PricePathStruct.(PricePathNames{ii}); - tempsize=size(temp); - PricePathSizeVec(ii)=tempsize(tempsize~=T); % Get the dimension which is not T -end -PricePathSizeVec=cumsum(PricePathSizeVec); -if length(PricePathNames)>1 - PricePathSizeVec=[[1,PricePathSizeVec(1:end-1)+1];PricePathSizeVec]; -else - PricePathSizeVec=[1;PricePathSizeVec]; -end -PricePath=zeros(T,PricePathSizeVec(2,end));% Do this seperately afterwards so that can preallocate the memory -for ii=1:length(PricePathNames) - if size(PricePathStruct.(PricePathNames{ii}),1)==T - PricePath(:,PricePathSizeVec(1,ii):PricePathSizeVec(2,ii))=PricePathStruct.(PricePathNames{ii}); - else % Need to transpose - PricePath(:,PricePathSizeVec(1,ii):PricePathSizeVec(2,ii))=PricePathStruct.(PricePathNames{ii})'; - end -end +%% Internally PricePath is matrix of size T-by-'number of prices'. % ParamPath is matrix of size T-by-'number of parameters that change over the transition path'. -% Actually, some of those prices may be 1-by-N_j, so is more subtle than this. -ParamPathNames=fieldnames(ParamPath); -ParamPathStruct=ParamPath; -ParamPathSizeVec=zeros(1,length(ParamPathNames)); % Allows for a given price param to depend on age (or permanent type) -for ii=1:length(ParamPathNames) - temp=ParamPathStruct.(ParamPathNames{ii}); - tempsize=size(temp); - ParamPathSizeVec(ii)=tempsize(tempsize~=T); % Get the dimension which is not T -end -ParamPathSizeVec=cumsum(ParamPathSizeVec); -if length(ParamPathNames)>1 - ParamPathSizeVec=[[1,ParamPathSizeVec(1:end-1)+1];ParamPathSizeVec]; -else - ParamPathSizeVec=[1;ParamPathSizeVec]; -end -ParamPath=zeros(T,ParamPathSizeVec(2,end));% Do this seperately afterwards so that can preallocate the memory -for ii=1:length(ParamPathNames) - if size(ParamPathStruct.(ParamPathNames{ii}),1)==T - ParamPath(:,ParamPathSizeVec(1,ii):ParamPathSizeVec(2,ii))=ParamPathStruct.(ParamPathNames{ii}); - else % Need to transpose - ParamPath(:,ParamPathSizeVec(1,ii):ParamPathSizeVec(2,ii))=ParamPathStruct.(ParamPathNames{ii})'; - end -end - +[PricePath,ParamPath,PricePathNames,ParamPathNames,PricePathSizeVec,ParamPathSizeVec]=PricePathParamPath_FHorz_StructToMatrix(PricePath,ParamPath,N_j,T); %% % Make sure all the relevant inputs are GPU arrays (not standard arrays) @@ -125,7 +78,7 @@ %% Set up exogenous shock processes -[~, pi_z_J, pi_z_J_sim, ~, pi_e_J, pi_e_J_sim, transpathoptions, simoptions]=ExogShockSetup_TPath_FHorz(n_z,[],pi_z,N_a,N_j,Parameters,PricePathNames,ParamPathNames,transpathoptions,simoptions,2); +[~, pi_z_J, pi_z_J_sim, ~, pi_e_J, pi_e_J_sim, ~, transpathoptions, simoptions]=ExogShockSetup_TPath_FHorz(n_z,[],pi_z,N_a,N_j,Parameters,PricePathNames,ParamPathNames,transpathoptions,simoptions,2); % Convert z and e to age-dependent joint-grids and transtion matrix % output: z_gridvals_J, pi_z_J, e_gridvals_J, pi_e_J, transpathoptions,vfoptions,simoptions @@ -202,7 +155,7 @@ AgeWeights_initial=sum(AgentDist_initial,1); % [1,N_j] if simoptions.fastOLG==1 AgentDist_initial=reshape(AgentDist_initial,[N_a,N_z,N_e,N_j]); - AgentDist_initial=permute(AgentDist_initial,[1,4,3,2]); + AgentDist_initial=permute(AgentDist_initial,[1,4,2,3]); AgentDist_initial=reshape(AgentDist_initial,[N_a*N_j*N_z,N_e]); end end @@ -218,28 +171,12 @@ end end -%% Some inputs needed for simoptions.fastOLG=1 that get precomputed -if simoptions.fastOLG==1 - if N_z==0 && N_e==0 - % No need to do anything - elseif N_z>0 && N_e==0 - % Precompute some things needed for fastOLG agent dist iteration - exceptlastj=kron(ones(1,(N_j-1)*N_z),1:1:N_a)+kron(kron(ones(1,N_z),N_a*(0:1:N_j-2)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_z-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist - exceptfirstj=kron(ones(1,(N_j-1)*N_z),1:1:N_a)+kron(kron(ones(1,N_z),N_a*(1:1:N_j-1)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_z-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist - justfirstj=repmat(1:1:N_a,1,N_z)+N_a*N_j*repelem(0:1:N_z-1,1,N_a); - elseif N_z==0 && N_e>0 - % Precompute some things needed for fastOLG agent dist iteration - exceptlastj=kron(ones(1,(N_j-1)*N_e),1:1:N_a)+kron(kron(ones(1,N_e),N_a*(0:1:N_j-2)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_e-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist - exceptfirstj=kron(ones(1,(N_j-1)*N_e),1:1:N_a)+kron(kron(ones(1,N_e),N_a*(1:1:N_j-1)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_e-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist - justfirstj=repmat(1:1:N_a,1,N_e)+N_a*N_j*repelem(0:1:N_e-1,1,N_a); - elseif N_z>0 && N_e>0 - % Precompute some things needed for fastOLG agent dist iteration - exceptlastj=kron(ones(1,(N_j-1)*N_z*N_e),1:1:N_a)+kron(kron(ones(1,N_z*N_e),N_a*(0:1:N_j-2)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_z*N_e-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist - exceptfirstj=kron(ones(1,(N_j-1)*N_z*N_e),1:1:N_a)+kron(kron(ones(1,N_z*N_e),N_a*(1:1:N_j-1)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_z*N_e-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist - justfirstj=repmat(1:1:N_a,1,N_z*N_e)+N_a*N_j*repelem(0:1:N_z*N_e-1,1,N_a); - end -end +%% +N_probs=1; % Not using N_probs +if simoptions.gridinterplayer==1 + N_probs=2; +end %% Reorganize PolicyPath to get just what we need, and in the shape needed if N_e==0 @@ -255,74 +192,126 @@ PolicyPath=reshape(PolicyPath, [size(PolicyPath,1),N_a,N_z,N_e,N_j,T]); end end -if l_a==1 - if N_e==0 - if N_z==0 - if simoptions.fastOLG==0 - Policy_aprimePath=reshape(PolicyPath(l_d+1,:,:,:),[1,N_a,N_j,T]); - elseif simoptions.fastOLG==1 - % PolicyPath=permute(PolicyPath,[1,2,3,4]); % no shocks, so no permute here - if simoptions.gridinterplayer==0 - Policy_aprimePath=reshape(PolicyPath(l_d+1,:,1:N_j-1,:),[1,N_a*(N_j-1),T]); - else - Policy_aprimePath=[reshape(PolicyPath(l_d+1,:,1:N_j-1,:),[N_a*(N_j-1),1,T]), 1+reshape(PolicyPath(l_d+1,:,1:N_j-1,:),[N_a*(N_j-1),1,T])]; % lower and upper gridpoints [N_a*(N_j-1),2,T] - upperprob=(reshape(PolicyPath(l_d+2,:,1:N_j-1,:),[N_a*(N_j-1),1,T])-1)/(simoptions.ngridinterp+1); - PolicyProbsPath=zeros(N_a*(N_j-1),2,T,'gpuArray'); - PolicyProbsPath(:,1,:)=1-upperprob; - PolicyProbsPath(:,2,:)=upperprob; - end +if N_e==0 + if N_z==0 % no z, no e + % Create version of PolicyPath called PolicyaprimePath, which only tracks aprime and has j=1:N_j-1 as we don't use N_j to iterate agent dist (there is no N_j+1) + % For fastOLG we use PolicyaprimejPath, if there is z then PolicyaprimejzPath + % When using grid interpolation layer also PolicyProbsPath + if isscalar(n_a) + PolicyaprimePath=reshape(PolicyPath(l_d+1,:,1:N_j-1,:),[N_a,N_j-1,T]); % aprime index + elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyPath(l_d+1,:,1:N_j-1,:)+n_a(1)*(PolicyPath(l_d+2,:,1:N_j-1,:)-1),[N_a,N_j-1,T]); + elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyPath(l_d+1,:,1:N_j-1,:)+n_a(1)*(PolicyPath(l_d+2,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyPath(l_d+3,:,1:N_j-1,:)-1),[N_a,N_j-1,T]); + elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyPath(l_d+1,:,1:N_j-1,:)+n_a(1)*(PolicyPath(l_d+2,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyPath(l_d+3,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyPath(l_d+4,:,1:N_j-1,:)-1),[N_a,N_j-1,T]); + end + if simoptions.fastOLG==0 + % PolicyaprimePath=PolicyaprimePath; + elseif simoptions.fastOLG==1 + PolicyaprimePath=reshape(permute(reshape(PolicyaprimePath,[N_a,N_j-1,T]),[1,2,3]),[N_a*(N_j-1),T]); + PolicyaprimejPath=PolicyaprimePath+repelem(N_a*gpuArray(0:1:(N_j-1)-1)',N_a,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyPath(l_d+l_aprime+1,:,1:N_j-1,:),[1,N_a,N_j-1,T]); % PolicyPath is of size [l_d+l_aprime+1,N_a,N_j,T] + L2index=reshape(permute(L2index,[2,3,1,4]),[N_a*(N_j-1),1,T]); + PolicyaprimejPath=reshape(PolicyaprimejPath,[N_a*(N_j-1),1,T]); % reinterpret this as lower grid index + PolicyaprimejPath=repelem(PolicyaprimejPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejPath(:,2,:)=PolicyaprimejPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point end - else - if simoptions.fastOLG==0 - Policy_aprimePath=reshape(PolicyPath(l_d+1,:,:,:,:),[1,N_a*N_z,N_j,T]); - elseif simoptions.fastOLG==1 - PolicyPath=permute(PolicyPath,[1,2,4,3,5]); % swap j and z - if simoptions.gridinterplayer==0 - Policy_aprimePath=reshape(PolicyPath(l_d+1,:,1:N_j-1,:,:),[1,N_a*(N_j-1)*N_z,T]); - else - Policy_aprimePath=[reshape(PolicyPath(l_d+1,:,1:N_j-1,:,:),[N_a*(N_j-1)*N_z,1,T]), 1+reshape(PolicyPath(l_d+1,:,1:N_j-1,:,:),[N_a*(N_j-1)*N_z,1,T])]; % lower and upper gridpoints [N_a*(N_j-1),2,T] - upperprob=(reshape(PolicyPath(l_d+2,:,1:N_j-1,:,:),[N_a*(N_j-1)*N_z,1,T])-1)/(simoptions.ngridinterp+1); - PolicyProbsPath=zeros(N_a*(N_j-1)*N_z,2,T,'gpuArray'); - PolicyProbsPath(:,1,:)=1-upperprob; - PolicyProbsPath(:,2,:)=upperprob; - end + end + else % z, no e + % Create version of PolicyPath called PolicyaprimePath, which only tracks aprime and has j=1:N_j-1 as we don't use N_j to iterate agent dist (there is no N_j+1) + % For fastOLG we use PolicyaprimejPath, if there is z then PolicyaprimejzPath + % When using grid interpolation layer also PolicyProbsPath + if isscalar(n_a) + PolicyaprimePath=reshape(PolicyPath(l_d+1,:,:,1:N_j-1,:),[N_a*N_z,N_j-1,T]); % aprime index + elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyPath(l_d+1,:,:,1:N_j-1,:)+n_a(1)*(PolicyPath(l_d+2,:,:,1:N_j-1,:)-1),[N_a*N_z,N_j-1,T]); + elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyPath(l_d+1,:,:,1:N_j-1,:)+n_a(1)*(PolicyPath(l_d+2,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyPath(l_d+3,:,:,1:N_j-1,:)-1),[N_a*N_z,N_j-1,T]); + elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyPath(l_d+1,:,:,1:N_j-1,:)+n_a(1)*(PolicyPath(l_d+2,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyPath(l_d+3,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyPath(l_d+4,:,:,1:N_j-1,:)-1),[N_a*N_z,N_j-1,T]); + end + if simoptions.fastOLG==0 + PolicyaprimezPath=PolicyaprimePath+repelem(N_a*gpuArray(0:1:N_z-1)',N_a,1); + elseif simoptions.fastOLG==1 + PolicyaprimePath=reshape(permute(reshape(PolicyaprimePath,[N_a,N_z,N_j-1,T]),[1,3,2,4]),[N_a*(N_j-1)*N_z,T]); + PolicyaprimejzPath=PolicyaprimePath+repelem(N_a*gpuArray(0:1:(N_j-1)*N_z-1)',N_a,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyPath(l_d+l_aprime+1,:,:,1:N_j-1,:),[1,N_a,N_z,N_j-1,T]); % PolicyPath is of size [l_d+l_aprime+1,N_a,N_z,N_j,T] + L2index=reshape(permute(L2index,[2,4,3,1,5]),[N_a*(N_j-1)*N_z,1,T]); + PolicyaprimejzPath=reshape(PolicyaprimejzPath,[N_a*(N_j-1)*N_z,1,T]); % reinterpret this as lower grid index + PolicyaprimejzPath=repelem(PolicyaprimejzPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejzPath(:,2,:)=PolicyaprimejzPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point end end - else - if N_z==0 - if simoptions.fastOLG==0 - Policy_aprimePath=reshape(PolicyPath(l_d+1,:,:,:,:),[1,N_a*N_e,N_j,T]); - elseif simoptions.fastOLG==1 - PolicyPath=permute(PolicyPath,[1,2,4,3,5]); % swap j and e - if simoptions.gridinterplayer==0 - Policy_aprimePath=reshape(PolicyPath(l_d+1,:,1:N_j-1,:,:),[1,N_a*(N_j-1)*N_e,T]); - else - Policy_aprimePath=[reshape(PolicyPath(l_d+1,:,1:N_j-1,:,:),[N_a*(N_j-1)*N_e,1,T]), 1+reshape(PolicyPath(l_d+1,:,1:N_j-1,:,:),[N_a*(N_j-1)*N_e,1,T])]; % lower and upper gridpoints [N_a*(N_j-1),2,T] - upperprob=(reshape(PolicyPath(l_d+2,:,1:N_j-1,:,:),[N_a*(N_j-1)*N_e,1,T])-1)/(simoptions.ngridinterp+1); - PolicyProbsPath=zeros(N_a*(N_j-1)*N_e,2,T,'gpuArray'); - PolicyProbsPath(:,1,:)=1-upperprob; - PolicyProbsPath(:,2,:)=upperprob; - end + end +else + if N_z==0 % no z, e + % Create version of PolicyPath called PolicyaprimePath, which only tracks aprime and has j=1:N_j-1 as we don't use N_j to iterate agent dist (there is no N_j+1) + % For fastOLG we use PolicyaprimejPath, if there is z then PolicyaprimejzPath + % When using grid interpolation layer also PolicyProbsPath + if isscalar(n_a) + PolicyaprimePath=reshape(PolicyPath(l_d+1,:,:,1:N_j-1,:),[N_a*N_e,N_j-1,T]); % aprime index + elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyPath(l_d+1,:,:,1:N_j-1,:)+n_a(1)*(PolicyPath(l_d+2,:,:,1:N_j-1,:)-1),[N_a*N_e,N_j-1,T]); + elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyPath(l_d+1,:,:,1:N_j-1,:)+n_a(1)*(PolicyPath(l_d+2,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyPath(l_d+3,:,:,1:N_j-1,:)-1),[N_a*N_e,N_j-1,T]); + elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyPath(l_d+1,:,:,1:N_j-1,:)+n_a(1)*(PolicyPath(l_d+2,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyPath(l_d+3,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyPath(l_d+4,:,:,1:N_j-1,:)-1),[N_a*N_e,N_j-1,T]); + end + if simoptions.fastOLG==0 + % PolicyaprimePath=PolicyaprimePath; + elseif simoptions.fastOLG==1 + PolicyaprimePath=reshape(permute(reshape(PolicyaprimePath,[N_a,N_e,N_j-1,T]),[1,3,2,4]),[N_a*(N_j-1)*N_e,T]); + PolicyaprimejPath=PolicyaprimePath+repmat(repelem(N_a*gpuArray(0:1:(N_j-1)-1)',N_a,1),N_e,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyPath(l_d+l_aprime+1,:,:,1:N_j-1,:),[1,N_a,N_e,N_j-1,T]); % PolicyPath is of size [l_d+l_aprime+1,N_a,N_e,N_j,T] + L2index=reshape(permute(L2index,[2,4,3,1,5]),[N_a*(N_j-1)*N_e,1,T]); + PolicyaprimejPath=reshape(PolicyaprimejPath,[N_a*(N_j-1)*N_e,1,T]); % reinterpret this as lower grid index + PolicyaprimejPath=repelem(PolicyaprimejPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejPath(:,2,:)=PolicyaprimejPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point end - else - if simoptions.fastOLG==0 - Policy_aprimePath=reshape(PolicyPath(l_d+1,:,:,:,:),[1,N_a*N_z*N_e,N_j,T]); - elseif simoptions.fastOLG==1 - PolicyPath=permute(PolicyPath,[1,2,5,3,4,6]); % swap j and z,e - if simoptions.gridinterplayer==0 - Policy_aprimePath=reshape(PolicyPath(l_d+1,:,1:N_j-1,:,:,:),[1,N_a*(N_j-1)*N_z*N_e,T]); - else - Policy_aprimePath=[reshape(PolicyPath(l_d+1,:,1:N_j-1,:,:,:),[N_a*(N_j-1)*N_z*N_e,1,T]), 1+reshape(PolicyPath(l_d+1,:,1:N_j-1,:,:,:),[N_a*(N_j-1)*N_z*N_e,1,T])]; % lower and upper gridpoints [N_a*(N_j-1),2,T] - upperprob=(reshape(PolicyPath(l_d+2,:,1:N_j-1,:,:,:),[N_a*(N_j-1)*N_z*N_e,1,T])-1)/(simoptions.ngridinterp+1); - PolicyProbsPath=zeros(N_a*(N_j-1)*N_z*N_e,2,T,'gpuArray'); - PolicyProbsPath(:,1,:)=1-upperprob; - PolicyProbsPath(:,2,:)=upperprob; - end + end + else % z, e + % Create version of PolicyPath called PolicyaprimePath, which only tracks aprime and has j=1:N_j-1 as we don't use N_j to iterate agent dist (there is no N_j+1) + % For fastOLG we use PolicyaprimejPath, if there is z then PolicyaprimejzPath + % When using grid interpolation layer also PolicyProbsPath + if isscalar(n_a) + PolicyaprimePath=reshape(PolicyPath(l_d+1,:,:,:,1:N_j-1,:),[N_a*N_z*N_e,N_j-1,T]); % aprime index + elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyPath(l_d+1,:,:,:,1:N_j-1,:)+n_a(1)*(PolicyPath(l_d+2,:,:,:,1:N_j-1,:)-1),[N_a*N_z*N_e,N_j-1,T]); + elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyPath(l_d+1,:,:,:,1:N_j-1,:)+n_a(1)*(PolicyPath(l_d+2,:,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyPath(l_d+3,:,:,:,1:N_j-1,:)-1),[N_a*N_z*N_e,N_j-1,T]); + elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyPath(l_d+1,:,:,:,1:N_j-1,:)+n_a(1)*(PolicyPath(l_d+2,:,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyPath(l_d+3,:,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyPath(l_d+4,:,:,:,1:N_j-1,:)-1),[N_a*N_z*N_e,N_j-1,T]); + end + if simoptions.fastOLG==0 + PolicyaprimezPath=PolicyaprimePath+repmat(repelem(N_a*gpuArray(0:1:N_z-1)',N_a,1),N_e,1); + elseif simoptions.fastOLG==1 + PolicyaprimePath=reshape(permute(reshape(PolicyaprimePath,[N_a,N_z*N_e,N_j-1,T]),[1,3,2,4]),[N_a*(N_j-1)*N_z*N_e,T]); + PolicyaprimejzPath=PolicyaprimePath+repmat(repelem(N_a*gpuArray(0:1:(N_j-1)*N_z-1)',N_a,1),N_e,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyPath(l_d+l_aprime+1,:,:,:,1:N_j-1,:),[1,N_a,N_z*N_e,N_j-1,T]); % PolicyPath is of size [l_d+l_aprime+1,N_a,N_z,N_e,N_j,T] + L2index=reshape(permute(L2index,[2,4,3,1,5]),[N_a*(N_j-1)*N_z*N_e,1,T]); + PolicyaprimejzPath=reshape(PolicyaprimejzPath,[N_a*(N_j-1)*N_z*N_e,1,T]); % reinterpret this as lower grid index + PolicyaprimejzPath=repelem(PolicyaprimejzPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejzPath(:,2,:)=PolicyaprimejzPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point end end end -else - error('Only one endogenous state currently supported for TPath') end @@ -370,13 +359,16 @@ %% Remove the age weights, do all the iterations, then put the age weights back in at the end. (faster as saves putting weights in and then removing them T times) +%% Because of the need to drop j=N_j (exceptlastj) before each agent dist iteration and then put j=1 (justfirstj) after each iteration I keep the AgentDist on gpu, and then use sparse(gather()) and gpuArray(full()) before and after %% Do the AgentDistPath calculations -if simoptions.gridinterplayer==0 +if N_probs==1 % Not using N_probs if N_e==0 if N_z==0 % no z, no e if simoptions.fastOLG==0 %% fastOLG=0, no z, no e + II1=1:1:N_a; + II2=ones(N_a,1); AgentDistPath=zeros(N_a,N_j,T,'gpuArray'); AgentDist=AgentDist_initial./AgeWeights_initial; % remove age weights AgentDistPath(:,:,1)=AgentDist; @@ -385,13 +377,15 @@ jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist end % Get the current optimal policy - Policy_aprime=Policy_aprimePath(:,:,:,tt); - AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_noz_raw(AgentDist,Policy_aprime,N_a,N_j,jequalOneDist); + Policy_aprime=PolicyaprimePath(:,:,tt); + AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_noz_raw(AgentDist,Policy_aprime,N_a,N_j,II1,II2,jequalOneDist); AgentDistPath(:,:,tt+1)=AgentDist; end AgentDistPath=AgentDistPath.*shiftdim(AgeWeights_T,-1); % put in the age weights else %% fastOLG=1, no z, no e + II1=1:1:N_a*(N_j-1); + II2=ones(N_a*(N_j-1),1); AgentDistPath=zeros(N_a*N_j,T,'gpuArray'); AgentDist=AgentDist_initial./repelem(AgeWeights_initial',N_a,1); % remove age weights AgentDistPath(:,1)=AgentDist; @@ -400,8 +394,8 @@ jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist end % Get the current optimal policy - Policy_aprime=Policy_aprimePath(:,:,tt); - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_raw(AgentDist,Policy_aprime,N_a,N_j,jequalOneDist); + Policy_aprimej=PolicyaprimejPath(:,tt); + AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_raw(AgentDist,Policy_aprimej,N_a,N_j,II1,II2,jequalOneDist); AgentDistPath(:,tt+1)=AgentDist; end AgentDistPath=AgentDistPath.*repelem(AgeWeights_T,N_a,1); % put in the age weights @@ -410,6 +404,8 @@ else % z, no e if simoptions.fastOLG==0 %% fastOLG=0, z, no e + II1=1:1:N_a*N_z; + II2=ones(N_a*N_z,1); AgentDistPath=zeros(N_a*N_z,N_j,T,'gpuArray'); AgentDist=AgentDist_initial./AgeWeights_initial; % remove age weights AgentDistPath(:,:,1)=AgentDist; @@ -421,14 +417,19 @@ jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist end % Get the current optimal policy - Policy_aprime=Policy_aprimePath(:,:,:,tt); - AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_raw(AgentDist,Policy_aprime,N_a,N_z,N_j,pi_z_J,jequalOneDist); + Policy_aprimez=PolicyaprimezPath(:,:,tt); + AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_raw(AgentDist,Policy_aprimez,N_a,N_z,N_j,pi_z_J,II1,II2,jequalOneDist); AgentDistPath(:,:,tt+1)=AgentDist; end AgentDistPath=AgentDistPath.*shiftdim(AgeWeights_T,-1); % put in the age weights else %% fastOLG=1, z, no e % AgentDist is [N_a*N_j*N_z,1] + II1=1:1:N_a*(N_j-1)*N_z; + II2=ones(N_a*(N_j-1)*N_z,1); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_z,1)+N_a*N_j*repelem((0:1:N_z-1)',N_a,1); AgentDistPath=zeros(N_a*N_j*N_z,T,'gpuArray'); AgentDist=AgentDist_initial./repmat(repelem(AgeWeights_initial',N_a,1),N_z,1); % remove age weights AgentDistPath(:,1)=AgentDist; @@ -440,8 +441,8 @@ jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist end % Get the current optimal policy - Policy_aprime=Policy_aprimePath(:,:,tt); - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_raw(AgentDist,Policy_aprime,N_a,N_z,N_j,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + Policy_aprimejz=PolicyaprimejzPath(:,tt); + AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_raw(AgentDist,Policy_aprimejz,N_a,N_z,N_j,pi_z_J_sim,II1,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); AgentDistPath(:,tt+1)=AgentDist; end AgentDistPath=AgentDistPath.*repmat(repelem(AgeWeights_T,N_a,1),N_z,1); % put in the age weights @@ -451,6 +452,8 @@ if N_z==0 % no z, e if simoptions.fastOLG==0 %% fastOLG=0, no z, e + II1=1:1:N_a*N_e; + II2=ones(N_a*N_e,1); AgentDistPath=zeros(N_a*N_e,N_j,T,'gpuArray'); AgentDist=AgentDist_initial./AgeWeights_initial; % remove age weights AgentDistPath(:,:,1)=AgentDist; @@ -462,14 +465,19 @@ jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist end % Get the current optimal policy - Policy_aprime=Policy_aprimePath(:,:,tt); - AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_noz_e_raw(AgentDist,Policy_aprime,N_a,N_e,N_j,pi_e_J,jequalOneDist); + Policy_aprime=PolicyaprimePath(:,:,tt); + AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_noz_e_raw(AgentDist,Policy_aprime,N_a,N_e,N_j,pi_e_J,II1,II2,jequalOneDist); AgentDistPath(:,:,tt+1)=AgentDist; end AgentDistPath=AgentDistPath.*shiftdim(AgeWeights_T,-1); % put in the age weights else %% fastOLG=1, no z, e % AgentDist is [N_a*N_j,N_e,1] + II1=1:1:N_a*(N_j-1)*N_e; + II2=ones(N_a*(N_j-1)*N_e,1); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_e,1)+N_a*N_j*repelem((0:1:N_e-1)',N_a,1); AgentDistPath=zeros(N_a*N_j,N_e,T,'gpuArray'); AgentDist=AgentDist_initial./repelem(AgeWeights_initial',N_a,1); % remove age weights AgentDistPath(:,:,1)=AgentDist; @@ -481,8 +489,8 @@ jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist end % Get the current optimal policy - Policy_aprime=Policy_aprimePath(:,:,tt); - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_e_raw(AgentDist,Policy_aprime,N_a,N_e,N_j,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + Policy_aprimej=PolicyaprimejPath(:,tt); + AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_e_raw(AgentDist,Policy_aprimej,N_a,N_e,N_j,pi_e_J_sim,II1,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); AgentDistPath(:,:,tt+1)=AgentDist; end AgentDistPath=AgentDistPath.*repelem(reshape(AgeWeights_T,[N_j,1,T]),N_a,1); % put in the age weights @@ -491,6 +499,8 @@ else % z and e if simoptions.fastOLG==0 %% fastOLG=0, z, e + II1=1:1:N_a*N_z*N_e; + II2=ones(N_a*N_z*N_e,1); AgentDistPath=zeros(N_a*N_z*N_e,N_j,T,'gpuArray'); % Whether or not using simoptions.fastOLG AgentDist=AgentDist_initial./AgeWeights_initial; % remove age weights AgentDistPath(:,:,1)=AgentDist; @@ -505,13 +515,18 @@ jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist end % Get the current optimal policy - Policy_aprime=Policy_aprimePath(:,:,:,:,tt); - AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_e_raw(AgentDist,Policy_aprime,N_a,N_z,N_e,N_j,pi_z_J,pi_e_J,jequalOneDist); + Policy_aprimez=PolicyaprimezPath(:,:,tt); + AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_e_raw(AgentDist,Policy_aprimez,N_a,N_z,N_e,N_j,pi_z_J,pi_e_J,II1,II2,jequalOneDist); AgentDistPath(:,:,tt+1)=AgentDist; end AgentDistPath=AgentDistPath.*shiftdim(AgeWeights_T,-1); % put in the age weights else %% fastOLG=1, z, e + II1=1:1:N_a*(N_j-1)*N_z*N_e; + II2=ones(N_a*(N_j-1)*N_z*N_e,1); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a,1); AgentDistPath=zeros(N_a*N_j*N_z,N_e,T,'gpuArray'); % Whether or not using simoptions.fastOLG AgentDist=AgentDist_initial./repmat(repelem(AgeWeights_initial',N_a,1),N_z,1); % remove age weights AgentDistPath(:,:,1)=AgentDist; @@ -526,8 +541,8 @@ jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist end % Get the current optimal policy - Policy_aprime=Policy_aprimePath(:,:,tt); - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_e_raw(AgentDist,Policy_aprime,N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + Policy_aprimejz=PolicyaprimejzPath(:,tt); + AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_e_raw(AgentDist,Policy_aprimejz,N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,II1,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); AgentDistPath(:,:,tt+1)=AgentDist; end AgentDistPath=AgentDistPath.*repmat(repelem(reshape(AgeWeights_T,[N_j,1,T]),N_a,1),N_z,1); % put in the age weights @@ -536,14 +551,16 @@ end -elseif simoptions.gridinterplayer==1 +else + %% N_probs>1 if N_e==0 if N_z==0 % no z, no e if simoptions.fastOLG==0 - %% fastOLG=0, no z, no e, gridinterplayer=1 + %% fastOLG=0, no z, no e, N_probs error('Not yet implemented') else - %% fastOLG=1, no z, no e, gridinterplayer=1 + %% fastOLG=1, no z, no e, N_probs + II=repelem((1:1:N_a*(N_j-1))',1,N_probs); AgentDistPath=zeros(N_a*N_j,T,'gpuArray'); AgentDist=AgentDist_initial./repelem(AgeWeights_initial',N_a,1); % remove age weights AgentDistPath(:,1)=AgentDist; @@ -552,9 +569,9 @@ jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist end % Get the current optimal policy - Policy_aprime=Policy_aprimePath(:,:,tt); + Policy_aprimej=PolicyaprimejPath(:,:,tt); PolicyProbs=PolicyProbsPath(:,:,tt); - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_noz_raw(AgentDist,Policy_aprime,PolicyProbs,N_a,N_j,jequalOneDist); + AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_raw(AgentDist,Policy_aprimej,PolicyProbs,N_a,N_j,II,jequalOneDist); AgentDistPath(:,tt+1)=AgentDist; end AgentDistPath=AgentDistPath.*repelem(AgeWeights_T,N_a,1); % put in the age weights @@ -562,11 +579,15 @@ else % z, no e if simoptions.fastOLG==0 - %% fastOLG=0, z, no e, gridinterplayer=1 + %% fastOLG=0, z, no e, N_probs error('Not yet implemented') else - %% fastOLG=1, z, no e, gridinterplayer=1 + %% fastOLG=1, z, no e, N_probs % AgentDist is [N_a*N_j*N_z,1] + II=repelem((1:1:N_a*(N_j-1)*N_z)',1,N_probs); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_z,1)+N_a*N_j*repelem((0:1:N_z-1)',N_a,1); AgentDistPath=zeros(N_a*N_j*N_z,T,'gpuArray'); AgentDist=AgentDist_initial./repmat(repelem(AgeWeights_initial',N_a,1),N_z,1); % remove age weights AgentDistPath(:,1)=AgentDist; @@ -578,9 +599,9 @@ jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist end % Get the current optimal policy - Policy_aprime=Policy_aprimePath(:,:,tt); + Policy_aprimejz=PolicyaprimejzPath(:,:,tt); PolicyProbs=PolicyProbsPath(:,:,tt); - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_raw(AgentDist,Policy_aprime,PolicyProbs,N_a,N_z,N_j,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_raw(AgentDist,Policy_aprimejz,PolicyProbs,N_a,N_z,N_j,pi_z_J_sim,II,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); AgentDistPath(:,tt+1)=AgentDist; end AgentDistPath=AgentDistPath.*repmat(repelem(AgeWeights_T,N_a,1),N_z,1); % put in the age weights @@ -590,10 +611,14 @@ else if N_z==0 % no z, e if simoptions.fastOLG==0 - %% fastOLG=0, no z, e, gridinterplayer=1 + %% fastOLG=0, no z, e, N_probs error('Not yet implemented') else - %% fastOLG=1, no z, e, gridinterplayer=1 + %% fastOLG=1, no z, e, N_probs + II=repelem((1:1:N_a*(N_j-1)*N_e)',1,N_probs); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_e,1)+N_a*N_j*repelem((0:1:N_e-1)',N_a,1); AgentDistPath=zeros(N_a*N_j,N_e,T,'gpuArray'); % Whether or not using simoptions.fastOLG AgentDist=AgentDist_initial./repelem(AgeWeights_initial',N_a,1); % remove age weights AgentDistPath(:,:,1)=AgentDist; @@ -605,9 +630,9 @@ jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist end % Get the current optimal policy - Policy_aprime=Policy_aprimePath(:,:,tt); + Policy_aprimej=PolicyaprimejPath(:,:,tt); PolicyProbs=PolicyProbsPath(:,:,tt); - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_noz_e_raw(AgentDist,Policy_aprime,PolicyProbs,N_a,N_e,N_j,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_e_raw(AgentDist,Policy_aprimej,PolicyProbs,N_a,N_e,N_j,pi_e_J_sim,II,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); AgentDistPath(:,:,tt+1)=AgentDist; end AgentDistPath=AgentDistPath.*repelem(reshape(AgeWeights_T,[N_j,1,T]),N_a,1); % put in the age weights @@ -615,10 +640,14 @@ else % z and e if simoptions.fastOLG==0 - %% fastOLG=0, z, e, gridinterplayer=1 + %% fastOLG=0, z, e, N_probs error('Not yet implemented') else - %% fastOLG=1, z, e, gridinterplayer=1 + %% fastOLG=1, z, e, N_probs + II=repelem((1:1:N_a*(N_j-1)*N_z*N_e)',1,N_probs); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_z*N_e,1)+N_a*N_j*repelem((0:1:N_z*N_e-1)',N_a,1); AgentDistPath=zeros(N_a*N_j*N_z,N_e,T,'gpuArray'); % Whether or not using simoptions.fastOLG AgentDist=AgentDist_initial./repmat(repelem(AgeWeights_initial',N_a,1),N_z,1); % remove age weights AgentDistPath(:,:,1)=AgentDist; @@ -633,9 +662,9 @@ jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist end % Get the current optimal policy - Policy_aprime=Policy_aprimePath(:,:,tt); + Policy_aprimejz=PolicyaprimejzPath(:,:,tt); PolicyProbs=PolicyProbsPath(:,:,tt); - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_e_raw(AgentDist,Policy_aprime,PolicyProbs,N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_e_raw(AgentDist,Policy_aprimejz,PolicyProbs,N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,II,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); AgentDistPath(:,:,tt+1)=AgentDist; end AgentDistPath=AgentDistPath.*repmat(repelem(reshape(AgeWeights_T,[N_j,1,T]),N_a,1),N_z,1); % put in the age weights diff --git a/StationaryDist/TransPathFHorz/AgentDistOnTransPath_Case1_FHorz_noz.m b/StationaryDist/TransPathFHorz/AgentDistOnTransPath_Case1_FHorz_noz.m deleted file mode 100644 index ffd98d47..00000000 --- a/StationaryDist/TransPathFHorz/AgentDistOnTransPath_Case1_FHorz_noz.m +++ /dev/null @@ -1,63 +0,0 @@ -function AgentDistPath=AgentDistOnTransPath_Case1_FHorz_noz(AgentDist_initial, PolicyPath, AgeWeights,n_d,n_a,N_j, T, simoptions) - -N_d=prod(n_d); -N_a=prod(n_a); - -AgentDist_initial=reshape(AgentDist_initial,[N_a,N_j]); % if simoptions.fastOLG==0 -AgeWeights_initial=sum(AgentDist_initial,1); % [1,N_j] -if transpathoptions.ageweightstrivial==0 - AgeWeights_T=AgeWeights; -elseif transpathoptions.ageweightstrivial==1 - AgeWeights=AgeWeights_initial; - AgeWeightsOld=AgeWeights; -end -if simoptions.fastOLG==1 - AgentDist_initial=reshape(AgentDist_initial,[N_a*N_j,1]); % if simoptions.fastOLG==0 -end - - -%% -if simoptions.fastOLG==0 - AgentDistPath=zeros(N_a,N_j,T); - AgentDistPath(:,:,1)=AgentDist_initial; -else % simoptions.fastOLG==1 - AgentDistPath=zeros(N_a*N_j,T); - AgentDistPath(:,1)=AgentDist_initial; -end -PolicyPath=KronPolicyIndexes_TransPathFHorz_Case1_noz(PolicyPath, n_d, n_a, N_j,T); - -% Now we have the full PolicyIndexesPath, we go forward in time from 1 -% to T using the policies to update the agents distribution generating anew price path - -% Call AgentDist the current periods distn -AgentDist=AgentDist_initial; -for tt=1:T-1 - - %Get the current optimal policy - if N_d>0 - Policy=PolicyPath(:,:,:,tt); - else - Policy=PolicyPath(:,:,tt); - end - - if transpathoptions.ageweightstrivial==0 - AgeWeightsOld=AgeWeights; - AgeWeights=AgeWeights_T(tt,:); - end - if simoptions.fastOLG==0 - AgentDist=StationaryDist_FHorz_Case1_TPath_SingleStep_Iteration_noz_raw(AgentDist,AgeWeights,AgeWeightsOld,Policy,N_d,N_a,N_j); - AgentDistPath(:,:,tt+1)=AgentDist; - else % simoptions.fastOLG==1 - AgentDist=StationaryDist_FHorz_Case1_TPath_SingleStep_IterFast_noz_raw(AgentDist,AgeWeights,AgeWeightsOld,Policy,N_d,N_a,N_j); - AgentDistPath(:,tt+1)=AgentDist; - end - -end - -AgentDistPath=reshape(AgentDistPath,[n_a,N_j,T]); - - - - - -end \ No newline at end of file diff --git a/StationaryDist/TransPathFHorz/AgentDistOnTransPath_Case1_FHorz_raw.m b/StationaryDist/TransPathFHorz/AgentDistOnTransPath_Case1_FHorz_raw.m deleted file mode 100644 index 50966abc..00000000 --- a/StationaryDist/TransPathFHorz/AgentDistOnTransPath_Case1_FHorz_raw.m +++ /dev/null @@ -1,72 +0,0 @@ -function AgentDistPath=AgentDistOnTransPath_Case1_FHorz_raw(AgentDist_initial, PolicyPath, AgeWeights,n_d,n_a,n_z,N_j, T, pi_z_J, transpathoptions, simoptions) - -N_d=prod(n_d); -N_a=prod(n_a); -N_z=prod(n_z); - -AgentDist_initial=reshape(AgentDist_initial,[N_a*N_z,N_j]); % if simoptions.fastOLG==0 -AgeWeights_initial=sum(AgentDist_initial,1); % [1,N_j] -if transpathoptions.ageweightstrivial==0 - AgeWeights_T=AgeWeights; -elseif transpathoptions.ageweightstrivial==1 - AgeWeights=AgeWeights_initial; - AgeWeightsOld=AgeWeights; -end -if simoptions.fastOLG==1 - AgentDist_initial=reshape(AgentDist_initial,[N_a*N_z*N_j,1]); - pi_z_J=permute(pi_z_J,[4,2,1,3]); % note, 4th dimension is singular: so get 1-zprime-z-j -end - -%% -if simoptions.fastOLG==0 - AgentDistPath=zeros(N_a*N_z,N_j,T); - AgentDistPath(:,:,1)=AgentDist_initial; -else % simoptions.fastOLG==1 - AgentDistPath=zeros(N_a*N_j*N_z,T); - AgentDistPath(:,1)=AgentDist_initial; -end -PolicyPath=KronPolicyIndexes_TransPathFHorz_Case1(PolicyPath, n_d, n_a, n_z, N_j,T); - -% Now we have the full PolicyIndexesPath, we go forward in time from 1 -% to T using the policies to update the agents distribution generating anew price path - -% Call AgentDist the current periods distn -AgentDist=AgentDist_initial; -for tt=1:T-1 - - %Get the current optimal policy - if N_d>0 - Policy=PolicyPath(:,:,:,:,tt); - else - Policy=PolicyPath(:,:,:,tt); - end - - if transpathoptions.zpathtrivial==1 - pi_z_J=transpathoptions.pi_z_J_T(:,:,:,tt); - if simoptions.fastOLG==1 - pi_z_J=transpathoptions.pi_z_J_T(:,:,:,:,tt); - end - end - - if transpathoptions.ageweightstrivial==0 - AgeWeightsOld=AgeWeights; - AgeWeights=AgeWeights_T(tt,:); - end - if simoptions.fastOLG==0 - AgentDist=StationaryDist_FHorz_Case1_TPath_SingleStep_Iteration_raw(AgentDist,AgeWeights,AgeWeightsOld,PolicyIndexesKron,N_d,N_a,N_z,N_j,pi_z_J); - AgentDistPath(:,:,tt+1)=AgentDist; % [N_a*N_z,N_j,T] - elseif simoptions.fastOLG==1 - AgentDist=StationaryDist_FHorz_Case1_TPath_SingleStep_IterFast_raw(AgentDist,AgeWeights,AgeWeightsOld,Policy,N_d,N_a,N_z,N_j,pi_z_J); - AgentDistPath(:,tt+1)=AgentDist; % [N_a*N_z*N_j,T] - end -end - -if simoptions.fastOLG==1 - AgentDistPath=reshape(AgentDistPath,[N_a,N_j,N_z,T]); - AgentDistPath=permute(AgentDistPath,[1,3,2,4]); -end - -AgentDistPath=reshape(AgentDistPath,[n_a,n_z,N_j,T]); - - -end \ No newline at end of file diff --git a/SubCodes/ExoShocks/ExogShockSetup_TPath_FHorz.m b/SubCodes/ExoShocks/ExogShockSetup_TPath_FHorz.m index 69d0ca58..138d9152 100644 --- a/SubCodes/ExoShocks/ExogShockSetup_TPath_FHorz.m +++ b/SubCodes/ExoShocks/ExogShockSetup_TPath_FHorz.m @@ -1,8 +1,9 @@ -function [z_gridvals_J, pi_z_J, pi_z_J_sim, e_gridvals_J, pi_e_J, pi_e_J_sim, transpathoptions, options]=ExogShockSetup_TPath_FHorz(n_z,z_grid,pi_z,N_a,N_j,Parameters,PricePathNames,ParamPathNames,transpathoptions,options,gridpiboth) +function [z_gridvals_J, pi_z_J, pi_z_J_sim, e_gridvals_J, pi_e_J, pi_e_J_sim, ze_gridvals_J_fastOLG, transpathoptions, options]=ExogShockSetup_TPath_FHorz(n_z,z_grid,pi_z,N_a,N_j,Parameters,PricePathNames,ParamPathNames,transpathoptions,options,gridpiboth) % Convert z and e to age-dependent joint-grids and transtion matrix % Can input vfoptions OR simoptions % output: z_gridvals_J, pi_z_J, e_gridvals_J, pi_e_J, transpathoptions, options % pi_z_J_sim and pi_e_J_sim are for simoptions.fastOLG=1 (otherwise omitted) +% ze_gridvals_J_fastOLG is for the fastOLG version of AggVars % Sets up % transpathoptions.zpathtrivial=1; % z_gridvals_J and pi_z_J are not varying over the path @@ -12,6 +13,8 @@ % and % transpathoptions.gridsinGE=1; % grids depend on a GE parameter and so need to be recomputed every iteration % =0; % grids are exogenous +% +% transpathoptions.zepathtrivial=0 when either of zpathtrival and epathtrivial both are zero % gridpiboth=4: sometimes (trans path GE) we want both grid and transition probabilties, including pi_z_J_sim alternative transition probs % gridpiboth=3: sometimes (value fn iter) we want both grid and transition probabilties @@ -41,6 +44,7 @@ z_gridvals_J=[]; pi_z_J=[]; pi_z_J_sim=[]; +l_z=0; if N_z>0 l_z=length(n_z); @@ -227,6 +231,7 @@ e_gridvals_J=[]; pi_e_J=[]; pi_e_J_sim=[]; +l_e=0; if N_e>0 l_e=length(n_e); % Check if e_grid and/or pi_e depend on prices. If not then create pi_e_J and e_grid_J for the entire transition before we start @@ -298,60 +303,60 @@ else % Not ExogShockFn, or at least not any more if gridpiboth==1 % for most FnsToEvaluate, we don't use pi_z if isfield(options,'e_grid') - if isscalar(n_e) % pointless manual hack because Matlab was shitting itself for no reason telling me it couldnt find CreateGridVals function - e_gridvals_J=options.e_grid.*ones(1,1,N_j,'gpuArray'); - else - e_gridvals_J=CreateGridVals(n_e,options.e_grid,1).*ones(1,1,N_j,'gpuArray'); - end - options=rmfield(options,'e_grid'); - elseif isfield(options,'e_grid_J') - if ndims(options.e_grid_J)==3 % already gridvals - e_gridvals_J=gpuArray(options.e_grid_J); - elseif ndims(options.e_grid_J)==2 - e_gridvals_J=zeros(N_e,l_e,N_j,'gpuArray'); - for jj=1:N_j - e_gridvals_J(:,:,jj)=CreateGridVals(n_e,options.e_grid_J(:,jj),1); + if ndims(options.e_grid)==3 % already age-dependent gridvals + e_gridvals_J=gpuArray(options.e_grid); + elseif ndims(options.e_grid)==2 + % Could be be age-dependent e_grid_J or e_gridvals + if size(options.e_grid,2)==N_j + if l_e==1 + e_gridvals_J=reshape(options.e_grid,[N_e,l_e,N_j]); % Avoid Matlab getting annoyed about CreateGridVals() for no apparent reason + else + e_gridvals_J=zeros(N_e,l_e,N_j,'gpuArray'); + for jj=1:N_j + e_gridvals_J(:,:,jj)=CreateGridVals(n_e,options.e_grid(:,jj),1); + end + end + else + e_gridvals_J=options.e_grid.*ones(1,1,N_j,'gpuArray'); end end - options=rmfield(options,'e_grid_J'); + options=rmfield(options,'e_grid'); end elseif gridpiboth==2 % For agent dist, we don't use grid if isfield(options,'pi_e') - pi_e_J=options.pi_e.*ones(1,N_j,'gpuArray'); + pi_e_J=options.pi_e.*ones(1,N_j,'gpuArray'); % this works regardless of if pi_e depends on j or not options=rmfield(options,'pi_e'); - elseif isfield(options,'pi_e_J') - pi_e_J=gpuArray(options.pi_e_J); - options=rmfield(options,'pi_e_J'); end elseif gridpiboth==3 || gridpiboth==4 % For value fn, both z_gridvals_J and pi_z_J if isfield(options,'pi_e') - if isscalar(n_e) % pointless manual hack because Matlab was shitting itself for no reason telling me it couldnt find CreateGridVals function - e_gridvals_J=options.e_grid.*ones(1,1,N_j,'gpuArray'); - else - e_gridvals_J=CreateGridVals(n_e,options.e_grid,1).*ones(1,1,N_j,'gpuArray'); + % Just assume there is also options.e_grid + if ndims(options.e_grid)==3 % already age-dependent gridvals + e_gridvals_J=gpuArray(options.e_grid); + elseif ndims(options.e_grid)==2 + % Could be be age-dependent e_grid_J or e_gridvals + if size(options.e_grid,2)==N_j + if l_e==1 + e_gridvals_J=reshape(options.e_grid,[N_e,l_e,N_j]); % Avoid Matlab getting annoyed about CreateGridVals() for no apparent reason + else + e_gridvals_J=zeros(N_e,l_e,N_j,'gpuArray'); + for jj=1:N_j + e_gridvals_J(:,:,jj)=CreateGridVals(n_e,options.e_grid(:,jj),1); + end + end + else + e_gridvals_J=options.e_grid.*ones(1,1,N_j,'gpuArray'); + end end - pi_e_J=options.pi_e.*ones(1,N_j,'gpuArray'); options=rmfield(options,'e_grid'); + pi_e_J=options.pi_e.*ones(1,N_j,'gpuArray'); % this works regardless of if pi_e depends on j or not options=rmfield(options,'pi_e'); - elseif isfield(options,'pi_e_J') - if ndims(options.e_grid_J)==3 % already gridvals - e_gridvals_J=gpuArray(options.e_grid_J); - elseif ndims(options.e_grid_J)==2 - e_gridvals_J=zeros(N_e,l_e,N_j,'gpuArray'); - for jj=1:N_j - e_gridvals_J(:,:,jj)=CreateGridVals(n_e,options.e_grid_J(:,jj),1); - end - end - pi_e_J=gpuArray(options.pi_e_J); - options=rmfield(options,'e_grid_J'); - options=rmfield(options,'pi_e_J'); end end end % Make sure they are on grid pi_e_J=gpuArray(pi_e_J); e_gridvals_J=gpuArray(e_gridvals_J); - + % When using fastOLG we want an alternative version of pi_e_J that we use for the agent distribution, call it pi_e_J_sim if gridpiboth==2 || gridpiboth==4 if options.fastOLG==1 @@ -361,7 +366,7 @@ pi_e_J_sim=repelem(pi_e_J(:,2:end)',N_a,1); % (a,j)-by-e (but only for jj=2:end) else % pi_e_J_sim maps (a,j,z)-to-e (but only for jj=2:end), is [N_a*(N_j-1)*N_z,N_e] - pi_e_J_sim=repmat(repelem(pi_e_J(:,2:end)',N_a,1),N_z,1); + pi_e_J_sim=repmat(repelem(pi_e_J(:,2:end)',N_a,1),N_z,1); % (a,j,z)-by-e (but only for jj=2:end) end end end @@ -482,4 +487,89 @@ + +%% Create ze_gridvals_J_fastOLG, which is used for AggVars. Will be z_gridvals_J_fastOLG or e_gridvals_J_OLG if only one of them is used +% gridpiboth=4: sometimes (trans path GE) we want both grid and transition probabilties, including pi_z_J_sim alternative transition probs +% gridpiboth=3: sometimes (value fn iter) we want both grid and transition probabilties +% gridpiboth=2: sometimes (agent dist) we want just transition probabilties, including pi_z_J_sim alternative transition probs +% gridpiboth=1: sometimes (FnsToEvaluate) we want just grid +if gridpiboth==3 || gridpiboth==2 + ze_gridvals_J_fastOLG=[]; +else + if transpathoptions.zpathtrivial==0 || transpathoptions.epathtrivial==0 + transpathoptions.zepathtrivial=0; + else + transpathoptions.zepathtrivial=1; + end + + if N_e==0 && N_z==0 + ze_gridvals_J_fastOLG=[]; + else + l_ze=l_z+l_e; + if l_z>0 && l_e>0 + N_ze=N_z*N_e; + if transpathoptions.fastOLG==0 + ze_gridvals_J=[repmat(z_gridvals_J,N_e,1),repelem(e_gridvals_J,N_z,1)]; + elseif transpathoptions.fastOLG==1 + ze_gridvals_J=zeros(N_j,N_ze,l_ze,'gpuArray'); + ze_gridvals_J(:,:,1:l_z)=repmat(z_gridvals_J,1,N_e,1); + ze_gridvals_J(:,:,l_z+1:end)=repmat(squeeze(e_gridvals_J),1,N_z,1); + end + end + + % Version that is used for model stats, good shape for calculating AggVars fast + if transpathoptions.fastOLG==0 + if N_z>0 && N_e>0 + ze_gridvals_J_fastOLG=shiftdim(permute(ze_gridvals_J,[3,1,2]),-1); % [1,N_j,N_ze,l_ze] need this for fastOLG agent dist (it is not used for value fn, so can overwrite) + elseif N_z>0 + ze_gridvals_J_fastOLG=shiftdim(permute(z_gridvals_J,[3,1,2]),-1); % [1,N_j,N_z,l_z] need this for fastOLG agent dist, but need the standard still for the value fn without fastOLG + elseif N_e>0 + ze_gridvals_J_fastOLG=shiftdim(permute(e_gridvals_J,[3,1,2]),-1); % [1,N_j,N_e,l_e] need this for fastOLG agent dist, but need the standard still for the value fn without fastOLG + end + else + if N_z>0 && N_e>0 + ze_gridvals_J_fastOLG=shiftdim(ze_gridvals_J,-1); % [1,N_j,N_ze,l_ze] need this for fastOLG agent dist (it is not used for value fn, so can overwrite) + elseif N_z>0 + ze_gridvals_J_fastOLG=shiftdim(z_gridvals_J,-1); % [1,N_j,N_z,l_z] need this for fastOLG agent dist, but need the standard still for the value fn without fastOLG + elseif N_e>0 + ze_gridvals_J_fastOLG=shiftdim(e_gridvals_J,-1); % [1,N_j,N_e,l_e] need this for fastOLG agent dist, but need the standard still for the value fn without fastOLG + end + end + end + + % If ze_gridvals_J_fastOLG depends on t, set up transpathoptions.ze_gridvals_J_T_fastOLG + if transpathoptions.zepathtrivial==0 + if l_z>0 && l_e>0 + N_ze=N_z*N_e; + if transpathoptions.fastOLG==0 + ze_gridvals_J_T=[repmat(transpathoptions.z_gridvals_J_T,N_e,1,1),repelem(transpathoptions.e_gridvals_J_T,N_z,1,1)]; + elseif transpathoptions.fastOLG==1 + ze_gridvals_J_T=zeros(N_j,N_ze,l_ze,'gpuArray'); + ze_gridvals_J_T(:,:,1:l_z,:)=repmat(transpathoptions.z_gridvals_J,1,N_e,1); + ze_gridvals_J_T(:,:,l_z+1:end,:)=repmat(squeeze(transpathoptions.e_gridvals_J),1,N_z,1); + end + end + + if transpathoptions.fastOLG==0 + if N_z>0 && N_e>0 + transpathoptions.ze_gridvals_J_T_fastOLG=shiftdim(permute(ze_gridvals_J_T,[3,1,2,4]),-1); % [1,N_j,N_ze,l_ze,T] need this for fastOLG agent dist (it is not used for value fn, so can overwrite) + elseif N_z>0 + transpathoptions.ze_gridvals_J_T_fastOLG=shiftdim(permute(transpathoptions.z_gridvals_J_T,[3,1,2,4]),-1); % [1,N_j,N_z,l_z,T] need this for fastOLG agent dist, but need the standard still for the value fn without fastOLG + elseif N_e>0 + transpathoptions.ze_gridvals_J_T_fastOLG=shiftdim(permute(transpathoptions.e_gridvals_J_T,[3,1,2,4]),-1); % [1,N_j,N_e,l_e,T] need this for fastOLG agent dist, but need the standard still for the value fn without fastOLG + end + else + if N_z>0 && N_e>0 + transpathoptions.ze_gridvals_J_T_fastOLG=shiftdim(transpathoptions.ze_gridvals_J_T,-1); % [1,N_j,N_ze,l_ze,T] need this for fastOLG agent dist (it is not used for value fn, so can overwrite) + elseif N_z>0 + transpathoptions.ze_gridvals_J_T_fastOLG=shiftdim(transpathoptions.z_gridvals_J_T,-1); % [1,N_j,N_z,l_z,T] need this for fastOLG agent dist, but need the standard still for the value fn without fastOLG + elseif N_e>0 + transpathoptions.ze_gridvals_J_T_fastOLG=shiftdim(transpathoptions.e_gridvals_J_T,-1); % [1,N_j,N_e,l_e,T] need this for fastOLG agent dist, but need the standard still for the value fn without fastOLG + end + end + + end +end + + end \ No newline at end of file diff --git a/SubCodes/UnKronPolicyIndexes/OnCPU/UnKronPolicyIndexes_FHorz_CPU.m b/SubCodes/UnKronPolicyIndexes/OnCPU/UnKronPolicyIndexes_FHorz_CPU.m new file mode 100644 index 00000000..9529fad0 --- /dev/null +++ b/SubCodes/UnKronPolicyIndexes/OnCPU/UnKronPolicyIndexes_FHorz_CPU.m @@ -0,0 +1,43 @@ +function Policy=UnKronPolicyIndexes_FHorz_CPU(PolicyKron, n_d,n_a, n_z,N_j) +% Input: PolicyKron is (2,N_a,N_z,N_j) first dim indexes the optimal choice for d and aprime +% (N_a,N_z,N_j) if there is no d +% Output: Policy is (l_d+l_a,n_a,n_z,N_j); + +N_a=prod(n_a); +N_z=prod(n_z); + +l_aprime=length(n_a); +n_aprime=n_a; + +% On CPU +Policy=zeros(l_aprime,N_a,N_z,N_j); +if n_d(1)==0 + for a_c=1:N_a + for z_c=1:N_z + for jj=1:N_j + optaindexKron=PolicyKron(a_c,z_c,jj); + optA=ind2sub_homemade(n_aprime',optaindexKron); + Policy(:,a_c,z_c,jj)=optA'; + end + end + end + Policy=reshape(Policy,[l_aprime,n_a,n_z,N_j]); +else + l_d=length(n_d); + Policy=zeros(l_d+l_aprime,N_a,N_z,N_j); + for a_c=1:N_a + for z_c=1:N_z + for jj=1:N_j + optdindexKron=PolicyKron(1,a_c,z_c,jj); + optaindexKron=PolicyKron(2,a_c,z_c,jj); + optD=ind2sub_homemade(n_d',optdindexKron); + optA=ind2sub_homemade(n_aprime',optaindexKron); + Policy(:,a_c,z_c,jj)=[optD';optA']; + end + end + end + Policy=reshape(Policy,[l_d+l_aprime,n_a,n_z,N_j]); +end + + +end \ No newline at end of file diff --git a/SubCodes/UnKronPolicyIndexes/OnCPU/UnKronPolicyIndexes_FHorz_noz_CPU.m b/SubCodes/UnKronPolicyIndexes/OnCPU/UnKronPolicyIndexes_FHorz_noz_CPU.m new file mode 100644 index 00000000..11fc1904 --- /dev/null +++ b/SubCodes/UnKronPolicyIndexes/OnCPU/UnKronPolicyIndexes_FHorz_noz_CPU.m @@ -0,0 +1,36 @@ +function Policy=UnKronPolicyIndexes_FHorz_noz_CPU(PolicyKron, n_d,n_a, N_j) +% Can use vfoptions OR simoptions +% Input: PolicyKron=zeros(2,N_a,N_j); %first dim indexes the optimal choice for d and aprime rest of dimensions a,z +% (N_a,N_j) if there is no d +% Output: Policy (l_d+l_a,n_a,N_j); + +N_a=prod(n_a); + +% On CPU +if n_d(1)==0 + Policy=zeros(l_aprime,N_a,N_j); + for a_c=1:N_a + for jj=1:N_j + optaindexKron=PolicyKron(a_c,jj); + optA=ind2sub_homemade(n_aprime',optaindexKron); + Policy(:,a_c,jj)=optA'; + end + end + Policy=reshape(Policy,[l_aprime,n_a,N_j]); +else + l_d=length(n_d); + Policy=zeros(l_d+l_aprime,N_a,N_j); + for a_c=1:N_a + for jj=1:N_j + optdindexKron=PolicyKron(1,a_c,jj); + optaindexKron=PolicyKron(2,a_c,jj); + optD=ind2sub_homemade(n_d',optdindexKron); + optA=ind2sub_homemade(n_aprime',optaindexKron); + Policy(:,a_c,jj)=[optD';optA']; + end + end + Policy=reshape(Policy,[l_d+l_aprime,n_a,N_j]); +end + + +end \ No newline at end of file diff --git a/SubCodes/UnKronPolicyIndexes/OnCPU/UnKronPolicyIndexes_InfHorz_CPU.m b/SubCodes/UnKronPolicyIndexes/OnCPU/UnKronPolicyIndexes_InfHorz_CPU.m new file mode 100644 index 00000000..ea3f770e --- /dev/null +++ b/SubCodes/UnKronPolicyIndexes/OnCPU/UnKronPolicyIndexes_InfHorz_CPU.m @@ -0,0 +1,36 @@ +function Policy=UnKronPolicyIndexes_InfHorz_CPU(PolicyKron, n_d,n_a, n_z) +% Can use vfoptions OR simoptions +% Input: PolicyKron is (2,N_a,N_z) first dim indexes the optimal choice for d and aprime +% (N_a,N_z) if there is no d +% Output: Policy is (l_d+l_a,n_a,n_z); + +N_a=prod(n_a); +N_z=prod(n_z); + +% On CPU +if n_d(1)==0 + Policy=zeros(l_aprime,N_a,N_z); + for i=1:N_a + for j=1:N_z + optaindexKron=PolicyKron(i,j); + optA=ind2sub_homemade(n_aprime',optaindexKron); + Policy(:,i,j)=optA'; + end + end + Policy=reshape(Policy,[l_aprime,n_a,n_z]); +else + l_d=length(n_d); + Policy=zeros(l_d+l_aprime,N_a,N_z); + for i=1:N_a + for j=1:N_z + optdindexKron=PolicyKron(1,i,j); + optaindexKron=PolicyKron(2,i,j); + optD=ind2sub_homemade(n_d',optdindexKron); + optA=ind2sub_homemade(n_aprime',optaindexKron); + Policy(:,i,j)=[optD';optA']; + end + end + Policy=reshape(Policy,[l_d+l_aprime,n_a,n_z]); +end + +end \ No newline at end of file diff --git a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1.m b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1.m index 3dd50d74..4d6f23c3 100644 --- a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1.m +++ b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1.m @@ -1,152 +1,64 @@ -function Policy=UnKronPolicyIndexes_Case1(PolicyKron, n_d, n_a, n_z,vfoptions) - -% Input: PolicyKron=zeros(2,N_a,N_z); %first dim indexes the optimal choice for d and aprime rest of dimensions a,z -% (N_a,N_z) if there is no d -% Output: Policy (l_d+l_a,n_a,n_z); -% Note: simoptions.gridinterplayer=1 means there will be an additional index for the second layer in both the input and output versions +function Policy=UnKronPolicyIndexes_Case1(PolicyKron, n_d,n_a, n_z, vfoptions) +% Can use vfoptions OR simoptions +% Input: PolicyKron is (2,N_a,N_z) first dim indexes the optimal choice for d and aprime +% (1,N_a,N_z) if there is no d +% vfoptions.gridinterplayer=1 will mean the first dimension has one extra value (so 3 if d, 2 without) +% Output: Policy is (l_d+l_a,n_a,n_z); N_a=prod(n_a); N_z=prod(n_z); -l_a=length(n_a); - -if vfoptions.gridinterplayer==0 - - if vfoptions.parallel==2 - if n_d(1)==0 - Policy=zeros(l_a,N_a,N_z,'gpuArray'); - - Policy(1,:,:)=shiftdim(rem(PolicyKron-1,n_a(1))+1,-1); - if l_a>1 - if l_a>2 - for ii=2:l_a-1 - Policy(ii,:,:)=shiftdim(rem(ceil(PolicyKron/prod(n_a(1:ii-1)))-1,n_a(ii))+1,-1); - end - end - Policy(l_a,:,:)=shiftdim(ceil(PolicyKron/prod(n_a(1:l_a-1))),-1); - end - - Policy=reshape(Policy,[l_a,n_a,n_z]); - else - l_d=length(n_d); - l_da=length(n_d)+length(n_a); - n_da=[n_d,n_a]; - Policy=zeros(l_da,N_a,N_z,'gpuArray'); +l_aprime=length(n_a); +n_aprime=n_a; +extra=(vfoptions.gridinterplayer==1); - Policy(1,:,:)=rem(PolicyKron(1,:,:)-1,n_da(1))+1; - if l_d>1 - if l_d>2 - for ii=2:l_d-1 - Policy(ii,:,:)=rem(ceil(PolicyKron(1,:,:)/prod(n_d(1:ii-1)))-1,n_d(ii))+1; - end - end - Policy(l_d,:,:)=ceil(PolicyKron(1,:,:)/prod(n_d(1:l_d-1))); - end - - Policy(l_d+1,:,:)=rem(PolicyKron(2,:,:)-1,n_a(1))+1; - if l_a>1 - if l_a>2 - for ii=2:l_a-1 - Policy(l_d+ii,:,:)=rem(ceil(PolicyKron(2,:,:)/prod(n_a(1:ii-1)))-1,n_a(ii))+1; - end - end - Policy(l_da,:,:)=ceil(PolicyKron(2,:,:)/prod(n_a(1:l_a-1))); - end +if n_d(1)==0 + Policy=zeros(l_aprime+extra,N_a,N_z,'gpuArray'); - Policy=reshape(Policy,[l_da,n_a,n_z]); - end - - else - % On CPU - if n_d(1)==0 - Policy=zeros(l_a,N_a,N_z); - for i=1:N_a - for j=1:N_z - optaindexKron=PolicyKron(i,j); - optA=ind2sub_homemade(n_a',optaindexKron); - Policy(:,i,j)=optA'; - end - end - Policy=reshape(Policy,[l_a,n_a,n_z]); - else - l_d=length(n_d); - Policy=zeros(l_d+l_a,N_a,N_z); - for i=1:N_a - for j=1:N_z - optdindexKron=PolicyKron(1,i,j); - optaindexKron=PolicyKron(2,i,j); - optD=ind2sub_homemade(n_d',optdindexKron); - optA=ind2sub_homemade(n_a',optaindexKron); - Policy(:,i,j)=[optD';optA']; - end + Policy(1,:,:)=rem(PolicyKron(1,:,:)-1,n_aprime(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=2:l_aprime-1 + Policy(ii,:,:)=rem(ceil(PolicyKron(1,:,:)/prod(n_aprime(1:ii-1)))-1,n_a(ii))+1; end - Policy=reshape(Policy,[l_d+l_a,n_a,n_z]); end + Policy(l_aprime,:,:)=ceil(PolicyKron(1,:,:)/prod(n_aprime(1:l_aprime-1))); end -elseif vfoptions.gridinterplayer==1 - - if n_d(1)==0 - Policy=zeros(l_a+1,N_a,N_z,'gpuArray'); - - Policy(1,:,:)=PolicyKron(1,:,:); - if l_a==2 - Policy(2,:,:)=PolicyKron(2,:,:); - elseif l_a>2 - Policy(2,:,:)=shiftdim(rem(PolicyKron(2,:,:)-1,n_a(1))+1,-1); - if l_a>3 - for ii=3:l_a-1 - Policy(ii,:,:)=shiftdim(rem(ceil(PolicyKron(2,:,:)/prod(n_a(1:ii-1)))-1,n_a(ii))+1,-1); - end - end - Policy(l_a,:,:)=shiftdim(ceil(PolicyKron(2,:,:)/prod(n_a(1:l_a-1))),-1); - end - - if l_a==1 - Policy(l_a+1,:,:)=PolicyKron(2,:,:); % L2 index - else - Policy(l_a+1,:,:)=PolicyKron(3,:,:); % L2 index - end + if vfoptions.gridinterplayer==1 + Policy(l_aprime+1,:,:)=PolicyKron(2,:,:); + end - Policy=reshape(Policy,[l_a+1,n_a,n_z]); - else - l_d=length(n_d); - l_da=length(n_d)+length(n_a); - n_da=[n_d,n_a]; - Policy=zeros(l_da+1,N_a,N_z,'gpuArray'); + Policy=reshape(Policy,[l_aprime+extra,n_a,n_z]); +else + l_d=length(n_d); + Policy=zeros(l_d+l_aprime+extra,N_a,N_z,'gpuArray'); - Policy(1,:,:)=rem(PolicyKron(1,:,:)-1,n_da(1))+1; - if l_d>1 - if l_d>2 - for ii=2:l_d-1 - Policy(ii,:,:)=rem(ceil(PolicyKron(1,:,:)/prod(n_d(1:ii-1)))-1,n_d(ii))+1; - end + Policy(1,:,:)=rem(PolicyKron(1,:,:)-1,n_d(1))+1; + if l_d>1 + if l_d>2 + for ii=2:l_d-1 + Policy(ii,:,:)=rem(ceil(PolicyKron(1,:,:)/prod(n_d(1:ii-1)))-1,n_d(ii))+1; end - Policy(l_d,:,:)=ceil(PolicyKron(1,:,:)/prod(n_d(1:l_d-1))); end + Policy(l_d,:,:)=ceil(PolicyKron(1,:,:)/prod(n_d(1:l_d-1))); + end - Policy(l_d+1,:,:)=PolicyKron(2,:,:); - if l_a==2 - Policy(l_d+2,:,:)=PolicyKron(3,:,:); - elseif l_a>2 - Policy(l_d+2,:,:)=shiftdim(rem(PolicyKron(3,:,:)-1,n_a(1))+1,-1); - if l_a>3 - for ii=3:l_a-1 - Policy(l_d+ii,:,:)=shiftdim(rem(ceil(PolicyKron(3,:,:)/prod(n_a(1:ii-1)))-1,n_a(ii))+1,-1); - end + Policy(l_d+1,:,:)=rem(PolicyKron(2,:,:)-1,n_aprime(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=2:l_aprime-1 + Policy(l_d+ii,:,:)=rem(ceil(PolicyKron(2,:,:)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; end - Policy(l_d+l_a,:,:)=shiftdim(ceil(PolicyKron(3,:,:)/prod(n_a(1:l_a-1))),-1); - end - - if l_a==1 - Policy(l_da+1,:,:)=PolicyKron(3,:,:); % L2 index - else - Policy(l_da+1,:,:)=PolicyKron(4,:,:); % L2 index end + Policy(l_d+l_aprime,:,:)=ceil(PolicyKron(2,:,:)/prod(n_aprime(1:l_aprime-1))); + end - Policy=reshape(Policy,[l_da+1,n_a,n_z]); + if vfoptions.gridinterplayer==1 + Policy(l_d+l_aprime+1,:,:)=PolicyKron(3,:,:); end + Policy=reshape(Policy,[l_d+l_aprime+extra,n_a,n_z]); end diff --git a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz.m b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz.m index 4fd85aea..98579ee8 100644 --- a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz.m +++ b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz.m @@ -1,108 +1,64 @@ -function Policy=UnKronPolicyIndexes_Case1_FHorz(Policy, n_d, n_a, n_z,N_j,vfoptions) +function Policy=UnKronPolicyIndexes_Case1_FHorz(PolicyKron, n_d,n_a, n_z,N_j, vfoptions) +% Can use vfoptions OR simoptions +% Input: PolicyKron is (2,N_a,N_z,N_j) first dim indexes the optimal choice for d and aprime +% (1,N_a,N_z,N_j) if there is no d +% vfoptions.gridinterplayer=1 will mean the first dimension has one extra value (so 3 if d, 2 without) +% Output: Policy is (l_d+l_a,n_a,n_z,N_j); -%Input: Policy=zeros(2,N_a,N_z,N_j); %first dim indexes the optimal choice for d and aprime rest of dimensions a,z -% (N_a,N_z,N_j) if there is no d -%Output: Policy (l_d+l_a,n_a,n_z,N_j); - -N_d=prod(n_d); N_a=prod(n_a); N_z=prod(n_z); -l_a=length(n_a); - - -% Sometimes numerical rounding errors (of the order of 10^(-16) can mean -% that Policy is not integer valued. The following corrects this by converting to int64 and then -% makes the output back into double as Matlab otherwise cannot use it in -% any arithmetical expressions. -if ~isfield(vfoptions,'policy_forceintegertype') - vfoptions.policy_forceintegertype=0; -end -if vfoptions.policy_forceintegertype==1 - Policy=round(Policy); -end +l_aprime=length(n_a); +n_aprime=n_a; +extra=(vfoptions.gridinterplayer==1); -if N_d==0 - if vfoptions.parallel~=2 - PolicyTemp=zeros(l_a,N_a,N_z,N_j); - for a_c=1:N_a - for z_c=1:N_z - for jj=1:N_j - optaindexKron=Policy(a_c,z_c,jj); - optA=ind2sub_homemade([n_a'],optaindexKron); - PolicyTemp(:,a_c,z_c,jj)=[optA']; - end +if n_d(1)==0 + Policy=zeros(l_aprime+extra,N_a,N_z,N_j,'gpuArray'); + Policy(1,:,:,:)=rem(PolicyKron(1,:,:,:)-1,n_aprime(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=2:l_aprime-1 + Policy(ii,:,:,:)=rem(ceil(PolicyKron(1,:,:,:)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; end end - Policy=reshape(PolicyTemp,[l_a,n_a,n_z,N_j]); - else - PolicyTemp=zeros(l_a,N_a,N_z,N_j,'gpuArray'); - - for jj=1:N_j - PolicyTemp(1,:,:,jj)=shiftdim(rem(Policy(:,:,jj)-1,n_a(1))+1,-1); - if l_a>1 - if l_a>2 - for ii=2:l_a-1 - PolicyTemp(ii,:,:,jj)=shiftdim(rem(ceil(Policy(:,:,jj)/prod(n_a(1:ii-1)))-1,n_a(ii))+1,-1); - end - end - PolicyTemp(l_a,:,:,jj)=shiftdim(ceil(Policy(:,:,jj)/prod(n_a(1:l_a-1))),-1); - end - end - - Policy=reshape(PolicyTemp,[l_a,n_a,n_z,N_j]); + Policy(l_aprime,:,:,:)=ceil(PolicyKron(1,:,:,:)/prod(n_aprime(1:l_aprime-1))); + end + + if vfoptions.gridinterplayer==1 + Policy(l_aprime+1,:,:,:)=PolicyKron(2,:,:,:); end - + + Policy=reshape(Policy,[l_aprime+extra,n_a,n_z,N_j]); else l_d=length(n_d); + Policy=zeros(l_d+l_aprime+extra,N_a,N_z,N_j,'gpuArray'); - if vfoptions.parallel~=2 - PolicyTemp=zeros(l_d+l_a,N_a,N_z,N_j); - for a_c=1:N_a - for z_c=1:N_z - for jj=1:N_j - optdindexKron=Policy(1,a_c,z_c,jj); - optaindexKron=Policy(2,a_c,z_c,jj); - optD=ind2sub_homemade(n_d',optdindexKron); - optA=ind2sub_homemade(n_a',optaindexKron); - PolicyTemp(:,a_c,z_c,jj)=[optD';optA']; - end + Policy(1,:,:,:)=rem(PolicyKron(1,:,:,:)-1,n_d(1))+1; + if l_d>1 + if l_d>2 + for ii=2:l_d-1 + Policy(ii,:,:,:)=rem(ceil(PolicyKron(1,:,:,:)/prod(n_d(1:ii-1)))-1,n_d(ii))+1; end end - Policy=reshape(PolicyTemp,[l_d+l_a,n_a,n_z,N_j]); - else - l_da=length(n_d)+length(n_a); - n_da=[n_d,n_a]; - PolicyTemp=zeros(l_da,N_a,N_z,N_j,'gpuArray'); - - for jj=1:N_j - PolicyTemp(1,:,:,jj)=rem(Policy(1,:,:,jj)-1,n_da(1))+1; - if l_d>1 - if l_d>2 - for ii=2:l_d-1 - PolicyTemp(ii,:,:,jj)=rem(ceil(Policy(1,:,:,jj)/prod(n_d(1:ii-1)))-1,n_d(ii))+1; - end - end - PolicyTemp(l_d,:,:,jj)=ceil(Policy(1,:,:,jj)/prod(n_d(1:l_d-1))); - end - - PolicyTemp(l_d+1,:,:,jj)=rem(Policy(2,:,:,jj)-1,n_a(1))+1; - if l_a>1 - if l_a>2 - for ii=2:l_a-1 - PolicyTemp(l_d+ii,:,:,jj)=rem(ceil(Policy(2,:,:,jj)/prod(n_a(1:ii-1)))-1,n_a(ii))+1; - end - end - PolicyTemp(l_da,:,:,jj)=ceil(Policy(2,:,:,jj)/prod(n_a(1:l_a-1))); + Policy(l_d,:,:,:)=ceil(PolicyKron(1,:,:,:)/prod(n_d(1:l_d-1))); + end + + Policy(l_d+1,:,:,:)=rem(PolicyKron(2,:,:,:)-1,n_aprime(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=2:l_aprime-1 + Policy(l_d+ii,:,:,:)=rem(ceil(PolicyKron(2,:,:,:)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; end end - - Policy=reshape(PolicyTemp,[l_da,n_a,n_z,N_j]); + Policy(l_d+l_aprime,:,:,:)=ceil(PolicyKron(2,:,:,:)/prod(n_aprime(1:l_aprime-1))); + end + + if vfoptions.gridinterplayer==1 + Policy(l_d+l_aprime+1,:,:,:)=PolicyKron(3,:,:,:); end -end -if vfoptions.policy_forceintegertype==1 - Policy=round(Policy); + Policy=reshape(Policy,[l_d+l_aprime+extra,n_a,n_z,N_j]); end + end \ No newline at end of file diff --git a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_PType.m b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_PType.m deleted file mode 100644 index f7f2bda7..00000000 --- a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_PType.m +++ /dev/null @@ -1,50 +0,0 @@ -function PolicyIndexes=UnKronPolicyIndexes_Case1_FHorz_PType(PolicyIndexesKron, n_d, n_a, n_z,n_i,N_j) - -%PolicyIndexesKron=zeros(2,N_a,N_z); %first dim indexes the optimal choice for d and aprime rest of dimensions a,z -%PolicyIndexesIntermediate (number_d_vars+number_a_vars,N_a,N_z) -%PolicyIndexes (number_d_vars+number_a_vars,n_a,n_z); - -N_d=prod(n_d); -N_a=prod(n_a); -N_z=prod(n_z); -N_i=prod(n_i); - -num_a_vars=length(n_a); - -if N_d==0 - PolicyIndexesIntermediate=zeros(num_a_vars,N_a,N_z,N_i,N_j); - for i1=1:N_a - for i2=1:N_z - for i3=1:N_i - for i4=1:N_j - optaindexKron=PolicyIndexesKron(1,i1,i2,i3,i4); - optA=ind2sub_homemade([n_a'],optaindexKron); - PolicyIndexesIntermediate(:,i1,i2,i3,i4)=[optA']; - end - end - end - end - PolicyIndexes=reshape(PolicyIndexesIntermediate,[num_a_vars,n_a,n_z,n_i,N_j]); - return -end - -num_d_vars=length(n_d); - -PolicyIndexesIntermediate=zeros(num_d_vars+num_a_vars,N_a,N_z,N_i,N_j); -for i1=1:N_a - for i2=1:N_z - for i3=1:N_i - for i4=1:N_j - optdindexKron=PolicyIndexesKron(1,i1,i2,i3,i4); - optaindexKron=PolicyIndexesKron(2,i1,i2,i3,i4); - optD=ind2sub_homemade(n_d',optdindexKron); - optA=ind2sub_homemade(n_a',optaindexKron); - PolicyIndexesIntermediate(:,i1,i2,i3,i4)=[optD';optA']; - end - end - end -end -PolicyIndexes=reshape(PolicyIndexesIntermediate,[num_d_vars+num_a_vars,n_a,n_z,n_i,N_j]); - - -end \ No newline at end of file diff --git a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_e.m b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_e.m index fa112467..6af03436 100644 --- a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_e.m +++ b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_e.m @@ -1,109 +1,65 @@ -function Policy=UnKronPolicyIndexes_Case1_FHorz_e(Policy, n_d, n_a, n_z,n_e,N_j,vfoptions) +function Policy=UnKronPolicyIndexes_Case1_FHorz_e(PolicyKron, n_d,n_a, n_z,n_e,N_j, vfoptions) +% Can use vfoptions OR simoptions +% Input: PolicyKron is (2,N_a,N_z,N_e,N_j) first dim indexes the optimal choice for d and aprime +% (1,N_a,N_z,N_e,N_j) if there is no d +% vfoptions.gridinterplayer=1 will mean the first dimension has one extra value (so 3 if d, 2 without) +% Output: Policy is (l_d+l_a,n_a,n_z,n_e,N_j); -%Input: Policy=zeros(2,N_a,N_z,N_e,N_j); %first dim indexes the optimal choice for d and aprime rest of dimensions a,z -% (N_a,N_z,N_e,N_j) if there is no d -%Output: Policy (l_d+l_a,n_a,n_z,n_e,N_j); - -N_d=prod(n_d); N_a=prod(n_a); N_z=prod(n_z); N_e=prod(n_e); -l_a=length(n_a); - -% Sometimes numerical rounding errors (of the order of 10^(-16) can mean -% that Policy is not integer valued. The following corrects this by converting to int64 and then -% makes the output back into double as Matlab otherwise cannot use it in -% any arithmetical expressions. -if vfoptions.policy_forceintegertype==1 - Policy=round(Policy); -end +l_aprime=length(n_a); +n_aprime=n_a; +extra=(vfoptions.gridinterplayer==1); -if N_d==0 - if vfoptions.parallel~=2 - PolicyTemp=zeros(l_a,N_a,N_z,N_e,N_j); - for a_c=1:N_a - for z_c=1:N_z - for e_c=1:N_e - for jj=1:N_j - optaindexKron=Policy(a_c,z_c,e_c,jj); - optA=ind2sub_homemade([n_a'],optaindexKron); - PolicyTemp(:,a_c,z_c,e_c,jj)=[optA']; - end - end - end - end - Policy=reshape(PolicyTemp,[l_a,n_a,n_z,n_e,N_j]); - else - PolicyTemp=zeros(l_a,N_a,N_z,N_e,N_j,'gpuArray'); - - for jj=1:N_j - PolicyTemp(1,:,:,:,jj)=shiftdim(rem(Policy(:,:,:,jj)-1,n_a(1))+1,-1); - if l_a>1 - if l_a>2 - for ii=2:l_a-1 - PolicyTemp(ii,:,:,:,jj)=shiftdim(rem(ceil(Policy(:,:,:,jj)/prod(n_a(1:ii-1)))-1,n_a(ii))+1,-1); - end - end - PolicyTemp(l_a,:,:,:,jj)=shiftdim(ceil(Policy(:,:,:,jj)/prod(n_a(1:l_a-1))),-1); +if n_d(1)==0 + Policy=zeros(l_aprime+extra,N_a,N_z,N_e,N_j,'gpuArray'); + Policy(1,:,:,:,:)=rem(PolicyKron(1,:,:,:,:)-1,n_aprime(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=2:l_aprime-1 + Policy(ii,:,:,:,:)=rem(ceil(PolicyKron(1,:,:,:,:)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; end end - - Policy=reshape(PolicyTemp,[l_a,n_a,n_z,n_e,N_j]); + Policy(l_aprime,:,:,:,:)=ceil(PolicyKron(1,:,:,:,:)/prod(n_aprime(1:l_aprime-1))); + end + + if vfoptions.gridinterplayer==1 + Policy(l_aprime+1,:,:,:,:)=PolicyKron(2,:,:,:,:); end - + + Policy=reshape(Policy,[l_aprime+extra,n_a,n_z,n_e,N_j]); else l_d=length(n_d); - - if vfoptions.parallel~=2 - PolicyTemp=zeros(l_d+l_a,N_a,N_z,N_e,N_j); - for a_c=1:N_a - for z_c=1:N_z - for e_c=1:N_e - for jj=1:N_j - optdindexKron=Policy(1,a_c,z_c,e_c,jj); - optaindexKron=Policy(2,a_c,z_c,e_c,jj); - optD=ind2sub_homemade(n_d',optdindexKron); - optA=ind2sub_homemade(n_a',optaindexKron); - PolicyTemp(:,a_c,z_c,e_c,jj)=[optD';optA']; - end - end + Policy=zeros(l_d+l_aprime+extra,N_a,N_z,N_e,N_j,'gpuArray'); + + Policy(1,:,:,:,:)=rem(PolicyKron(1,:,:,:,:)-1,n_d(1))+1; + if l_d>1 + if l_d>2 + for ii=2:l_d-1 + Policy(ii,:,:,:,:)=rem(ceil(PolicyKron(1,:,:,:,:)/prod(n_d(1:ii-1)))-1,n_d(ii))+1; end end - Policy=reshape(PolicyTemp,[l_d+l_a,n_a,n_z,n_e,N_j]); - else - l_da=length(n_d)+length(n_a); - n_da=[n_d,n_a]; - PolicyTemp=zeros(l_da,N_a,N_z,N_e,N_j,'gpuArray'); + Policy(l_d,:,:,:,:)=ceil(PolicyKron(1,:,:,:,:)/prod(n_d(1:l_d-1))); + end - for jj=1:N_j - PolicyTemp(1,:,:,:,jj)=rem(Policy(1,:,:,:,jj)-1,n_da(1))+1; - if l_d>1 - if l_d>2 - for ii=2:l_d-1 - PolicyTemp(ii,:,:,:,jj)=rem(ceil(Policy(1,:,:,:,jj)/prod(n_d(1:ii-1)))-1,n_d(ii))+1; - end - end - PolicyTemp(l_d,:,:,:,jj)=ceil(Policy(1,:,:,:,jj)/prod(n_d(1:l_d-1))); - end - - PolicyTemp(l_d+1,:,:,:,jj)=rem(Policy(2,:,:,:,jj)-1,n_a(1))+1; - if l_a>1 - if l_a>2 - for ii=2:l_a-1 - PolicyTemp(l_d+ii,:,:,:,jj)=rem(ceil(Policy(2,:,:,:,jj)/prod(n_a(1:ii-1)))-1,n_a(ii))+1; - end - end - PolicyTemp(l_da,:,:,:,jj)=ceil(Policy(2,:,:,:,jj)/prod(n_a(1:l_a-1))); + Policy(l_d+1,:,:,:,:)=rem(PolicyKron(2,:,:,:,:)-1,n_aprime(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=2:l_aprime-1 + Policy(l_d+ii,:,:,:,:)=rem(ceil(PolicyKron(2,:,:,:,:)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; end end - - Policy=reshape(PolicyTemp,[l_da,n_a,n_z,n_e,N_j]); + Policy(l_d+l_aprime,:,:,:,:)=ceil(PolicyKron(2,:,:,:,:)/prod(n_aprime(1:l_aprime-1))); end -end -if vfoptions.policy_forceintegertype==1 - Policy=round(Policy); + if vfoptions.gridinterplayer==1 + Policy(l_d+l_aprime+1,:,:,:,:)=PolicyKron(3,:,:,:,:); + end + + Policy=reshape(Policy,[l_d+l_aprime+extra,n_a,n_z,n_e,N_j]); end + end \ No newline at end of file diff --git a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_noz.m b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_noz.m index d1a0db8a..bb272a1a 100644 --- a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_noz.m +++ b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_noz.m @@ -1,102 +1,64 @@ -function Policy=UnKronPolicyIndexes_Case1_FHorz_noz(Policy, n_d, n_a,N_j,vfoptions) +function Policy=UnKronPolicyIndexes_Case1_FHorz_noz(PolicyKron, n_d,n_a, N_j, vfoptions) +% Can use vfoptions OR simoptions +% Input: PolicyKron is (2,N_a,N_j) first dim indexes the optimal choice for d and aprime +% (1,N_a,N_j) if there is no d +% vfoptions.gridinterplayer=1 will mean the first dimension has one extra value (so 3 if d, 2 without) +% Output: Policy is (l_d+l_a,n_a,N_j); -%Input: Policy=zeros(2,N_a,N_j); %first dim indexes the optimal choice for d and aprime rest of dimensions a,z -% (N_a,N_j) if there is no d -%Output: Policy (l_d+l_a,n_a,N_j); - -N_d=prod(n_d); +% N_d=prod(n_d); N_a=prod(n_a); -l_a=length(n_a); +l_aprime=length(n_a); +n_aprime=n_a; +extra=(vfoptions.gridinterplayer==1); -% Sometimes numerical rounding errors (of the order of 10^(-16) can mean -% that Policy is not integer valued. The following corrects this by converting to int64 and then -% makes the output back into double as Matlab otherwise cannot use it in -% any arithmetical expressions. -if ~isfield(vfoptions,'policy_forceintegertype') - vfoptions.policy_forceintegertype=0; -end -if vfoptions.policy_forceintegertype==1 - Policy=round(Policy); -end - -if N_d==0 - if vfoptions.parallel~=2 - PolicyTemp=zeros(l_a,N_a,N_j); - for a_c=1:N_a - for jj=1:N_j - optaindexKron=Policy(a_c,jj); - optA=ind2sub_homemade([n_a'],optaindexKron); - PolicyTemp(:,a_c,jj)=[optA']; +if n_d(1)==0 + Policy=zeros(l_aprime+extra,N_a,N_j,'gpuArray'); + Policy(1,:,:)=rem(PolicyKron(1,:,:)-1,n_aprime(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=2:l_aprime-1 + Policy(ii,:,:)=rem(ceil(PolicyKron(1,:,:)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; end end - Policy=reshape(PolicyTemp,[l_a,n_a,N_j]); - else - PolicyTemp=zeros(l_a,N_a,N_j,'gpuArray'); - - for jj=1:N_j - PolicyTemp(1,:,jj)=shiftdim(rem(Policy(:,jj)-1,n_a(1))+1,-1); - if l_a>1 - if l_a>2 - for ii=2:l_a-1 - PolicyTemp(ii,:,jj)=shiftdim(rem(ceil(Policy(:,jj)/prod(n_a(1:ii-1)))-1,n_a(ii))+1,-1); - end - end - PolicyTemp(l_a,:,jj)=shiftdim(ceil(Policy(:,jj)/prod(n_a(1:l_a-1))),-1); - end - end - - Policy=reshape(PolicyTemp,[l_a,n_a,N_j]); + Policy(l_aprime,:,:)=ceil(PolicyKron(1,:,:)/prod(n_aprime(1:l_aprime-1))); + end + + if vfoptions.gridinterplayer==1 + Policy(l_aprime+1,:,:)=PolicyKron(2,:,:); end - + + Policy=reshape(Policy,[l_aprime+extra,n_a,N_j]); else l_d=length(n_d); - - if vfoptions.parallel~=2 - PolicyTemp=zeros(l_d+l_a,N_a,N_j); - for a_c=1:N_a - for jj=1:N_j - optdindexKron=Policy(1,a_c,jj); - optaindexKron=Policy(2,a_c,jj); - optD=ind2sub_homemade(n_d',optdindexKron); - optA=ind2sub_homemade(n_a',optaindexKron); - PolicyTemp(:,a_c,jj)=[optD';optA']; + Policy=zeros(l_d+l_aprime+extra,N_a,N_j,'gpuArray'); + + Policy(1,:,:)=rem(PolicyKron(1,:,:)-1,n_d(1))+1; + if l_d>1 + if l_d>2 + for ii=2:l_d-1 + Policy(ii,:,:)=rem(ceil(PolicyKron(1,:,:)/prod(n_d(1:ii-1)))-1,n_d(ii))+1; end end - Policy=reshape(PolicyTemp,[l_d+l_a,n_a,N_j]); - else - l_da=length(n_d)+length(n_a); - n_da=[n_d,n_a]; - PolicyTemp=zeros(l_da,N_a,N_j,'gpuArray'); - - for jj=1:N_j - PolicyTemp(1,:,jj)=rem(Policy(1,:,jj)-1,n_da(1))+1; - if l_d>1 - if l_d>2 - for ii=2:l_d-1 - PolicyTemp(ii,:,jj)=rem(ceil(Policy(1,:,jj)/prod(n_d(1:ii-1)))-1,n_d(ii))+1; - end - end - PolicyTemp(l_d,:,jj)=ceil(Policy(1,:,jj)/prod(n_d(1:l_d-1))); - end - - PolicyTemp(l_d+1,:,jj)=rem(Policy(2,:,jj)-1,n_a(1))+1; - if l_a>1 - if l_a>2 - for ii=2:l_a-1 - PolicyTemp(l_d+ii,:,jj)=rem(ceil(Policy(2,:,jj)/prod(n_a(1:ii-1)))-1,n_a(ii))+1; - end - end - PolicyTemp(l_da,:,jj)=ceil(Policy(2,:,jj)/prod(n_a(1:l_a-1))); + Policy(l_d,:,:)=ceil(PolicyKron(1,:,:)/prod(n_d(1:l_d-1))); + end + + Policy(l_d+1,:,:)=rem(PolicyKron(2,:,:)-1,n_a(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=2:l_aprime-1 + Policy(l_d+ii,:,:)=rem(ceil(PolicyKron(2,:,:)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; end end - - Policy=reshape(PolicyTemp,[l_da,n_a,N_j]); + Policy(l_d+l_aprime,:,:)=ceil(PolicyKron(2,:,:)/prod(n_aprime(1:l_aprime-1))); + end + + if vfoptions.gridinterplayer==1 + Policy(l_d+l_aprime+1,:,:)=PolicyKron(3,:,:); end -end -if vfoptions.policy_forceintegertype==1 - Policy=round(Policy); + Policy=reshape(Policy,[l_d+l_aprime+extra,n_a,N_j]); end + end \ No newline at end of file diff --git a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_semiz.m b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_semiz.m index b9305e6b..4b1caa82 100644 --- a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_semiz.m +++ b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_semiz.m @@ -1,98 +1,92 @@ -function Policy=UnKronPolicyIndexes_Case1_FHorz_semiz(Policy3, n_d1, n_d2, n_a, n_z,N_j,vfoptions) -% n_z should be [n_z,n_semiz] - -%Input: Policy3=zeros(3,N_a,N_z,N_j); %first dim indexes the optimal choice for d2 and (d1,aprime) rest of dimensions a,z -%Output: Policy (l_d+l_a,n_a,n_z,N_j); - -% Note that if there is no d1 then input is instead of size: Policy3=zeros(2,N_a,N_z,N_j) +function Policy=UnKronPolicyIndexes_Case1_FHorz_semiz(PolicyKron, n_d1, n_d2, n_a, n_semiz,n_z,N_j,vfoptions) +% Can use vfoptions OR simoptions +% Input: PolicyKron is (3,N_a,N_semiz,N_z,N_j); % first dim indexes the optimal choice for (d1,d2,aprime) +% without d1, the first dim is 2 and indexes the optimal choice for (d2,aprime) +% vfoptions.gridinterplayer=1 will mean the first dimension has one extra value (so 4 if d1, 3 without) +% Output: Policy (l_d+l_a,n_a,n_semiz,n_z,N_j); N_d1=prod(n_d1); % N_d2=prod(n_d2); N_a=prod(n_a); +N_semiz=prod(n_semiz); N_z=prod(n_z); -l_d1=length(n_d1); % Note: this is anyway only used is N_d1~=0 l_d2=length(n_d2); -l_a=length(n_a); - -% Sometimes numerical rounding errors (of the order of 10^(-16) can mean -% that Policy is not integer valued. The following corrects this by converting to int64 and then -% makes the output back into double as Matlab otherwise cannot use it in -% any arithmetical expressions. -if ~isfield(vfoptions,'policy_forceintegertype') - vfoptions.policy_forceintegertype=0; -end -if vfoptions.policy_forceintegertype==1 - Policy3=round(Policy3); -end + +l_aprime=length(n_a); +n_aprime=n_a; +extra=(vfoptions.gridinterplayer==1); % Only for GPU if N_d1==0 - Policy=zeros(l_d2+l_a,N_a,N_z,N_j,'gpuArray'); - - for jj=1:N_j - Policy(1,:,:,jj)=rem(Policy3(1,:,:,jj)-1,n_d2(1))+1; - if l_d2>1 - if l_d2>2 - for ii=1:l_d2-1 - Policy(ii,:,:,jj)=rem(ceil(Policy3(1,:,:,jj)/prod(n_d2(1:ii-1)))-1,n_d2(ii))+1; - end + Policy=zeros(l_d2+l_aprime+extra,N_a,N_semiz,N_z,N_j,'gpuArray'); + + Policy(1,:,:,:,:)=rem(PolicyKron(1,:,:,:,:)-1,n_d2(1))+1; + if l_d2>1 + if l_d2>2 + for ii=1:l_d2-1 + Policy(ii,:,:,:,:)=rem(ceil(PolicyKron(1,:,:,:,:)/prod(n_d2(1:ii-1)))-1,n_d2(ii))+1; end - Policy(l_d2,:,:,jj)=ceil(Policy3(1,:,:,jj)/prod(n_d2(1:l_d2-1))); end + Policy(l_d2,:,:,:,:)=ceil(PolicyKron(1,:,:,:,:)/prod(n_d2(1:l_d2-1))); + end - Policy(l_d2+1,:,:,jj)=rem(Policy3(2,:,:,jj)-1,n_a(1))+1; - if l_a>1 - if l_a>2 - for ii=1:l_a-1 - Policy(l_d2+ii,:,:,jj)=rem(ceil(Policy3(2,:,:,jj)/prod(n_a(1:ii-1)))-1,n_a(ii))+1; - end + Policy(l_d2+1,:,:,:,:)=rem(PolicyKron(2,:,:,:,:)-1,n_aprime(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=1:l_aprime-1 + Policy(l_d2+ii,:,:,:,:)=rem(ceil(PolicyKron(2,:,:,:,:)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; end - Policy(l_d2+l_a,:,:,jj)=ceil(Policy3(2,:,:,jj)/prod(n_a(1:l_a-1))); end + Policy(l_d2+l_aprime,:,:,:,:)=ceil(PolicyKron(2,:,:,:,:)/prod(n_aprime(1:l_aprime-1))); + end + + if vfoptions.gridinterplayer==1 + Policy(l_d2+l_aprime+1,:,:,:,:)=PolicyKron(3,:,:,:,:); end - Policy=reshape(Policy,[l_d2+l_a,n_a,n_z,N_j]); - -else - Policy=zeros(l_d1+l_d2+l_a,N_a,N_z,N_j,'gpuArray'); - - for jj=1:N_j - Policy(1,:,:,jj)=rem(Policy3(1,:,:,jj)-1,n_d1(1))+1; - if l_d1>1 - if l_d1>2 - for ii=1:l_d1-1 - Policy(ii,:,:,jj)=rem(ceil(Policy3(1,:,:,jj)/prod(n_d1(1:ii-1)))-1,n_d1(ii))+1; - end + + Policy=reshape(Policy,[l_d2+l_aprime+extra,n_a,n_semiz,n_z,N_j]); + +else % N_d1>0 + l_d1=length(n_d1); % Note: this is anyway only used is N_d1~=0 + + Policy=zeros(l_d1+l_d2+l_aprime+extra,N_a,N_semiz,N_z,N_j,'gpuArray'); + + Policy(1,:,:,:,:)=rem(PolicyKron(1,:,:,:,:)-1,n_d1(1))+1; + if l_d1>1 + if l_d1>2 + for ii=1:l_d1-1 + Policy(ii,:,:,:,:)=rem(ceil(PolicyKron(1,:,:,:,:)/prod(n_d1(1:ii-1)))-1,n_d1(ii))+1; end - Policy(l_d1,:,:,jj)=ceil(Policy3(1,:,:,jj)/prod(n_d1(1:l_d1-1))); end - - Policy(l_d1+1,:,:,jj)=rem(Policy3(2,:,:,jj)-1,n_d2(1))+1; - if l_d2>1 - if l_d2>2 - for ii=1:l_d2-1 - Policy(l_d1+ii,:,:,jj)=rem(ceil(Policy3(2,:,:,jj)/prod(n_d2(1:ii-1)))-1,n_d2(ii))+1; - end + Policy(l_d1,:,:,:,:)=ceil(PolicyKron(1,:,:,:,:)/prod(n_d1(1:l_d1-1))); + end + + Policy(l_d1+1,:,:,:,:)=rem(PolicyKron(2,:,:,:,:)-1,n_d2(1))+1; + if l_d2>1 + if l_d2>2 + for ii=1:l_d2-1 + Policy(l_d1+ii,:,:,:,:)=rem(ceil(PolicyKron(2,:,:,:,:)/prod(n_d2(1:ii-1)))-1,n_d2(ii))+1; end - Policy(l_d1+l_d2,:,:,jj)=ceil(Policy3(2,:,:,jj)/prod(n_d2(1:l_d2-1))); end + Policy(l_d1+l_d2,:,:,:,:)=ceil(PolicyKron(2,:,:,:,:)/prod(n_d2(1:l_d2-1))); + end - Policy(l_d1+l_d2+1,:,:,jj)=rem(Policy3(3,:,:,jj)-1,n_a(1))+1; - if l_a>1 - if l_a>2 - for ii=1:l_a-1 - Policy(l_d1+l_d2+ii,:,:,jj)=rem(ceil(Policy3(3,:,:,jj)/prod(n_a(1:ii-1)))-1,n_a(ii))+1; - end + Policy(l_d1+l_d2+1,:,:,:,:)=rem(PolicyKron(3,:,:,:,:)-1,n_aprime(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=1:l_aprime-1 + Policy(l_d1+l_d2+ii,:,:,:,:)=rem(ceil(PolicyKron(3,:,:,:,:)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; end - Policy(l_d1+l_d2+l_a,:,:,jj)=ceil(Policy3(3,:,:,jj)/prod(n_a(1:l_a-1))); end + Policy(l_d1+l_d2+l_aprime,:,:,:,:)=ceil(PolicyKron(3,:,:,:,:)/prod(n_aprime(1:l_aprime-1))); end - Policy=reshape(Policy,[l_d1+l_d2+l_a,n_a,n_z,N_j]); -end + if vfoptions.gridinterplayer==1 + Policy(l_d1+l_d2+l_aprime+1,:,:,:,:)=PolicyKron(4,:,:,:,:); + end -if vfoptions.policy_forceintegertype==1 - Policy=round(Policy); + Policy=reshape(Policy,[l_d1+l_d2+l_aprime+extra,n_a,n_semiz,n_z,N_j]); end diff --git a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_semiz_e.m b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_semiz_e.m index d758093c..b740e2d7 100644 --- a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_semiz_e.m +++ b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_semiz_e.m @@ -1,94 +1,93 @@ -function Policy=UnKronPolicyIndexes_Case1_FHorz_semiz_e(Policy3, n_d1, n_d2, n_a, n_z,n_e,N_j,vfoptions) -% n_z should be [n_z,n_semiz] - -%Input: Policy3=zeros(3,N_a,N_z,N_e,N_j); %first dim indexes the optimal choice for d2 and (d1,aprime) rest of dimensions a,z -%Output: Policy (l_d+l_a,n_a,n_z,n_e,N_j); - -% l_d=l_d1+l_d2 +function Policy=UnKronPolicyIndexes_Case1_FHorz_semiz_e(PolicyKron, n_d1, n_d2, n_a, n_semiz,n_z,n_e,N_j,vfoptions) +% Can use vfoptions OR simoptions +% Input: PolicyKron is (3,N_a,N_semiz,N_z,N_e,N_j); % first dim indexes the optimal choice for (d1,d2,aprime) +% without d1, the first dim is 2 and indexes the optimal choice for (d2,aprime) +% vfoptions.gridinterplayer=1 will mean the first dimension has one extra value (so 4 if d1, 3 without) +% Output: Policy (l_d+l_a,n_a,n_semiz,n_z,n_e,N_j); N_d1=prod(n_d1); +% N_d2=prod(n_d2); N_a=prod(n_a); +N_semiz=prod(n_semiz); N_z=prod(n_z); N_e=prod(n_e); -l_d1=length(n_d1); % Just d1 l_d2=length(n_d2); -l_a=length(n_a); - -% Sometimes numerical rounding errors (of the order of 10^(-16) can mean -% that Policy is not integer valued. The following corrects this by converting to int64 and then -% makes the output back into double as Matlab otherwise cannot use it in -% any arithmetical expressions. -if vfoptions.policy_forceintegertype==1 - Policy3=round(Policy3); -end -% Only for GPU +l_aprime=length(n_a); +n_aprime=n_a; +extra=(vfoptions.gridinterplayer==1); + if N_d1==0 - Policy=zeros(l_d2+l_a,N_a,N_z,N_e,N_j,'gpuArray'); - - for jj=1:N_j - Policy(1,:,:,:,jj)=rem(Policy3(1,:,:,:,jj)-1,n_d2(1))+1; - if l_d2>1 - if l_d2>2 - for ii=2:l_d2-1 - Policy(ii,:,:,:,jj)=rem(ceil(Policy3(1,:,:,:,jj)/prod(n_d2(1:ii-1)))-1,n_d2(ii))+1; - end + Policy=zeros(l_d2+l_aprime+extra,N_a,N_semiz,N_z,N_e,N_j,'gpuArray'); + + Policy(1,:,:,:,:,:)=rem(PolicyKron(1,:,:,:,:,:)-1,n_d2(1))+1; + if l_d2>1 + if l_d2>2 + for ii=1:l_d2-1 + Policy(ii,:,:,:,:,:)=rem(ceil(PolicyKron(1,:,:,:,:,:)/prod(n_d2(1:ii-1)))-1,n_d2(ii))+1; end - Policy(l_d2,:,:,:,jj)=ceil(Policy3(1,:,:,:,jj)/prod(n_d2(1:l_d2-1))); end + Policy(l_d2,:,:,:,:,:)=ceil(PolicyKron(1,:,:,:,:,:)/prod(n_d2(1:l_d2-1))); + end - Policy(l_d2+1,:,:,:,jj)=rem(Policy3(2,:,:,:,jj)-1,n_a(1))+1; - if l_a>1 - if l_a>2 - for ii=2:l_a-1 - Policy(l_d2+ii,:,:,:,jj)=rem(ceil(Policy3(2,:,:,:,jj)/prod(n_a(1:ii-1)))-1,n_a(ii))+1; - end + Policy(l_d2+1,:,:,:,:,:)=rem(PolicyKron(2,:,:,:,:,:)-1,n_aprime(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=1:l_aprime-1 + Policy(l_d2+ii,:,:,:,:,:)=rem(ceil(PolicyKron(2,:,:,:,:,:)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; end - Policy(l_d2+l_a,:,:,:,jj)=ceil(Policy3(2,:,:,:,jj)/prod(n_a(1:l_a-1))); end + Policy(l_d2+l_aprime,:,:,:,:,:)=ceil(PolicyKron(2,:,:,:,:,:)/prod(n_aprime(1:l_aprime-1))); + end + + if vfoptions.gridinterplayer==1 + Policy(l_d2+l_aprime+1,:,:,:,:,:)=PolicyKron(3,:,:,:,:,:); end - Policy=reshape(Policy,[l_d2+l_a,n_a,n_z,n_e,N_j]); -else - Policy=zeros(l_d1+l_d2+l_a,N_a,N_z,N_e,N_j,'gpuArray'); - - for jj=1:N_j - Policy(1,:,:,:,jj)=rem(Policy3(1,:,:,:,jj)-1,n_d1(1))+1; - if l_d1>1 - if l_d1>2 - for ii=2:l_d1-1 - Policy(ii,:,:,:,jj)=rem(ceil(Policy3(1,:,:,:,jj)/prod(n_d1(1:ii-1)))-1,n_d1(ii))+1; - end + + Policy=reshape(Policy,[l_d2+l_aprime+extra,n_a,n_semiz,n_z,n_e,N_j]); + +else % N_d1>0 + l_d1=length(n_d1); % Note: this is anyway only used is N_d1~=0 + + Policy=zeros(l_d1+l_d2+l_aprimeextra,N_a,N_semiz,N_z,N_e,N_j,'gpuArray'); + + Policy(1,:,:,:,:,:)=rem(PolicyKron(1,:,:,:,:,:)-1,n_d1(1))+1; + if l_d1>1 + if l_d1>2 + for ii=1:l_d1-1 + Policy(ii,:,:,:,:,:)=rem(ceil(PolicyKron(1,:,:,:,:,:)/prod(n_d1(1:ii-1)))-1,n_d1(ii))+1; end - Policy(l_d1,:,:,:,jj)=ceil(Policy3(1,:,:,:,jj)/prod(n_d1(1:l_d1-1))); end - - Policy(l_d1+1,:,:,:,jj)=rem(Policy3(2,:,:,:,jj)-1,n_d2(1))+1; - if l_d2>1 - if l_d2>2 - for ii=2:l_d2-1 - Policy(l_d1+ii,:,:,:,jj)=rem(ceil(Policy3(2,:,:,:,jj)/prod(n_d2(1:ii-1)))-1,n_d2(ii))+1; - end + Policy(l_d1,:,:,:,:,:)=ceil(PolicyKron(1,:,:,:,:,:)/prod(n_d1(1:l_d1-1))); + end + + Policy(l_d1+1,:,:,:,:,:)=rem(PolicyKron(2,:,:,:,:,:)-1,n_d2(1))+1; + if l_d2>1 + if l_d2>2 + for ii=1:l_d2-1 + Policy(l_d1+ii,:,:,:,:,:)=rem(ceil(PolicyKron(2,:,:,:,:,:)/prod(n_d2(1:ii-1)))-1,n_d2(ii))+1; end - Policy(l_d1+l_d2,:,:,:,jj)=ceil(Policy3(2,:,:,:,jj)/prod(n_d2(1:l_d2-1))); end + Policy(l_d1+l_d2,:,:,:,:,:)=ceil(PolicyKron(2,:,:,:,:,:)/prod(n_d2(1:l_d2-1))); + end - Policy(l_d1+l_d2+1,:,:,:,jj)=rem(Policy3(3,:,:,:,jj)-1,n_a(1))+1; - if l_a>1 - if l_a>2 - for ii=2:l_a-1 - Policy(l_d1+l_d2+ii,:,:,:,jj)=rem(ceil(Policy3(3,:,:,:,jj)/prod(n_a(1:ii-1)))-1,n_a(ii))+1; - end + Policy(l_d1+l_d2+1,:,:,:,:,:)=rem(PolicyKron(3,:,:,:,:,:)-1,n_aprime(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=1:l_aprime-1 + Policy(l_d1+l_d2+ii,:,:,:,:,:)=rem(ceil(PolicyKron(3,:,:,:,:,:)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; end - Policy(l_d1+l_d2+l_a,:,:,:,jj)=ceil(Policy3(3,:,:,:,jj)/prod(n_a(1:l_a-1))); end + Policy(l_d1+l_d2+l_aprime,:,:,:,:,:)=ceil(PolicyKron(3,:,:,:,:,:)/prod(n_aprime(1:l_aprime-1))); + end + + if vfoptions.gridinterplayer==1 + Policy(l_d1+l_d2+l_aprime+1,:,:,:,:,:)=PolicyKron(4,:,:,:,:,:); end - Policy=reshape(Policy,[l_d1+l_d2+l_a,n_a,n_z,n_e,N_j]); -end -if vfoptions.policy_forceintegertype==1 - Policy=round(Policy); + Policy=reshape(Policy,[l_d1+l_d2+l_aprime+extra,n_a,n_semiz,n_z,n_e,N_j]); end -end \ No newline at end of file +end diff --git a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_semiz_noz.m b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_semiz_noz.m new file mode 100644 index 00000000..54240dee --- /dev/null +++ b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_FHorz_semiz_noz.m @@ -0,0 +1,91 @@ +function Policy=UnKronPolicyIndexes_Case1_FHorz_semiz_noz(PolicyKron, n_d1, n_d2, n_a, n_semiz,N_j,vfoptions) +% Can use vfoptions OR simoptions +% Input: PolicyKron is (3,N_a,N_semiz,N_j); % first dim indexes the optimal choice for (d1,d2,aprime) +% without d1, the first dim is 2 and indexes the optimal choice for (d2,aprime) +% vfoptions.gridinterplayer=1 will mean the first dimension has one extra value (so 4 if d1, 3 without) +% Output: Policy (l_d+l_a,n_a,n_semiz,N_j); + +N_d1=prod(n_d1); +% N_d2=prod(n_d2); +N_a=prod(n_a); +N_semiz=prod(n_semiz); + +l_d2=length(n_d2); + +l_aprime=length(n_a); +n_aprime=n_a; +extra=(vfoptions.gridinterplayer==1); + +if N_d1==0 + Policy=zeros(l_d2+l_aprime+extra,N_a,N_semiz,N_j,'gpuArray'); + + Policy(1,:,:,:)=rem(PolicyKron(1,:,:,:)-1,n_d2(1))+1; + if l_d2>1 + if l_d2>2 + for ii=1:l_d2-1 + Policy(ii,:,:,:)=rem(ceil(PolicyKron(1,:,:,:)/prod(n_d2(1:ii-1)))-1,n_d2(ii))+1; + end + end + Policy(l_d2,:,:,:)=ceil(PolicyKron(1,:,:,:)/prod(n_d2(1:l_d2-1))); + end + + Policy(l_d2+1,:,:,:)=rem(PolicyKron(2,:,:,:)-1,n_aprime(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=1:l_aprime-1 + Policy(l_d2+ii,:,:,:)=rem(ceil(PolicyKron(2,:,:,:)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; + end + end + Policy(l_d2+l_aprime,:,:,:)=ceil(PolicyKron(2,:,:,:)/prod(n_aprime(1:l_aprime-1))); + end + + if vfoptions.gridinterplayer==1 + Policy(l_d2+l_aprime+1,:,:,:)=PolicyKron(3,:,:,:); + end + + Policy=reshape(Policy,[l_d2+l_aprime+extra,n_a,n_semiz,N_j]); + +else % N_d1>0 + l_d1=length(n_d1); % Note: this is anyway only used is N_d1~=0 + + Policy=zeros(l_d1+l_d2+l_aprime+extra,N_a,N_semiz,N_j,'gpuArray'); + + Policy(1,:,:,:)=rem(PolicyKron(1,:,:,:)-1,n_d1(1))+1; + if l_d1>1 + if l_d1>2 + for ii=1:l_d1-1 + Policy(ii,:,:,:)=rem(ceil(PolicyKron(1,:,:,:)/prod(n_d1(1:ii-1)))-1,n_d1(ii))+1; + end + end + Policy(l_d1,:,:,:)=ceil(PolicyKron(1,:,:,:)/prod(n_d1(1:l_d1-1))); + end + + Policy(l_d1+1,:,:,:)=rem(PolicyKron(2,:,:,:)-1,n_d2(1))+1; + if l_d2>1 + if l_d2>2 + for ii=1:l_d2-1 + Policy(l_d1+ii,:,:,:)=rem(ceil(PolicyKron(2,:,:,:)/prod(n_d2(1:ii-1)))-1,n_d2(ii))+1; + end + end + Policy(l_d1+l_d2,:,:,:)=ceil(PolicyKron(2,:,:,:)/prod(n_d2(1:l_d2-1))); + end + + Policy(l_d1+l_d2+1,:,:,:)=rem(PolicyKron(3,:,:,:)-1,n_aprime(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=1:l_aprime-1 + Policy(l_d1+l_d2+ii,:,:,:)=rem(ceil(PolicyKron(3,:,:,:)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; + end + end + Policy(l_d1+l_d2+l_aprime,:,:,:)=ceil(PolicyKron(3,:,:,:)/prod(n_aprime(1:l_aprime-1))); + end + + if vfoptions.gridinterplayer==1 + Policy(l_d1+l_d2+l_aprime+1,:,:,:)=PolicyKron(4,:,:,:); + end + + Policy=reshape(Policy,[l_d1+l_d2+l_aprime+extra,n_a,n_semiz,N_j]); +end + + +end diff --git a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_PType.m b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_PType.m deleted file mode 100644 index 75914a49..00000000 --- a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_PType.m +++ /dev/null @@ -1,45 +0,0 @@ -function PolicyIndexes=UnKronPolicyIndexes_Case1_PType(PolicyIndexesKron, n_d, n_a, n_z,n_i) - -%PolicyIndexesKron=zeros(2,N_a,N_z); %first dim indexes the optimal choice for d and aprime rest of dimensions a,z -%PolicyIndexesIntermediate (number_d_vars+number_a_vars,N_a,N_z) -%PolicyIndexes (number_d_vars+number_a_vars,n_a,n_z); - -N_a=prod(n_a); -N_z=prod(n_z); -N_i=prod(n_i); - -num_a_vars=length(n_a); - -if length(n_d)==1 && n_d(1)==0 - PolicyIndexesIntermediate=zeros(num_a_vars,N_a,N_z,N_i); - for a_c=1:N_a - for z_c=1:N_z - for i=1:N_i - optaindexKron=PolicyIndexesKron(1,a_c,z_c,i); - optA=ind2sub_homemade([n_a'],optaindexKron); - PolicyIndexesIntermediate(:,a_c,z_c,i)=[optA']; - end - end - end - PolicyIndexes=reshape(PolicyIndexesIntermediate,[num_a_vars,n_a,n_z,n_i]); - return -end - -num_d_vars=length(n_d); - -PolicyIndexesIntermediate=zeros(num_d_vars+num_a_vars,N_a,N_z,N_i); -for a_c=1:N_a - for z_c=1:N_z - for i=1:N_i - optdindexKron=PolicyIndexesKron(1,a_c,z_c,i); - optaindexKron=PolicyIndexesKron(2,a_c,z_c,i); - optD=ind2sub_homemade(n_d',optdindexKron); - optA=ind2sub_homemade(n_a',optaindexKron); - PolicyIndexesIntermediate(:,a_c,z_c,i)=[optD';optA']; - end - end -end -PolicyIndexes=reshape(PolicyIndexesIntermediate,[num_d_vars+num_a_vars,n_a,n_z,n_i]); - - -end \ No newline at end of file diff --git a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_TransPathFHorz.m b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_TransPathFHorz.m index ff318b1d..2d0cb1af 100644 --- a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_TransPathFHorz.m +++ b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_TransPathFHorz.m @@ -1,82 +1,63 @@ -function Policy=UnKronPolicyIndexes_Case1_TransPathFHorz(Policy, n_d, n_a, n_z,N_j,T,vfoptions) -% can input vfoptions OR simoptions -%Input: Policy=zeros(2,N_a,N_z,N_j,T); %first dim indexes the optimal choice for d and aprime rest of dimensions a,z -% (N_a,N_z,N_j,T) if there is no d -%Output: Policy (l_d+l_a,n_a,n_z,N_j,T); +function PolicyPath=UnKronPolicyIndexes_Case1_TransPathFHorz(PolicyPathKron, n_d, n_a, n_z,N_j,T,vfoptions) +% Can use vfoptions OR simoptions +% Input: PolicyPathKron is (2,N_a,N_z,N_j,T) first dim indexes the optimal choice for d and aprime +% (1,N_a,N_z,N_j,T) if there is no d +% vfoptions.gridinterplayer=1 will mean the first dimension has one extra value (so 3 if d, 2 without) +% Output: Policy is (l_d+l_a,n_a,n_z,N_j,T); -N_d=prod(n_d); N_a=prod(n_a); N_z=prod(n_z); -l_a=length(n_a); -if vfoptions.gridinterplayer==0 - l_aprime=l_a; - n_aprime=n_a; -elseif vfoptions.gridinterplayer==1 - l_aprime=l_a+1; - n_aprime=[n_a,vfoptions.ngridinterp+2]; -end - -if N_d==0 - - PolicyTemp=zeros(l_aprime,N_a,N_z,N_j,T,'gpuArray'); - - for jj=1:N_j - for tt=1:T - PolicyTemp(1,:,:,jj,tt)=shiftdim(rem(Policy(1,:,:,jj,tt)-1,n_aprime(1))+1,-1); - if l_aprime>1 - if l_aprime>2 - for ii=2:l_aprime-1 - PolicyTemp(ii,:,:,jj,tt)=shiftdim(rem(ceil(Policy(1,:,:,jj,tt)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1,-1); - end - end - PolicyTemp(l_aprime,:,:,jj,tt)=shiftdim(ceil(Policy(1,:,:,jj,tt)/prod(n_aprime(1:l_aprime-1))),-1); +l_aprime=length(n_a); +n_aprime=n_a; +extra=(vfoptions.gridinterplayer==1); + +if n_d(1)==0 + PolicyPath=zeros(l_aprime+extra,N_a,N_z,N_j,T,'gpuArray'); + PolicyPath(1,:,:,:,:)=rem(PolicyPathKron(1,:,:,:,:)-1,n_aprime(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=2:l_aprime-1 + PolicyPath(ii,:,:,:,:)=rem(ceil(PolicyPathKron(1,:,:,:,:)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; end end + PolicyPath(l_aprime,:,:,:,:)=ceil(PolicyPathKron(1,:,:,:,:)/prod(n_aprime(1:l_aprime-1))); end - Policy=reshape(PolicyTemp,[l_aprime,n_a,n_z,N_j,T]); - + if vfoptions.gridinterplayer==1 + PolicyPath(l_aprime+1,:,:,:,:)=PolicyPathKron(2,:,:,:,:); + end + + PolicyPath=reshape(PolicyPath,[l_aprime+extra,n_a,n_z,N_j,T]); else l_d=length(n_d); - l_daprime=length(n_d)+l_aprime; - PolicyTemp=zeros(l_daprime,N_a,N_z,N_j,T,'gpuArray'); + PolicyPath=zeros(l_d+l_aprime+extra,N_a,N_z,N_j,T,'gpuArray'); - for jj=1:N_j - for tt=1:T - PolicyTemp(1,:,:,jj,tt)=rem(Policy(1,:,:,jj,tt)-1,n_d(1))+1; - if l_d>1 - if l_d>2 - for ii=2:l_d-1 - PolicyTemp(ii,:,:,jj,tt)=rem(ceil(Policy(1,:,:,jj,tt)/prod(n_d(1:ii-1)))-1,n_d(ii))+1; - end - end - PolicyTemp(l_d,:,:,jj,tt)=ceil(Policy(1,:,:,jj,tt)/prod(n_d(1:l_d-1))); + PolicyPath(1,:,:,:,:)=rem(PolicyPathKron(1,:,:,:,:)-1,n_d(1))+1; + if l_d>1 + if l_d>2 + for ii=2:l_d-1 + PolicyPath(ii,:,:,:,:)=rem(ceil(PolicyPathKron(1,:,:,:,:)/prod(n_d(1:ii-1)))-1,n_d(ii))+1; end + end + PolicyPath(l_d,:,:,:,:)=ceil(PolicyPathKron(1,:,:,:,:)/prod(n_d(1:l_d-1))); + end - PolicyTemp(l_d+1,:,:,jj,tt)=rem(Policy(2,:,:,jj,tt)-1,n_aprime(1))+1; - if l_aprime>1 - if l_aprime>2 - for ii=2:l_aprime-1 - PolicyTemp(l_d+ii,:,:,jj,tt)=rem(ceil(Policy(2,:,:,jj,tt)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; - end - end - PolicyTemp(l_daprime,:,:,jj,tt)=ceil(Policy(2,:,:,jj,tt)/prod(n_aprime(1:l_aprime-1))); + PolicyPath(l_d+1,:,:,:,:)=rem(PolicyPathKron(2,:,:,:,:)-1,n_aprime(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=2:l_aprime-1 + PolicyPath(l_d+ii,:,:,:,:)=rem(ceil(PolicyPathKron(2,:,:,:,:)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; end end + PolicyPath(l_d+l_aprime,:,:,:,:)=ceil(PolicyPathKron(2,:,:,:,:)/prod(n_aprime(1:l_aprime-1))); end - Policy=reshape(PolicyTemp,[l_daprime,n_a,n_z,N_j,T]); -end - -% % Sometimes numerical rounding errors (of the order of 10^(-16) can mean -% % that Policy is not integer valued. The following corrects this by converting to int64 and then -% % makes the output back into double as Matlab otherwise cannot use it in -% % any arithmetical expressions. -% if vfoptions.policy_forceintegertype==1 -% Policy=uint64(Policy); -% Policy=double(Policy); -% end + if vfoptions.gridinterplayer==1 + PolicyPath(l_d+l_aprime+1,:,:,:,:)=PolicyPathKron(3,:,:,:,:); + end + PolicyPath=reshape(PolicyPath,[l_d+l_aprime+extra,n_a,n_z,N_j,T]); +end end \ No newline at end of file diff --git a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_TransPathFHorz_e.m b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_TransPathFHorz_e.m index 0806b563..13bdca5f 100644 --- a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_TransPathFHorz_e.m +++ b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_TransPathFHorz_e.m @@ -1,83 +1,65 @@ -function Policy=UnKronPolicyIndexes_Case1_TransPathFHorz_e(Policy, n_d, n_a, n_z,n_e,N_j,T,vfoptions) -% can input vfoptions OR simoptions -%Input: Policy=zeros(2,N_a,N_z,N_e,N_j,T); %first dim indexes the optimal choice for d and aprime rest of dimensions a,z -% (N_a,N_z,N_e,N_j,T) if there is no d -%Output: Policy (l_d+l_a,n_a,n_z,n_e,N_j,T); +function PolicyPath=UnKronPolicyIndexes_Case1_TransPathFHorz_e(PolicyPathKron, n_d, n_a, n_z,n_e,N_j,T,vfoptions) +% Can use vfoptions OR simoptions +% Input: PolicyPathKron is (2,N_a,N_z,N_e,N_j,T) first dim indexes the optimal choice for d and aprime +% (1,N_a,N_z,N_e,N_j,T) if there is no d +% vfoptions.gridinterplayer=1 will mean the first dimension has one extra value (so 3 if d, 2 without) +% Output: Policy is (l_d+l_a,n_a,n_z,n_e,N_j,T); -N_d=prod(n_d); N_a=prod(n_a); N_z=prod(n_z); N_e=prod(n_e); -l_a=length(n_a); -if vfoptions.gridinterplayer==0 - l_aprime=l_a; - n_aprime=n_a; -elseif vfoptions.gridinterplayer==1 - l_aprime=l_a+1; - n_aprime=[n_a,vfoptions.ngridinterp+2]; -end - -if N_d==0 - - PolicyTemp=zeros(l_aprime,N_a,N_z,N_e,N_j,T,'gpuArray'); +l_aprime=length(n_a); +n_aprime=n_a; +extra=(vfoptions.gridinterplayer==1); - for jj=1:N_j - for tt=1:T - PolicyTemp(1,:,:,:,jj,tt)=shiftdim(rem(Policy(1,:,:,:,jj,tt)-1,n_aprime(1))+1,-1); - if l_aprime>1 - if l_aprime>2 - for ii=2:l_aprime-1 - PolicyTemp(ii,:,:,:,jj,tt)=shiftdim(rem(ceil(Policy(1,:,:,:,jj,tt)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1,-1); - end - end - PolicyTemp(l_aprime,:,:,:,jj,tt)=shiftdim(ceil(Policy(1,:,:,:,jj,tt)/prod(n_aprime(1:l_aprime-1))),-1); +if n_d(1)==0 + PolicyPath=zeros(l_aprime+extra,N_a,N_z,N_e,N_j,T,'gpuArray'); + PolicyPath(1,:,:,:,:,:)=rem(PolicyPathKron(1,:,:,:,:,:)-1,n_aprime(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=2:l_aprime-1 + PolicyPath(ii,:,:,:,:,:)=rem(ceil(PolicyPathKron(1,:,:,:,:,:)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; end end + PolicyPath(l_aprime,:,:,:,:,:)=ceil(PolicyPathKron(1,:,:,:,:,:)/prod(n_aprime(1:l_aprime-1))); + end + + if vfoptions.gridinterplayer==1 + PolicyPath(l_aprime+1,:,:,:,:,:)=PolicyPathKron(2,:,:,:,:,:); end - Policy=reshape(PolicyTemp,[l_aprime,n_a,n_z,n_e,N_j,T]); - + PolicyPath=reshape(PolicyPath,[l_aprime+extra,n_a,n_z,n_e,N_j,T]); else l_d=length(n_d); - l_daprime=length(n_d)+l_aprime; - PolicyTemp=zeros(l_daprime,N_a,N_z,N_e,N_j,T,'gpuArray'); + PolicyPath=zeros(l_d+l_aprime+extra,N_a,N_z,N_e,N_j,T,'gpuArray'); - for jj=1:N_j - for tt=1:T - PolicyTemp(1,:,:,:,jj,tt)=rem(Policy(1,:,:,:,jj,tt)-1,n_d(1))+1; - if l_d>1 - if l_d>2 - for ii=2:l_d-1 - PolicyTemp(ii,:,:,:,jj,tt)=rem(ceil(Policy(1,:,:,:,jj,tt)/prod(n_d(1:ii-1)))-1,n_d(ii))+1; - end - end - PolicyTemp(l_d,:,:,:,jj,tt)=ceil(Policy(1,:,:,:,jj,tt)/prod(n_d(1:l_d-1))); + PolicyPath(1,:,:,:,:,:)=rem(PolicyPathKron(1,:,:,:,:,:)-1,n_d(1))+1; + if l_d>1 + if l_d>2 + for ii=2:l_d-1 + PolicyPath(ii,:,:,:,:,:)=rem(ceil(PolicyPathKron(1,:,:,:,:,:)/prod(n_d(1:ii-1)))-1,n_d(ii))+1; end + end + PolicyPath(l_d,:,:,:,:,:)=ceil(PolicyPathKron(1,:,:,:,:,:)/prod(n_d(1:l_d-1))); + end - PolicyTemp(l_d+1,:,:,:,jj,tt)=rem(Policy(2,:,:,:,jj,tt)-1,n_aprime(1))+1; - if l_aprime>1 - if l_aprime>2 - for ii=2:l_aprime-1 - PolicyTemp(l_d+ii,:,:,:,jj,tt)=rem(ceil(Policy(2,:,:,:,jj,tt)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; - end - end - PolicyTemp(l_daprime,:,:,:,jj,tt)=ceil(Policy(2,:,:,:,jj,tt)/prod(n_aprime(1:l_aprime-1))); + PolicyPath(l_d+1,:,:,:,:,:)=rem(PolicyPathKron(2,:,:,:,:,:)-1,n_aprime(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=2:l_aprime-1 + PolicyPath(l_d+ii,:,:,:,:,:)=rem(ceil(PolicyPathKron(2,:,:,:,:,:)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; end end + PolicyPath(l_d+l_aprime,:,:,:,:,:)=ceil(PolicyPathKron(2,:,:,:,:,:)/prod(n_aprime(1:l_aprime-1))); end - Policy=reshape(PolicyTemp,[l_daprime,n_a,n_z,n_e,N_j,T]); -end + if vfoptions.gridinterplayer==1 + PolicyPath(l_d+l_aprime+1,:,:,:,:,:)=PolicyPathKron(3,:,:,:,:,:); + end -% % Sometimes numerical rounding errors (of the order of 10^(-16) can mean -% % that Policy is not integer valued. The following corrects this by converting to int64 and then -% % makes the output back into double as Matlab otherwise cannot use it in -% % any arithmetical expressions. -% if vfoptions.policy_forceintegertype==1 -% Policy=uint64(Policy); -% Policy=double(Policy); -% end + PolicyPath=reshape(PolicyPath,[l_d+l_aprime+extra,n_a,n_z,n_e,N_j,T]); +end end \ No newline at end of file diff --git a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_TransPathFHorz_noz.m b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_TransPathFHorz_noz.m index fd41d07c..af0fcc9d 100644 --- a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_TransPathFHorz_noz.m +++ b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_TransPathFHorz_noz.m @@ -1,82 +1,64 @@ -function Policy=UnKronPolicyIndexes_Case1_TransPathFHorz_noz(Policy, n_d, n_a,N_j,T,vfoptions) -% can input vfoptions OR simoptions -%Input: Policy=zeros(2,N_a,N_j,T); %first dim indexes the optimal choice for d and aprime rest of dimensions a,z -% (N_a,N_j,T) if there is no d -%Output: Policy (l_d+l_a,n_a,N_j,T); +function PolicyPath=UnKronPolicyIndexes_Case1_TransPathFHorz_noz(PolicyPathKron, n_d, n_a,N_j,T,vfoptions) +% Can use vfoptions OR simoptions +% Input: PolicyKron is (2,N_a,N_j,T) first dim indexes the optimal choice for d and aprime +% (1,N_a,N_j,T) if there is no d +% vfoptions.gridinterplayer=1 will mean the first dimension has one extra value (so 3 if d, 2 without) +% Output: Policy is (l_d+l_a,n_a,N_j,T); -N_d=prod(n_d); +% N_d=prod(n_d); N_a=prod(n_a); -l_a=length(n_a); -if vfoptions.gridinterplayer==0 - l_aprime=l_a; - n_aprime=n_a; -elseif vfoptions.gridinterplayer==1 - l_aprime=l_a+1; - n_aprime=[n_a,vfoptions.ngridinterp+2]; -end - - -if N_d==0 - - PolicyTemp=zeros(l_aprime,N_a,N_j,T,'gpuArray'); +l_aprime=length(n_a); +n_aprime=n_a; +extra=(vfoptions.gridinterplayer==1); - for jj=1:N_j - for tt=1:T - PolicyTemp(1,:,jj,tt)=shiftdim(rem(Policy(1,:,jj,tt)-1,n_aprime(1))+1,-1); - if l_aprime>1 - if l_aprime>2 - for ii=2:l_aprime-1 - PolicyTemp(ii,:,jj,tt)=shiftdim(rem(ceil(Policy(1,:,jj,tt)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1,-1); - end - end - PolicyTemp(l_aprime,:,jj,tt)=shiftdim(ceil(Policy(1,:,jj,tt)/prod(n_aprime(1:l_aprime-1))),-1); +if n_d(1)==0 + PolicyPath=zeros(l_aprime+extra,N_a,N_j,T,'gpuArray'); + PolicyPath(1,:,:,:)=rem(PolicyPathKron(1,:,:,:)-1,n_aprime(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=2:l_aprime-1 + PolicyPath(ii,:,:,:)=rem(ceil(PolicyPathKron(1,:,:,:)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; end end + PolicyPath(l_aprime,:,:,:)=ceil(PolicyPathKron(1,:,:,:)/prod(n_aprime(1:l_aprime-1))); + end + + if vfoptions.gridinterplayer==1 + PolicyPath(l_aprime+1,:,:,:)=PolicyPathKron(2,:,:,:); end - Policy=reshape(PolicyTemp,[l_aprime,n_a,N_j,T]); - + PolicyPath=reshape(PolicyPath,[l_aprime+extra,n_a,N_j,T]); else l_d=length(n_d); - l_daprime=length(n_d)+l_aprime; - PolicyTemp=zeros(l_daprime,N_a,N_j,T,'gpuArray'); + PolicyPath=zeros(l_d+l_aprime+extra,N_a,N_j,T,'gpuArray'); - for jj=1:N_j - for tt=1:T - PolicyTemp(1,:,jj,tt)=rem(Policy(1,:,jj,tt)-1,n_d(1))+1; - if l_d>1 - if l_d>2 - for ii=2:l_d-1 - PolicyTemp(ii,:,jj,tt)=rem(ceil(Policy(1,:,jj,tt)/prod(n_d(1:ii-1)))-1,n_d(ii))+1; - end - end - PolicyTemp(l_d,:,jj,tt)=ceil(Policy(1,:,jj,tt)/prod(n_d(1:l_d-1))); + PolicyPath(1,:,:,:)=rem(PolicyPathKron(1,:,:,:)-1,n_d(1))+1; + if l_d>1 + if l_d>2 + for ii=2:l_d-1 + PolicyPath(ii,:,:,:)=rem(ceil(PolicyPathKron(1,:,:,:)/prod(n_d(1:ii-1)))-1,n_d(ii))+1; end + end + PolicyPath(l_d,:,:,:)=ceil(PolicyPathKron(1,:,:,:)/prod(n_d(1:l_d-1))); + end - PolicyTemp(l_d+1,:,jj,tt)=rem(Policy(2,:,jj,tt)-1,n_aprime(1))+1; - if l_aprime>1 - if l_aprime>2 - for ii=2:l_aprime-1 - PolicyTemp(l_d+ii,:,jj,tt)=rem(ceil(Policy(2,:,jj,tt)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; - end - end - PolicyTemp(l_daprime,:,jj,tt)=ceil(Policy(2,:,jj,tt)/prod(n_aprime(1:l_aprime-1))); + PolicyPath(l_d+1,:,:,:)=rem(PolicyPathKron(2,:,:,:)-1,n_a(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=2:l_aprime-1 + PolicyPath(l_d+ii,:,:,:)=rem(ceil(PolicyPathKron(2,:,:,:)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; end end + PolicyPath(l_d+l_aprime,:,:,:)=ceil(PolicyPathKron(2,:,:,:)/prod(n_aprime(1:l_aprime-1))); end - Policy=reshape(PolicyTemp,[l_daprime,n_a,N_j,T]); -end + if vfoptions.gridinterplayer==1 + PolicyPath(l_d+l_aprime+1,:,:,:)=PolicyPathKron(3,:,:,:); + end -% % Sometimes numerical rounding errors (of the order of 10^(-16) can mean -% % that Policy is not integer valued. The following corrects this by converting to int64 and then -% % makes the output back into double as Matlab otherwise cannot use it in -% % any arithmetical expressions. -% if vfoptions.policy_forceintegertype==1 -% Policy=uint64(Policy); -% Policy=double(Policy); -% end + PolicyPath=reshape(PolicyPath,[l_d+l_aprime+extra,n_a,N_j,T]); +end end \ No newline at end of file diff --git a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_e.m b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_e.m new file mode 100644 index 00000000..3fe8962c --- /dev/null +++ b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_e.m @@ -0,0 +1,66 @@ +function Policy=UnKronPolicyIndexes_Case1_e(PolicyKron, n_d,n_a, n_z,n_e, vfoptions) +% Can use vfoptions OR simoptions +% Input: PolicyKron is (2,N_a,N_z,N_e) first dim indexes the optimal choice for d and aprime +% (1,N_a,N_z,N_e) if there is no d +% vfoptions.gridinterplayer=1 will mean the first dimension has one extra value (so 3 if d, 2 without) +% Output: Policy is (l_d+l_a,n_a,n_z,n_e); + +N_a=prod(n_a); +N_z=prod(n_z); +N_e=prod(n_e); + +l_aprime=length(n_a); +n_aprime=n_a; +extra=(vfoptions.gridinterplayer==1); + +if n_d(1)==0 + Policy=zeros(l_aprime+extra,N_a,N_z,N_e,'gpuArray'); + + Policy(1,:,:,:)=rem(PolicyKron(1,:,:,:)-1,n_aprime(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=2:l_aprime-1 + Policy(ii,:,:,:)=rem(ceil(PolicyKron(1,:,:,:)/prod(n_aprime(1:ii-1)))-1,n_a(ii))+1; + end + end + Policy(l_aprime,:,:,:)=ceil(PolicyKron(1,:,:,:)/prod(n_aprime(1:l_aprime-1))); + end + + if vfoptions.gridinterplayer==1 + Policy(l_aprime+1,:,:,:)=PolicyKron(2,:,:,:); + end + + Policy=reshape(Policy,[l_aprime+extra,n_a,n_z,n_e]); +else + l_d=length(n_d); + Policy=zeros(l_d+l_aprime+extra,N_a,N_z,N_e,'gpuArray'); + + Policy(1,:,:,:)=rem(PolicyKron(1,:,:,:)-1,n_d(1))+1; + if l_d>1 + if l_d>2 + for ii=2:l_d-1 + Policy(ii,:,:,:)=rem(ceil(PolicyKron(1,:,:,:)/prod(n_d(1:ii-1)))-1,n_d(ii))+1; + end + end + Policy(l_d,:,:,:)=ceil(PolicyKron(1,:,:,:)/prod(n_d(1:l_d-1))); + end + + Policy(l_d+1,:,:,:)=rem(PolicyKron(2,:,:,:)-1,n_aprime(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=2:l_aprime-1 + Policy(l_d+ii,:,:,:)=rem(ceil(PolicyKron(2,:,:,:)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; + end + end + Policy(l_d+l_aprime,:,:,:)=ceil(PolicyKron(2,:,:,:)/prod(n_aprime(1:l_aprime-1))); + end + + if vfoptions.gridinterplayer==1 + Policy(l_d+l_aprime+1,:,:,:)=PolicyKron(3,:,:,:); + end + + Policy=reshape(Policy,[l_d+l_aprime+extra,n_a,n_z,n_e]); +end + + +end \ No newline at end of file diff --git a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_noz.m b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_noz.m new file mode 100644 index 00000000..2e98a5d1 --- /dev/null +++ b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case1_noz.m @@ -0,0 +1,65 @@ +function Policy=UnKronPolicyIndexes_Case1_noz(PolicyKron, n_d,n_a, vfoptions) +% Can use vfoptions OR simoptions +% Input: PolicyKron is (2,N_a) first dim indexes the optimal choice for d and aprime +% (1,N_a) if there is no d +% vfoptions.gridinterplayer=1 will mean the first dimension has one extra value (so 3 if d, 2 without) +% Output: Policy is (l_d+l_a,n_a); + +N_a=prod(n_a); + +l_aprime=length(n_a); +n_aprime=n_a; +extra=(vfoptions.gridinterplayer==1); + +if n_d(1)==0 + Policy=zeros(l_aprime+extra,N_a,'gpuArray'); + + Policy(1,:)=rem(PolicyKron(1,:)-1,n_aprime(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=2:l_aprime-1 + Policy(ii,:)=rem(ceil(PolicyKron(1,:)/prod(n_aprime(1:ii-1)))-1,n_a(ii))+1; + end + end + Policy(l_aprime,:)=ceil(PolicyKron(1,:)/prod(n_aprime(1:l_aprime-1))); + end + + if vfoptions.gridinterplayer==1 + Policy(l_aprime+1,:)=PolicyKron(2,:); + end + + Policy=reshape(Policy,[l_aprime+extra,n_a]); +else + l_d=length(n_d); + Policy=zeros(l_d+l_aprime+extra,N_a,'gpuArray'); + + Policy(1,:)=rem(PolicyKron(1,:)-1,n_d(1))+1; + if l_d>1 + if l_d>2 + for ii=2:l_d-1 + Policy(ii,:)=rem(ceil(PolicyKron(1,:)/prod(n_d(1:ii-1)))-1,n_d(ii))+1; + end + end + Policy(l_d,:)=ceil(PolicyKron(1,:)/prod(n_d(1:l_d-1))); + end + + Policy(l_d+1,:)=rem(PolicyKron(2,:)-1,n_aprime(1))+1; + if l_aprime>1 + if l_aprime>2 + for ii=2:l_aprime-1 + Policy(l_d+ii,:)=rem(ceil(PolicyKron(2,:)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1; + end + end + Policy(l_d+l_aprime,:)=ceil(PolicyKron(2,:)/prod(n_aprime(1:l_aprime-1))); + end + + if vfoptions.gridinterplayer==1 + Policy(l_d+l_aprime+1,:)=PolicyKron(2,:); + end + + Policy=reshape(Policy,[l_d+l_aprime+extra,n_a]); +end + + + +end \ No newline at end of file diff --git a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2.m b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2.m index 0ea3e4eb..bb80e086 100644 --- a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2.m +++ b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2.m @@ -1,48 +1,27 @@ -function Policy=UnKronPolicyIndexes_Case2(Policy, n_d, n_a, n_z,vfoptions) - -%PolicyIndexesKron=zeros(N_a,N_z); %first dim indexes the optimal choice for d and aprime rest of dimensions a,z -%PolicyIndexesIntermediate (l_d,N_a,N_z) -%PolicyIndexes (l_d,n_a,n_z); +function Policy=UnKronPolicyIndexes_Case2(PolicyKron, n_d, n_a, n_z,vfoptions) +% For models with z and e, just input [n_z,n_e] in place of n_z +% Can input vfoptions OR simoptions +% Input: PolicyKron=zeros(N_a,N_z); % indexes the optimal choice for d +% Output: Policy is (l_d,n_a,n_z); N_a=prod(n_a); N_z=prod(n_z); l_d=length(n_d); -if vfoptions.parallel~=2 - PolicyTemp=zeros(l_d,N_a,N_z); - for i=1:N_a - for j=1:N_z - optdindexKron=Policy(i,j); - optD=ind2sub_homemade(n_d',optdindexKron); - PolicyTemp(:,i,j)=[optD']; - end - end - Policy=reshape(PolicyTemp,[l_d,n_a,n_z]); -else - PolicyTemp=zeros(l_d,N_a,N_z,'gpuArray'); - - PolicyTemp(1,:,:)=shiftdim(rem(Policy-1,n_d(1))+1,-1); - if l_d>1 - if l_d>2 - for ii=2:l_d-1 - PolicyTemp(ii,:,:)=shiftdim(rem(ceil(Policy/prod(n_d(1:ii-1)))-1,n_d(ii))+1,-1); - end +Policy=zeros(l_d,N_a,N_z,'gpuArray'); + +Policy(1,:,:)=shiftdim(rem(PolicyKron-1,n_d(1))+1,-1); +if l_d>1 + if l_d>2 + for ii=2:l_d-1 + Policy(ii,:,:)=shiftdim(rem(ceil(PolicyKron/prod(n_d(1:ii-1)))-1,n_d(ii))+1,-1); end - PolicyTemp(l_d,:,:)=shiftdim(ceil(Policy/prod(n_d(1:l_d-1))),-1); end - - Policy=reshape(PolicyTemp,[l_d,n_a,n_z]); + Policy(l_d,:,:)=shiftdim(ceil(PolicyKron/prod(n_d(1:l_d-1))),-1); end -% % Sometimes numerical rounding errors (of the order of 10^(-16) can mean -% % that Policy is not integer valued. The following corrects this by converting to int64 and then -% % makes the output back into double as Matlab otherwise cannot use it in -% % any arithmetical expressions. -% if vfoptions.policy_forceintegertype==1 -% Policy=uint64(Policy); -% Policy=double(Policy); -% end +Policy=reshape(Policy,[l_d,n_a,n_z]); end \ No newline at end of file diff --git a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2_FHorz.m b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2_FHorz.m index e5c0b8e4..5951d3ec 100644 --- a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2_FHorz.m +++ b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2_FHorz.m @@ -1,49 +1,26 @@ -function Policy=UnKronPolicyIndexes_Case2_FHorz(Policy, n_d, n_a, n_z,N_j, vfoptions) - -%Input: Policy (N_a,N_z,N_j); -%PolicyIndexesIntermediate (l_d,N_a,N_z,N_j) -%Output: Policy (l_d,n_a,n_z,N_j); +function Policy=UnKronPolicyIndexes_Case2_FHorz(PolicyKron, n_d, n_a, n_z,N_j, vfoptions) +% Can input vfoptions OR simoptions +% Input: PolicyKron=zeros(N_a,N_z,N_j); % indexes the optimal choice for d +% Output: Policy is (l_d,n_a,n_z,N_j); N_a=prod(n_a); N_z=prod(n_z); l_d=length(n_d); -if vfoptions.parallel~=2 - PolicyTemp=zeros(l_d,N_a,N_z,N_j); - for i=1:N_a - for j=1:N_z - for k=1:N_j - optdindexKron=Policy(i,j,k); - optD=ind2sub_homemade(n_d',optdindexKron); - PolicyTemp(:,i,j,k)=[optD']; - end - end - end - Policy=reshape(PolicyTemp,[l_d,n_a,n_z, N_j]); -else - PolicyTemp=zeros(l_d,N_a,N_z,N_j,'gpuArray'); - - PolicyTemp(1,:,:,:)=shiftdim(rem(Policy-1,n_d(1))+1,-1); - if l_d>1 - if l_d>2 - for ii=2:l_d-1 - PolicyTemp(ii,:,:,:)=shiftdim(rem(ceil(Policy/prod(n_d(1:ii-1)))-1,n_d(ii))+1,-1); - end +Policy=zeros(l_d,N_a,N_z,N_j,'gpuArray'); + +Policy(1,:,:,:)=shiftdim(rem(PolicyKron-1,n_d(1))+1,-1); +if l_d>1 + if l_d>2 + for ii=2:l_d-1 + Policy(ii,:,:,:)=shiftdim(rem(ceil(PolicyKron/prod(n_d(1:ii-1)))-1,n_d(ii))+1,-1); end - PolicyTemp(l_d,:,:,:)=shiftdim(ceil(Policy/prod(n_d(1:l_d-1))),-1); end - - Policy=reshape(PolicyTemp,[l_d,n_a,n_z,N_j]); + Policy(l_d,:,:,:)=shiftdim(ceil(PolicyKron/prod(n_d(1:l_d-1))),-1); end -% % Sometimes numerical rounding errors (of the order of 10^(-16) can mean -% % that Policy is not integer valued. The following corrects this by converting to int64 and then -% % makes the output back into double as Matlab otherwise cannot use it in -% % any arithmetical expressions. -% if vfoptions.policy_forceintegertype==1 -% Policy=uint64(Policy); -% Policy=double(Policy); -% end +Policy=reshape(Policy,[l_d,n_a,n_z,N_j]); + end \ No newline at end of file diff --git a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2_FHorz_PType.m b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2_FHorz_PType.m deleted file mode 100644 index 39169892..00000000 --- a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2_FHorz_PType.m +++ /dev/null @@ -1,27 +0,0 @@ -function PolicyIndexes=UnKronPolicyIndexes_Case2_FHorz_PType(PolicyIndexesKron, n_d, n_a, n_z,n_i,N_j) - -%PolicyIndexesKron (N_a,N_z,N_j); -%PolicyIndexesIntermediate (num_d_vars,N_a,N_z,N_j) -%PolicyIndexes (numb_d_vars,n_a,n_z,N_j); - -N_a=prod(n_a); -N_z=prod(n_z); -N_i=prod(n_i); - -num_d_vars=length(n_d); - -PolicyIndexesIntermediate=zeros(num_d_vars,N_a,N_z,N_i,N_j); -for i1=1:N_a - for i2=1:N_z - for i3=1:N_i - for i4=1:N_j - optdindexKron=PolicyIndexesKron(i1,i2,i3,i4); - optD=ind2sub_homemade(n_d',optdindexKron); - PolicyIndexesIntermediate(:,i1,i2,i3,i4)=[optD']; - end - end - end -end -PolicyIndexes=reshape(PolicyIndexesIntermediate,[num_d_vars,n_a,n_z,n_i,N_j]); - -end \ No newline at end of file diff --git a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2_FHorz_e.m b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2_FHorz_e.m index a5be9879..76ac105e 100644 --- a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2_FHorz_e.m +++ b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2_FHorz_e.m @@ -1,8 +1,7 @@ -function Policy=UnKronPolicyIndexes_Case2_FHorz_e(Policy, n_d, n_a, n_z,n_e,N_j, vfoptions) - -% Input: Policy (N_a,N_z,N_e,N_j); -% PolicyIndexesIntermediate (l_d,N_a,N_z,N_e,N_j) -% Output: Policy (l_d,n_a,n_z,n_e,N_j); +function Policy=UnKronPolicyIndexes_Case2_FHorz_e(PolicyKron, n_d, n_a, n_z,n_e,N_j, vfoptions) +% Can input vfoptions OR simoptions +% Input: PolicyKron=zeros(N_a,N_z,N_j); % indexes the optimal choice for d +% Output: Policy is (l_d,n_a,n_z,N_j); N_a=prod(n_a); N_z=prod(n_z); @@ -10,43 +9,18 @@ l_d=length(n_d); -if vfoptions.parallel~=2 - PolicyTemp=zeros(l_d,N_a,N_z,N_e,N_j); - for i=1:N_a - for j=1:N_z - for e_c=1:N_e - for k=1:N_j - optdindexKron=Policy(i,j,e_c,k); - optD=ind2sub_homemade(n_d',optdindexKron); - PolicyTemp(:,i,j,e_c,k)=[optD']; - end - end - end - end - Policy=reshape(PolicyTemp,[l_d,n_a,n_z,n_e, N_j]); -else - PolicyTemp=zeros(l_d,N_a,N_z,N_e,N_j,'gpuArray'); - - PolicyTemp(1,:,:,:,:)=shiftdim(rem(Policy-1,n_d(1))+1,-1); - if l_d>1 - if l_d>2 - for ii=2:l_d-1 - PolicyTemp(ii,:,:,:,:)=shiftdim(rem(ceil(Policy/prod(n_d(1:ii-1)))-1,n_d(ii))+1,-1); - end +Policy=zeros(l_d,N_a,N_z,N_e,N_j,'gpuArray'); + +Policy(1,:,:,:,:)=shiftdim(rem(PolicyKron-1,n_d(1))+1,-1); +if l_d>1 + if l_d>2 + for ii=2:l_d-1 + Policy(ii,:,:,:,:)=shiftdim(rem(ceil(PolicyKron/prod(n_d(1:ii-1)))-1,n_d(ii))+1,-1); end - PolicyTemp(l_d,:,:,:,:)=shiftdim(ceil(Policy/prod(n_d(1:l_d-1))),-1); end - - Policy=reshape(PolicyTemp,[l_d,n_a,n_z,n_e,N_j]); + Policy(l_d,:,:,:,:)=shiftdim(ceil(PolicyKron/prod(n_d(1:l_d-1))),-1); end -% % Sometimes numerical rounding errors (of the order of 10^(-16) can mean -% % that Policy is not integer valued. The following corrects this by converting to int64 and then -% % makes the output back into double as Matlab otherwise cannot use it in -% % any arithmetical expressions. -% if vfoptions.policy_forceintegertype==1 -% Policy=uint64(Policy); -% Policy=double(Policy); -% end +Policy=reshape(Policy,[l_d,n_a,n_z,n_e,N_j]); end \ No newline at end of file diff --git a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2_FHorz_noz.m b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2_FHorz_noz.m index 166ca8e6..654c69ea 100644 --- a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2_FHorz_noz.m +++ b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2_FHorz_noz.m @@ -1,46 +1,24 @@ -function Policy=UnKronPolicyIndexes_Case2_FHorz_noz(Policy, n_d, n_a,N_j, vfoptions) - -%Input: Policy (N_a,N_j); -%PolicyIndexesIntermediate (l_d,N_a,N_j) -%Output: Policy (l_d,n_a,N_j); +function Policy=UnKronPolicyIndexes_Case2_FHorz_noz(PolicyKron, n_d, n_a,N_j, vfoptions) +% Can input vfoptions OR simoptions +% Input: PolicyKron=zeros(N_a,N_j); % indexes the optimal choice for d +% Output: Policy is (l_d,n_a,N_j); N_a=prod(n_a); l_d=length(n_d); -if vfoptions.parallel~=2 - PolicyTemp=zeros(l_d,N_a,N_j); - for i=1:N_a - for k=1:N_j - optdindexKron=Policy(i,k); - optD=ind2sub_homemade(n_d',optdindexKron); - PolicyTemp(:,i,k)=[optD']; - end - end - Policy=reshape(PolicyTemp,[l_d,n_a,N_j]); -else - PolicyTemp=zeros(l_d,N_a,N_j,'gpuArray'); - - PolicyTemp(1,:,:)=shiftdim(rem(Policy-1,n_d(1))+1,-1); - if l_d>1 - if l_d>2 - for ii=2:l_d-1 - PolicyTemp(ii,:,:)=shiftdim(rem(ceil(Policy/prod(n_d(1:ii-1)))-1,n_d(ii))+1,-1); - end +Policy=zeros(l_d,N_a,N_j,'gpuArray'); + +Policy(1,:,:)=shiftdim(rem(PolicyKron-1,n_d(1))+1,-1); +if l_d>1 + if l_d>2 + for ii=2:l_d-1 + Policy(ii,:,:)=shiftdim(rem(ceil(PolicyKron/prod(n_d(1:ii-1)))-1,n_d(ii))+1,-1); end - PolicyTemp(l_d,:,:)=shiftdim(ceil(Policy/prod(n_d(1:l_d-1))),-1); end - - Policy=reshape(PolicyTemp,[l_d,n_a,N_j]); + Policy(l_d,:,:)=shiftdim(ceil(PolicyKron/prod(n_d(1:l_d-1))),-1); end -% % Sometimes numerical rounding errors (of the order of 10^(-16) can mean -% % that Policy is not integer valued. The following corrects this by converting to int64 and then -% % makes the output back into double as Matlab otherwise cannot use it in -% % any arithmetical expressions. -% if vfoptions.policy_forceintegertype==1 -% Policy=uint64(Policy); -% Policy=double(Policy); -% end +Policy=reshape(Policy,[l_d,n_a,N_j]); end \ No newline at end of file diff --git a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2_PType.m b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2_PType.m deleted file mode 100644 index c407aeb3..00000000 --- a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_Case2_PType.m +++ /dev/null @@ -1,25 +0,0 @@ -function PolicyIndexes=UnKronPolicyIndexes_Case2_PType(PolicyIndexesKron, n_d, n_a, n_z,n_i) - -%PolicyIndexesKron=zeros(N_a,N_z); %first dim indexes the optimal choice for d and aprime rest of dimensions a,z -%PolicyIndexesIntermediate (number_d_vars,N_a,N_z) -%PolicyIndexes (number_d_vars,n_a,n_z); - -N_a=prod(n_a); -N_z=prod(n_z); -N_i=prod(n_i); - -num_d_vars=length(n_d); - -PolicyIndexesIntermediate=zeros(num_d_vars,N_a,N_z,N_i); -for a_c=1:N_a - for z_c=1:N_z - for i=1:N_i - optdindexKron=PolicyIndexesKron(a_c,z_c,i); - optD=ind2sub_homemade(n_d',optdindexKron); - PolicyIndexesIntermediate(:,a_c,z_c,i)=[optD']; - end - end -end -PolicyIndexes=reshape(PolicyIndexesIntermediate,[num_d_vars,n_a,n_z,n_i]); - -end \ No newline at end of file diff --git a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_InfHorz_TransPath.m b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_InfHorz_TransPath.m index 0e9e15f4..430a6688 100644 --- a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_InfHorz_TransPath.m +++ b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_InfHorz_TransPath.m @@ -1,120 +1,14 @@ function PolicyPath=UnKronPolicyIndexes_InfHorz_TransPath(PolicyPathKron, n_d, n_a, n_z,T,vfoptions,justfirstdim) - -% Input: PolicyPathKron=zeros(2,N_a,N_z,T); % first dim indexes the optimal choice for d and aprime rest of dimensions a,z -% (N_a,N_z,T) if there is no d -% Output: PolicyPath (l_d+l_a,n_a,n_z,T); -% Note: This can look slightly different based on vfoptions - -N_d=prod(n_d); -N_a=prod(n_a); -N_z=prod(n_z); - -l_aprime=length(n_a); - -if N_d==0 - if vfoptions.gridinterplayer==0 - PolicyPath=zeros(l_aprime,N_a,N_z,T,'gpuArray'); - - PolicyPath(1,:,:,:)=shiftdim(rem(PolicyPathKron(:,:,:)-1,n_a(1))+1,-1); - if l_aprime>1 - if l_aprime>2 - for ii=2:l_aprime-1 - PolicyPath(ii,:,:,:)=shiftdim(rem(ceil(PolicyPathKron(:,:,:)/prod(n_a(1:ii-1)))-1,n_a(ii))+1,-1); - end - end - PolicyPath(l_aprime,:,:,:)=shiftdim(ceil(PolicyPathKron(:,:,:)/prod(n_a(1:l_aprime-1))),-1); - end - - if justfirstdim==0 - PolicyPath=reshape(PolicyPath,[l_aprime,n_a,n_z,T]); - end - elseif vfoptions.gridinterplayer==1 - PolicyPath=zeros(l_aprime+1,N_a,N_z,T,'gpuArray'); - - PolicyPath(1,:,:,:)=PolicyPathKron(1,:,:,:); - if l_aprime==2 - PolicyPath(2,:,:,:)=PolicyPathKron(2,:,:,:); - elseif l_aprime>2 - PolicyPath(2,:,:,:)=shiftdim(rem(PolicyPathKron(2,:,:,:)-1,n_a(2))+1,-1); - for ii=3:l_aprime-1 - PolicyPath(ii,:,:,:)=shiftdim(rem(ceil(PolicyPathKron(2,:,:,:)/prod(n_a(2:ii-1)))-1,n_a(ii))+1,-1); - end - PolicyPath(l_aprime,:,:,:)=shiftdim(ceil(PolicyPathKron(2,:,:,:)/prod(n_a(2:l_aprime-1))),-1); - end - - if l_aprime==1 - PolicyPath(l_aprime+1,:,:,:)=PolicyPathKron(2,:,:,:); - else - PolicyPath(l_aprime+1,:,:,:)=PolicyPathKron(3,:,:,:); - end - - if justfirstdim==0 - PolicyPath=reshape(PolicyPath,[l_aprime+1,n_a,n_z,T]); - end - end - -elseif N_d>0 - l_d=length(n_d); - if vfoptions.gridinterplayer==0 - PolicyPath=zeros(l_d+l_aprime,N_a,N_z,T,'gpuArray'); - - PolicyPath(1,:,:,:)=shiftdim(rem(PolicyPathKron(1,:,:,:)-1,n_d(1))+1,-1); - if l_d>1 - if l_d>2 - for ii=2:l_d-1 - PolicyPath(ii,:,:,:)=shiftdim(rem(ceil(PolicyPathKron(1,:,:,:)/prod(n_d(1:ii-1)))-1,n_d(ii))+1,-1); - end - end - PolicyPath(l_d,:,:,:)=shiftdim(ceil(PolicyPathKron(1,:,:,:)/prod(n_d(1:l_d-1))),-1); - end - - PolicyPath(l_d+1,:,:,:)=shiftdim(rem(PolicyPathKron(2,:,:,:)-1,n_a(1))+1,-1); - if l_aprime>1 - for ii=2:l_aprime-1 - PolicyPath(l_d+ii,:,:,:)=shiftdim(rem(ceil(PolicyPathKron(2,:,:,:)/prod(n_a(1:ii-1)))-1,n_a(ii))+1,-1); - end - PolicyPath(l_d+l_aprime,:,:,:)=shiftdim(ceil(PolicyPathKron(2,:,:,:)/prod(n_a(1:l_aprime-1))),-1); - end - - if justfirstdim==0 - PolicyPath=reshape(PolicyPath,[l_d+l_aprime,n_a,n_z,T]); - end - - elseif vfoptions.gridinterplayer==1 - PolicyPath=zeros(l_d+l_aprime+1,N_a,N_z,T,'gpuArray'); - - PolicyPath(1,:,:,:)=shiftdim(rem(PolicyPathKron(1,:,:,:)-1,n_d(1))+1,-1); - if l_d>1 - if l_d>2 - for ii=2:l_d-1 - PolicyPath(ii,:,:,:)=shiftdim(rem(ceil(PolicyPathKron(1,:,:,:)/prod(n_d(1:ii-1)))-1,n_d(ii))+1,-1); - end - end - PolicyPath(l_d,:,:,:)=shiftdim(ceil(PolicyPathKron(1,:,:,:)/prod(n_d(1:l_d-1))),-1); - end - - PolicyPath(l_d+1,:,:,:)=PolicyPathKron(2,:,:,:); - if l_aprime==2 - PolicyPath(l_d+2,:,:,:)=PolicyPathKron(3,:,:,:); - elseif l_aprime>2 - PolicyPath(l_d+2,:,:,:)=shiftdim(rem(PolicyPathKron(3,:,:,:)-1,n_a(2))+1,-1); - for ii=3:l_aprime-1 - PolicyPath(l_d+ii,:,:,:)=shiftdim(rem(ceil(PolicyPathKron(3,:,:,:)/prod(n_a(2:ii-1)))-1,n_a(ii))+1,-1); - end - PolicyPath(l_d+l_aprime,:,:,:)=shiftdim(ceil(PolicyPathKron(3,:,:,:)/prod(n_a(2:l_aprime-1))),-1); - end - - if l_aprime==1 - PolicyPath(l_d+l_aprime+1,:,:,:)=PolicyPathKron(3,:,:,:); - else - PolicyPath(l_d+l_aprime+1,:,:,:)=PolicyPathKron(4,:,:,:); - end - - if justfirstdim==0 - PolicyPath=reshape(PolicyPath,[l_d+l_aprime+1,n_a,n_z,T]); - end - end +% Can use vfoptions OR simoptions +% Input: PolicyKron is (2,N_a,N_z,T) first dim indexes the optimal choice for d and aprime +% (1,N_a,N_z,T) if there is no d +% vfoptions.gridinterplayer=1 will mean the first dimension has one extra value (so 3 if d, 2 without) +% Output: Policy is (l_d+l_a,n_a,n_z,T); + +% Really this is just the same things as when T is N_j, so just redirect rather than duplicate +PolicyPath=UnKronPolicyIndexes_Case1_FHorz(PolicyPathKron,n_d,n_a,n_z,T,vfoptions); +if justfirstdim==1 + PolicyPath=reshape(PolicyPath,[size(PolicyPath,1),N_a,N_z,T]); end - end \ No newline at end of file diff --git a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_InfHorz_TransPath_ExpAsset.m b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_InfHorz_TransPath_ExpAsset.m index 96c955be..a56f0009 100644 --- a/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_InfHorz_TransPath_ExpAsset.m +++ b/SubCodes/UnKronPolicyIndexes/UnKronPolicyIndexes_InfHorz_TransPath_ExpAsset.m @@ -1,5 +1,5 @@ function PolicyPath=UnKronPolicyIndexes_InfHorz_TransPath_ExpAsset(PolicyPathKron, n_d, n_a1, n_a, n_z,T,vfoptions,justfirstdim) - +error('THIS IS NOT SETUP CORRECTLY YET') % Input: PolicyPathKron=zeros(2,N_a,N_z,T); % if no d1: this is d2,a1prime % PolicyPathKron=zeros(3,N_a,N_z,T); % d1,d2,a1prime % Output: PolicyPath (l_d+l_a,n_a,n_z,T); @@ -8,8 +8,6 @@ N_a=prod(n_a); N_z=prod(n_z); -l_aprime=length(n_a1); - l_d=length(n_d); % expasset so has to be a least 1 due to d2 if l_d==1 l_d1=0; @@ -19,102 +17,57 @@ end if vfoptions.gridinterplayer==0 - PolicyPath=zeros(l_d+l_aprime,N_a,N_z,T,'gpuArray'); - - if l_d1==0 - % d2 - PolicyPath(1,:,:,:)=PolicyPathKron(1,:,:,:); - - % a1prime - PolicyPath(l_d+1,:,:,:)=shiftdim(rem(PolicyPathKron(2,:,:,:)-1,n_a1(1))+1,-1); - if l_aprime>1 - for ii=2:l_aprime-1 - PolicyPath(l_d+ii,:,:,:)=shiftdim(rem(ceil(PolicyPathKron(2,:,:,:)/prod(n_a1(1:ii-1)))-1,n_a1(ii))+1,-1); - end - PolicyPath(l_d+l_aprime,:,:,:)=shiftdim(ceil(PolicyPathKron(2,:,:,:)/prod(n_a1(1:l_aprime-1))),-1); - end + l_aprime=length(n_a1); + n_aprime=n_a1; +elseif vfoptions.gridinterplayer==1 + l_aprime=length(n_a1)+1; + n_aprime=[n_a1,vfoptions.ngridinterp+2]; +end - else - % d1 - PolicyPath(1,:,:,:)=shiftdim(rem(PolicyPathKron(1,:,:,:)-1,n_d1(1))+1,-1); - if l_d1>1 - if l_d1>2 - for ii=2:l_d1-1 - PolicyPath(ii,:,:,:)=shiftdim(rem(ceil(PolicyPathKron(1,:,:,:)/prod(n_d1(1:ii-1)))-1,n_d1(ii))+1,-1); - end - end - PolicyPath(l_d1,:,:,:)=shiftdim(ceil(PolicyPathKron(1,:,:,:)/prod(n_d1(1:l_d1-1))),-1); - end +PolicyPath=zeros(l_d+l_aprime,N_a,N_z,T,'gpuArray'); - % d2 - PolicyPath(l_d1+1,:,:,:)=PolicyPathKron(2,:,:,:); +if l_d1==0 + % d2 + PolicyPath(1,:,:,:)=PolicyPathKron(1,:,:,:); - % a1prime - PolicyPath(l_d+1,:,:,:)=shiftdim(rem(PolicyPathKron(3,:,:,:)-1,n_a1(1))+1,-1); - if l_aprime>1 - for ii=2:l_aprime-1 - PolicyPath(l_d+ii,:,:,:)=shiftdim(rem(ceil(PolicyPathKron(3,:,:,:)/prod(n_a1(1:ii-1)))-1,n_a1(ii))+1,-1); - end - PolicyPath(l_d+l_aprime,:,:,:)=shiftdim(ceil(PolicyPathKron(3,:,:,:)/prod(n_a1(1:l_aprime-1))),-1); + % a1prime + PolicyPath(l_d+1,:,:,:)=shiftdim(rem(PolicyPathKron(2,:,:,:)-1,n_aprime(1))+1,-1); + if l_aprime>1 + for ii=2:l_aprime-1 + PolicyPath(l_d+ii,:,:,:)=shiftdim(rem(ceil(PolicyPathKron(2,:,:,:)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1,-1); end - end - - if justfirstdim==0 - PolicyPath=reshape(PolicyPath,[l_d+l_aprime,n_a,n_z,T]); + PolicyPath(l_d+l_aprime,:,:,:)=shiftdim(ceil(PolicyPathKron(2,:,:,:)/prod(n_aprime(1:l_aprime-1))),-1); end -elseif vfoptions.gridinterplayer==1 - PolicyPath=zeros(l_d+l_aprime+1,N_a,N_z,T,'gpuArray'); - - if l_d1==0 - % d2 - PolicyPath(1,:,:,:)=PolicyPathKron(1,:,:,:); - - % a1prime - PolicyPath(l_d+1,:,:,:)=PolicyPathKron(2,:,:,:); - if l_aprime==2 - PolicyPath(l_d+2,:,:,:)=PolicyPathKron(3,:,:,:); - elseif l_aprime>2 - PolicyPath(l_d+2,:,:,:)=shiftdim(rem(PolicyPathKron(3,:,:,:)-1,n_a1(2))+1,-1); - for ii=3:l_aprime-1 - PolicyPath(l_d+ii,:,:,:)=shiftdim(rem(ceil(PolicyPathKron(3,:,:,:)/prod(n_a1(2:ii-1)))-1,n_a1(ii))+1,-1); +else + % d1 + PolicyPath(1,:,:,:)=shiftdim(rem(PolicyPathKron(1,:,:,:)-1,n_d1(1))+1,-1); + if l_d1>1 + if l_d1>2 + for ii=2:l_d1-1 + PolicyPath(ii,:,:,:)=shiftdim(rem(ceil(PolicyPathKron(1,:,:,:)/prod(n_d1(1:ii-1)))-1,n_d1(ii))+1,-1); end - PolicyPath(l_d+l_aprime,:,:,:)=shiftdim(ceil(PolicyPathKron(3,:,:,:)/prod(n_a1(2:l_aprime-1))),-1); - end - else - % d1 - PolicyPath(1,:,:,:)=shiftdim(rem(PolicyPathKron(1,:,:,:)-1,n_d1(1))+1,-1); - if l_d1>1 - if l_d1>2 - for ii=2:l_d1-1 - PolicyPath(ii,:,:,:)=shiftdim(rem(ceil(PolicyPathKron(1,:,:,:)/prod(n_d1(1:ii-1)))-1,n_d1(ii))+1,-1); - end - end - PolicyPath(l_d1,:,:,:)=shiftdim(ceil(PolicyPathKron(1,:,:,:)/prod(n_d1(1:l_d1-1))),-1); end + PolicyPath(l_d1,:,:,:)=shiftdim(ceil(PolicyPathKron(1,:,:,:)/prod(n_d1(1:l_d1-1))),-1); + end - PolicyPath(l_d1+1,:,:,:)=PolicyPathKron(2,:,:,:); % d2 + % d2 + PolicyPath(l_d1+1,:,:,:)=PolicyPathKron(2,:,:,:); - % a1prime - PolicyPath(l_d+1,:,:,:)=PolicyPathKron(3,:,:,:); - if l_aprime==2 - PolicyPath(l_d+2,:,:,:)=PolicyPathKron(4,:,:,:); - elseif l_aprime>2 - PolicyPath(l_d+2,:,:,:)=shiftdim(rem(PolicyPathKron(4,:,:,:)-1,n_a1(2))+1,-1); - for ii=3:l_aprime-1 - PolicyPath(l_d+ii,:,:,:)=shiftdim(rem(ceil(PolicyPathKron(4,:,:,:)/prod(n_a1(2:ii-1)))-1,n_a1(ii))+1,-1); - end - PolicyPath(l_d+l_aprime,:,:,:)=shiftdim(ceil(PolicyPathKron(4,:,:,:)/prod(n_a1(2:l_aprime-1))),-1); + % a1prime + PolicyPath(l_d+1,:,:,:)=shiftdim(rem(PolicyPathKron(3,:,:,:)-1,n_aprime(1))+1,-1); + if l_aprime>1 + for ii=2:l_aprime-1 + PolicyPath(l_d+ii,:,:,:)=shiftdim(rem(ceil(PolicyPathKron(3,:,:,:)/prod(n_aprime(1:ii-1)))-1,n_aprime(ii))+1,-1); end + PolicyPath(l_d+l_aprime,:,:,:)=shiftdim(ceil(PolicyPathKron(3,:,:,:)/prod(n_aprime(1:l_aprime-1))),-1); end +end - % L2 index - PolicyPath(l_d+l_aprime+1,:,:,:)=PolicyPathKron(end,:,:,:); - - if justfirstdim==0 - PolicyPath=reshape(PolicyPath,[l_d+l_aprime+1,n_a,n_z,T]); - end +if justfirstdim==0 + PolicyPath=reshape(PolicyPath,[l_d+l_aprime,n_a,n_z,T]); end + end \ No newline at end of file diff --git a/TransitionPaths/FHorz/Shooting_GI/TransitionPath_FHorz_shooting_fastOLG_GI.m b/TransitionPaths/FHorz/Shooting_GI/TransitionPath_FHorz_shooting_fastOLG_GI.m deleted file mode 100644 index aa21a965..00000000 --- a/TransitionPaths/FHorz/Shooting_GI/TransitionPath_FHorz_shooting_fastOLG_GI.m +++ /dev/null @@ -1,224 +0,0 @@ -function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_GI(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n2short, n_d, n_a, n_z, N_j, N_d,N_a,N_z, l_d,l_a,l_z, d_gridvals,aprimefine_gridvals,a_gridvals,d_grid,a_grid,z_gridvals_J, pi_z_J,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluate, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) -% fastOLG: fastOLG uses (a,j,z) instead of the standard (a,z,j) -% This (a,j,z) is important for ability to implement codes based on matrix -% multiplications (especially for Tan improvement) - -% PricePathOld is matrix of size T-by-'number of prices' -% ParamPath is matrix of size T-by-'number of parameters that change over path' - -if transpathoptions.verbose==1 - % Set up some things to be used later - pathnametitles=cell(1,2*length(PricePathNames)); - for ii=1:length(PricePathNames) - pathnametitles{ii}={['Old ',PricePathNames{ii}]}; - pathnametitles{ii+length(PricePathNames)}={['New ',PricePathNames{ii}]}; - end -end - -%% -PricePathDist=Inf; -pathcounter=1; - -% fastOLG so everything is (a,j,z) -% Shapes: -% V is [N_a,N_j,N_z] -% AgentDist for fastOLG is [N_a*N_j*N_z,1] - -PricePathNew=zeros(size(PricePathOld),'gpuArray'); -PricePathNew(T,:)=PricePathOld(T,:); -AggVarsPath=zeros(T-1,length(FnsToEvaluate),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect -GEcondnPath=zeros(T-1,length(GeneralEqmEqnsCell),'gpuArray'); - -% preallocate -PolicyPath_aprime=zeros([N_a*(N_j-1)*N_z,2,T-1],'gpuArray'); -PolicyProbsPath=zeros([N_a*(N_j-1)*N_z,2,T-1],'gpuArray'); - -if transpathoptions.trivialjequalonedist==0 - jequalOneDist_T=jequalOneDist; - jequalOneDist=jequalOneDist_T(:,1); -end - -%% -while PricePathDist>transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - - PolicyPath=zeros(3,N_a,N_j,N_z,T-1,'gpuArray'); %Periods 1 to T-1 - - %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. - % Since we won't need to keep the value functions for anything later we just store the current one in V - V=V_final; - for ttr=1:T-1 %so tt=T-ttr - - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(T-ttr,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(T-ttr,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - if transpathoptions.zpathtrivial==0 - z_gridvals_J=transpathoptions.z_gridvals_J_T(:,:,:,T-ttr); - pi_z_J=transpathoptions.pi_z_J_T(:,:,:,T-ttr); % fastOLG value function uses (j,z',z) - end - - [V, Policy]=ValueFnIter_FHorz_TPath_SingleStep_fastOLG(V,n_d,n_a,n_z,N_j,d_grid, a_grid, z_gridvals_J, pi_z_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); - % The V input is next period value fn, the V output is this period. - % Policy in fastOLG is [N_a,N_j,N_z] and contains the joint-index for (d,aprime) - - PolicyPath(:,:,:,:,T-ttr)=Policy; % fastOLG: so a-by-j-by-z - end - - - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path - - % PolicyPath_d=PolicyPath(1,:,:,:,:); - PolicyPath_aprimefine=(n2short+1)*(PolicyPath(2,:,:,:,:)-1)+PolicyPath(3,:,:,:,:); - PolicyPath_aprime(:,1,:)=reshape(PolicyPath(2,:,1:end-1,:,:),[N_a*(N_j-1)*N_z,1,T-1]); % lower grid point index - PolicyPath_aprime(:,2,:)=PolicyPath_aprime(:,1,:)+1; % upper grid point index - PolicyProbsPath(:,2,:)=reshape((PolicyPath(3,:,1:end-1,:,:)-1)/n2short,[N_a*(N_j-1)*N_z,1,T-1]); % prob of upper grid point - PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % prob of lower grid point - - % Call AgentDist the current periods distn - AgentDist=AgentDist_initial; - for tt=1:T-1 - %% Setup the Parameters for period tt - % Get t-1 PricePath and ParamPath before we update them - if use_tminus1price==1 - for pp=1:length(tminus1priceNames) - if tt>1 - Parameters.([tminus1priceNames{pp},'_tminus1'])=Parameters.(tminus1priceNames{pp}); - else - Parameters.([tminus1priceNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1priceNames{pp}); - end - end - end - if use_tminus1params==1 - for pp=1:length(tminus1paramNames) - if tt>1 - Parameters.([tminus1paramNames{pp},'_tminus1'])=Parameters.(tminus1paramNames{pp}); - else - Parameters.([tminus1paramNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1paramNames{pp}); - end - end - end - % Get t-1 AggVars before we update them - if use_tminus1AggVars==1 - for pp=1:length(tminus1AggVarsNames) - if tt>1 - % The AggVars have not yet been updated, so they still contain previous period values - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=Parameters.(tminus1AggVarsNames{pp}); - else - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1AggVarsNames{pp}); - end - end - end - - % Update current PricePath and ParamPath - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(tt,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(tt,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - % Get t+1 PricePath - if use_tplus1price==1 - for pp=1:length(tplus1priceNames) - kk=tplus1pricePathkk(pp); - Parameters.([tplus1priceNames{pp},'_tplus1'])=PricePathOld(tt+1,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); % Make is so that the time t+1 variables can be used - end - end - - if transpathoptions.zpathtrivial==0 - z_gridvals_J=transpathoptions.z_gridvals_J_T(:,:,:,tt); - pi_z_J_sim=transpathoptions.pi_z_J_sim_T(:,:,:,tt); % fastOLG value function uses (j,z,z') - end - - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights_T(:,tt),PolicyPath(1,:,:,:,tt), PolicyPath_aprimefine(:,:,:,:,tt), FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_z,N_a,N_z,d_gridvals,aprimefine_gridvals,a_gridvals,z_gridvals_J,1); - for ii=1:length(AggVarNames) - Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; - end - - % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) - [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); - PricePathNew(tt,:)=PricePathNew_tt; - GEcondnPath(tt,:)=GEcondnPath_tt; - - % Sometimes, want to keep the AggVars to plot them - if transpathoptions.graphaggvarspath==1 - for ii=1:length(AggVarNames) - AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; - end - end - - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - % simoptions.fastOLG=1 is hardcoded - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_raw(AgentDist,PolicyPath_aprime(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_z,N_j,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % Policy for jj=1:N_j-1 - end - - - %% Now update prices, give verbose feedback, and check for convergence - - % See how far apart the price paths are - PricePathDist=max(abs(reshape(PricePathNew(1:T-1,:)-PricePathOld(1:T-1,:),[numel(PricePathOld(1:T-1,:)),1]))); - % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges - - if transpathoptions.verbose==1 - pathcounter - disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) - pathnametitles{:} - [PricePathOld,PricePathNew] - end - - % Create plots of the transition path (before we update pricepath) - createTPathFeedbackPlots(PricePathNames,AggVarNames,GEeqnNames,PricePathOld,AggVarsPath,GEcondnPath,transpathoptions); - - % Set price path to be 9/10ths the old path and 1/10th the new path (but making sure to leave prices in periods 1 & T unchanged). - if transpathoptions.weightscheme==0 - PricePathOld=PricePathNew; % The update weights are already in GEnewprice setup - elseif transpathoptions.weightscheme==1 % Just a constant weighting - PricePathOld(1:T-1,:)=transpathoptions.oldpathweight*PricePathOld(1:T-1,:)+(1-transpathoptions.oldpathweight)*PricePathNew(1:T-1,:); - elseif transpathoptions.weightscheme==2 % A exponentially decreasing weighting on new path from (1-oldpathweight) in first period, down to 0.1*(1-oldpathweight) in T-1 period. - Ttheta=transpathoptions.Ttheta; - PricePathOld(1:Ttheta,:)=transpathoptions.oldpathweight*PricePathOld(1:Ttheta,:)+(1-transpathoptions.oldpathweight)*PricePathNew(1:Ttheta,:); - PricePathOld(Ttheta:T-1,:)=((transpathoptions.oldpathweight+(1-exp(linspace(0,log(0.2),T-Ttheta)))*(1-transpathoptions.oldpathweight))'*ones(1,l_p)).*PricePathOld(Ttheta:T-1,:)+((exp(linspace(0,log(0.2),T-Ttheta)).*(1-transpathoptions.oldpathweight))'*ones(1,l_p)).*PricePathNew(Ttheta:T-1,:); - elseif transpathoptions.weightscheme==3 % A gradually opening window. - if (pathcounter*3)transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - - PolicyPath=zeros(3,N_a,N_j,N_z,N_e,T-1,'gpuArray'); %Periods 1 to T-1 - - %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. - % Since we won't need to keep the value functions for anything later we just store the current one in V - V=V_final; - for ttr=1:T-1 %so tt=T-ttr - - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(T-ttr,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(T-ttr,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - if transpathoptions.zpathtrivial==0 - pi_z_J=transpathoptions.pi_z_J_T(:,:,:,T-ttr); % fastOLG value function uses (j,z',z) - z_gridvals_J=transpathoptions.z_gridvals_J(:,:,T-ttr); - end - if transpathoptions.epathtrivial==0 - pi_e_J=transpathoptions.pi_e_J_T(:,1,:,T-ttr); - e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,:,T-ttr); - end - - [V, Policy]=ValueFnIter_FHorz_TPath_SingleStep_fastOLG_e(V,n_d,n_a,n_z,n_e,N_j,d_grid, a_grid, z_gridvals_J, e_gridvals_J, pi_z_J, pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); - % The V input is next period value fn, the V output is this period. - % Policy in fastOLG is [N_a,N_j,N_z,N_e] and contains the joint-index for (d,aprime) - - PolicyPath(:,:,:,:,:,T-ttr)=Policy; % fastOLG: so a-by-j-by-z-by-e - - end - - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path - - % PolicyPath_d=PolicyPath(1,:,:,:,:,:); - PolicyPath_aprimefine=(n2short+1)*(PolicyPath(2,:,:,:,:,:)-1)+PolicyPath(3,:,:,:,:,:); - PolicyPath_aprime(:,1,:)=reshape(PolicyPath(2,:,1:end-1,:,:,:),[N_a*(N_j-1)*N_z*N_e,1,T-1]); % lower grid point index - PolicyPath_aprime(:,2,:)=PolicyPath_aprime(:,1,:)+1; % upper grid point index - PolicyProbsPath(:,2,:)=reshape((PolicyPath(3,:,1:end-1,:,:,:)-1)/n2short,[N_a*(N_j-1)*N_z*N_e,1,T-1]); % prob of upper grid point - PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % prob of lower grid point - - % Call AgentDist the current periods distn - AgentDist=AgentDist_initial; - for tt=1:T-1 - - % Get the current optimal policy (not needed, only use PolicyPath_parimefine, PolicyPath_aprime, and PolicyProbPath) - % Policy=PolicyPath(:,:,:,:,:,tt); % fastOLG: so (a,j)-by-z-by-e - - % Get t-1 PricePath and ParamPath before we update them - if use_tminus1price==1 - for pp=1:length(tminus1priceNames) - if tt>1 - Parameters.([tminus1priceNames{pp},'_tminus1'])=Parameters.(tminus1priceNames{pp}); - else - Parameters.([tminus1priceNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1priceNames{pp}); - end - end - end - if use_tminus1params==1 - for pp=1:length(tminus1paramNames) - if tt>1 - Parameters.([tminus1paramNames{pp},'_tminus1'])=Parameters.(tminus1paramNames{pp}); - else - Parameters.([tminus1paramNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1paramNames{pp}); - end - end - end - % Get t-1 AggVars before we update them - if use_tminus1AggVars==1 - for pp=1:length(tminus1AggVarsNames) - if tt>1 - % The AggVars have not yet been updated, so they still contain previous period values - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=Parameters.(tminus1AggVarsNames{pp}); - else - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1AggVarsNames{pp}); - end - end - end - - % Update current PricePath and ParamPath - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(tt,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(tt,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - % Get t+1 PricePath - if use_tplus1price==1 - for pp=1:length(tplus1priceNames) - kk=tplus1pricePathkk(pp); - Parameters.([tplus1priceNames{pp},'_tplus1'])=PricePathOld(tt+1,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); % Make is so that the time t+1 variables can be used - end - end - - if transpathoptions.zpathtrivial==0 - z_gridvals_J=transpathoptions.z_gridvals_J_T(:,:,:,tt); - pi_z_J_sim=transpathoptions.pi_z_J_sim_T(:,:,:,tt); - end - if transpathoptions.epathtrivial==0 - e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,:,tt); - pi_e_J_sim=transpathoptions.pi_e_J_sim_T(:,:,tt); % (a,j,z)-by-e - end - - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights_T(:,:,tt),PolicyPath(1,:,:,:,:,tt), PolicyPath_aprimefine(:,:,:,:,:,tt), FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_ze,N_a,N_ze,d_gridvals,aprimefine_gridvals,a_gridvals,ze_gridvals_J,1); - for ii=1:length(AggVarNames) - Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; - end - - % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) - [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); - PricePathNew(tt,:)=PricePathNew_tt; - GEcondnPath(tt,:)=GEcondnPath_tt; - - % Sometimes, want to keep the AggVars to plot them - if transpathoptions.graphaggvarspath==1 - for ii=1:length(AggVarNames) - AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; - end - end - - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - % simoptions.fastOLG=1 is hardcoded - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_e_raw(AgentDist,PolicyPath_aprime(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); - end - - - %% Now update prices, give verbose feedback, and check for convergence - - % See how far apart the price paths are - PricePathDist=max(abs(reshape(PricePathNew(1:T-1,:)-PricePathOld(1:T-1,:),[numel(PricePathOld(1:T-1,:)),1]))); - % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges - - if transpathoptions.verbose==1 - pathcounter - disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) - pathnametitles{:} - [PricePathOld,PricePathNew] - end - - % Create plots of the transition path (before we update pricepath) - createTPathFeedbackPlots(PricePathNames,AggVarNames,GEeqnNames,PricePathOld,AggVarsPath,GEcondnPath,transpathoptions); - - % Set price path to be 9/10ths the old path and 1/10th the new path (but making sure to leave prices in periods 1 & T unchanged). - if transpathoptions.weightscheme==0 - PricePathOld=PricePathNew; % The update weights are already in GEnewprice setup - elseif transpathoptions.weightscheme==1 % Just a constant weighting - PricePathOld(1:T-1,:)=transpathoptions.oldpathweight*PricePathOld(1:T-1,:)+(1-transpathoptions.oldpathweight)*PricePathNew(1:T-1,:); - elseif transpathoptions.weightscheme==2 % A exponentially decreasing weighting on new path from (1-oldpathweight) in first period, down to 0.1*(1-oldpathweight) in T-1 period. - Ttheta=transpathoptions.Ttheta; - PricePathOld(1:Ttheta,:)=transpathoptions.oldpathweight*PricePathOld(1:Ttheta,:)+(1-transpathoptions.oldpathweight)*PricePathNew(1:Ttheta,:); - PricePathOld(Ttheta:T-1,:)=((transpathoptions.oldpathweight+(1-exp(linspace(0,log(0.2),T-Ttheta)))*(1-transpathoptions.oldpathweight))'*ones(1,l_p)).*PricePathOld(Ttheta:T-1,:)+((exp(linspace(0,log(0.2),T-Ttheta)).*(1-transpathoptions.oldpathweight))'*ones(1,l_p)).*PricePathNew(Ttheta:T-1,:); - elseif transpathoptions.weightscheme==3 % A gradually opening window. - if (pathcounter*3)transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - - PolicyPath=zeros(2,N_a,N_j,N_z,T-1,'gpuArray'); %Periods 1 to T-1 - - %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. - % Since we won't need to keep the value functions for anything later we just store the current one in V - V=V_final; - for ttr=1:T-1 %so tt=T-ttr - - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(T-ttr,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(T-ttr,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - if transpathoptions.zpathtrivial==0 - z_gridvals_J=transpathoptions.z_gridvals_J_T(:,:,:,T-ttr); - pi_z_J=transpathoptions.pi_z_J_T(:,:,:,T-ttr); % fastOLG value function uses (j,z',z) - end - - [V, Policy]=ValueFnIter_FHorz_TPath_SingleStep_fastOLG(V,0,n_a,n_z,N_j,[], a_grid, z_gridvals_J, pi_z_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); - % The V input is next period value fn, the V output is this period. - % Policy in fastOLG is [N_a,N_j,N_z] and contains the joint-index for (d,aprime) - - PolicyPath(:,:,:,:,T-ttr)=Policy; % fastOLG: so a-by-j-by-z - - end - - - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path - - PolicyPath_aprimefine=(n2short+1)*(PolicyPath(1,:,:,:,:)-1)+PolicyPath(2,:,:,:,:); - PolicyPath_aprime(:,1,:)=reshape(PolicyPath(1,:,1:end-1,:,:),[N_a*(N_j-1)*N_z,1,T-1]); % lower grid point index - PolicyPath_aprime(:,2,:)=PolicyPath_aprime(:,1,:)+1; % upper grid point index - PolicyProbsPath(:,2,:)=reshape((PolicyPath(2,:,1:end-1,:,:)-1)/n2short,[N_a*(N_j-1)*N_z,1,T-1]); % prob of upper grid point - PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % prob of lower grid point - - % Call AgentDist the current periods distn - AgentDist=AgentDist_initial; - for tt=1:T-1 - - % Get the current optimal policy (not needed, only use PolicyPath_parimefine, PolicyPath_aprime, and PolicyProbPath) - % Policy=PolicyPath(:,:,:,:,tt); % fastOLG: so a-by-j-by-z - - % Get t-1 PricePath and ParamPath before we update them - if use_tminus1price==1 - for pp=1:length(tminus1priceNames) - if tt>1 - Parameters.([tminus1priceNames{pp},'_tminus1'])=Parameters.(tminus1priceNames{pp}); - else - Parameters.([tminus1priceNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1priceNames{pp}); - end - end - end - if use_tminus1params==1 - for pp=1:length(tminus1paramNames) - if tt>1 - Parameters.([tminus1paramNames{pp},'_tminus1'])=Parameters.(tminus1paramNames{pp}); - else - Parameters.([tminus1paramNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1paramNames{pp}); - end - end - end - % Get t-1 AggVars before we update them - if use_tminus1AggVars==1 - for pp=1:length(tminus1AggVarsNames) - if tt>1 - % The AggVars have not yet been updated, so they still contain previous period values - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=Parameters.(tminus1AggVarsNames{pp}); - else - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1AggVarsNames{pp}); - end - end - end - - % Update current PricePath and ParamPath - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(tt,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(tt,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - % Get t+1 PricePath - if use_tplus1price==1 - for pp=1:length(tplus1priceNames) - kk=tplus1pricePathkk(pp); - Parameters.([tplus1priceNames{pp},'_tplus1'])=PricePathOld(tt+1,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); % Make is so that the time t+1 variables can be used - end - end - - if transpathoptions.zpathtrivial==0 - z_gridvals_J=transpathoptions.z_gridvals_J_T(:,:,:,tt); - pi_z_J_sim=transpathoptions.pi_z_J_sim_T(:,:,:,tt); % fastOLG value function uses (j,z,z') - end - - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights_T(:,tt),[], PolicyPath_aprimefine(:,:,:,:,tt), FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,0,l_a,l_a,l_z,N_a,N_z,[],aprimefine_gridvals,a_gridvals,z_gridvals_J,1); - for ii=1:length(AggVarNames) - Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; - end - - % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) - [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); - PricePathNew(tt,:)=PricePathNew_tt; - GEcondnPath(tt,:)=GEcondnPath_tt; - - % Sometimes, want to keep the AggVars to plot them - if transpathoptions.graphaggvarspath==1 - for ii=1:length(AggVarNames) - AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; - end - end - - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - % simoptions.fastOLG=1 is hardcoded - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_raw(AgentDist,PolicyPath_aprime(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_z,N_j,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % Policy for jj=1:N_j-1 - end - - - %% Now update prices, give verbose feedback, and check for convergence - - % See how far apart the price paths are - PricePathDist=max(abs(reshape(PricePathNew(1:T-1,:)-PricePathOld(1:T-1,:),[numel(PricePathOld(1:T-1,:)),1]))); - % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges - - if transpathoptions.verbose==1 - pathcounter - disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) - pathnametitles{:} - [PricePathOld,PricePathNew] - end - - % Create plots of the transition path (before we update pricepath) - createTPathFeedbackPlots(PricePathNames,AggVarNames,GEeqnNames,PricePathOld,AggVarsPath,GEcondnPath,transpathoptions); - - % Set price path to be 9/10ths the old path and 1/10th the new path (but making sure to leave prices in periods 1 & T unchanged). - if transpathoptions.weightscheme==0 - PricePathOld=PricePathNew; % The update weights are already in GEnewprice setup - elseif transpathoptions.weightscheme==1 % Just a constant weighting - PricePathOld(1:T-1,:)=transpathoptions.oldpathweight*PricePathOld(1:T-1,:)+(1-transpathoptions.oldpathweight)*PricePathNew(1:T-1,:); - elseif transpathoptions.weightscheme==2 % A exponentially decreasing weighting on new path from (1-oldpathweight) in first period, down to 0.1*(1-oldpathweight) in T-1 period. - Ttheta=transpathoptions.Ttheta; - PricePathOld(1:Ttheta,:)=transpathoptions.oldpathweight*PricePathOld(1:Ttheta,:)+(1-transpathoptions.oldpathweight)*PricePathNew(1:Ttheta,:); - PricePathOld(Ttheta:T-1,:)=((transpathoptions.oldpathweight+(1-exp(linspace(0,log(0.2),T-Ttheta)))*(1-transpathoptions.oldpathweight))'*ones(1,l_p)).*PricePathOld(Ttheta:T-1,:)+((exp(linspace(0,log(0.2),T-Ttheta)).*(1-transpathoptions.oldpathweight))'*ones(1,l_p)).*PricePathNew(Ttheta:T-1,:); - elseif transpathoptions.weightscheme==3 % A gradually opening window. - if (pathcounter*3)transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - - PolicyPath=zeros(2,N_a,N_j,N_z,N_e,T-1,'gpuArray'); %Periods 1 to T-1 - - %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. - % Since we won't need to keep the value functions for anything later we just store the current one in V - V=V_final; - for ttr=1:T-1 %so tt=T-ttr - - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(T-ttr,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(T-ttr,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - if transpathoptions.zpathtrivial==0 - pi_z_J=transpathoptions.pi_z_J_T(:,:,:,T-ttr); % fastOLG value function uses (j,z',z) - z_gridvals_J=transpathoptions.z_gridvals_J(:,:,T-ttr); - end - if transpathoptions.epathtrivial==0 - pi_e_J=transpathoptions.pi_e_J_T(:,1,:,T-ttr); - e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,:,T-ttr); - end - - [V, Policy]=ValueFnIter_FHorz_TPath_SingleStep_fastOLG_e(V,0,n_a,n_z,n_e,N_j,[], a_grid, z_gridvals_J, e_gridvals_J, pi_z_J, pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); - % The V input is next period value fn, the V output is this period. - % Policy in fastOLG is [N_a,N_j,N_z,N_e] and contains the joint-index for (d,aprime) - - PolicyPath(:,:,:,:,:,T-ttr)=Policy; % fastOLG: so a-by-j-by-z-by-e - - end - - - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path - - PolicyPath_aprimefine=(n2short+1)*(PolicyPath(1,:,:,:,:,:)-1)+PolicyPath(2,:,:,:,:,:); - PolicyPath_aprime(:,1,:)=reshape(PolicyPath(1,:,1:end-1,:,:,:),[N_a*(N_j-1)*N_z*N_e,1,T-1]); % lower grid point index - PolicyPath_aprime(:,2,:)=PolicyPath_aprime(:,1,:)+1; % upper grid point index - PolicyProbsPath(:,2,:)=reshape((PolicyPath(2,:,1:end-1,:,:,:)-1)/n2short,[N_a*(N_j-1)*N_z*N_e,1,T-1]); % prob of upper grid point - PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % prob of lower grid point - - % Call AgentDist the current periods distn - AgentDist=AgentDist_initial; - for tt=1:T-1 - - % Get the current optimal policy (not needed, only use PolicyPath_parimefine, PolicyPath_aprime, and PolicyProbPath) - % Policy=PolicyPath(:,:,:,:,:,tt); % fastOLG: so (a,j)-by-z-by-e - - % Get t-1 PricePath and ParamPath before we update them - if use_tminus1price==1 - for pp=1:length(tminus1priceNames) - if tt>1 - Parameters.([tminus1priceNames{pp},'_tminus1'])=Parameters.(tminus1priceNames{pp}); - else - Parameters.([tminus1priceNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1priceNames{pp}); - end - end - end - if use_tminus1params==1 - for pp=1:length(tminus1paramNames) - if tt>1 - Parameters.([tminus1paramNames{pp},'_tminus1'])=Parameters.(tminus1paramNames{pp}); - else - Parameters.([tminus1paramNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1paramNames{pp}); - end - end - end - % Get t-1 AggVars before we update them - if use_tminus1AggVars==1 - for pp=1:length(tminus1AggVarsNames) - if tt>1 - % The AggVars have not yet been updated, so they still contain previous period values - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=Parameters.(tminus1AggVarsNames{pp}); - else - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1AggVarsNames{pp}); - end - end - end - - % Update current PricePath and ParamPath - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(tt,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(tt,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - % Get t+1 PricePath - if use_tplus1price==1 - for pp=1:length(tplus1priceNames) - kk=tplus1pricePathkk(pp); - Parameters.([tplus1priceNames{pp},'_tplus1'])=PricePathOld(tt+1,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); % Make is so that the time t+1 variables can be used - end - end - - if transpathoptions.zpathtrivial==0 - z_gridvals_J=transpathoptions.z_gridvals_J_T(:,:,:,tt); - pi_z_J_sim=transpathoptions.pi_z_J_sim_T(:,:,:,tt); - end - if transpathoptions.epathtrivial==0 - e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,:,tt); - pi_e_J_sim=transpathoptions.pi_e_J_sim_T(:,:,tt); % (a,j,z)-by-e - end - - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights_T(:,:,tt),[], PolicyPath_aprimefine(:,:,:,:,:,tt), FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,0,l_a,l_a,l_ze,N_a,N_ze,[],aprimefine_gridvals,a_gridvals,ze_gridvals_J,1); - for ii=1:length(AggVarNames) - Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; - end - - % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) - [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); - PricePathNew(tt,:)=PricePathNew_tt; - GEcondnPath(tt,:)=GEcondnPath_tt; - - % Sometimes, want to keep the AggVars to plot them - if transpathoptions.graphaggvarspath==1 - for ii=1:length(AggVarNames) - AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; - end - end - - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - % simoptions.fastOLG=1 is hardcoded - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_e_raw(AgentDist,PolicyPath_aprime(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); - end - - - %% Now update prices, give verbose feedback, and check for convergence - - % See how far apart the price paths are - PricePathDist=max(abs(reshape(PricePathNew(1:T-1,:)-PricePathOld(1:T-1,:),[numel(PricePathOld(1:T-1,:)),1]))); - % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges - - if transpathoptions.verbose==1 - pathcounter - disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) - pathnametitles{:} - [PricePathOld,PricePathNew] - end - - % Create plots of the transition path (before we update pricepath) - createTPathFeedbackPlots(PricePathNames,AggVarNames,GEeqnNames,PricePathOld,AggVarsPath,GEcondnPath,transpathoptions); - - % Set price path to be 9/10ths the old path and 1/10th the new path (but making sure to leave prices in periods 1 & T unchanged). - if transpathoptions.weightscheme==0 - PricePathOld=PricePathNew; % The update weights are already in GEnewprice setup - elseif transpathoptions.weightscheme==1 % Just a constant weighting - PricePathOld(1:T-1,:)=transpathoptions.oldpathweight*PricePathOld(1:T-1,:)+(1-transpathoptions.oldpathweight)*PricePathNew(1:T-1,:); - elseif transpathoptions.weightscheme==2 % A exponentially decreasing weighting on new path from (1-oldpathweight) in first period, down to 0.1*(1-oldpathweight) in T-1 period. - Ttheta=transpathoptions.Ttheta; - PricePathOld(1:Ttheta,:)=transpathoptions.oldpathweight*PricePathOld(1:Ttheta,:)+(1-transpathoptions.oldpathweight)*PricePathNew(1:Ttheta,:); - PricePathOld(Ttheta:T-1,:)=((transpathoptions.oldpathweight+(1-exp(linspace(0,log(0.2),T-Ttheta)))*(1-transpathoptions.oldpathweight))'*ones(1,l_p)).*PricePathOld(Ttheta:T-1,:)+((exp(linspace(0,log(0.2),T-Ttheta)).*(1-transpathoptions.oldpathweight))'*ones(1,l_p)).*PricePathNew(Ttheta:T-1,:); - elseif transpathoptions.weightscheme==3 % A gradually opening window. - if (pathcounter*3)transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - - PolicyPath=zeros(2,N_a,N_j,T-1,'gpuArray'); %Periods 1 to T-1 - - %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. - % Since we won't need to keep the value functions for anything later we just store the current one in V - V=V_final; - for ttr=1:T-1 % so tt=T-ttr - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(T-ttr,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(T-ttr,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - [V, Policy]=ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz(V,0,n_a,N_j,[], a_grid, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); - % The V input is next period value fn, the V output is this period. - % Policy is kept in the form where it is just a single-value in (d,a') - - PolicyPath(:,:,:,T-ttr)=Policy; - end - - - - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path - - PolicyPath_aprimefine=(n2short+1)*(PolicyPath(1,:,:,:)-1)+PolicyPath(2,:,:,:); - PolicyPath_aprime(:,1,:)=reshape(PolicyPath(1,:,1:end-1,:),[N_a*(N_j-1),1,T-1]); % lower grid point index - PolicyPath_aprime(:,2,:)=PolicyPath_aprime(:,1,:)+1; % upper grid point index - PolicyProbsPath(:,2,:)=reshape((PolicyPath(2,:,1:end-1,:)-1)/n2short,[N_a*(N_j-1),1,T-1]); % prob of upper grid point - PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % prob of lower grid point - - % Call AgentDist the current periods distn - AgentDist=AgentDist_initial; - for tt=1:T-1 - - % Get the current optimal policy (not needed, only use PolicyPath_parimefine, PolicyPath_aprime, and PolicyProbPath) - % Policy=PolicyPath(:,:,:,tt); - - % Get t-1 PricePath and ParamPath before we update them - if use_tminus1price==1 - for pp=1:length(tminus1priceNames) - if tt>1 - Parameters.([tminus1priceNames{pp},'_tminus1'])=Parameters.(tminus1priceNames{pp}); - else - Parameters.([tminus1priceNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1priceNames{pp}); - end - end - end - if use_tminus1params==1 - for pp=1:length(tminus1paramNames) - if tt>1 - Parameters.([tminus1paramNames{pp},'_tminus1'])=Parameters.(tminus1paramNames{pp}); - else - Parameters.([tminus1paramNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1paramNames{pp}); - end - end - end - % Get t-1 AggVars before we update them - if use_tminus1AggVars==1 - for pp=1:length(tminus1AggVarsNames) - if tt>1 - % The AggVars have not yet been updated, so they still contain previous period values - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=Parameters.(tminus1AggVarsNames{pp}); - else - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1AggVarsNames{pp}); - end - end - end - - % Update current PricePath and ParamPath - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(tt,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(tt,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - % Get t+1 PricePath - if use_tplus1price==1 - for pp=1:length(tplus1priceNames) - kk=tplus1pricePathkk(pp); - Parameters.([tplus1priceNames{pp},'_tplus1'])=PricePathOld(tt+1,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); % Make is so that the time t+1 variables can be used - end - end - - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz(AgentDist.*AgeWeights_T(:,tt),[], PolicyPath_aprimefine(:,:,:,tt), FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,0,l_a,l_a,N_a,[],aprimefine_gridvals,a_gridvals,1); - for ii=1:length(AggVarNames) - Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; - end - - % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) - [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); - PricePathNew(tt,:)=PricePathNew_tt; - GEcondnPath(tt,:)=GEcondnPath_tt; - - % Sometimes, want to keep the AggVars to plot them - if transpathoptions.graphaggvarspath==1 - for ii=1:length(AggVarNames) - AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; - end - end - - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - % simoptions.fastOLG=1 is hardcoded - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_noz_raw(AgentDist,PolicyPath_aprime(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_j,jequalOneDist); - end - - - %% Now update prices, give verbose feedback, and check for convergence - - % See how far apart the price paths are - PricePathDist=max(abs(reshape(PricePathNew(1:T-1,:)-PricePathOld(1:T-1,:),[numel(PricePathOld(1:T-1,:)),1]))); - % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges - - if transpathoptions.verbose==1 - pathcounter - disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) - pathnametitles{:} - [PricePathOld,PricePathNew] - end - - % Create plots of the transition path (before we update pricepath) - createTPathFeedbackPlots(PricePathNames,AggVarNames,GEeqnNames,PricePathOld,AggVarsPath,GEcondnPath,transpathoptions); - - % Set price path to be 9/10ths the old path and 1/10th the new path (but making sure to leave prices in periods 1 & T unchanged). - if transpathoptions.weightscheme==0 - PricePathOld=PricePathNew; % The update weights are already in GEnewprice setup - elseif transpathoptions.weightscheme==1 % Just a constant weighting - PricePathOld(1:T-1,:)=transpathoptions.oldpathweight*PricePathOld(1:T-1,:)+(1-transpathoptions.oldpathweight)*PricePathNew(1:T-1,:); - elseif transpathoptions.weightscheme==2 % A exponentially decreasing weighting on new path from (1-oldpathweight) in first period, down to 0.1*(1-oldpathweight) in T-1 period. - Ttheta=transpathoptions.Ttheta; - PricePathOld(1:Ttheta,:)=transpathoptions.oldpathweight*PricePathOld(1:Ttheta,:)+(1-transpathoptions.oldpathweight)*PricePathNew(1:Ttheta,:); - PricePathOld(Ttheta:T-1,:)=((transpathoptions.oldpathweight+(1-exp(linspace(0,log(0.2),T-Ttheta)))*(1-transpathoptions.oldpathweight))'*ones(1,l_p)).*PricePathOld(Ttheta:T-1,:)+((exp(linspace(0,log(0.2),T-Ttheta)).*(1-transpathoptions.oldpathweight))'*ones(1,l_p)).*PricePathNew(Ttheta:T-1,:); - elseif transpathoptions.weightscheme==3 % A gradually opening window. - if (pathcounter*3)transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - - PolicyPath=zeros(2,N_a,N_j,N_e,T-1,'gpuArray'); %Periods 1 to T-1 - - %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. - % Since we won't need to keep the value functions for anything later we just store the current one in V - V=V_final; - for ttr=1:T-1 %so tt=T-ttr - - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(T-ttr,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(T-ttr,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - if transpathoptions.zpathtrivial==0 - e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,T-ttr); - pi_e_J=transpathoptions.pi_e_J_T(:,:,T-ttr); % fastOLG value function uses (j,z',z) - end - - [V, Policy]=ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e(V,0,n_a,n_e,N_j,[], a_grid, e_gridvals_J, pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); - % The V input is next period value fn, the V output is this period. - % Policy in fastOLG is [N_a,N_j,N_e] and contains the joint-index for (d,aprime) - - PolicyPath(:,:,:,:,T-ttr)=Policy; % fastOLG: so a-by-j-by-z - - end - - - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path - - PolicyPath_aprimefine=(n2short+1)*(PolicyPath(1,:,:,:,:)-1)+PolicyPath(2,:,:,:,:); - PolicyPath_aprime(:,1,:)=reshape(PolicyPath(1,:,1:end-1,:,:),[N_a*(N_j-1)*N_e,1,T-1]); % lower grid point index - PolicyPath_aprime(:,2,:)=PolicyPath_aprime(:,1,:)+1; % upper grid point index - PolicyProbsPath(:,2,:)=reshape((PolicyPath(2,:,1:end-1,:,:)-1)/n2short,[N_a*(N_j-1)*N_e,1,T-1]); % prob of upper grid point - PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % prob of lower grid point - - % Call AgentDist the current periods distn - AgentDist=AgentDist_initial; - for tt=1:T-1 - - % Get the current optimal policy (not needed, only use PolicyPath_parimefine, PolicyPath_aprime, and PolicyProbPath) - % Policy=PolicyPath(:,:,:,:,tt); % fastOLG: so a-by-j-by-z - - % Get t-1 PricePath and ParamPath before we update them - if use_tminus1price==1 - for pp=1:length(tminus1priceNames) - if tt>1 - Parameters.([tminus1priceNames{pp},'_tminus1'])=Parameters.(tminus1priceNames{pp}); - else - Parameters.([tminus1priceNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1priceNames{pp}); - end - end - end - if use_tminus1params==1 - for pp=1:length(tminus1paramNames) - if tt>1 - Parameters.([tminus1paramNames{pp},'_tminus1'])=Parameters.(tminus1paramNames{pp}); - else - Parameters.([tminus1paramNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1paramNames{pp}); - end - end - end - % Get t-1 AggVars before we update them - if use_tminus1AggVars==1 - for pp=1:length(tminus1AggVarsNames) - if tt>1 - % The AggVars have not yet been updated, so they still contain previous period values - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=Parameters.(tminus1AggVarsNames{pp}); - else - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1AggVarsNames{pp}); - end - end - end - - % Update current PricePath and ParamPath - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(tt,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(tt,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - % Get t+1 PricePath - if use_tplus1price==1 - for pp=1:length(tplus1priceNames) - kk=tplus1pricePathkk(pp); - Parameters.([tplus1priceNames{pp},'_tplus1'])=PricePathOld(tt+1,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); % Make is so that the time t+1 variables can be used - end - end - - if transpathoptions.zpathtrivial==0 - e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,tt); - pi_e_J_sim=transpathoptions.pi_e_J_sim_T(:,:,tt); % fastOLG value function uses (j,z,z') - end - - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights_T(:,:,tt),[], PolicyPath_aprimefine(:,:,:,:,tt), FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,0,l_a,l_a,l_e,N_a,N_e,[],aprimefine_gridvals,a_gridvals,e_gridvals_J,1); - for ii=1:length(AggVarNames) - Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; - end - - % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) - [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); - PricePathNew(tt,:)=PricePathNew_tt; - GEcondnPath(tt,:)=GEcondnPath_tt; - - % Sometimes, want to keep the AggVars to plot them - if transpathoptions.graphaggvarspath==1 - for ii=1:length(AggVarNames) - AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; - end - end - - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - % if simoptions.fastOLG=1 is hardcoded - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_noz_e_raw(AgentDist,PolicyPath_aprime(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_e,N_j,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % Policy for jj=1:N_j-1 - end - - - %% Now update prices, give verbose feedback, and check for convergence - - % See how far apart the price paths are - PricePathDist=max(abs(reshape(PricePathNew(1:T-1,:)-PricePathOld(1:T-1,:),[numel(PricePathOld(1:T-1,:)),1]))); - % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges - - if transpathoptions.verbose==1 - pathcounter - disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) - pathnametitles{:} - [PricePathOld,PricePathNew] - end - - % Create plots of the transition path (before we update pricepath) - createTPathFeedbackPlots(PricePathNames,AggVarNames,GEeqnNames,PricePathOld,AggVarsPath,GEcondnPath,transpathoptions); - - % Set price path to be 9/10ths the old path and 1/10th the new path (but making sure to leave prices in periods 1 & T unchanged). - if transpathoptions.weightscheme==0 - PricePathOld=PricePathNew; % The update weights are already in GEnewprice setup - elseif transpathoptions.weightscheme==1 % Just a constant weighting - PricePathOld(1:T-1,:)=transpathoptions.oldpathweight*PricePathOld(1:T-1,:)+(1-transpathoptions.oldpathweight)*PricePathNew(1:T-1,:); - elseif transpathoptions.weightscheme==2 % A exponentially decreasing weighting on new path from (1-oldpathweight) in first period, down to 0.1*(1-oldpathweight) in T-1 period. - Ttheta=transpathoptions.Ttheta; - PricePathOld(1:Ttheta,:)=transpathoptions.oldpathweight*PricePathOld(1:Ttheta,:)+(1-transpathoptions.oldpathweight)*PricePathNew(1:Ttheta,:); - PricePathOld(Ttheta:T-1,:)=((transpathoptions.oldpathweight+(1-exp(linspace(0,log(0.2),T-Ttheta)))*(1-transpathoptions.oldpathweight))'*ones(1,l_p)).*PricePathOld(Ttheta:T-1,:)+((exp(linspace(0,log(0.2),T-Ttheta)).*(1-transpathoptions.oldpathweight))'*ones(1,l_p)).*PricePathNew(Ttheta:T-1,:); - elseif transpathoptions.weightscheme==3 % A gradually opening window. - if (pathcounter*3)transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - - PolicyPath=zeros(3,N_a,N_j,T-1,'gpuArray'); %Periods 1 to T-1 - - %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. - % Since we won't need to keep the value functions for anything later we just store the current one in V - V=V_final; - for ttr=1:T-1 % so tt=T-ttr - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(T-ttr,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(T-ttr,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - [V, Policy]=ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz(V,n_d,n_a,N_j,d_grid, a_grid, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); - % The V input is next period value fn, the V output is this period. - % Policy is kept in the form where it is just a single-value in (d,a') - - PolicyPath(:,:,:,T-ttr)=Policy; - end - - - - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path - - % PolicyPath_d=PolicyPath(1,:,:,:); - PolicyPath_aprimefine=(n2short+1)*(PolicyPath(2,:,:,:)-1)+PolicyPath(3,:,:,:); - PolicyPath_aprime(:,1,:)=reshape(PolicyPath(2,:,1:end-1,:),[N_a*(N_j-1),1,T-1]); % lower grid point index - PolicyPath_aprime(:,2,:)=PolicyPath_aprime(:,1,:)+1; % upper grid point index - PolicyProbsPath(:,2,:)=reshape((PolicyPath(3,:,1:end-1,:)-1)/n2short,[N_a*(N_j-1),1,T-1]); % prob of upper grid point - PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % prob of lower grid point - - % Call AgentDist the current periods distn - AgentDist=AgentDist_initial; - for tt=1:T-1 - - % Get the current optimal policy (not needed, only use PolicyPath_parimefine, PolicyPath_aprime, and PolicyProbPath) - % Policy=PolicyPath(:,:,:,tt); - - % Get t-1 PricePath and ParamPath before we update them - if use_tminus1price==1 - for pp=1:length(tminus1priceNames) - if tt>1 - Parameters.([tminus1priceNames{pp},'_tminus1'])=Parameters.(tminus1priceNames{pp}); - else - Parameters.([tminus1priceNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1priceNames{pp}); - end - end - end - if use_tminus1params==1 - for pp=1:length(tminus1paramNames) - if tt>1 - Parameters.([tminus1paramNames{pp},'_tminus1'])=Parameters.(tminus1paramNames{pp}); - else - Parameters.([tminus1paramNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1paramNames{pp}); - end - end - end - % Get t-1 AggVars before we update them - if use_tminus1AggVars==1 - for pp=1:length(tminus1AggVarsNames) - if tt>1 - % The AggVars have not yet been updated, so they still contain previous period values - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=Parameters.(tminus1AggVarsNames{pp}); - else - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1AggVarsNames{pp}); - end - end - end - - % Update current PricePath and ParamPath - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(tt,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(tt,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - % Get t+1 PricePath - if use_tplus1price==1 - for pp=1:length(tplus1priceNames) - kk=tplus1pricePathkk(pp); - Parameters.([tplus1priceNames{pp},'_tplus1'])=PricePathOld(tt+1,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); % Make is so that the time t+1 variables can be used - end - end - - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz(AgentDist.*AgeWeights_T(:,tt),PolicyPath(1,:,:,tt), PolicyPath_aprimefine(:,:,:,tt), FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,N_a,d_gridvals,aprimefine_gridvals,a_gridvals,1); - for ii=1:length(AggVarNames) - Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; - end - - % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) - [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); - PricePathNew(tt,:)=PricePathNew_tt; - GEcondnPath(tt,:)=GEcondnPath_tt; - - % Sometimes, want to keep the AggVars to plot them - if transpathoptions.graphaggvarspath==1 - for ii=1:length(AggVarNames) - AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; - end - end - - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - % simoptions.fastOLG=1 is hardcoded - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_noz_raw(AgentDist,PolicyPath_aprime(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_j,jequalOneDist); - end - - - %% Now update prices, give verbose feedback, and check for convergence - - % See how far apart the price paths are - PricePathDist=max(abs(reshape(PricePathNew(1:T-1,:)-PricePathOld(1:T-1,:),[numel(PricePathOld(1:T-1,:)),1]))); - % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges - - if transpathoptions.verbose==1 - pathcounter - disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) - pathnametitles{:} - [PricePathOld,PricePathNew] - end - - % Create plots of the transition path (before we update pricepath) - createTPathFeedbackPlots(PricePathNames,AggVarNames,GEeqnNames,PricePathOld,AggVarsPath,GEcondnPath,transpathoptions); - - % Set price path to be 9/10ths the old path and 1/10th the new path (but making sure to leave prices in periods 1 & T unchanged). - if transpathoptions.weightscheme==0 - PricePathOld=PricePathNew; % The update weights are already in GEnewprice setup - elseif transpathoptions.weightscheme==1 % Just a constant weighting - PricePathOld(1:T-1,:)=transpathoptions.oldpathweight*PricePathOld(1:T-1,:)+(1-transpathoptions.oldpathweight)*PricePathNew(1:T-1,:); - elseif transpathoptions.weightscheme==2 % A exponentially decreasing weighting on new path from (1-oldpathweight) in first period, down to 0.1*(1-oldpathweight) in T-1 period. - Ttheta=transpathoptions.Ttheta; - PricePathOld(1:Ttheta,:)=transpathoptions.oldpathweight*PricePathOld(1:Ttheta,:)+(1-transpathoptions.oldpathweight)*PricePathNew(1:Ttheta,:); - PricePathOld(Ttheta:T-1,:)=((transpathoptions.oldpathweight+(1-exp(linspace(0,log(0.2),T-Ttheta)))*(1-transpathoptions.oldpathweight))'*ones(1,l_p)).*PricePathOld(Ttheta:T-1,:)+((exp(linspace(0,log(0.2),T-Ttheta)).*(1-transpathoptions.oldpathweight))'*ones(1,l_p)).*PricePathNew(Ttheta:T-1,:); - elseif transpathoptions.weightscheme==3 % A gradually opening window. - if (pathcounter*3)transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - - PolicyPath=zeros(3,N_a,N_j,N_e,T-1,'gpuArray'); %Periods 1 to T-1 - - %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. - % Since we won't need to keep the value functions for anything later we just store the current one in V - V=V_final; - for ttr=1:T-1 %so tt=T-ttr - - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(T-ttr,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(T-ttr,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - if transpathoptions.zpathtrivial==0 - e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,T-ttr); - pi_e_J=transpathoptions.pi_e_J_T(:,:,T-ttr); % fastOLG value function uses (j,z',z) - end - - [V, Policy]=ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e(V,n_d,n_a,n_e,N_j,d_grid, a_grid, e_gridvals_J, pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); - % The V input is next period value fn, the V output is this period. - % Policy in fastOLG is [N_a,N_j,N_e] and contains the joint-index for (d,aprime) - - PolicyPath(:,:,:,:,T-ttr)=Policy; % fastOLG: so a-by-j-by-z - - end - - - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path - - % PolicyPath_d=PolicyPath(1,:,:,:,:); - PolicyPath_aprimefine=(n2short+1)*(PolicyPath(2,:,:,:,:)-1)+PolicyPath(3,:,:,:,:); - PolicyPath_aprime(:,1,:)=reshape(PolicyPath(2,:,1:end-1,:,:),[N_a*(N_j-1)*N_e,1,T-1]); % lower grid point index - PolicyPath_aprime(:,2,:)=PolicyPath_aprime(:,1,:)+1; % upper grid point index - PolicyProbsPath(:,2,:)=reshape((PolicyPath(3,:,1:end-1,:,:)-1)/n2short,[N_a*(N_j-1)*N_e,1,T-1]); % prob of upper grid point - PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % prob of lower grid point - - % Call AgentDist the current periods distn - AgentDist=AgentDist_initial; - for tt=1:T-1 - - % Get the current optimal policy (not needed, only use PolicyPath_parimefine, PolicyPath_aprime, and PolicyProbPath) - % Policy=PolicyPath(:,:,:,:,tt); % fastOLG: so a-by-j-by-z - - % Get t-1 PricePath and ParamPath before we update them - if use_tminus1price==1 - for pp=1:length(tminus1priceNames) - if tt>1 - Parameters.([tminus1priceNames{pp},'_tminus1'])=Parameters.(tminus1priceNames{pp}); - else - Parameters.([tminus1priceNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1priceNames{pp}); - end - end - end - if use_tminus1params==1 - for pp=1:length(tminus1paramNames) - if tt>1 - Parameters.([tminus1paramNames{pp},'_tminus1'])=Parameters.(tminus1paramNames{pp}); - else - Parameters.([tminus1paramNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1paramNames{pp}); - end - end - end - % Get t-1 AggVars before we update them - if use_tminus1AggVars==1 - for pp=1:length(tminus1AggVarsNames) - if tt>1 - % The AggVars have not yet been updated, so they still contain previous period values - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=Parameters.(tminus1AggVarsNames{pp}); - else - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1AggVarsNames{pp}); - end - end - end - - % Update current PricePath and ParamPath - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(tt,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(tt,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - % Get t+1 PricePath - if use_tplus1price==1 - for pp=1:length(tplus1priceNames) - kk=tplus1pricePathkk(pp); - Parameters.([tplus1priceNames{pp},'_tplus1'])=PricePathOld(tt+1,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); % Make is so that the time t+1 variables can be used - end - end - - if transpathoptions.zpathtrivial==0 - e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,tt); - pi_e_J_sim=transpathoptions.pi_e_J_sim_T(:,:,tt); % fastOLG value function uses (j,z,z') - end - - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights_T(:,:,tt),PolicyPath(1,:,:,:,tt), PolicyPath_aprimefine(:,:,:,:,tt), FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_e,N_a,N_e,d_gridvals,aprimefine_gridvals,a_gridvals,e_gridvals_J,1); - for ii=1:length(AggVarNames) - Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; - end - - % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) - [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); - PricePathNew(tt,:)=PricePathNew_tt; - GEcondnPath(tt,:)=GEcondnPath_tt; - - % Sometimes, want to keep the AggVars to plot them - if transpathoptions.graphaggvarspath==1 - for ii=1:length(AggVarNames) - AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; - end - end - - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - % if simoptions.fastOLG=1 is hardcoded - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_noz_e_raw(AgentDist,PolicyPath_aprime(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_e,N_j,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % Policy for jj=1:N_j-1 - end - - - %% Now update prices, give verbose feedback, and check for convergence - - % See how far apart the price paths are - PricePathDist=max(abs(reshape(PricePathNew(1:T-1,:)-PricePathOld(1:T-1,:),[numel(PricePathOld(1:T-1,:)),1]))); - % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges - - if transpathoptions.verbose==1 - pathcounter - disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) - pathnametitles{:} - [PricePathOld,PricePathNew] - end - - % Create plots of the transition path (before we update pricepath) - createTPathFeedbackPlots(PricePathNames,AggVarNames,GEeqnNames,PricePathOld,AggVarsPath,GEcondnPath,transpathoptions); - - % Set price path to be 9/10ths the old path and 1/10th the new path (but making sure to leave prices in periods 1 & T unchanged). - if transpathoptions.weightscheme==0 - PricePathOld=PricePathNew; % The update weights are already in GEnewprice setup - elseif transpathoptions.weightscheme==1 % Just a constant weighting - PricePathOld(1:T-1,:)=transpathoptions.oldpathweight*PricePathOld(1:T-1,:)+(1-transpathoptions.oldpathweight)*PricePathNew(1:T-1,:); - elseif transpathoptions.weightscheme==2 % A exponentially decreasing weighting on new path from (1-oldpathweight) in first period, down to 0.1*(1-oldpathweight) in T-1 period. - Ttheta=transpathoptions.Ttheta; - PricePathOld(1:Ttheta,:)=transpathoptions.oldpathweight*PricePathOld(1:Ttheta,:)+(1-transpathoptions.oldpathweight)*PricePathNew(1:Ttheta,:); - PricePathOld(Ttheta:T-1,:)=((transpathoptions.oldpathweight+(1-exp(linspace(0,log(0.2),T-Ttheta)))*(1-transpathoptions.oldpathweight))'*ones(1,l_p)).*PricePathOld(Ttheta:T-1,:)+((exp(linspace(0,log(0.2),T-Ttheta)).*(1-transpathoptions.oldpathweight))'*ones(1,l_p)).*PricePathNew(Ttheta:T-1,:); - elseif transpathoptions.weightscheme==3 % A gradually opening window. - if (pathcounter*3)0); % GPU where available, otherwise parallel CPU. transpathoptions.GEnewprice=1; % 1 is shooting algorithm, 0 is that the GE should evaluate to zero and the 'new' is the old plus the "non-zero" (for each time period seperately); % 2 is to do optimization routine with 'distance between old and new path', 3 is just same as 0, but easier to set up - transpathoptions.oldpathweight=0.9; % default =0.9 - transpathoptions.weightscheme=1; % default =1 - transpathoptions.Ttheta=1; transpathoptions.maxiter=1000; % Based on personal experience anything that hasn't converged well before this is just hung-up on trying to get the 4th decimal place (typically because the number of grid points was not large enough to allow this level of accuracy). + % Feedback options transpathoptions.verbose=0; transpathoptions.graphpricepath=0; % 1: creates a graph of the 'current' price path which updates each iteration. transpathoptions.graphaggvarspath=0; % 1: creates a graph of the 'current' aggregate variables which updates each iteration. transpathoptions.graphGEcondns=0; % 1: creates a graph of the 'current' general eqm conditions which updates each iteration. transpathoptions.historyofpricepath=0; - transpathoptions.fastOLG=0; % fastOLG is done as (a,j,z), rather than standard (a,z,j) + % Update rule options + transpathoptions.oldpathweight=0.9; % default =0.9 + transpathoptions.weightscheme=1; % default =1 + transpathoptions.Ttheta=1; % transpathoptions.updateageweights % Don't declare if not being used else - %Check transpathoptions for missing fields, if there are some fill them with the defaults + % Check transpathoptions for missing fields, if there are some fill them with the defaults + if ~isfield(transpathoptions,'fastOLG') + transpathoptions.fastOLG=0; % fastOLG is done as (a,j,z), rather than standard (a,z,j) + end if ~isfield(transpathoptions,'tolerance') transpathoptions.tolerance=10^(-4); end if ~isfield(transpathoptions,'parallel') - transpathoptions.parallel=1+(gpuDeviceCount>0); + transpathoptions.parallel=1+(gpuDeviceCount>0); % GPU where available end if ~isfield(transpathoptions,'GEnewprice') transpathoptions.GEnewprice=1; % 0 is that the GE should evaluate to zero and the 'new' is the old plus the "non-zero" (for each time period seperately); @@ -46,21 +50,10 @@ % 2 is to do optimization routine with 'distance between old and new path' % 3 is just same as 0, but easier to set end - if ~isfield(transpathoptions,'oldpathweight') - transpathoptions.oldpathweight=0.9; - % Note that when using transpathoptions.GEnewprice==3 - % Implicitly it is setting transpathoptions.oldpathweight=0 - % because the user anyway has to specify them as part of setup - end - if ~isfield(transpathoptions,'weightscheme') - transpathoptions.weightscheme=1; - end - if ~isfield(transpathoptions,'Ttheta') - transpathoptions.Ttheta=1; - end if ~isfield(transpathoptions,'maxiter') transpathoptions.maxiter=1000; end + % Feedback options if ~isfield(transpathoptions,'verbose') transpathoptions.verbose=0; end @@ -76,11 +69,22 @@ if ~isfield(transpathoptions,'historyofpricepath') transpathoptions.historyofpricepath=0; end - if ~isfield(transpathoptions,'fastOLG') - transpathoptions.fastOLG=0; % fastOLG is done as (a,j,z), rather than standard (a,z,j) + % Update rule optoins + if ~isfield(transpathoptions,'oldpathweight') + transpathoptions.oldpathweight=0.9; + % Note that when using transpathoptions.GEnewprice==3 + % Implicitly it is setting transpathoptions.oldpathweight=0 + % because the user anyway has to specify them as part of setup + end + if ~isfield(transpathoptions,'weightscheme') + transpathoptions.weightscheme=1; + end + if ~isfield(transpathoptions,'Ttheta') + transpathoptions.Ttheta=1; end - % transpathoptions.updateageweights %Don't declare if not being used + % transpathoptions.updateageweights % Don't declare if not being used end +transpathoptions.parallel=2; % transition path is GPU only %% Check which vfoptions have been used, set all others to defaults @@ -89,15 +93,13 @@ %If vfoptions is not given, just use all the defaults vfoptions.divideandconquer=0; vfoptions.gridinterplayer=0; - vfoptions.parallel=transpathoptions.parallel; - vfoptions.verbose=0; vfoptions.lowmemory=0; + % Feedback options + vfoptions.verbose=0; + % Model setup vfoptions.exoticpreferences='None'; - vfoptions.polindorval=1; - vfoptions.policy_forceintegertype=0; - vfoptions.endotype=0; else - %Check vfoptions for missing fields, if there are some fill them with the defaults + % Check vfoptions for missing fields, if there are some fill them with the defaults if ~isfield(vfoptions,'divideandconquer') vfoptions.divideandconquer=0; elseif vfoptions.divideandconquer==1 @@ -112,30 +114,20 @@ error('You have vfoptions.gridinterplayer, so must also set vfoptions.ngridinterp') end end - - if ~isfield(vfoptions,'parallel') - vfoptions.parallel=transpathoptions.parallel; % GPU where available, otherwise parallel CPU. - end if ~isfield(vfoptions,'lowmemory') vfoptions.lowmemory=0; end + % Feedback options if ~isfield(vfoptions,'verbose') vfoptions.verbose=0; end + % Model setup if ~isfield(vfoptions,'exoticpreferences') vfoptions.exoticpreferences='None'; end - if ~isfield(vfoptions,'polindorval') - vfoptions.polindorval=1; - end - if ~isfield(vfoptions,'policy_forceintegertype') - vfoptions.policy_forceintegertype=0; - end - if ~isfield(vfoptions,'endotype') - vfoptions.endotype=0; - end end -vfoptions.preEV=0; % =1 is used by 'Matched Expecations Path', for TPath we want =0 (this relates to details of fastOLG=1 value fn code) +vfoptions.parallel=2; % transition path is GPU only +vfoptions.EVpre=0; % =1 is used by 'Matched Expecations Path', for TPath we want =0 (this relates to details of fastOLG=1 value fn code) @@ -144,20 +136,20 @@ simoptions.fastOLG=1; end if exist('simoptions','var')==0 - simoptions.parallel=transpathoptions.parallel; % GPU where available, otherwise parallel CPU. simoptions.verbose=0; simoptions.fastOLG=1; + simoptions.gridinterplayer=0; else - %Check vfoptions for missing fields, if there are some fill them with the defaults - if ~isfield(simoptions,'parallel') - simoptions.parallel=transpathoptions.parallel; - end + % Check vfoptions for missing fields, if there are some fill them with the defaults if ~isfield(simoptions,'verbose') simoptions.verbose=0; end if ~isfield(simoptions,'fastOLG') simoptions.fastOLG=1; end + if ~isfield(simoptions,'gridinterplayer') + simoptions.gridinterplayer=0; + end end @@ -179,17 +171,6 @@ end end -%% -N_d=prod(n_d); -N_a=prod(n_a); -N_z=prod(n_z); -if isfield(vfoptions, 'n_e') - n_e=vfoptions.n_e; -else - n_e=0; -end -N_e=prod(n_e); - %% Make sure all the relevant inputs are GPU arrays (not standard arrays) pi_z=gpuArray(pi_z); d_grid=gpuArray(d_grid); @@ -201,40 +182,58 @@ AgentDist_initial=gather(AgentDist_initial); -%% Handle ReturnFn and FnsToEvaluate structures -l_d=length(n_d); +%% Check the sizes of some of the inputs +N_d=prod(n_d); +N_a=prod(n_a); +N_z=prod(n_z); +if isfield(vfoptions, 'n_e') + n_e=vfoptions.n_e; +else + n_e=0; +end +N_e=prod(n_e); + if N_d==0 l_d=0; +else + l_d=length(n_d); end l_a=length(n_a); l_aprime=l_a; -l_z=length(n_z); if N_z==0 l_z=0; -end -l_a_temp=l_a; -l_z_temp=l_z; -if max(vfoptions.endotype)==1 - l_a_temp=l_a-sum(vfoptions.endotype); - l_z_temp=l_z+sum(vfoptions.endotype); +else + l_z=length(n_z); end if N_e==0 l_e=0; else - l_e=length(vfoptions.n_e); + l_e=length(n_e); end - -% Create ReturnFnParamNames -temp=getAnonymousFnInputNames(ReturnFn); -if length(temp)>(l_d+l_a_temp+l_a_temp+l_z_temp) - ReturnFnParamNames={temp{l_d+l_aprime+l_a_temp+l_z_temp+l_e+1:end}}; % the first inputs will always be (d,aprime,a,z) +if N_z==0 + if N_e==0 + l_ze=0; + N_ze=0; + else + l_ze=l_e; + N_ze=N_e; + end else - ReturnFnParamNames={}; + if N_e==0 + l_ze=l_z; + N_ze=N_z; + else + l_ze=l_z+l_e; + N_ze=N_z*N_e; + end end +%% Implement new way of handling ReturnFn inputs +ReturnFnParamNames=ReturnFnParamNamesFn(ReturnFn,n_d,n_a,n_z,N_j,vfoptions,Parameters); + %% Set up exogenous shock processes -[z_gridvals_J, pi_z_J, pi_z_J_sim, e_gridvals_J, pi_e_J, pi_e_J_sim, transpathoptions, simoptions]=ExogShockSetup_TPath_FHorz(n_z,z_grid,pi_z,N_a,N_j,Parameters,PricePathNames,ParamPathNames,transpathoptions,simoptions,4); +[z_gridvals_J, pi_z_J, pi_z_J_sim, e_gridvals_J, pi_e_J, pi_e_J_sim, ze_gridvals_J_fastOLG, transpathoptions, simoptions]=ExogShockSetup_TPath_FHorz(n_z,z_grid,pi_z,N_a,N_j,Parameters,PricePathNames,ParamPathNames,transpathoptions,simoptions,4); % Convert z and e to age-dependent joint-grids and transtion matrix % output: z_gridvals_J, pi_z_J, e_gridvals_J, pi_e_J, transpathoptions,vfoptions,simoptions @@ -246,35 +245,8 @@ % and % transpathoptions.gridsinGE=1; % grids depend on a GE parameter and so need to be recomputed every iteration % =0; % grids are exogenous - - -l_ze=l_z+l_e; -if l_z>0 && l_e>0 - N_ze=N_z*N_e; - if transpathoptions.fastOLG==0 - ze_gridvals_J=[repmat(z_gridvals_J,N_e,1),repelem(e_gridvals_J,N_z,1)]; - elseif transpathoptions.fastOLG==1 - ze_gridvals_J=zeros(N_j,N_ze,l_ze,'gpuArray'); - ze_gridvals_J(:,:,1:l_z)=repmat(z_gridvals_J,1,N_e,1); - ze_gridvals_J(:,:,l_z+1:end)=repmat(squeeze(e_gridvals_J),1,N_z,1); - end -end - -if transpathoptions.fastOLG==0 - if N_z>0 && N_e>0 - ze_gridvals_J=permute(ze_gridvals_J,[3,1,2]); % [N_j,N_z,l_z] need this for fastOLG agent dist (it is not used for value fn, so can overwrite) - elseif N_z>0 - z_gridvals_J_fastOLG=permute(z_gridvals_J,[3,1,2]); % [N_j,N_z,l_z] need this for fastOLG agent dist, but need the standard still for the value fn without fastOLG - elseif N_e>0 - e_gridvals_J_fastOLG=permute(e_gridvals_J,[3,1,2]); % [N_j,N_e,l_e] need this for fastOLG agent dist, but need the standard still for the value fn without fastOLG - end -else - if N_z>0 && N_e==0 - z_gridvals_J_fastOLG=[]; - elseif N_z==0 && N_e>0 - e_gridvals_J_fastOLG=[]; - end -end +% +% transpathoptions.zepathtrivial=0 when either of zpathtrival and epathtrivial both are zero %% Setup for V_final @@ -397,7 +369,7 @@ AgeWeights_initial=sum(AgentDist_initial,1); % [1,N_j] if simoptions.fastOLG==1 AgentDist_initial=reshape(AgentDist_initial,[N_a,N_z,N_e,N_j]); - AgentDist_initial=permute(AgentDist_initial,[1,4,3,2]); + AgentDist_initial=permute(AgentDist_initial,[1,4,2,3]); AgentDist_initial=reshape(AgentDist_initial,[N_a*N_j*N_z,N_e]); end end @@ -445,29 +417,6 @@ end end -%% Some inputs needed for simoptions.fastOLG=1 that get precomputed -if simoptions.fastOLG==1 - if N_z==0 && N_e==0 - % No need to do anything - elseif N_z>0 && N_e==0 - % Precompute some things needed for fastOLG agent dist iteration - exceptlastj=kron(ones(1,(N_j-1)*N_z),1:1:N_a)+kron(kron(ones(1,N_z),N_a*(0:1:N_j-2)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_z-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist - exceptfirstj=kron(ones(1,(N_j-1)*N_z),1:1:N_a)+kron(kron(ones(1,N_z),N_a*(1:1:N_j-1)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_z-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist - justfirstj=repmat(1:1:N_a,1,N_z)+N_a*N_j*repelem(0:1:N_z-1,1,N_a); - elseif N_z==0 && N_e>0 - % Precompute some things needed for fastOLG agent dist iteration - exceptlastj=kron(ones(1,(N_j-1)*N_e),1:1:N_a)+kron(kron(ones(1,N_e),N_a*(0:1:N_j-2)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_e-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist - exceptfirstj=kron(ones(1,(N_j-1)*N_e),1:1:N_a)+kron(kron(ones(1,N_e),N_a*(1:1:N_j-1)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_e-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist - justfirstj=repmat(1:1:N_a,1,N_e)+N_a*N_j*repelem(0:1:N_e-1,1,N_a); - elseif N_z>0 && N_e>0 - % Precompute some things needed for fastOLG agent dist iteration - exceptlastj=kron(ones(1,(N_j-1)*N_z*N_e),1:1:N_a)+kron(kron(ones(1,N_z*N_e),N_a*(0:1:N_j-2)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_z*N_e-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist - exceptfirstj=kron(ones(1,(N_j-1)*N_z*N_e),1:1:N_a)+kron(kron(ones(1,N_z*N_e),N_a*(1:1:N_j-1)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_z*N_e-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist - justfirstj=repmat(1:1:N_a,1,N_z*N_e)+N_a*N_j*repelem(0:1:N_z*N_e-1,1,N_a); - end -end - - %% Check if jequalOneDistPath is a path or not (and reshape appropriately) jequalOneDist=gpuArray(jequalOneDist); @@ -511,6 +460,77 @@ end +%% Precompute some stuff for the AgentDist iterations +if simoptions.gridinterplayer==0 + N_probs=1; % not used +elseif simoptions.gridinterplayer==1 + N_probs=2; +end + +% But only bother with this when using fastOLG=1 +if transpathoptions.fastOLG==1 + if N_z==0 + if N_e==0 % no z, no e + if simoptions.gridinterplayer==0 + II1=1:1:N_a*(N_j-1); + II2=ones(N_a*(N_j-1),1); + exceptlastj=repmat((1:1:N_a)',N_j-1,1)+repelem(N_a*(0:1:N_j-2)',N_a,1); % Note: there is one use of N_j which is because we want to index AgentDist + elseif simoptions.gridinterplayer==1 + II=repelem((1:1:N_a*(N_j-1))',1,N_probs); + exceptlastj=[]; % not needed + end + else % no z, yes e + if simoptions.gridinterplayer==0 + II1=1:1:N_a*(N_j-1)*N_e; + II2=ones(N_a*(N_j-1)*N_e,1); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_e,1)+N_a*N_j*repelem((0:1:N_e-1)',N_a,1); + elseif simoptions.gridinterplayer==1 + II=repelem((1:1:N_a*(N_j-1)*N_e)',1,N_probs); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_e,1)+N_a*N_j*repelem((0:1:N_e-1)',N_a,1); + end + end + else % N_z>0 + if N_e==0 % z, no e + if simoptions.gridinterplayer==0 + II1=1:1:N_a*(N_j-1)*N_z; + II2=ones(N_a*(N_j-1)*N_z,1); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_z,1)+N_a*N_j*repelem((0:1:N_z-1)',N_a,1); + elseif simoptions.gridinterplayer==1 + II=repelem((1:1:N_a*(N_j-1)*N_z)',1,N_probs); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_z,1)+N_a*N_j*repelem((0:1:N_z-1)',N_a,1); + end + else % z and e + if simoptions.gridinterplayer==0 + II1=1:1:N_a*(N_j-1)*N_z*N_e; + II2=ones(N_a*(N_j-1)*N_z*N_e,1); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_z*N_e,1)+N_a*N_j*repelem((0:1:N_z*N_e-1)',N_a,1); + elseif simoptions.gridinterplayer==1 + II=repelem((1:1:N_a*(N_j-1)*N_z*N_e)',1,N_probs); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_z*N_e,1)+N_a*N_j*repelem((0:1:N_z*N_e-1)',N_a,1); + end + end + end + % To keep inputs simpler + if simoptions.gridinterplayer==0 + II1orII=II1; + elseif simoptions.gridinterplayer==1 + II1orII=II; + II2=[]; + end +end + %% Change to FnsToEvaluate as cell so that it is not being recomputed all the time l_daprime=l_d+l_a; @@ -528,16 +548,30 @@ % Change FnsToEvaluate out of structure form, but want to still create AggVars as a structure simoptions.outputasstructure=1; -%% Set up some things for the FnsToEvaluate with fastOLG -a_gridvals=CreateGridvals(n_a,a_grid,1); % a_grivdals is [N_a,l_a] -if N_d==0 - aprime_gridvals=a_gridvals; -else +%% Set up some things for the FnsToEvaluate +a_gridvals=CreateGridvals(n_a,a_grid,1); % a_gridvals is [N_a,l_a] +% with fastOLG also need d_gridvals and aprime_gridvals +if N_d>0 d_gridvals=CreateGridvals(n_d,d_grid,1); +end +if vfoptions.gridinterplayer==0 aprime_gridvals=a_gridvals; +elseif vfoptions.gridinterplayer==1 + % use fine grid for aprime_gridvals + if isscalar(n_a) + n_aprime=n_a+(n_a-1)*vfoptions.ngridinterp; + aprime_grid=interp1(gpuArray(1:1:N_a)',a_grid,gpuArray(linspace(1,N_a,n_aprime))'); + aprime_gridvals=CreateGridvals(n_aprime,aprime_grid,1); + else + a1_grid=a_grid(1:n_a(1)); + n_a1prime=n_a(1)+(n_a(1)-1)*vfoptions.ngridinterp; + n_aprime=[n_a1prime,n_a(2:end)]; + a1prime_grid=interp1(gpuArray(1:1:n_a(1))',a1_grid,gpuArray(linspace(1,n_a(1),n_a1prime))'); + aprime_grid=[a1prime_grid; a_grid(n_a(1)+1:end)]; + aprime_gridvals=CreateGridvals(n_aprime,aprime_grid,1); + end end - %% GE eqns, switch from structure to cell setup GEeqnNames=fieldnames(GeneralEqmEqns); nGeneralEqmEqns=length(GEeqnNames); @@ -667,7 +701,7 @@ end % Note: I used this approach (rather than just creating _tplus1 and _tminus1 for everything) as it will be same computation. -if transpathoptions.verbose>1 +if transpathoptions.verbose==2 use_tplus1price use_tminus1price use_tminus1params @@ -695,143 +729,69 @@ %% Shooting algorithm if transpathoptions.GEnewprice~=2 - if vfoptions.gridinterplayer==0 - if transpathoptions.fastOLG==0 - if vfoptions.divideandconquer==1 - error('Cannot yet use vfoptions.divideandconquer=1 with transpathoptions.fastOLG=0 (only implemented for fastOLG=1; tell me if you need this)') - end - if N_d==0 - if N_z==0 - if N_e==0 - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_nod_noz(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist ,n_a,N_j, N_a, l_a, aprime_gridvals,a_gridvals, a_grid, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - else - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_nod_noz_e(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_e,N_j, N_a,N_e, l_a,l_e, aprime_gridvals,a_gridvals,a_grid,e_gridvals_J,e_gridvals_J_fastOLG, pi_e_J,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - end + if transpathoptions.fastOLG==0 + if vfoptions.divideandconquer==1 + error('Cannot yet use vfoptions.divideandconquer=1 with transpathoptions.fastOLG=0 (only implemented for fastOLG=1; tell me if you need this)') + end + if vfoptions.gridinterplayer==1 + error('Cannot yet use vfoptions.gridinterplayer=1 with transpathoptions.fastOLG=0 (only implemented for fastOLG=1; tell me if you need this)') + end + if N_d==0 + if N_z==0 + if N_e==0 + [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_nod_noz(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,N_j, N_a, l_aprime,l_a ,a_gridvals,a_grid, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions); else - if N_e==0 - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_nod(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_z,N_j, N_a,N_z, l_a,l_z, aprime_gridvals,a_gridvals,a_grid,z_gridvals_J,z_gridvals_J_fastOLG, pi_z_J,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - else - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_nod_e(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_z,n_e,N_j, N_a,N_z,N_e,N_ze, l_a,l_z,l_e,l_ze, aprime_gridvals,a_gridvals,a_grid,z_gridvals_J,e_gridvals_J,ze_gridvals_J, pi_z_J,pi_e_J,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - end + [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_nod_noz_e(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_e,N_j, N_a,N_e, l_aprime,l_a,l_e, a_gridvals,a_grid,e_gridvals_J,ze_gridvals_J_fastOLG, pi_e_J,pi_e_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions); end - else % N_d>0 - if N_z==0 - if N_e==0 - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_noz(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d,n_a,N_j, N_d,N_a, l_d,l_a, d_gridvals,aprime_gridvals,a_gridvals, a_grid, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - else - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_noz_e(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d,n_a,n_e,N_j, N_d,N_a,N_e, l_d,l_a,l_e, d_gridvals,aprime_gridvals,a_gridvals,a_grid,e_gridvals_J,e_gridvals_J_fastOLG, pi_e_J,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - end + else + if N_e==0 + [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_nod(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_z,N_j, N_a,N_z, l_aprime,l_a,l_z, a_gridvals,a_grid,z_gridvals_J,ze_gridvals_J_fastOLG, pi_z_J,pi_z_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions); else - if N_e==0 - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d,n_a,n_z,N_j, N_d,N_a,N_z, l_d,l_a,l_z, d_gridvals,aprime_gridvals,a_gridvals,a_grid,z_gridvals_J,z_gridvals_J_fastOLG, pi_z_J,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - else - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_e(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d,n_a,n_z,n_e,N_j, N_d,N_a,N_z,N_e,N_ze, l_d,l_a,l_z,l_e,l_ze, d_gridvals,aprime_gridvals,a_gridvals,a_grid,z_gridvals_J,e_gridvals_J,ze_gridvals_J, pi_z_J,pi_e_J,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - end + [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_nod_e(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_z,n_e,N_j, N_a,N_z,N_e,N_ze, l_aprime,l_a,l_z,l_e,l_ze, a_gridvals,a_grid,z_gridvals_J,e_gridvals_J,ze_gridvals_J_fastOLG, pi_z_J,pi_e_J,pi_z_J_sim,pi_e_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions); end end - else % use fastOLG setting - if N_d==0 - if N_z==0 - if N_e==0 - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_nod_noz(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,N_j, N_a, l_a, aprime_gridvals,a_gridvals,a_grid, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - else - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_nod_noz_e(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_e,N_j, N_a,N_e, l_a,l_e, aprime_gridvals,a_gridvals,a_grid,e_gridvals_J, pi_e_J,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - end + else % N_d>0 + if N_z==0 + if N_e==0 + [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_noz(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d, n_a, N_j, N_d,N_a, l_d,l_aprime,l_a, d_gridvals,d_grid, a_gridvals,a_grid, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions); else - if N_e==0 - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_nod(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_z,N_j, N_a,N_z, l_a,l_z, aprime_gridvals,a_gridvals,a_grid,z_gridvals_J, pi_z_J,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - else % use fastOLG setting - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_nod_e(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_z,n_e,N_j, N_a,N_z,N_e,N_ze, l_a,l_z,l_e,l_ze, aprime_gridvals,a_gridvals,a_grid,z_gridvals_J,e_gridvals_J,ze_gridvals_J, pi_z_J, pi_e_J,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - end + [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_noz_e(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d,n_a,n_e,N_j, N_d,N_a,N_e, l_d,l_aprime,l_a,l_e, d_gridvals,d_grid, a_gridvals,a_grid,e_gridvals_J,ze_gridvals_J_fastOLG, pi_e_J,pi_e_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions); end - else % N_d>0 - if N_z==0 - if N_e==0 - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_noz(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d,n_a,N_j, N_d,N_a, l_d,l_a, d_gridvals,aprime_gridvals,a_gridvals,d_grid,a_grid, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - else - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_noz_e(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d,n_a,n_e,N_j, N_d,N_a,N_e, l_d,l_a,l_e, d_gridvals,aprime_gridvals,a_gridvals,d_grid,a_grid,e_gridvals_J, pi_e_J,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - end + else + if N_e==0 + [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d,n_a,n_z,N_j, N_d,N_a,N_z, l_d,l_aprime,l_a,l_z, d_gridvals,d_grid, a_gridvals,a_grid,z_gridvals_J,ze_gridvals_J_fastOLG, pi_z_J,pi_z_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions); else - if N_e==0 - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d,n_a,n_z,N_j, N_d,N_a,N_z, l_d,l_a,l_z, d_gridvals,aprime_gridvals,a_gridvals,d_grid,a_grid,z_gridvals_J, pi_z_J, pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - else % use fastOLG setting - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_e(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d,n_a,n_z,n_e,N_j, N_d,N_a,N_z,N_e,N_ze, l_d,l_a,l_z,l_e,l_ze, d_gridvals,aprime_gridvals,a_gridvals,d_grid,a_grid,z_gridvals_J,e_gridvals_J,e_gridvals_J, pi_z_J, pi_e_J,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - end + [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_e(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d, n_a, n_z, n_e, N_j, N_d,N_a,N_z,N_e,N_ze, l_d,l_aprime,l_a,l_z,l_e,l_ze, d_gridvals,d_grid, a_gridvals,a_grid,z_gridvals_J,e_gridvals_J,ze_gridvals_J_fastOLG, pi_z_J, pi_e_J,pi_z_J_sim,pi_e_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions); end end end - elseif vfoptions.gridinterplayer==1 - % Grid interpolation - % vfoptions.ngridinterp=9; - n2short=vfoptions.ngridinterp; % number of (evenly spaced) points to put between each grid point (not counting the two points themselves) - n2long=vfoptions.ngridinterp*2+3; % total number of aprime points we end up looking at in second layer - aprimefine_grid=interp1(1:1:N_a,a_grid,linspace(1,N_a,N_a+(N_a-1)*n2short))'; - n2aprime=length(aprimefine_grid); - % Note: internally the VFI commands recreate these, the copies here are used for the AggVars - aprimefine_gridvals=CreateGridvals(n2aprime,aprimefine_grid,1); - - if transpathoptions.fastOLG==0 - error('Cannot yet use vfoptions.gridinterplayer=1 with transpathoptions.fastOLG=0 (only implemented for fastOLG=1; tell me if you need this)') - % NOTE TO SELF: THE VFI COMMANDS ARE WHAT NEEDS CREATING - % - % - % if N_d==0 - % if N_z==0 - % if N_e==0 - % [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_GI_nod_noz(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist ,n_a,N_j, N_a, l_a, aprimefine_gridvals,a_gridvals, a_grid, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - % else - % [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_GI_nod_noz_e(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_e,N_j, N_a,N_e, l_a,l_e, aprimefine_gridvals,a_gridvals,a_grid,e_gridvals_J,e_gridvals_J_fastOLG, pi_e_J,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - % end - % else - % if N_e==0 - % [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_GI_nod(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_z,N_j, N_a,N_z, l_a,l_z, aprimefine_gridvals,a_gridvals,a_grid,z_gridvals_J,z_gridvals_J_fastOLG, pi_z_J,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - % else - % [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_GI_nod_e(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_z,n_e,N_j, N_a,N_z,N_e,N_ze, l_a,l_z,l_e,l_ze, aprimefine_gridvals,a_gridvals,a_grid,z_gridvals_J,e_gridvals_J,ze_gridvals_J, pi_z_J,pi_e_J,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - % end - % end - % else % N_d>0 - % if N_z==0 - % if N_e==0 - % [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_GI_noz(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d,n_a,N_j, N_d,N_a, l_d,l_a, d_gridvals,aprimefine_gridvals,a_gridvals, a_grid, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - % else - % [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_GI_noz_e(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d,n_a,n_e,N_j, N_d,N_a,N_e, l_d,l_a,l_e, d_gridvals,aprimefine_gridvals,a_gridvals,a_grid,e_gridvals_J,e_gridvals_J_fastOLG, pi_e_J,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - % end - % else - % if N_e==0 - % [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_GI(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d,n_a,n_z,N_j, N_d,N_a,N_z, l_d,l_a,l_z, d_gridvals,aprimefine_gridvals,a_gridvals,a_grid,z_gridvals_J,z_gridvals_J_fastOLG, pi_z_J,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - % else - % [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_GI_e(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d,n_a,n_z,n_e,N_j, N_d,N_a,N_z,N_e,N_ze, l_d,l_a,l_z,l_e,l_ze, d_gridvals,aprimefine_gridvals,a_gridvals,a_grid,z_gridvals_J,e_gridvals_J,ze_gridvals_J, pi_z_J,pi_e_J,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - % end - % end - % end - else % use fastOLG setting - if N_d==0 - if N_z==0 - if N_e==0 - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_GI_nod_noz(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n2short, n_a,N_j, N_a, l_a, aprimefine_gridvals,a_gridvals,a_grid, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - else - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_GI_nod_noz_e(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n2short, n_a,n_e,N_j, N_a,N_e, l_a,l_e, aprimefine_gridvals,a_gridvals,a_grid,e_gridvals_J, pi_e_J,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - end + else % use fastOLG setting + if N_d==0 + if N_z==0 + if N_e==0 + [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_nod_noz(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,N_j, N_a, l_aprime,l_a, aprime_gridvals,a_gridvals,a_grid, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, N_probs,II1orII,II2,exceptlastj, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions); else - if N_e==0 - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_GI_nod(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n2short, n_a,n_z,N_j, N_a,N_z, l_a,l_z, aprimefine_gridvals,a_gridvals,a_grid,z_gridvals_J, pi_z_J,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - else % use fastOLG setting - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_GI_nod_e(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n2short, n_a,n_z,n_e,N_j, N_a,N_z,N_e,N_ze, l_a,l_z,l_e,l_ze, aprimefine_gridvals,a_gridvals,a_grid,z_gridvals_J,e_gridvals_J,ze_gridvals_J, pi_z_J, pi_e_J,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - end + [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_nod_noz_e(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_e,N_j, N_a,N_e, l_aprime,l_a,l_e, aprime_gridvals,a_gridvals,a_grid,e_gridvals_J,ze_gridvals_J_fastOLG, pi_e_J,pi_e_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, N_probs,II1orII,II2,exceptlastj,exceptfirstj,justfirstj, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions); + end + else + if N_e==0 + [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_nod(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_z,N_j, N_a,N_z, l_aprime,l_a,l_z, aprime_gridvals,a_gridvals,a_grid,z_gridvals_J,ze_gridvals_J_fastOLG, pi_z_J,pi_z_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, N_probs,II1orII,II2,exceptlastj,exceptfirstj,justfirstj, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions); + else % use fastOLG setting + [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_nod_e(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_z,n_e,N_j, N_a,N_z,N_e,N_ze, l_aprime,l_a,l_z,l_e,l_ze, aprime_gridvals,a_gridvals,a_grid,z_gridvals_J,e_gridvals_J,ze_gridvals_J_fastOLG, pi_z_J,pi_e_J,pi_z_J_sim,pi_e_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, N_probs,II1orII,II2,exceptlastj,exceptfirstj,justfirstj, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions); end - else % N_d>0 - if N_z==0 - if N_e==0 - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_GI_noz(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n2short, n_d,n_a,N_j, N_d,N_a, l_d,l_a, d_gridvals,aprimefine_gridvals,a_gridvals,d_grid,a_grid, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - else - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_GI_noz_e(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n2short, n_d,n_a,n_e,N_j, N_d,N_a,N_e, l_d,l_a,l_e, d_gridvals,aprimefine_gridvals,a_gridvals,d_grid,a_grid,e_gridvals_J, pi_e_J,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - end + end + else % N_d>0 + if N_z==0 + if N_e==0 + [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_noz(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d, n_a, N_j, N_d,N_a, l_d,l_aprime,l_a, d_gridvals,aprime_gridvals,a_gridvals,d_grid,a_grid, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, N_probs,II1orII,II2,exceptlastj, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions); else - if N_e==0 - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_GI(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n2short, n_d,n_a,n_z,N_j, N_d,N_a,N_z, l_d,l_a,l_z, d_gridvals,aprimefine_gridvals,a_gridvals,d_grid,a_grid,z_gridvals_J, pi_z_J, pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - else % use fastOLG setting - [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_GI_e(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n2short, n_d,n_a,n_z,n_e,N_j, N_d,N_a,N_z,N_e,N_ze, l_d,l_a,l_z,l_e,l_ze, d_gridvals,aprimefine_gridvals,a_gridvals,d_grid,a_grid,z_gridvals_J,e_gridvals_J,e_gridvals_J, pi_z_J, pi_e_J,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions,transpathoptions); - end + [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_noz_e(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d, n_a, n_e, N_j, N_d,N_a,N_e, l_d,l_aprime,l_a,l_e, d_gridvals,aprime_gridvals,a_gridvals,d_grid,a_grid,e_gridvals_J,ze_gridvals_J_fastOLG, pi_e_J,pi_e_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, N_probs,II1orII,II2,exceptlastj,exceptfirstj,justfirstj, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions); + end + else + if N_e==0 + [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d, n_a, n_z, N_j, N_d,N_a,N_z, l_d,l_aprime,l_a,l_z, d_gridvals,aprime_gridvals,a_gridvals,d_grid,a_grid,z_gridvals_J,ze_gridvals_J_fastOLG, pi_z_J,pi_z_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, N_probs,II1orII,II2,exceptlastj,exceptfirstj,justfirstj, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions); + else % use fastOLG setting + [PricePath,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_e(PricePath0, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d,n_a,n_z,n_e,N_j, N_d,N_a,N_z,N_e,N_ze, l_d,l_aprime,l_a,l_z,l_e,l_ze, d_gridvals,aprime_gridvals,a_gridvals,d_grid,a_grid,z_gridvals_J,e_gridvals_J,ze_gridvals_J_fastOLG, pi_z_J,pi_e_J,pi_z_J_sim,pi_e_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, N_probs,II1orII,II2,exceptlastj,exceptfirstj,justfirstj, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions); end end end @@ -852,6 +812,7 @@ %% Set up transition path as minimization of a function (default is to use as objective the weighted sum of squares of the general eqm conditions) +% Only bothered implementing this with fastOLG=1 if transpathoptions.GEnewprice==2 PricePathVec=gather(reshape(PricePath0,[T*length(PricePathNames),1])); % Has to be vector for optimization algorithms. Additionally, provides a double check on sizes. @@ -859,7 +820,7 @@ % I HAVEN'T GOTTEN THIS TO WORK WELL ENOUGH THAT I AM COMFORTABLE LEAVING IT ENABLED if transpathoptions.GEnewprice==2 % Function minimization error('transpathoptions.GEnewprice==2 not currently enabled') - % GeneralEqmConditionsPathFn=@(pricepath) TransitionPath_FHorz_subfn(pricepath, PricePathNames, ParamPath, ParamPathNames, T, V_final, StationaryDist_init, n_d, n_a, n_z, N_j, pi_z, d_grid,a_grid,z_grid, ReturnFn, FnsToEvaluate, GeneralEqmEqns, Parameters, DiscountFactorParamNames, ReturnFnParamNames, AgeWeightsParamNames, FnsToEvaluateParamNames, GeneralEqmEqnParamNames, vfoptions, simoptions,transpathoptions); + % GeneralEqmConditionsPathFn=@(pricepath) TransitionPath_FHorz_subfn(pricepath, PricePathNames, ParamPath, ParamPathNames, T, V_final, StationaryDist_init, n_d, n_a, n_z, N_j, pi_z, d_grid,a_grid,z_grid, ReturnFn, FnsToEvaluateCell, GeneralEqmEqns, Parameters, DiscountFactorParamNames, ReturnFnParamNames, AgeWeightsParamNames, FnsToEvaluateParamNames, GeneralEqmEqnParamNames, vfoptions, simoptions,transpathoptions); end % I WANT TO DO THIS WITH lsqnonlin() diff --git a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting.m b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting.m index 69e0b39b..efde7fc1 100644 --- a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting.m +++ b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting.m @@ -1,4 +1,4 @@ -function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d,n_a,n_z,N_j, N_d,N_a,N_z, l_d,l_a,l_z, d_gridvals, aprime_gridvals,a_gridvals,a_grid,z_gridvals_J,z_gridvals_J_fastOLG, pi_z_J,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluate, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) +function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d,n_a,n_z,N_j, N_d,N_a,N_z, l_d,l_aprime,l_a,l_z, d_gridvals,d_grid, a_gridvals,a_grid,z_gridvals_J,z_gridvals_J_fastOLG, pi_z_J,pi_z_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) % PricePathOld is matrix of size T-by-'number of prices' % ParamPath is matrix of size T-by-'number of parameters that change over path' @@ -12,10 +12,13 @@ end %% +% interpret jequalOneDist input +if transpathoptions.trivialjequalonedist==0 + jequalOneDist_T=jequalOneDist; + jequalOneDist=jequalOneDist_T(:,1); +end -PricePathDist=Inf; -pathcounter=1; - +%% % Shapes: % V is [N_a,N_z,N_j] % AgentDist for basic is [N_a*N_z,N_j] @@ -23,18 +26,42 @@ PricePathNew=zeros(size(PricePathOld),'gpuArray'); PricePathNew(T,:)=PricePathOld(T,:); -AggVarsPath=zeros(T-1,length(FnsToEvaluate),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect GEcondnPath=zeros(T-1,length(GeneralEqmEqnsCell),'gpuArray'); -if transpathoptions.trivialjequalonedist==0 - jequalOneDist_T=jequalOneDist; - jequalOneDist=jequalOneDist_T(:,1); +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_d+l_aprime,N_a,N_z,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + PolicyIndexesPath=zeros(l_d+l_aprime+1,N_a,N_z,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +end +if simoptions.gridinterplayer==0 + if simoptions.fastOLG==0 + II1=1:1:N_a*N_z; + II2=ones(N_a*N_z,1); + elseif simoptions.fastOLG==1 + II1=1:1:N_a*(N_j-1)*N_z; + II2=ones(N_a*(N_j-1)*N_z,1); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_z,1)+N_a*N_j*repelem((0:1:N_z-1)',N_a,1); + end +elseif simoptions.gridinterplayer==1 + N_probs=2; + if simoptions.fastOLG==0 + error('Cannot use simoptions.fastOLG=0 with grid interpolation layer') + elseif simoptions.fastOLG==1 + PolicyProbsPath=zeros(N_a*(N_j-1)*N_z,N_probs,T-1,'gpuArray'); % preallocate + II=repelem((1:1:N_a*(N_j-1)*N_z)',1,N_probs); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_z,1)+N_a*N_j*repelem((0:1:N_z-1)',N_a,1); + end end %% +PricePathDist=Inf; +pathcounter=1; while PricePathDist>transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - PolicyPath=zeros(2,N_a,N_z,N_j,T-1,'gpuArray'); %Periods 1 to T-1 - %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. % Since we won't need to keep the value functions for anything later we just store the current one in V @@ -57,19 +84,47 @@ % The V input is next period value fn, the V output is this period. % Policy is kept in the form where it is just a single-value in (d,a') - PolicyPath(:,:,:,:,T-ttr)=Policy; + PolicyIndexesPath(:,:,:,:,T-ttr)=Policy; end - - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path + %% Modify PolicyIndexesPath into forms needed for forward iteration + % Create version of PolicyIndexesPath called PolicyaprimePath, which only tracks aprime and has j=1:N_j-1 as we don't use N_j to iterate agent dist (there is no N_j+1) + % For fastOLG we use PolicyaprimejPath, if there is z then PolicyaprimejzPath + % When using grid interpolation layer also PolicyProbsPath + if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,1:N_j-1,:),[N_a*N_z,N_j-1,T-1]); % aprime index + elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,:,1:N_j-1,:)-1),[N_a*N_z,N_j-1,T-1]); + elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,:,1:N_j-1,:)-1),[N_a*N_z,N_j-1,T-1]); + elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(l_d+4,:,:,1:N_j-1,:)-1),[N_a*N_z,N_j-1,T-1]); + end + if simoptions.fastOLG==0 + PolicyaprimezPath_slowOLG=PolicyaprimePath+repelem(N_a*gpuArray(0:1:N_z-1)',N_a,1); + elseif simoptions.fastOLG==1 + PolicyaprimePath=reshape(permute(reshape(PolicyaprimePath,[N_a,N_z,N_j-1,T-1]),[1,3,2,4]),[N_a*(N_j-1)*N_z,T-1]); + PolicyaprimejzPath=PolicyaprimePath+repelem(N_a*gpuArray(0:1:(N_j-1)*N_z-1)',N_a,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_d+l_aprime+1,:,:,1:N_j-1,:),[1,N_a,N_z,N_j-1,T-1]); % PolicyIndexesPath is of size [l_d+l_aprime+1,N_a,N_z,N_j,T] + L2index=reshape(permute(L2index,[2,4,3,1,5]),[N_a*(N_j-1)*N_z,1,T-1]); + PolicyaprimejzPath=reshape(PolicyaprimejzPath,[N_a*(N_j-1)*N_z,1,T-1]); % reinterpret this as lower grid index + PolicyaprimejzPath=repelem(PolicyaprimejzPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejzPath(:,2,:)=PolicyaprimejzPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point + end + end + % Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats + PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,n_d,n_a,n_z,N_j,T-1,d_grid,a_grid,vfoptions,1,0); + PolicyValuesPath=permute(PolicyValuesPath,[2,4,3,1,5]); %[N_a,N_j,N_z,l_d+l_aprime,T-1] % fastOLG ordering is needed for AggVars - % Call AgentDist the current periods distn + %% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm + % Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate AgentDist=AgentDist_initial; for tt=1:T-1 - % Get the current optimal policy - Policy=PolicyPath(:,:,:,:,tt); - % Get t-1 PricePath and ParamPath before we update them if use_tminus1price==1 for pp=1:length(tminus1priceNames) @@ -117,28 +172,43 @@ end end + %% Get the current optimal policy, and iterate the agent dist if transpathoptions.zpathtrivial==0 - z_gridvals_J=transpathoptions.z_gridvals_J_T(:,:,:,tt); + z_gridvals_J_fastOLG=transpathoptions.ze_gridvals_J_fastOLG(:,:,:,tt); if simoptions.fastOLG==0 pi_z_J=transpathoptions.pi_z_J_T(:,:,:,tt); else pi_z_J_sim=transpathoptions.pi_z_J_sim_T(:,:,:,tt); end end - + if simoptions.fastOLG==0 AgeWeights=AgeWeights_T(:,:,tt); else % simoptions.fastOLG==1 AgeWeights=AgeWeights_T(:,tt); end - Policy_fastOLG_d=reshape(permute(Policy(1,:,:,:),[1,2,4,3]),[1,N_a*N_j*N_z]); - Policy_fastOLG_aprime=reshape(permute(Policy(2,:,:,:),[1,2,4,3]),[1,N_a*N_j*N_z]); - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights,Policy_fastOLG_d, Policy_fastOLG_aprime, FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_z,N_a,N_z,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J_fastOLG,1); + if transpathoptions.trivialjequalonedist==0 + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + end + + if simoptions.fastOLG==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_Iteration_raw(AgentDist,PolicyaprimezPath_slowOLG(:,:,tt),N_a,N_z,N_j,pi_z_J,II1,II2,jequalOneDist); + else % simoptions.fastOLG==1 + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_raw(AgentDist,PolicyaprimejzPath(:,tt),N_a,N_z,N_j,pi_z_J_sim,II1,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_raw(AgentDist,PolicyaprimejzPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_z,N_j,pi_z_J_sim,II,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + end + end + + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights, PolicyValuesPath(:,:,:,1:l_d,tt), PolicyValuesPath(:,:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_z,N_a,N_z,a_gridvals,z_gridvals_J_fastOLG,1); for ii=1:length(AggVarNames) Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; end + %% General Eqm Eqns % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); PricePathNew(tt,:)=PricePathNew_tt; @@ -151,14 +221,7 @@ end end - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - if simoptions.fastOLG==0 - AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_raw(AgentDist,Policy(2,:,:,:),N_a,N_z,N_j,pi_z_J,jequalOneDist); - else % simoptions.fastOLG==1 - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_raw(AgentDist,Policy_fastOLG_aprime(exceptlastj),N_a,N_z,N_j,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); - end + AgentDist=AgentDistnext; end @@ -169,10 +232,8 @@ % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges if transpathoptions.verbose==1 - pathcounter disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) + % Would be nice to have a way to get the iteration count without having the whole printout of path values (I think that would be useful?) pathnametitles{:} [PricePathOld,PricePathNew] end diff --git a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_e.m b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_e.m index e3309d87..7f0709dd 100644 --- a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_e.m +++ b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_e.m @@ -1,4 +1,4 @@ -function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_e(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d, n_a, n_z, n_e, N_j, N_d,N_a,N_z,N_e,N_ze, l_d,l_a,l_z,l_e,l_ze, d_gridvals,aprime_gridvals,a_gridvals,a_grid,z_gridvals_J,e_gridvals_J,ze_gridvals_J, pi_z_J, pi_e_J,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluate, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) +function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_e(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d, n_a, n_z, n_e, N_j, N_d,N_a,N_z,N_e,N_ze, l_d,l_aprime,l_a,l_z,l_e,l_ze, d_gridvals,d_grid, a_gridvals,a_grid,z_gridvals_J,e_gridvals_J,ze_gridvals_J_fastOLG, pi_z_J, pi_e_J,pi_z_J_sim,pi_e_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) % PricePathOld is matrix of size T-by-'number of prices' % ParamPath is matrix of size T-by-'number of parameters that change over path' @@ -13,10 +13,13 @@ %% +% interpret jequalOneDist input +if transpathoptions.trivialjequalonedist==0 + jequalOneDist_T=jequalOneDist; + jequalOneDist=jequalOneDist_T(:,1); +end -PricePathDist=Inf; -pathcounter=1; - +%% % Shapes: % V is [N_a,N_z,N_e,N_j] % AgentDist for basic is [N_a*N_z*N_e,N_j] @@ -24,18 +27,43 @@ PricePathNew=zeros(size(PricePathOld),'gpuArray'); PricePathNew(T,:)=PricePathOld(T,:); -AggVarsPath=zeros(T-1,length(FnsToEvaluate),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect GEcondnPath=zeros(T-1,length(GeneralEqmEqnsCell),'gpuArray'); -if transpathoptions.trivialjequalonedist==0 - jequalOneDist_T=jequalOneDist; - jequalOneDist=jequalOneDist_T(:,1); +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_d+l_aprime,N_a,N_z,N_e,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + PolicyIndexesPath=zeros(l_d+l_aprime+1,N_a,N_z,N_e,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +end +if simoptions.gridinterplayer==0 + if simoptions.fastOLG==0 + II1=1:1:N_a*N_z*N_e; + II2=ones(N_a*N_z*N_e,1); + elseif simoptions.fastOLG==1 + II1=1:1:N_a*(N_j-1)*N_z*N_e; + II2=ones(N_a*(N_j-1)*N_z*N_e,1); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_z*N_e,1)+N_a*N_j*repelem((0:1:N_z*N_e-1)',N_a,1); + end +elseif simoptions.gridinterplayer==1 + N_probs=2; + if simoptions.fastOLG==0 + error('Cannot use simoptions.fastOLG=0 with grid interpolation layer') + elseif simoptions.fastOLG==1 + PolicyProbsPath=zeros(N_a*(N_j-1)*N_z*N_e,N_probs,T-1,'gpuArray'); % preallocate + II=repelem((1:1:N_a*(N_j-1)*N_z*N_e)',1,N_probs); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_z*N_e,1)+N_a*N_j*repelem((0:1:N_z*N_e-1)',N_a,1); + end end %% +PricePathDist=Inf; +pathcounter=1; while PricePathDist>transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - PolicyPath=zeros(2,N_a,N_z,N_e,N_j,T-1,'gpuArray'); % Periods 1 to T-1 - + %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. % Since we won't need to keep the value functions for anything later we just store the current one in V V=V_final; @@ -61,19 +89,47 @@ % The V input is next period value fn, the V output is this period. % Policy is kept in the form where it is just a single-value in (d,a') - PolicyPath(:,:,:,:,:,T-ttr)=Policy; + PolicyIndexesPath(:,:,:,:,:,T-ttr)=Policy; end - - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path + %% Modify PolicyIndexesPath into forms needed for forward iteration + % Create version of PolicyIndexesPath called PolicyaprimePath, which only tracks aprime and has j=1:N_j-1 as we don't use N_j to iterate agent dist (there is no N_j+1) + % For fastOLG we use PolicyaprimejPath, if there is z then PolicyaprimejzPath + % When using grid interpolation layer also PolicyProbsPath + if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,:,1:N_j-1,:),[N_a*N_z*N_e,N_j-1,T-1]); % aprime index + elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,:,:,1:N_j-1,:)-1),[N_a*N_z*N_e,N_j-1,T-1]); + elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,:,:,1:N_j-1,:)-1),[N_a*N_z*N_e,N_j-1,T-1]); + elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(l_d+4,:,:,:,1:N_j-1,:)-1),[N_a*N_z*N_e,N_j-1,T-1]); + end + if simoptions.fastOLG==0 + PolicyaprimezPath_slowOLG=PolicyaprimePath+repmat(repelem(N_a*gpuArray(0:1:N_z-1)',N_a,1),N_e,1); + elseif simoptions.fastOLG==1 + PolicyaprimePath=reshape(permute(reshape(PolicyaprimePath,[N_a,N_z*N_e,N_j-1,T-1]),[1,3,2,4]),[N_a*(N_j-1)*N_z*N_e,T-1]); + PolicyaprimejzPath=PolicyaprimePath+repmat(repelem(N_a*gpuArray(0:1:(N_j-1)*N_z-1)',N_a,1),N_e,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_d+l_aprime+1,:,:,:,1:N_j-1,:),[1,N_a,N_z*N_e,N_j-1,T-1]); % PolicyIndexesPath is of size [l_d+l_aprime+1,N_a,N_z,N_e,N_j,T] + L2index=reshape(permute(L2index,[2,4,3,1,5]),[N_a*(N_j-1)*N_z*N_e,1,T-1]); + PolicyaprimejzPath=reshape(PolicyaprimejzPath,[N_a*(N_j-1)*N_z*N_e,1,T-1]); % reinterpret this as lower grid index + PolicyaprimejzPath=repelem(PolicyaprimejzPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejzPath(:,2,:)=PolicyaprimejzPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point + end + end + % Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats + PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,n_d,n_a,[n_z,n_e],N_j,T-1,d_grid,a_grid,vfoptions,1,0); + PolicyValuesPath=permute(PolicyValuesPath,[2,4,3,1,5]); %[N_a,N_j,N_z*N_e,l_d+l_aprime,T-1] % fastOLG ordering is needed for AggVars - % Call AgentDist the current periods distn + %% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm + % Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate AgentDist=AgentDist_initial; for tt=1:T-1 - - % Get the current optimal policy - Policy=PolicyPath(:,:,:,:,:,tt); - + % Get t-1 PricePath and ParamPath before we update them if use_tminus1price==1 for pp=1:length(tminus1priceNames) @@ -121,8 +177,11 @@ end end + %% Get the current optimal policy, and iterate the agent dist + if transpathoptions.zepathtrivial==0 + ze_gridvals_J_fastOLG=transpathoptions.ze_gridvals_J_T_fastOLG(:,:,:,:,tt); + end if transpathoptions.zpathtrivial==0 - z_gridvals_J=transpathoptions.z_gridvals_J_T(:,:,:,tt); if simoptions.fastOLG==0 pi_z_J=transpathoptions.pi_z_J_T(:,:,:,tt); else @@ -130,7 +189,6 @@ end end if transpathoptions.epathtrivial==0 - e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,tt); if simoptions.fastOLG==0 pi_e_J=transpathoptions.pi_e_J_T(:,:,tt); else @@ -140,13 +198,27 @@ AgeWeights=AgeWeights_T(:,:,tt); % by coincidence this is for fastOLG=0,1 - Policy_fastOLG_d=reshape(permute(Policy(1,:,:,:,:),[1,2,5,3,4]),[1,N_a*N_j*N_z*N_e]); - Policy_fastOLG_aprime=reshape(permute(Policy(2,:,:,:,:),[1,2,5,3,4]),[1,N_a*N_j*N_z*N_e]); - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights,Policy_fastOLG_d, Policy_fastOLG_aprime, FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_ze,N_a,N_ze,d_gridvals,aprime_gridvals,a_gridvals,ze_gridvals_J,1); + if transpathoptions.trivialjequalonedist==0 + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + end + + if simoptions.fastOLG==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_Iteration_e_raw(AgentDist,PolicyaprimezPath_slowOLG(:,:,tt),N_a,N_z,N_e,N_j,pi_z_J,pi_e_J,II1,II2,jequalOneDist); + else % simoptions.fastOLG==1 + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_e_raw(AgentDist,PolicyaprimejzPath(:,tt),N_a,N_z,N_e,N_j,pi_z_J_sim, pi_e_J_sim,II1,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_e_raw(AgentDist,PolicyaprimejzPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,II,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + end + end + + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights, PolicyValuesPath(:,:,:,1:l_d,tt), PolicyValuesPath(:,:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_ze,N_a,N_ze,a_gridvals,ze_gridvals_J_fastOLG,1); for ii=1:length(AggVarNames) Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; end + %% General Eqm Eqns % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); PricePathNew(tt,:)=PricePathNew_tt; @@ -159,14 +231,7 @@ end end - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - if simoptions.fastOLG==0 - AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_e_raw(AgentDist,Policy(2,:,:,:,1:end-1),N_a,N_z,N_e,N_j,pi_z_J,pi_e_J,jequalOneDist); - else % simoptions.fastOLG==1 - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_e_raw(AgentDist,Policy_fastOLG_aprime(exceptlastj),N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); - end + AgentDist=AgentDistnext; end @@ -177,10 +242,8 @@ % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges if transpathoptions.verbose==1 - pathcounter disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) + % Would be nice to have a way to get the iteration count without having the whole printout of path values (I think that would be useful?) pathnametitles{:} [PricePathOld,PricePathNew] end diff --git a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG.m b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG.m index df304473..8001d2ba 100644 --- a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG.m +++ b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG.m @@ -1,4 +1,4 @@ -function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d, n_a, n_z, N_j, N_d,N_a,N_z, l_d,l_a,l_z, d_gridvals,aprime_gridvals,a_gridvals,d_grid,a_grid,z_gridvals_J, pi_z_J,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluate, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) +function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d, n_a, n_z, N_j, N_d,N_a,N_z, l_d,l_aprime,l_a,l_z, d_gridvals,aprime_gridvals,a_gridvals,d_grid,a_grid,z_gridvals_J,z_gridvals_J_fastOLG, pi_z_J,pi_z_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, N_probs,II1orII,II2,exceptlastj,exceptfirstj,justfirstj, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) % fastOLG: fastOLG uses (a,j,z) instead of the standard (a,z,j) % This (a,j,z) is important for ability to implement codes based on matrix % multiplications (especially for Tan improvement) @@ -16,9 +16,13 @@ end %% -PricePathDist=Inf; -pathcounter=1; +% interpret jequalOneDist input +if transpathoptions.trivialjequalonedist==0 + jequalOneDist_T=jequalOneDist; + jequalOneDist=jequalOneDist_T(:,1); +end +%% % fastOLG so everything is (a,j,z) % Shapes: % V is [N_a,N_j,N_z] @@ -26,19 +30,21 @@ PricePathNew=zeros(size(PricePathOld),'gpuArray'); PricePathNew(T,:)=PricePathOld(T,:); -AggVarsPath=zeros(T-1,length(FnsToEvaluate),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect GEcondnPath=zeros(T-1,length(GeneralEqmEqnsCell),'gpuArray'); -if transpathoptions.trivialjequalonedist==0 - jequalOneDist_T=jequalOneDist; - jequalOneDist=jequalOneDist_T(:,1); +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_d+l_aprime,N_a,N_j,N_z,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + PolicyIndexesPath=zeros(l_d+l_aprime+1,N_a,N_j,N_z,T-1,'gpuArray'); %Periods 1 to T-1 + PolicyProbsPath=zeros(N_a*(N_j-1)*N_z,N_probs,T-1,'gpuArray'); % preallocate end %% +PricePathDist=Inf; +pathcounter=1; while PricePathDist>transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - - PolicyPath=zeros(2,N_a,N_j,N_z,T-1,'gpuArray'); %Periods 1 to T-1 - + %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. % Since we won't need to keep the value functions for anything later we just store the current one in V V=V_final; @@ -60,20 +66,41 @@ % The V input is next period value fn, the V output is this period. % Policy in fastOLG is [N_a,N_j,N_z] and contains the joint-index for (d,aprime) - PolicyPath(:,:,:,:,T-ttr)=Policy; % fastOLG: so a-by-j-by-z + PolicyIndexesPath(:,:,:,:,T-ttr)=Policy; % fastOLG: so a-by-j-by-z end - - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path + %% Modify PolicyIndexesPath into forms needed for forward iteration + % Create version of PolicyIndexesPath in form we want for the agent distribution iteration + % Creates PolicyaprimejzPath (omits j=N_j), and when using grid interpolation layer also PolicyProbsPath + if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:),[N_a*(N_j-1)*N_z,T-1]); % aprime index + elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:,:)-1),[N_a*(N_j-1)*N_z,T-1]); + elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,1:N_j-1,:,:)-1),[N_a*(N_j-1)*N_z,T-1]); + elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,1:N_j-1,:,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(l_d+4,:,1:N_j-1,:,:)-1),[N_a*(N_j-1)*N_z,T-1]); + end + PolicyaprimejzPath=PolicyaprimePath+repelem(N_a*gpuArray(0:1:(N_j-1)*N_z-1)',N_a,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_d+l_aprime+1,:,1:N_j-1,:,:),[N_a*(N_j-1)*N_z,1,T-1]); % PolicyIndexesPath is of size [l_d+l_aprime+1,N_a,N_j,N_z,T-1] + PolicyaprimejzPath=reshape(PolicyaprimejzPath,[N_a*(N_j-1)*N_z,1,T-1]); % reinterpret this as lower grid index + PolicyaprimejzPath=repelem(PolicyaprimejzPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejzPath(:,2,:)=PolicyaprimejzPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point + end + % Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats + PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,n_d,n_a,n_z,N_j,T-1,d_gridvals,aprime_gridvals,vfoptions,1,1); % [size(PolicyValuesPath,1),N_a,N_j,N_z,T] + PolicyValuesPath=permute(PolicyValuesPath,[2,3,4,1,5]); %[N_a,N_j,N_z,l_d+l_aprime,T-1] % fastOLG ordering is needed for AggVars - % Call AgentDist the current periods distn + %% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm + % Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate AgentDist=AgentDist_initial; for tt=1:T-1 - % Get the current optimal policy - Policy=PolicyPath(:,:,:,:,tt); % fastOLG: so a-by-j-by-z - % Get t-1 PricePath and ParamPath before we update them if use_tminus1price==1 for pp=1:length(tminus1priceNames) @@ -121,16 +148,32 @@ end end + %% Get the current optimal policy, and iterate the agent dist if transpathoptions.zpathtrivial==0 - z_gridvals_J=transpathoptions.z_gridvals_J_T(:,:,:,tt); + z_gridvals_J_fastOLG=transpathoptions.ze_gridvals_J_fastOLG(:,:,:,tt); pi_z_J_sim=transpathoptions.pi_z_J_sim_T(:,:,:,tt); % fastOLG value function uses (j,z,z') end - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights_T(:,tt),Policy(1,:,:,:), Policy(2,:,:,:), FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_z,N_a,N_z,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J,1); + if transpathoptions.trivialjequalonedist==0 + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + end + + AgeWeights=AgeWeights_T(:,tt); + + % simoptions.fastOLG=1 is hardcoded + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_raw(AgentDist,PolicyaprimejzPath(:,tt),N_a,N_z,N_j,pi_z_J_sim,II1orII,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % II1orII,II2 are II1 and II2 + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_raw(AgentDist,PolicyaprimejzPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_z,N_j,pi_z_J_sim,II1orII,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % II1orII is II + end + + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights, PolicyValuesPath(:,:,:,1:l_d,tt), PolicyValuesPath(:,:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_z,N_a,N_z,a_gridvals,z_gridvals_J_fastOLG,1); for ii=1:length(AggVarNames) Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; end + %% General Eqm Eqns % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); PricePathNew(tt,:)=PricePathNew_tt; @@ -143,11 +186,7 @@ end end - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - % simoptions.fastOLG=1 is hardcoded - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_raw(AgentDist,reshape(Policy(2,:,1:end-1,:),[1,N_a*(N_j-1)*N_z]),N_a,N_z,N_j,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % Policy for jj=1:N_j-1 + AgentDist=AgentDistnext; end @@ -158,10 +197,8 @@ % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges if transpathoptions.verbose==1 - pathcounter disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) + % Would be nice to have a way to get the iteration count without having the whole printout of path values (I think that would be useful?) pathnametitles{:} [PricePathOld,PricePathNew] end diff --git a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_e.m b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_e.m index e232924e..328a3e65 100644 --- a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_e.m +++ b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_e.m @@ -1,4 +1,4 @@ -function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_e(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d,n_a,n_z,n_e,N_j, N_d,N_a,N_z,N_e,N_ze, l_d,l_a,l_z,l_e,l_ze, d_gridvals,aprime_gridvals,a_gridvals,d_grid,a_grid,z_gridvals_J,e_gridvals_J,ze_gridvals_J, pi_z_J,pi_e_J,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluate, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) +function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_e(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d,n_a,n_z,n_e,N_j, N_d,N_a,N_z,N_e,N_ze, l_d,l_aprime,l_a,l_z,l_e,l_ze, d_gridvals,aprime_gridvals,a_gridvals,d_grid,a_grid,z_gridvals_J,e_gridvals_J,ze_gridvals_J_fastOLG, pi_z_J,pi_e_J,pi_z_J_sim,pi_e_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, N_probs,II1orII,II2,exceptlastj,exceptfirstj,justfirstj, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) % fastOLG: fastOLG uses (a,j,z,e) instead of the standard (a,z,e,j) % This (a,j,z,e) is important for ability to implement codes based on matrix % multiplications (especially for Tan improvement) @@ -16,10 +16,13 @@ end %% +% interpret jequalOneDist input +if transpathoptions.trivialjequalonedist==0 + jequalOneDist_T=jequalOneDist; + jequalOneDist=jequalOneDist_T(:,1); +end -PricePathDist=Inf; -pathcounter=1; - +%% % fastOLG so everything is (a,j,z,e) % Shapes: % V is [N_a,N_j,N_z,N_e] @@ -27,20 +30,22 @@ PricePathNew=zeros(size(PricePathOld),'gpuArray'); PricePathNew(T,:)=PricePathOld(T,:); -AggVarsPath=zeros(T-1,length(FnsToEvaluate),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect GEcondnPath=zeros(T-1,length(GeneralEqmEqnsCell),'gpuArray'); -if transpathoptions.trivialjequalonedist==0 - jequalOneDist_T=jequalOneDist; - jequalOneDist=jequalOneDist_T(:,1); +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_d+l_aprime,N_a,N_j,N_z,N_e,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + PolicyIndexesPath=zeros(l_d+l_aprime+1,N_a,N_j,N_z,N_e,T-1,'gpuArray'); %Periods 1 to T-1 + N_probs=2; + PolicyProbsPath=zeros(N_a*(N_j-1)*N_z*N_e,N_probs,T-1,'gpuArray'); % preallocate end - %% +PricePathDist=Inf; +pathcounter=1; while PricePathDist>transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - - PolicyPath=zeros(2,N_a,N_j,N_z,N_e,T-1,'gpuArray'); %Periods 1 to T-1 - + %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. % Since we won't need to keep the value functions for anything later we just store the current one in V V=V_final; @@ -66,19 +71,41 @@ % The V input is next period value fn, the V output is this period. % Policy in fastOLG is [N_a,N_j,N_z,N_e] and contains the joint-index for (d,aprime) - PolicyPath(:,:,:,:,:,T-ttr)=Policy; % fastOLG: so a-by-j-by-z-by-e + PolicyIndexesPath(:,:,:,:,:,T-ttr)=Policy; % fastOLG: so a-by-j-by-z-by-e end + %% Modify PolicyIndexesPath into forms needed for forward iteration + % Create version of PolicyIndexesPath in form we want for the agent distribution iteration + % Creates PolicyaprimejzPath (omits j=N_j), and when using grid interpolation layer also PolicyProbsPath + if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:,:),[N_a*(N_j-1)*N_z*N_e,T-1]); % aprime index + elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:,:,:)-1),[N_a*(N_j-1)*N_z*N_e,T-1]); + elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:,:,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,1:N_j-1,:,:,:)-1),[N_a*(N_j-1)*N_z*N_e,T-1]); + elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:,:,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,1:N_j-1,:,:,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(l_d+4,:,1:N_j-1,:,:,:)-1),[N_a*(N_j-1)*N_z*N_e,T-1]); + end + PolicyaprimejzPath=PolicyaprimePath+repmat(repelem(N_a*gpuArray(0:1:(N_j-1)*N_z-1)',N_a,1),N_e,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_d+l_aprime+1,:,1:N_j-1,:,:,:),[N_a*(N_j-1)*N_z*N_e,1,T-1]); % PolicyIndexesPath is of size [l_d+l_aprime+1,N_a,N_j,N_z,N_e,T-1] + PolicyaprimejzPath=reshape(PolicyaprimejzPath,[N_a*(N_j-1)*N_z*N_e,1,T-1]); % reinterpret this as lower grid index + PolicyaprimejzPath=repelem(PolicyaprimejzPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejzPath(:,2,:)=PolicyaprimejzPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point + end + % Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats + PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,n_d,n_a,[n_z,n_e],N_j,T-1,d_gridvals,aprime_gridvals,vfoptions,1,1); % [size(PolicyValuesPath,1),N_a,N_j,N_z*N_e,T] + PolicyValuesPath=permute(PolicyValuesPath,[2,3,4,1,5]); %[N_a,N_j,N_z*N_e,l_d+l_aprime,T-1] % fastOLG ordering is needed for AggVars + - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path - - % Call AgentDist the current periods distn + %% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm + % Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate AgentDist=AgentDist_initial; for tt=1:T-1 - - % Get the current optimal policy - Policy=PolicyPath(:,:,:,:,:,tt); % fastOLG: so (a,j)-by-z-by-e % Get t-1 PricePath and ParamPath before we update them if use_tminus1price==1 @@ -127,20 +154,37 @@ end end + %% Get the current optimal policy, and iterate the agent dist + if transpathoptions.zepathtrivial==0 + ze_gridvals_J_fastOLG=transpathoptions.ze_gridvals_J_T_fastOLG(:,:,:,:,tt); + end if transpathoptions.zpathtrivial==0 - z_gridvals_J=transpathoptions.z_gridvals_J_T(:,:,:,tt); pi_z_J_sim=transpathoptions.pi_z_J_sim_T(:,:,:,tt); end if transpathoptions.epathtrivial==0 - e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,:,tt); pi_e_J_sim=transpathoptions.pi_e_J_sim_T(:,:,tt); % (a,j,z)-by-e end - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights_T(:,:,tt),Policy(1,:,:,:,:), Policy(2,:,:,:,:), FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_ze,N_a,N_ze,d_gridvals,aprime_gridvals,a_gridvals,ze_gridvals_J,1); + if transpathoptions.trivialjequalonedist==0 + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + end + + AgeWeights=AgeWeights_T(:,:,tt); % by coincidence this is for fastOLG=0,1 + + % simoptions.fastOLG=1 is hardcoded + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_e_raw(AgentDist,PolicyaprimejzPath(:,tt),N_a,N_z,N_e,N_j,pi_z_J_sim, pi_e_J_sim,II1orII,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % II1orII is II1 + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_e_raw(AgentDist,PolicyaprimejzPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,II1orII,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % II1orII is II + end + + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights, PolicyValuesPath(:,:,:,1:l_d,tt), PolicyValuesPath(:,:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_ze,N_a,N_ze,a_gridvals,ze_gridvals_J_fastOLG,1); for ii=1:length(AggVarNames) Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; end + %% General Eqm Eqns % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); PricePathNew(tt,:)=PricePathNew_tt; @@ -153,11 +197,7 @@ end end - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - % simoptions.fastOLG=1 is hardcoded - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_e_raw(AgentDist,reshape(Policy(2,:,1:end-1,:,:),[1,N_a*(N_j-1)*N_z*N_e]),N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + AgentDist=AgentDistnext; end @@ -168,10 +208,8 @@ % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges if transpathoptions.verbose==1 - pathcounter disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) + % Would be nice to have a way to get the iteration count without having the whole printout of path values (I think that would be useful?) pathnametitles{:} [PricePathOld,PricePathNew] end diff --git a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_nod.m b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_nod.m index b2dabd2b..931e6437 100644 --- a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_nod.m +++ b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_nod.m @@ -1,4 +1,4 @@ -function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_nod(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_z,N_j, N_a,N_z, l_a,l_z, aprime_gridvals,a_gridvals,a_grid,z_gridvals_J, pi_z_J,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluate, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) +function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_nod(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_z,N_j, N_a,N_z, l_aprime,l_a,l_z, aprime_gridvals,a_gridvals,a_grid,z_gridvals_J,z_gridvals_J_fastOLG, pi_z_J,pi_z_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, N_probs,II1orII,II2,exceptlastj,exceptfirstj,justfirstj, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) % fastOLG: fastOLG uses (a,j,z) instead of the standard (a,z,j) % This (a,j,z) is important for ability to implement codes based on matrix % multiplications (especially for Tan improvement) @@ -16,9 +16,13 @@ end %% -PricePathDist=Inf; -pathcounter=1; +% interpret jequalOneDist input +if transpathoptions.trivialjequalonedist==0 + jequalOneDist_T=jequalOneDist; + jequalOneDist=jequalOneDist_T(:,1); +end +%% % fastOLG so everything is (a,j,z) % Shapes: % V is [N_a,N_j,N_z] @@ -26,20 +30,21 @@ PricePathNew=zeros(size(PricePathOld),'gpuArray'); PricePathNew(T,:)=PricePathOld(T,:); -AggVarsPath=zeros(T-1,length(FnsToEvaluate),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect GEcondnPath=zeros(T-1,length(GeneralEqmEqnsCell),'gpuArray'); -if transpathoptions.trivialjequalonedist==0 - jequalOneDist_T=jequalOneDist; - jequalOneDist=jequalOneDist_T(:,1); +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_aprime,N_a,N_j,N_z,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + PolicyIndexesPath=zeros(l_aprime+1,N_a,N_j,N_z,T-1,'gpuArray'); %Periods 1 to T-1 + PolicyProbsPath=zeros(N_a*(N_j-1)*N_z,N_probs,T-1,'gpuArray'); % preallocate end - %% +PricePathDist=Inf; +pathcounter=1; while PricePathDist>transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - - PolicyPath=zeros(1,N_a,N_j,N_z,T-1,'gpuArray'); %Periods 1 to T-1 - + %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. % Since we won't need to keep the value functions for anything later we just store the current one in V V=V_final; @@ -61,20 +66,41 @@ % The V input is next period value fn, the V output is this period. % Policy in fastOLG is [N_a,N_j,N_z] and contains the joint-index for (d,aprime) - PolicyPath(1,:,:,:,T-ttr)=Policy; % fastOLG: so a-by-j-by-z + PolicyIndexesPath(:,:,:,:,T-ttr)=Policy; % fastOLG: so a-by-j-by-z end - - - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path - % Call AgentDist the current periods distn + %% Modify PolicyIndexesPath into forms needed for forward iteration + % Create version of PolicyIndexesPath in form we want for the agent distribution iteration + % Creates PolicyaprimejzPath (omits j=N_j), and when using grid interpolation layer also PolicyProbsPath + if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:N_j-1,:,:),[N_a*(N_j-1)*N_z,T-1]); % aprime index + elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:N_j-1,:,:)+n_a(1)*(PolicyIndexesPath(2,:,1:N_j-1,:,:)-1),[N_a*(N_j-1)*N_z,T-1]); + elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:N_j-1,:,:)+n_a(1)*(PolicyIndexesPath(2,:,1:N_j-1,:,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(3,:,1:N_j-1,:,:)-1),[N_a*(N_j-1)*N_z,T-1]); + elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:N_j-1,:,:)+n_a(1)*(PolicyIndexesPath(2,:,1:N_j-1,:,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(3,:,1:N_j-1,:,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(4,:,1:N_j-1,:,:)-1),[N_a*(N_j-1)*N_z,T-1]); + end + PolicyaprimejzPath=PolicyaprimePath+repelem(N_a*gpuArray(0:1:(N_j-1)*N_z-1)',N_a,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_aprime+1,:,1:N_j-1,:,:),[N_a*(N_j-1)*N_z,1,T-1]); % PolicyIndexesPath is of size [l_d+l_aprime+1,N_a,N_j,N_z,T-1] + PolicyaprimejzPath=reshape(PolicyaprimejzPath,[N_a*(N_j-1)*N_z,1,T-1]); % reinterpret this as lower grid index + PolicyaprimejzPath=repelem(PolicyaprimejzPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejzPath(:,2,:)=PolicyaprimejzPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point + end + % Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats + PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,0,n_a,n_z,N_j,T-1,[],aprime_gridvals,vfoptions,1,1); % [size(PolicyValuesPath,1),N_a,N_j,N_z,T] + PolicyValuesPath=permute(PolicyValuesPath,[2,3,4,1,5]); %[N_a,N_j,N_z,l_aprime,T-1] % fastOLG ordering is needed for AggVars + + %% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm + % Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate AgentDist=AgentDist_initial; for tt=1:T-1 - - % Get the current optimal policy - Policy=PolicyPath(1,:,:,:,tt); % fastOLG: so a-by-j-by-z - + % Get t-1 PricePath and ParamPath before we update them if use_tminus1price==1 for pp=1:length(tminus1priceNames) @@ -122,16 +148,32 @@ end end + %% Get the current optimal policy, and iterate the agent dist if transpathoptions.zpathtrivial==0 - z_gridvals_J=transpathoptions.z_gridvals_J_T(:,:,:,tt); + z_gridvals_J_fastOLG=transpathoptions.ze_gridvals_J_fastOLG(:,:,:,tt); pi_z_J_sim=transpathoptions.pi_z_J_sim_T(:,:,:,tt); % fastOLG value function uses (j,z,z') end - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights_T(:,tt),[], Policy, FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,0,l_a,l_a,l_z,N_a,N_z,[],aprime_gridvals,a_gridvals,z_gridvals_J,1); + if transpathoptions.trivialjequalonedist==0 + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + end + + AgeWeights=AgeWeights_T(:,tt); + + % simoptions.fastOLG=1 is hardcoded + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_raw(AgentDist,PolicyaprimejzPath(:,tt),N_a,N_z,N_j,pi_z_J_sim,II1orII,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % II1orII is II1 + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_raw(AgentDist,PolicyaprimejzPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_z,N_j,pi_z_J_sim,II1orII,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % II1orII is II + end + + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights,[], PolicyValuesPath(:,:,:,:,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,0,l_a,l_a,l_z,N_a,N_z,a_gridvals,z_gridvals_J_fastOLG,1); for ii=1:length(AggVarNames) Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; end + %% General Eqm Eqns % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); PricePathNew(tt,:)=PricePathNew_tt; @@ -144,11 +186,7 @@ end end - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - % simoptions.fastOLG=1 is hardcoded - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_raw(AgentDist,reshape(Policy(1,:,1:end-1,:),[1,N_a*(N_j-1)*N_z]),N_a,N_z,N_j,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % Policy for jj=1:N_j-1 + AgentDist=AgentDistnext; end @@ -159,10 +197,8 @@ % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges if transpathoptions.verbose==1 - pathcounter disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) + % Would be nice to have a way to get the iteration count without having the whole printout of path values (I think that would be useful?) pathnametitles{:} [PricePathOld,PricePathNew] end diff --git a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_nod_e.m b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_nod_e.m index 3b517125..7358955e 100644 --- a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_nod_e.m +++ b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_nod_e.m @@ -1,4 +1,4 @@ -function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_nod_e(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_z,n_e,N_j, N_a,N_z,N_e,N_ze, l_a,l_z,l_e,l_ze, aprime_gridvals,a_gridvals,a_grid,z_gridvals_J,e_gridvals_J,ze_gridvals_J, pi_z_J,pi_e_J,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluate, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) +function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_nod_e(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_z,n_e,N_j, N_a,N_z,N_e,N_ze, l_aprime,l_a,l_z,l_e,l_ze, aprime_gridvals,a_gridvals,a_grid,z_gridvals_J,e_gridvals_J,ze_gridvals_J_fastOLG, pi_z_J,pi_e_J,pi_z_J_sim,pi_e_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, N_probs,II1orII,II2,exceptlastj,exceptfirstj,justfirstj, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) % fastOLG: fastOLG uses (a,j,z,e) instead of the standard (a,z,e,j) % This (a,j,z,e) is important for ability to implement codes based on matrix % multiplications (especially for Tan improvement) @@ -16,10 +16,14 @@ end %% +% interpret jequalOneDist input +if transpathoptions.trivialjequalonedist==0 + jequalOneDist_T=jequalOneDist; + jequalOneDist=jequalOneDist_T(:,1); +end -PricePathDist=Inf; -pathcounter=1; +%% % fastOLG so everything is (a,j,z,e) % Shapes: % V is [N_a,N_j,N_z,N_e] @@ -27,19 +31,20 @@ PricePathNew=zeros(size(PricePathOld),'gpuArray'); PricePathNew(T,:)=PricePathOld(T,:); -AggVarsPath=zeros(T-1,length(FnsToEvaluate),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect GEcondnPath=zeros(T-1,length(GeneralEqmEqnsCell),'gpuArray'); -if transpathoptions.trivialjequalonedist==0 - jequalOneDist_T=jequalOneDist; - jequalOneDist=jequalOneDist_T(:,1); +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_aprime,N_a,N_j,N_z,N_e,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + PolicyIndexesPath=zeros(l_aprime+1,N_a,N_j,N_z,N_e,T-1,'gpuArray'); %Periods 1 to T-1 + PolicyProbsPath=zeros(N_a*(N_j-1)*N_z*N_e,N_probs,T-1,'gpuArray'); % preallocate end - %% -while PricePathDist>transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - - PolicyPath=zeros(1,N_a,N_j,N_z,N_e,T-1,'gpuArray'); %Periods 1 to T-1 +PricePathDist=Inf; +pathcounter=1; +while PricePathDist>transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. % Since we won't need to keep the value functions for anything later we just store the current one in V @@ -66,19 +71,41 @@ % The V input is next period value fn, the V output is this period. % Policy in fastOLG is [N_a,N_j,N_z,N_e] and contains the joint-index for (d,aprime) - PolicyPath(1,:,:,:,:,T-ttr)=Policy; % fastOLG: so a-by-j-by-z-by-e + PolicyIndexesPath(:,:,:,:,:,T-ttr)=Policy; % fastOLG: so a-by-j-by-z-by-e end + %% Modify PolicyIndexesPath into forms needed for forward iteration + % Create version of PolicyIndexesPath in form we want for the agent distribution iteration + % Creates PolicyaprimejzPath (omits j=N_j), and when using grid interpolation layer also PolicyProbsPath + if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:N_j-1,:,:,:),[N_a*(N_j-1)*N_z*N_e,T-1]); % aprime index + elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:N_j-1,:,:,:)+n_a(1)*(PolicyIndexesPath(2,:,1:N_j-1,:,:,:)-1),[N_a*(N_j-1)*N_z*N_e,T-1]); + elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:N_j-1,:,:,:)+n_a(1)*(PolicyIndexesPath(2,:,1:N_j-1,:,:,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(3,:,1:N_j-1,:,:,:)-1),[N_a*(N_j-1)*N_z*N_e,T-1]); + elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:N_j-1,:,:,:)+n_a(1)*(PolicyIndexesPath(2,:,1:N_j-1,:,:,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(3,:,1:N_j-1,:,:,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(4,:,1:N_j-1,:,:,:)-1),[N_a*(N_j-1)*N_z*N_e,T-1]); + end + PolicyaprimejzPath=PolicyaprimePath+repmat(repelem(N_a*gpuArray(0:1:(N_j-1)*N_z-1)',N_a,1),N_e,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_aprime+1,:,1:N_j-1,:,:,:),[N_a*(N_j-1)*N_z*N_e,1,T-1]); % PolicyIndexesPath is of size [l_d+l_aprime+1,N_a,N_j,N_z,N_e,T-1] + PolicyaprimejzPath=reshape(PolicyaprimejzPath,[N_a*(N_j-1)*N_z*N_e,1,T-1]); % reinterpret this as lower grid index + PolicyaprimejzPath=repelem(PolicyaprimejzPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejzPath(:,2,:)=PolicyaprimejzPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point + end + % Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats + PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,0,n_a,[n_z,n_e],N_j,T-1,[],aprime_gridvals,vfoptions,1,1); % [size(PolicyValuesPath,1),N_a,N_j,N_z*N_e,T] + PolicyValuesPath=permute(PolicyValuesPath,[2,3,4,1,5]); %[N_a,N_j,N_z*N_e,l_aprime,T-1] % fastOLG ordering is needed for AggVars + - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path - - % Call AgentDist the current periods distn + %% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm + % Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate AgentDist=AgentDist_initial; for tt=1:T-1 - - % Get the current optimal policy - Policy=PolicyPath(1,:,:,:,:,tt); % fastOLG: so (a,j)-by-z-by-e % Get t-1 PricePath and ParamPath before we update them if use_tminus1price==1 @@ -127,20 +154,37 @@ end end + %% Get the current optimal policy, and iterate the agent dist + if transpathoptions.zepathtrivial==0 + ze_gridvals_J_fastOLG=transpathoptions.ze_gridvals_J_T_fastOLG(:,:,:,:,tt); + end if transpathoptions.zpathtrivial==0 - z_gridvals_J=transpathoptions.z_gridvals_J_T(:,:,:,tt); pi_z_J_sim=transpathoptions.pi_z_J_sim_T(:,:,:,tt); end if transpathoptions.epathtrivial==0 - e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,:,tt); pi_e_J_sim=transpathoptions.pi_e_J_sim_T(:,:,tt); % (a,j,z)-by-e end - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights_T(:,:,tt),[], Policy, FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,0,l_a,l_a,l_ze,N_a,N_ze,[],aprime_gridvals,a_gridvals,ze_gridvals_J,1); + if transpathoptions.trivialjequalonedist==0 + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + end + + AgeWeights=AgeWeights_T(:,:,tt); % by coincidence this is for fastOLG=0,1 + + % simoptions.fastOLG=1 is hardcoded + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_e_raw(AgentDist,PolicyaprimejzPath(:,tt),N_a,N_z,N_e,N_j,pi_z_J_sim, pi_e_J_sim,II1orII,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % II1orII is II1 + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_e_raw(AgentDist,PolicyaprimejzPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,II1orII,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % II1orII is II + end + + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights,[], PolicyValuesPath(:,:,:,:,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,0,l_a,l_a,l_ze,N_a,N_ze,a_gridvals,ze_gridvals_J_fastOLG,1); for ii=1:length(AggVarNames) Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; end + %% General Eqm Eqns % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); PricePathNew(tt,:)=PricePathNew_tt; @@ -153,11 +197,7 @@ end end - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - % simoptions.fastOLG=1 is hardcoded - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_e_raw(AgentDist,reshape(Policy(1,:,1:end-1,:,:),[1,N_a*(N_j-1)*N_z*N_e]),N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + AgentDist=AgentDistnext; end @@ -168,10 +208,8 @@ % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges if transpathoptions.verbose==1 - pathcounter disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) + % Would be nice to have a way to get the iteration count without having the whole printout of path values (I think that would be useful?) pathnametitles{:} [PricePathOld,PricePathNew] end diff --git a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_nod_noz.m b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_nod_noz.m index 93e59b65..04c2f8bc 100644 --- a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_nod_noz.m +++ b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_nod_noz.m @@ -1,4 +1,4 @@ -function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_nod_noz(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,N_j, N_a, l_a, aprime_gridvals,a_gridvals,a_grid, ReturnFn, FnsToEvaluate, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) +function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_nod_noz(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,N_j, N_a, l_aprime,l_a, aprime_gridvals,a_gridvals,a_grid, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, N_probs,II1orII,II2,exceptlastj, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) % PricePathOld is matrix of size T-by-'number of prices' % ParamPath is matrix of size T-by-'number of parameters that change over path' @@ -14,9 +14,13 @@ end %% -PricePathDist=Inf; -pathcounter=1; +% interpret jequalOneDist input +if transpathoptions.trivialjequalonedist==0 + jequalOneDist_T=jequalOneDist; + jequalOneDist=jequalOneDist_T(:,1); +end +%% % fastOLG so everything is (a,j) % Shapes: % V is [N_a,N_j] @@ -24,18 +28,21 @@ PricePathNew=zeros(size(PricePathOld),'gpuArray'); PricePathNew(T,:)=PricePathOld(T,:); -AggVarsPath=zeros(T-1,length(FnsToEvaluate),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect GEcondnPath=zeros(T-1,length(GeneralEqmEqnsCell),'gpuArray'); -if transpathoptions.trivialjequalonedist==0 - jequalOneDist_T=jequalOneDist; - jequalOneDist=jequalOneDist_T(:,1); +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_aprime,N_a,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + PolicyIndexesPath=zeros(l_aprime+1,N_a,N_j,T-1,'gpuArray'); %Periods 1 to T-1 + PolicyProbsPath=zeros(N_a*(N_j-1),N_probs,T-1,'gpuArray'); % preallocate end + %% +PricePathDist=Inf; +pathcounter=1; while PricePathDist>transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - - PolicyPath=zeros(1,N_a,N_j,T-1,'gpuArray'); %Periods 1 to T-1 %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. % Since we won't need to keep the value functions for anything later we just store the current one in V @@ -52,20 +59,41 @@ % The V input is next period value fn, the V output is this period. % Policy is kept in the form where it is just a single-value in (d,a') - PolicyPath(1,:,:,T-ttr)=Policy; + PolicyIndexesPath(:,:,:,T-ttr)=Policy; end - + %% Modify PolicyIndexesPath into forms needed for forward iteration + % Create version of PolicyIndexesPath in form we want for the agent distribution iteration + % Creates PolicyaprimejPath (omits j=N_j), and when using grid interpolation layer also PolicyProbsPath + if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:N_j-1,:),[N_a*(N_j-1),T-1]); % aprime index + elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(2,:,1:N_j-1,:)-1),[N_a*(N_j-1),T-1]); + elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(2,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(3,:,1:N_j-1,:)-1),[N_a*(N_j-1),T-1]); + elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(2,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(3,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(4,:,1:N_j-1,:)-1),[N_a*(N_j-1),T-1]); + end + PolicyaprimejPath=PolicyaprimePath+repelem(N_a*gpuArray(0:1:(N_j-1)-1)',N_a,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_aprime+1,:,1:N_j-1,:),[N_a*(N_j-1),1,T-1]); % PolicyIndexesPath is of size [l_d+l_aprime+1,N_a,N_j,T-1] + PolicyaprimejPath=reshape(PolicyaprimejPath,[N_a*(N_j-1),1,T-1]); % reinterpret this as lower grid index + PolicyaprimejPath=repelem(PolicyaprimejPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejPath(:,2,:)=PolicyaprimejPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point + end + % Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats + PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,0,n_a,0,N_j,T-1,[],aprime_gridvals,vfoptions,1,1); % [size(PolicyValuesPath,1),N_a,N_j,T] + PolicyValuesPath=permute(PolicyValuesPath,[2,3,1,4]); %[N_a,N_j,l_aprime,T-1] % fastOLG ordering is needed for AggVars - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path - % Call AgentDist the current periods distn + %% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm + % Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate AgentDist=AgentDist_initial; for tt=1:T-1 - % Get the current optimal policy - Policy=PolicyPath(1,:,:,tt); - % Get t-1 PricePath and ParamPath before we update them if use_tminus1price==1 for pp=1:length(tminus1priceNames) @@ -113,11 +141,27 @@ end end - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz(AgentDist.*AgeWeights_T(:,tt),[], Policy, FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,0,l_a,l_a,N_a,[],aprime_gridvals,a_gridvals,1); + %% Get the current optimal policy, and iterate the agent dist + if transpathoptions.trivialjequalonedist==0 + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + end + + AgeWeights=AgeWeights_T(:,tt); + + % simoptions.fastOLG=1 is hardcoded + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_raw(AgentDist,PolicyaprimejPath(:,tt),N_a,N_j,II1orII,II2,jequalOneDist); % II1orII is II1 + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_raw(AgentDist,PolicyaprimejPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_j,II1orII,jequalOneDist); % II1orII is II + end + + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz(AgentDist.*AgeWeights,[], PolicyValuesPath(:,:,:,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,0,l_a,l_a,N_a,a_gridvals,1); for ii=1:length(AggVarNames) Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; end + %% General Eqm Eqns % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); PricePathNew(tt,:)=PricePathNew_tt; @@ -130,11 +174,7 @@ end end - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - % simoptions.fastOLG=1 is hardcoded - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_raw(AgentDist,reshape(Policy(1,:,1:end-1),[1,N_a*(N_j-1)]),N_a,N_j,jequalOneDist); + AgentDist=AgentDistnext; end @@ -145,10 +185,8 @@ % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges if transpathoptions.verbose==1 - pathcounter disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) + % Would be nice to have a way to get the iteration count without having the whole printout of path values (I think that would be useful?) pathnametitles{:} [PricePathOld,PricePathNew] end diff --git a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_nod_noz_e.m b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_nod_noz_e.m index 4b493332..d050d383 100644 --- a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_nod_noz_e.m +++ b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_nod_noz_e.m @@ -1,4 +1,4 @@ -function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_nod_noz_e(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_e,N_j, N_a,N_e, l_a,l_e, aprime_gridvals,a_gridvals,a_grid,e_gridvals_J, pi_e_J,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluate, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) +function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_nod_noz_e(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_e,N_j, N_a,N_e, l_aprime,l_a,l_e, aprime_gridvals,a_gridvals,a_grid,e_gridvals_J,e_gridvals_J_fastOLG, pi_e_J,pi_e_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, N_probs,II1orII,II2,exceptlastj,exceptfirstj,justfirstj, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) % fastOLG: fastOLG uses (a,j,e) instead of the standard (a,e,j) % This (a,j,e) is important for ability to implement codes based on matrix multiplications (especially for Tan improvement) @@ -15,9 +15,13 @@ end %% -PricePathDist=Inf; -pathcounter=1; +% interpret jequalOneDist input +if transpathoptions.trivialjequalonedist==0 + jequalOneDist_T=jequalOneDist; + jequalOneDist=jequalOneDist_T(:,1); +end +%% % fastOLG so everything is (a,j,e) % Shapes: % V is [N_a,N_j,N_e] @@ -25,19 +29,22 @@ PricePathNew=zeros(size(PricePathOld),'gpuArray'); PricePathNew(T,:)=PricePathOld(T,:); -AggVarsPath=zeros(T-1,length(FnsToEvaluate),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect GEcondnPath=zeros(T-1,length(GeneralEqmEqnsCell),'gpuArray'); -if transpathoptions.trivialjequalonedist==0 - jequalOneDist_T=jequalOneDist; - jequalOneDist=jequalOneDist_T(:,1); +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_aprime,N_a,N_j,N_e,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + PolicyIndexesPath=zeros(l_aprime+1,N_a,N_j,N_e,T-1,'gpuArray'); %Periods 1 to T-1 + PolicyProbsPath=zeros(N_a*(N_j-1)*N_e,N_probs,T-1,'gpuArray'); % preallocate end + %% +PricePathDist=Inf; +pathcounter=1; while PricePathDist>transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - - PolicyPath=zeros(1,N_a,N_j,N_e,T-1,'gpuArray'); %Periods 1 to T-1 - + %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. % Since we won't need to keep the value functions for anything later we just store the current one in V V=V_final; @@ -59,20 +66,43 @@ % The V input is next period value fn, the V output is this period. % Policy in fastOLG is [N_a,N_j,N_e] and contains the joint-index for (d,aprime) - PolicyPath(1,:,:,:,T-ttr)=Policy; % fastOLG: so a-by-j-by-z + PolicyIndexesPath(:,:,:,:,T-ttr)=Policy; % fastOLG: so a-by-j-by-z end + %% Modify PolicyIndexesPath into forms needed for forward iteration + % Create version of PolicyIndexesPath in form we want for the agent distribution iteration + % Creates PolicyaprimejzPath (omits j=N_j), and when using grid interpolation layer also PolicyProbsPath + if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:N_j-1,:,:),[N_a*(N_j-1)*N_e,T-1]); % aprime index + elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:N_j-1,:,:)+n_a(1)*(PolicyIndexesPath(2,:,1:N_j-1,:,:)-1),[N_a*(N_j-1)*N_e,T-1]); + elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:N_j-1,:,:)+n_a(1)*(PolicyIndexesPath(2,:,1:N_j-1,:,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(3,:,1:N_j-1,:,:)-1),[N_a*(N_j-1)*N_e,T-1]); + elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:N_j-1,:,:)+n_a(1)*(PolicyIndexesPath(2,:,1:N_j-1,:,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(3,:,1:N_j-1,:,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(4,:,1:N_j-1,:,:)-1),[N_a*(N_j-1)*N_e,T-1]); + end + PolicyaprimejPath=PolicyaprimePath+repmat(repelem(N_a*gpuArray(0:1:(N_j-1)-1)',N_a,1),N_e,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_aprime+1,:,1:N_j-1,:,:),[N_a*(N_j-1)*N_e,1,T-1]); % PolicyIndexesPath is of size [l_d+l_aprime+1,N_a,N_j,N_e,T-1] + PolicyaprimejPath=reshape(PolicyaprimejPath,[N_a*(N_j-1)*N_e,1,T-1]); % reinterpret this as lower grid index + PolicyaprimejPath=repelem(PolicyaprimejPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejPath(:,2,:)=PolicyaprimejPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point + end - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path + % Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats + PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,0,n_a,n_e,N_j,T-1,[],aprime_gridvals,vfoptions,1,1); % [size(PolicyValuesPath,1),N_a,N_j,N_e,T] + PolicyValuesPath=permute(PolicyValuesPath,[2,3,4,1,5]); %[N_a,N_j,N_e,l_aprime,T-1] % fastOLG ordering is needed for AggVars + - % Call AgentDist the current periods distn + %% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm + % Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate AgentDist=AgentDist_initial; for tt=1:T-1 - % Get the current optimal policy - Policy=PolicyPath(1,:,:,:,tt); % fastOLG: so a-by-j-by-z - % Get t-1 PricePath and ParamPath before we update them if use_tminus1price==1 for pp=1:length(tminus1priceNames) @@ -120,16 +150,32 @@ end end + %% Get the current optimal policy, and iterate the agent dist if transpathoptions.zpathtrivial==0 - e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,tt); + e_gridvals_J_fastOLG=transpathoptions.ze_gridvals_J_fastOLG(:,:,:,tt); pi_e_J_sim=transpathoptions.pi_e_J_sim_T(:,:,tt); % fastOLG value function uses (j,z,z') end - - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights_T(:,:,tt),[], Policy, FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,0,l_a,l_a,l_e,N_a,N_e,[],aprime_gridvals,a_gridvals,e_gridvals_J,1); + + if transpathoptions.trivialjequalonedist==0 + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + end + + AgeWeights=AgeWeights_T(:,:,tt); % By coincidence, this is same for fastOLG=0,1 + + % if simoptions.fastOLG=1 is hardcoded + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_e_raw(AgentDist,PolicyaprimejPath(:,tt),N_a,N_e,N_j,pi_e_J_sim,II1orII,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % II1orII is II1 + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_e_raw(AgentDist,PolicyaprimejPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_e,N_j,pi_e_J_sim,II1orII,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % II1orII is II + end + + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights,[], PolicyValuesPath(:,:,:,:,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,0,l_a,l_a,l_e,N_a,N_e,a_gridvals,e_gridvals_J_fastOLG,1); for ii=1:length(AggVarNames) Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; end + %% General Eqm Eqns % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); PricePathNew(tt,:)=PricePathNew_tt; @@ -142,11 +188,7 @@ end end - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - % if simoptions.fastOLG=1 is hardcoded - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_e_raw(AgentDist,reshape(Policy(1,:,1:end-1,:),[1,N_a*(N_j-1)*N_e]),N_a,N_e,N_j,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % Policy for jj=1:N_j-1 + AgentDist=AgentDistnext; end @@ -157,10 +199,8 @@ % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges if transpathoptions.verbose==1 - pathcounter disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) + % Would be nice to have a way to get the iteration count without having the whole printout of path values (I think that would be useful?) pathnametitles{:} [PricePathOld,PricePathNew] end diff --git a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_noz.m b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_noz.m index 5d1bdaa2..69715200 100644 --- a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_noz.m +++ b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_noz.m @@ -1,4 +1,4 @@ -function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_noz(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d, n_a, N_j, N_d,N_a, l_d,l_a, d_gridvals,aprime_gridvals,a_gridvals,d_grid,a_grid, ReturnFn, FnsToEvaluate, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) +function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_noz(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d, n_a, N_j, N_d,N_a, l_d,l_aprime,l_a, d_gridvals,aprime_gridvals,a_gridvals,d_grid,a_grid, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, N_probs,II1orII,II2,exceptlastj, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) % PricePathOld is matrix of size T-by-'number of prices' % ParamPath is matrix of size T-by-'number of parameters that change over path' @@ -14,9 +14,13 @@ end %% -PricePathDist=Inf; -pathcounter=1; +% interpret jequalOneDist input +if transpathoptions.trivialjequalonedist==0 + jequalOneDist_T=jequalOneDist; + jequalOneDist=jequalOneDist_T(:,1); +end +%% % fastOLG so everything is (a,j) % Shapes: % V is [N_a,N_j] @@ -24,18 +28,20 @@ PricePathNew=zeros(size(PricePathOld),'gpuArray'); PricePathNew(T,:)=PricePathOld(T,:); -AggVarsPath=zeros(T-1,length(FnsToEvaluate),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect GEcondnPath=zeros(T-1,length(GeneralEqmEqnsCell),'gpuArray'); -if transpathoptions.trivialjequalonedist==0 - jequalOneDist_T=jequalOneDist; - jequalOneDist=jequalOneDist_T(:,1); +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_d+l_aprime,N_a,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + PolicyIndexesPath=zeros(l_d+l_aprime+1,N_a,N_j,T-1,'gpuArray'); %Periods 1 to T-1 + PolicyProbsPath=zeros(N_a*(N_j-1),N_probs,T-1,'gpuArray'); % preallocate end %% +PricePathDist=Inf; +pathcounter=1; while PricePathDist>transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - - PolicyPath=zeros(2,N_a,N_j,T-1,'gpuArray'); %Periods 1 to T-1 %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. % Since we won't need to keep the value functions for anything later we just store the current one in V @@ -52,20 +58,40 @@ % The V input is next period value fn, the V output is this period. % Policy is kept in the form where it is just a single-value in (d,a') - PolicyPath(:,:,:,T-ttr)=Policy; + PolicyIndexesPath(:,:,:,T-ttr)=Policy; end - - - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path + %% Modify PolicyIndexesPath into forms needed for forward iteration + % Create version of PolicyIndexesPath in form we want for the agent distribution iteration + % Creates PolicyaprimejPath (omits j=N_j), and when using grid interpolation layer also PolicyProbsPath + if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:),[N_a*(N_j-1),T-1]); % aprime index + elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:)-1),[N_a*(N_j-1),T-1]); + elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,1:N_j-1,:)-1),[N_a*(N_j-1),T-1]); + elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(l_d+4,:,1:N_j-1,:)-1),[N_a*(N_j-1),T-1]); + end + PolicyaprimejPath=PolicyaprimePath+repelem(N_a*gpuArray(0:1:(N_j-1)-1)',N_a,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_d+l_aprime+1,:,1:N_j-1,:),[N_a*(N_j-1),1,T-1]); % PolicyIndexesPath is of size [l_d+l_aprime+1,N_a,N_j,T-1] + PolicyaprimejPath=reshape(PolicyaprimejPath,[N_a*(N_j-1),1,T-1]); % reinterpret this as lower grid index + PolicyaprimejPath=repelem(PolicyaprimejPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejPath(:,2,:)=PolicyaprimejPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point + end + % Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats + PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,n_d,n_a,0,N_j,T-1,d_gridvals,aprime_gridvals,vfoptions,1,1); % [size(PolicyValuesPath,1),N_a,N_j,T] + PolicyValuesPath=permute(PolicyValuesPath,[2,3,1,4]); %[N_a,N_j,l_d+l_aprime,T-1] % fastOLG ordering is needed for AggVars - % Call AgentDist the current periods distn + %% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm + % Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate AgentDist=AgentDist_initial; for tt=1:T-1 - - % Get the current optimal policy - Policy=PolicyPath(:,:,:,tt); - + % Get t-1 PricePath and ParamPath before we update them if use_tminus1price==1 for pp=1:length(tminus1priceNames) @@ -113,11 +139,27 @@ end end - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz(AgentDist.*AgeWeights_T(:,tt),Policy(1,:,:), Policy(2,:,:), FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,N_a,d_gridvals,aprime_gridvals,a_gridvals,1); + %% Get the current optimal policy, and iterate the agent dist + if transpathoptions.trivialjequalonedist==0 + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + end + + AgeWeights=AgeWeights_T(:,tt); + + % simoptions.fastOLG=1 is hardcoded + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_raw(AgentDist,PolicyaprimejPath(:,tt),N_a,N_j,II1orII,II2,jequalOneDist); % II1orII is II1 + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_raw(AgentDist,PolicyaprimejPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_j,II1orII,jequalOneDist); % II1orII is II + end + + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz(AgentDist.*AgeWeights,PolicyValuesPath(:,:,1:l_d,tt), PolicyValuesPath(:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,N_a,a_gridvals,1); for ii=1:length(AggVarNames) Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; end + %% General Eqm Eqns % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); PricePathNew(tt,:)=PricePathNew_tt; @@ -130,14 +172,10 @@ end end - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - % simoptions.fastOLG=1 is hardcoded - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_raw(AgentDist,reshape(Policy(2,:,1:end-1),[1,N_a*(N_j-1)]),N_a,N_j,jequalOneDist); + AgentDist=AgentDistnext; end - + %% Now update prices, give verbose feedback, and check for convergence % See how far apart the price paths are @@ -145,10 +183,8 @@ % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges if transpathoptions.verbose==1 - pathcounter disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) + % Would be nice to have a way to get the iteration count without having the whole printout of path values (I think that would be useful?) pathnametitles{:} [PricePathOld,PricePathNew] end diff --git a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_noz_e.m b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_noz_e.m index 670831bd..51c2494c 100644 --- a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_noz_e.m +++ b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_noz_e.m @@ -1,4 +1,4 @@ -function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_noz_e(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d, n_a, n_e, N_j, N_d,N_a,N_e, l_d,l_a,l_e, d_gridvals,aprime_gridvals,a_gridvals,d_grid,a_grid,e_gridvals_J, pi_e_J,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluate, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) +function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_fastOLG_noz_e(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d, n_a, n_e, N_j, N_d,N_a,N_e, l_d,l_aprime,l_a,l_e, d_gridvals,aprime_gridvals,a_gridvals,d_grid,a_grid,e_gridvals_J,e_gridvals_J_fastOLG, pi_e_J,pi_e_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, N_probs,II1orII,II2,exceptlastj,exceptfirstj,justfirstj, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) % fastOLG: fastOLG uses (a,j,e) instead of the standard (a,e,j) % This (a,j,e) is important for ability to implement codes based on matrix multiplications (especially for Tan improvement) @@ -15,9 +15,13 @@ end %% -PricePathDist=Inf; -pathcounter=1; +% interpret jequalOneDist input +if transpathoptions.trivialjequalonedist==0 + jequalOneDist_T=jequalOneDist; + jequalOneDist=jequalOneDist_T(:,1); +end +%% % fastOLG so everything is (a,j,e) % Shapes: % V is [N_a,N_j,N_e] @@ -25,18 +29,20 @@ PricePathNew=zeros(size(PricePathOld),'gpuArray'); PricePathNew(T,:)=PricePathOld(T,:); -AggVarsPath=zeros(T-1,length(FnsToEvaluate),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect GEcondnPath=zeros(T-1,length(GeneralEqmEqnsCell),'gpuArray'); -if transpathoptions.trivialjequalonedist==0 - jequalOneDist_T=jequalOneDist; - jequalOneDist=jequalOneDist_T(:,1); +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_d+l_aprime,N_a,N_j,N_e,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + PolicyIndexesPath=zeros(l_d+l_aprime+1,N_a,N_j,N_e,T-1,'gpuArray'); %Periods 1 to T-1 + PolicyProbsPath=zeros(N_a*(N_j-1)*N_e,N_probs,T-1,'gpuArray'); % preallocate end %% -while PricePathDist>transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - - PolicyPath=zeros(2,N_a,N_j,N_e,T-1,'gpuArray'); %Periods 1 to T-1 +PricePathDist=Inf; +pathcounter=1; +while PricePathDist>transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. % Since we won't need to keep the value functions for anything later we just store the current one in V @@ -59,20 +65,43 @@ % The V input is next period value fn, the V output is this period. % Policy in fastOLG is [N_a,N_j,N_e] and contains the joint-index for (d,aprime) - PolicyPath(:,:,:,:,T-ttr)=Policy; % fastOLG: so a-by-j-by-z + PolicyIndexesPath(:,:,:,:,T-ttr)=Policy; % fastOLG: so a-by-j-by-z end - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path + %% Modify PolicyIndexesPath into forms needed for forward iteration + % Create version of PolicyIndexesPath in form we want for the agent distribution iteration + % Creates PolicyaprimejzPath (omits j=N_j), and when using grid interpolation layer also PolicyProbsPath + if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:),[N_a*(N_j-1)*N_e,T-1]); % aprime index + elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:,:)-1),[N_a*(N_j-1)*N_e,T-1]); + elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,1:N_j-1,:,:)-1),[N_a*(N_j-1)*N_e,T-1]); + elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,1:N_j-1,:,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(l_d+4,:,1:N_j-1,:,:)-1),[N_a*(N_j-1)*N_e,T-1]); + end + PolicyaprimejPath=PolicyaprimePath+repmat(repelem(N_a*gpuArray(0:1:(N_j-1)-1)',N_a,1),N_e,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_d+l_aprime+1,:,1:N_j-1,:,:),[N_a*(N_j-1)*N_e,1,T-1]); % PolicyIndexesPath is of size [l_d+l_aprime+1,N_a,N_j,N_e,T-1] + PolicyaprimejPath=reshape(PolicyaprimejPath,[N_a*(N_j-1)*N_e,1,T-1]); % reinterpret this as lower grid index + PolicyaprimejPath=repelem(PolicyaprimejPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejPath(:,2,:)=PolicyaprimejPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point + end + % Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats + PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,n_d,n_a,n_e,N_j,T-1,d_gridvals,aprime_gridvals,vfoptions,1,1); % [size(PolicyValuesPath,1),N_a,N_j,N_e,T] + PolicyValuesPath=permute(PolicyValuesPath,[2,3,4,1,5]); %[N_a,N_j,N_e,l_d+l_aprime,T-1] % fastOLG ordering is needed for AggVars - % Call AgentDist the current periods distn + + %% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm + % Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate AgentDist=AgentDist_initial; for tt=1:T-1 - % Get the current optimal policy - Policy=PolicyPath(:,:,:,:,tt); % fastOLG: so a-by-j-by-z - % Get t-1 PricePath and ParamPath before we update them if use_tminus1price==1 for pp=1:length(tminus1priceNames) @@ -120,16 +149,32 @@ end end + %% Get the current optimal policy, and iterate the agent dist if transpathoptions.zpathtrivial==0 - e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,tt); + e_gridvals_J_fastOLG=transpathoptions.ze_gridvals_J_fastOLG(:,:,:,tt); pi_e_J_sim=transpathoptions.pi_e_J_sim_T(:,:,tt); % fastOLG value function uses (j,z,z') end - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights_T(:,:,tt),Policy(1,:,:,:), Policy(2,:,:,:), FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_e,N_a,N_e,d_gridvals,aprime_gridvals,a_gridvals,e_gridvals_J,1); + if transpathoptions.trivialjequalonedist==0 + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + end + + AgeWeights=AgeWeights_T(:,:,tt); % By coincidence, this is same for fastOLG=0,1 + + % simoptions.fastOLG=1 is hardcoded + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_e_raw(AgentDist,PolicyaprimejPath(:,tt),N_a,N_e,N_j,pi_e_J_sim,II1orII,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % II1orII is II1 + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_e_raw(AgentDist,PolicyaprimejPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_e,N_j,pi_e_J_sim,II1orII,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % II1orII is II + end + + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights, PolicyValuesPath(:,:,:,1:l_d,tt), PolicyValuesPath(:,:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_e,N_a,N_e,a_gridvals,e_gridvals_J_fastOLG,1); for ii=1:length(AggVarNames) Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; end + %% General Eqm Eqns % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); PricePathNew(tt,:)=PricePathNew_tt; @@ -142,11 +187,7 @@ end end - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - % simoptions.fastOLG=1 is hardcoded - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_e_raw(AgentDist,reshape(Policy(2,:,1:end-1,:),[1,N_a*(N_j-1)*N_e]),N_a,N_e,N_j,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % Policy for jj=1:N_j-1 + AgentDist=AgentDistnext; end @@ -157,10 +198,8 @@ % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges if transpathoptions.verbose==1 - pathcounter disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) + % Would be nice to have a way to get the iteration count without having the whole printout of path values (I think that would be useful?) pathnametitles{:} [PricePathOld,PricePathNew] end diff --git a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_nod.m b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_nod.m index 01dd31b1..440ddb10 100644 --- a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_nod.m +++ b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_nod.m @@ -1,4 +1,4 @@ -function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_nod(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_z,N_j, N_a,N_z, l_a,l_z, aprime_gridvals,a_gridvals,a_grid,z_gridvals_J,z_gridvals_J_fastOLG, pi_z_J,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluate, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) +function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_nod(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_z,N_j, N_a,N_z, l_aprime,l_a,l_z, a_gridvals,a_grid,z_gridvals_J,z_gridvals_J_fastOLG, pi_z_J,pi_z_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) % PricePathOld is matrix of size T-by-'number of prices' % ParamPath is matrix of size T-by-'number of parameters that change over path' @@ -12,10 +12,13 @@ end %% +% interpret jequalOneDist input +if transpathoptions.trivialjequalonedist==0 + jequalOneDist_T=jequalOneDist; + jequalOneDist=jequalOneDist_T(:,1); +end -PricePathDist=Inf; -pathcounter=1; - +%% % Shapes: % V is [N_a,N_z,N_j] % AgentDist for basic is [N_a*N_z,N_j] @@ -23,19 +26,43 @@ PricePathNew=zeros(size(PricePathOld),'gpuArray'); PricePathNew(T,:)=PricePathOld(T,:); -AggVarsPath=zeros(T-1,length(FnsToEvaluate),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect GEcondnPath=zeros(T-1,length(GeneralEqmEqnsCell),'gpuArray'); -if transpathoptions.trivialjequalonedist==0 - jequalOneDist_T=jequalOneDist; - jequalOneDist=jequalOneDist_T(:,1); +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_aprime,N_a,N_z,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + PolicyIndexesPath=zeros(l_aprime+1,N_a,N_z,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +end +if simoptions.gridinterplayer==0 + if simoptions.fastOLG==0 + II1=1:1:N_a*N_z; + II2=ones(N_a*N_z,1); + elseif simoptions.fastOLG==1 + II1=1:1:N_a*(N_j-1)*N_z; + II2=ones(N_a*(N_j-1)*N_z,1); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_z,1)+N_a*N_j*repelem((0:1:N_z-1)',N_a,1); + end +elseif simoptions.gridinterplayer==1 + N_probs=2; + if simoptions.fastOLG==0 + error('Cannot use simoptions.fastOLG=0 with grid interpolation layer') + elseif simoptions.fastOLG==1 + PolicyProbsPath=zeros(N_a*(N_j-1)*N_z,N_probs,T-1,'gpuArray'); % preallocate + II=repelem((1:1:N_a*(N_j-1)*N_z)',1,N_probs); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_z,1)+N_a*N_j*repelem((0:1:N_z-1)',N_a,1); + end end %% +PricePathDist=Inf; +pathcounter=1; while PricePathDist>transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - PolicyPath=zeros(1,N_a,N_z,N_j,T-1,'gpuArray'); %Periods 1 to T-1 - %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. % Since we won't need to keep the value functions for anything later we just store the current one in V V=V_final; @@ -57,19 +84,47 @@ % The V input is next period value fn, the V output is this period. % Policy is kept in the form where it is just a single-value in (d,a') - PolicyPath(1,:,:,:,T-ttr)=Policy; + PolicyIndexesPath(:,:,:,:,T-ttr)=Policy; end - - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path + %% Modify PolicyIndexesPath into forms needed for forward iteration + % Create version of PolicyIndexesPath called PolicyaprimePath, which only tracks aprime and has j=1:N_j-1 as we don't use N_j to iterate agent dist (there is no N_j+1) + % For fastOLG we use PolicyaprimejPath, if there is z then PolicyaprimejzPath + % When using grid interpolation layer also PolicyProbsPath + if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,:,1:N_j-1,:),[N_a*N_z,N_j-1,T-1]); % aprime index + elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(2,:,:,1:N_j-1,:)-1),[N_a*N_z,N_j-1,T-1]); + elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(2,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(3,:,:,1:N_j-1,:)-1),[N_a*N_z,N_j-1,T-1]); + elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(2,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(3,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(4,:,:,1:N_j-1,:)-1),[N_a*N_z,N_j-1,T-1]); + end + if simoptions.fastOLG==0 + PolicyaprimezPath_slowOLG=PolicyaprimePath+repelem(N_a*gpuArray(0:1:N_z-1)',N_a,1); + elseif simoptions.fastOLG==1 + PolicyaprimePath=reshape(permute(reshape(PolicyaprimePath,[N_a,N_z,N_j-1,T-1]),[1,3,2,4]),[N_a*(N_j-1)*N_z,T-1]); + PolicyaprimejzPath=PolicyaprimePath+repelem(N_a*gpuArray(0:1:(N_j-1)*N_z-1)',N_a,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_aprime+1,:,:,1:N_j-1,:),[1,N_a,N_z,N_j-1,T-1]); % PolicyIndexesPath is of size [l_d+l_aprime+1,N_a,N_z,N_j,T-1] + L2index=reshape(permute(L2index,[2,4,3,1,5]),[N_a*(N_j-1)*N_z,1,T-1]); + PolicyaprimejzPath=reshape(PolicyaprimejzPath,[N_a*(N_j-1)*N_z,1,T-1]); % reinterpret this as lower grid index + PolicyaprimejzPath=repelem(PolicyaprimejzPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejzPath(:,2,:)=PolicyaprimejzPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point + end + end + % Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats + PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,0,n_a,n_z,N_j,T-1,[],a_grid,vfoptions,1,0); + PolicyValuesPath=permute(PolicyValuesPath,[2,4,3,1,5]); %[N_a,N_j,N_z,l_aprime,T-1] % fastOLG ordering is needed for AggVars - % Call AgentDist the current periods distn + %% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm + % Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate AgentDist=AgentDist_initial; for tt=1:T-1 - % Get the current optimal policy - Policy=PolicyPath(1,:,:,:,tt); - % Get t-1 PricePath and ParamPath before we update them if use_tminus1price==1 for pp=1:length(tminus1priceNames) @@ -117,8 +172,9 @@ end end + %% Get the current optimal policy, and iterate the agent dist if transpathoptions.zpathtrivial==0 - z_gridvals_J=transpathoptions.z_gridvals_J_T(:,:,:,tt); + z_gridvals_J_fastOLG=transpathoptions.ze_gridvals_J_fastOLG(:,:,:,tt); if simoptions.fastOLG==0 pi_z_J=transpathoptions.pi_z_J_T(:,:,:,tt); else @@ -132,12 +188,27 @@ AgeWeights=AgeWeights_T(:,tt); end - Policy_fastOLG_aprime=reshape(permute(Policy(1,:,:,:),[1,2,4,3]),[1,N_a*N_j*N_z]); - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights,[], Policy_fastOLG_aprime, FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,0,l_a,l_a,l_z,N_a,N_z,[],aprime_gridvals,a_gridvals,z_gridvals_J_fastOLG,1); + if transpathoptions.trivialjequalonedist==0 + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + end + + if simoptions.fastOLG==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_Iteration_raw(AgentDist,PolicyaprimezPath_slowOLG(:,:,tt),N_a,N_z,N_j,pi_z_J,II1,II2,jequalOneDist); + else % simoptions.fastOLG==1 + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_raw(AgentDist,PolicyaprimejzPath(:,tt),N_a,N_z,N_j,pi_z_J_sim,II1,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_raw(AgentDist,PolicyaprimejzPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_z,N_j,N_probs,pi_z_J_sim,II,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + end + end + + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights,[], PolicyValuesPath(:,:,:,:,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,0,l_a,l_a,l_z,N_a,N_z,a_gridvals,z_gridvals_J_fastOLG,1); for ii=1:length(AggVarNames) Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; end + %% General Eqm Eqns % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); PricePathNew(tt,:)=PricePathNew_tt; @@ -150,14 +221,7 @@ end end - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - if simoptions.fastOLG==0 - AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_raw(AgentDist,Policy,N_a,N_z,N_j,pi_z_J,jequalOneDist); - else % simoptions.fastOLG==1 - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_raw(AgentDist,Policy_fastOLG_aprime(exceptlastj),N_a,N_z,N_j,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); - end + AgentDist=AgentDistnext; end @@ -168,10 +232,8 @@ % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges if transpathoptions.verbose==1 - pathcounter disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) + % Would be nice to have a way to get the iteration count without having the whole printout of path values (I think that would be useful?) pathnametitles{:} [PricePathOld,PricePathNew] end diff --git a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_nod_e.m b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_nod_e.m index a132ce8a..04af9c71 100644 --- a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_nod_e.m +++ b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_nod_e.m @@ -1,4 +1,4 @@ -function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_nod_e(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_z,n_e,N_j, N_a,N_z,N_e,N_ze, l_a,l_z,l_e,l_ze, aprime_gridvals,a_gridvals,a_grid,z_gridvals_J,e_gridvals_J,ze_gridvals_J, pi_z_J,pi_e_J,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluate, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) +function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_nod_e(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_z,n_e,N_j, N_a,N_z,N_e,N_ze, l_aprime,l_a,l_z,l_e,l_ze, a_gridvals,a_grid,z_gridvals_J,e_gridvals_J,ze_gridvals_J_fastOLG, pi_z_J,pi_e_J,pi_z_J_sim,pi_e_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) % PricePathOld is matrix of size T-by-'number of prices' % ParamPath is matrix of size T-by-'number of parameters that change over path' @@ -11,12 +11,14 @@ end end - %% +% interpret jequalOneDist input +if transpathoptions.trivialjequalonedist==0 + jequalOneDist_T=jequalOneDist; + jequalOneDist=jequalOneDist_T(:,1); +end -PricePathDist=Inf; -pathcounter=1; - +%% % Shapes: % V is [N_a,N_z,N_e,N_j] % AgentDist for basic is [N_a*N_z*N_e,N_j] @@ -24,17 +26,43 @@ PricePathNew=zeros(size(PricePathOld),'gpuArray'); PricePathNew(T,:)=PricePathOld(T,:); -AggVarsPath=zeros(T-1,length(FnsToEvaluate),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect GEcondnPath=zeros(T-1,length(GeneralEqmEqnsCell),'gpuArray'); -if transpathoptions.trivialjequalonedist==0 - jequalOneDist_T=jequalOneDist; - jequalOneDist=jequalOneDist_T(:,1); +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_aprime,N_a,N_z,N_e,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + PolicyIndexesPath=zeros(l_aprime+1,N_a,N_z,N_e,N_j,T-1,'gpuArray'); %Periods 1 to T-1 end +if simoptions.gridinterplayer==0 + if simoptions.fastOLG==0 + II1=1:1:N_a*N_z*N_e; + II2=ones(N_a*N_z*N_e,1); + elseif simoptions.fastOLG==1 + II1=1:1:N_a*(N_j-1)*N_z*N_e; + II2=ones(N_a*(N_j-1)*N_z*N_e,1); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_z*N_e,1)+N_a*N_j*repelem((0:1:N_z*N_e-1)',N_a,1); + end +elseif simoptions.gridinterplayer==1 + N_probs=2; + if simoptions.fastOLG==0 + error('Cannot use simoptions.fastOLG=0 with grid interpolation layer') + elseif simoptions.fastOLG==1 + PolicyProbsPath=zeros(N_a*(N_j-1)*N_z*N_e,N_probs,T-1,'gpuArray'); % preallocate + II=repelem((1:1:N_a*(N_j-1)*N_z*N_e)',1,N_probs); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_z*N_e,1)+N_a*N_j*repelem((0:1:N_z*N_e-1)',N_a,1); + end +end + %% +PricePathDist=Inf; +pathcounter=1; while PricePathDist>transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - PolicyPath=zeros(1,N_a,N_z,N_e,N_j,T-1,'gpuArray'); % Periods 1 to T-1 %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. % Since we won't need to keep the value functions for anything later we just store the current one in V @@ -61,19 +89,47 @@ % The V input is next period value fn, the V output is this period. % Policy is kept in the form where it is just a single-value in (d,a') - PolicyPath(1,:,:,:,:,T-ttr)=Policy; + PolicyIndexesPath(:,:,:,:,:,T-ttr)=Policy; end - - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path - - % Call AgentDist the current periods distn + %% Modify PolicyIndexesPath into forms needed for forward iteration + % Create version of PolicyIndexesPath called PolicyaprimePath, which only tracks aprime and has j=1:N_j-1 as we don't use N_j to iterate agent dist (there is no N_j+1) + % For fastOLG we use PolicyaprimejPath, if there is z then PolicyaprimejzPath + % When using grid interpolation layer also PolicyProbsPath + if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,:,:,1:N_j-1,:),[N_a*N_z*N_e,N_j-1,T-1]); % aprime index + elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(2,:,:,:,1:N_j-1,:)-1),[N_a*N_z*N_e,N_j-1,T-1]); + elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(2,:,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(3,:,:,:,1:N_j-1,:)-1),[N_a*N_z*N_e,N_j-1,T-1]); + elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(2,:,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(3,:,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(4,:,:,:,1:N_j-1,:)-1),[N_a*N_z*N_e,N_j-1,T-1]); + end + if simoptions.fastOLG==0 + PolicyaprimezPath_slowOLG=PolicyaprimePath+repmat(repelem(N_a*gpuArray(0:1:N_z-1)',N_a,1),N_e,1); + elseif simoptions.fastOLG==1 + PolicyaprimePath=reshape(permute(reshape(PolicyaprimePath,[N_a,N_z*N_e,N_j-1,T-1]),[1,3,2,4]),[N_a*(N_j-1)*N_z*N_e,T-1]); + PolicyaprimejzPath=PolicyaprimePath+repmat(repelem(N_a*gpuArray(0:1:(N_j-1)*N_z-1)',N_a,1),N_e,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_aprime+1,:,:,:,1:N_j-1,:),[1,N_a,N_z*N_e,N_j-1,T-1]); % PolicyIndexesPath is of size [l_d+l_aprime+1,N_a,N_z,N_e,N_j,T] + L2index=reshape(permute(L2index,[2,4,3,1,5]),[N_a*(N_j-1)*N_z*N_e,1,T-1]); + PolicyaprimejzPath=reshape(PolicyaprimejzPath,[N_a*(N_j-1)*N_z*N_e,1,T-1]); % reinterpret this as lower grid index + PolicyaprimejzPath=repelem(PolicyaprimejzPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejzPath(:,2,:)=PolicyaprimejzPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point + end + end + % Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats + PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,0,n_a,[n_z,n_e],N_j,T-1,[],a_grid,vfoptions,1,0); + PolicyValuesPath=permute(PolicyValuesPath,[2,4,3,1,5]); %[N_a,N_j,N_z*N_e,l_d+l_aprime,T-1] % fastOLG ordering is needed for AggVars + + %% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm + % Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate AgentDist=AgentDist_initial; for tt=1:T-1 - % Get the current optimal policy - Policy=PolicyPath(1,:,:,:,:,tt); - % Get t-1 PricePath and ParamPath before we update them if use_tminus1price==1 for pp=1:length(tminus1priceNames) @@ -121,8 +177,11 @@ end end + %% Get the current optimal policy, and iterate the agent dist + if transpathoptions.zepathtrivial==0 + ze_gridvals_J_fastOLG=transpathoptions.ze_gridvals_J_T_fastOLG(:,:,:,:,tt); + end if transpathoptions.zpathtrivial==0 - z_gridvals_J=transpathoptions.z_gridvals_J_T(:,:,:,tt); if simoptions.fastOLG==0 pi_z_J=transpathoptions.pi_z_J_T(:,:,:,tt); else @@ -130,7 +189,6 @@ end end if transpathoptions.epathtrivial==0 - e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,tt); if simoptions.fastOLG==0 pi_e_J=transpathoptions.pi_e_J_T(:,:,tt); else @@ -139,13 +197,28 @@ end AgeWeights=AgeWeights_T(:,:,tt); % by coincidence this is for fastOLG=0,1 + + if transpathoptions.trivialjequalonedist==0 + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + end + + if simoptions.fastOLG==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_Iteration_e_raw(AgentDist,PolicyaprimezPath_slowOLG(:,:,tt),N_a,N_z,N_e,N_j,pi_z_J,pi_e_J,II1,II2,jequalOneDist); + else % simoptions.fastOLG==1 + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_e_raw(AgentDist,PolicyaprimejzPath(:,tt),N_a,N_z,N_e,N_j,pi_z_J_sim, pi_e_J_sim,II1,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_e_raw(AgentDist,PolicyaprimejzPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,II,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + end + end - Policy_fastOLG_aprime=reshape(permute(Policy(1,:,:,:,:),[1,2,5,3,4]),[1,N_a*N_j*N_z*N_e]); - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights,[], Policy_fastOLG_aprime, FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,0,l_a,l_a,l_ze,N_a,N_ze,[],aprime_gridvals,a_gridvals,ze_gridvals_J,1); + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights,[], PolicyValuesPath(:,:,:,:,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,0,l_a,l_a,l_ze,N_a,N_ze,a_gridvals,ze_gridvals_J_fastOLG,1); for ii=1:length(AggVarNames) Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; end + %% General Eqm Eqns % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); PricePathNew(tt,:)=PricePathNew_tt; @@ -158,14 +231,7 @@ end end - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - if simoptions.fastOLG==0 - AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_e_raw(AgentDist,Policy,N_a,N_z,N_e,N_j,pi_z_J,pi_e_J,jequalOneDist); - else % simoptions.fastOLG==1 - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_e_raw(AgentDist,Policy_fastOLG_aprime(exceptlastj),N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); - end + AgentDist=AgentDistnext; end @@ -176,10 +242,8 @@ % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges if transpathoptions.verbose==1 - pathcounter disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) + % Would be nice to have a way to get the iteration count without having the whole printout of path values (I think that would be useful?) pathnametitles{:} [PricePathOld,PricePathNew] end diff --git a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_nod_noz.m b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_nod_noz.m index e82cd563..83c9921a 100644 --- a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_nod_noz.m +++ b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_nod_noz.m @@ -1,4 +1,4 @@ -function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_nod_noz(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,N_j, N_a, l_a, aprime_gridvals,a_gridvals,a_grid, ReturnFn, FnsToEvaluate, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) +function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_nod_noz(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,N_j, N_a, l_aprime,l_a ,a_gridvals,a_grid, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) % PricePathOld is matrix of size T-by-'number of prices' % ParamPath is matrix of size T-by-'number of parameters that change over path' @@ -12,9 +12,13 @@ end %% -PricePathDist=Inf; -pathcounter=1; +% interpret jequalOneDist input +if transpathoptions.trivialjequalonedist==0 + jequalOneDist_T=jequalOneDist; + jequalOneDist=jequalOneDist_T(:,1); +end +%% % Shapes: % V is [N_a,N_j] % AgentDist for basic is [N_a,N_j] @@ -22,18 +26,37 @@ PricePathNew=zeros(size(PricePathOld),'gpuArray'); PricePathNew(T,:)=PricePathOld(T,:); -AggVarsPath=zeros(T-1,length(FnsToEvaluate),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect GEcondnPath=zeros(T-1,length(GeneralEqmEqnsCell),'gpuArray'); -if transpathoptions.trivialjequalonedist==0 - jequalOneDist_T=jequalOneDist; - jequalOneDist=jequalOneDist_T(:,1); +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_aprime,N_a,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + PolicyIndexesPath=zeros(l_aprime+1,N_a,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +end +if simoptions.gridinterplayer==0 + if simoptions.fastOLG==0 + II1=1:1:N_a; + II2=ones(N_a,1); + elseif simoptions.fastOLG==1 + II1=1:1:N_a*(N_j-1); + II2=ones(N_a*(N_j-1),1); + end +elseif simoptions.gridinterplayer==1 + N_probs=2; + if simoptions.fastOLG==0 + error('Cannot use simoptions.fastOLG=0 with grid interpolation layer') + elseif simoptions.fastOLG==1 + PolicyProbsPath=zeros(N_a*(N_j-1),N_probs,T-1,'gpuArray'); % preallocate + II=repelem((1:1:N_a*(N_j-1))',1,N_probs); + end end + %% +PricePathDist=Inf; +pathcounter=1; while PricePathDist>transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - PolicyPath=zeros(1,N_a,N_j,T-1,'gpuArray'); %Periods 1 to T-1 - %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. % Since we won't need to keep the value functions for anything later we just store the current one in V V=V_final; @@ -49,20 +72,48 @@ % The V input is next period value fn, the V output is this period. % Policy is kept in the form where it is just a single-value in (d,a') - PolicyPath(1,:,:,T-tt)=Policy; + PolicyIndexesPath(:,:,:,T-tt)=Policy; end + %% Modify PolicyIndexesPath into forms needed for forward iteration + % Create version of PolicyPath called PolicyaprimePath, which only tracks aprime and has j=1:N_j-1 as we don't use N_j to iterate agent dist (there is no N_j+1) + % For fastOLG we use PolicyaprimejPath, if there is z then PolicyaprimejzPath + % When using grid interpolation layer also PolicyProbsPath + if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:N_j-1,:),[N_a,N_j-1,T-1]); % aprime index + elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(2,:,1:N_j-1,:)-1),[N_a,N_j-1,T-1]); + elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(2,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(3,:,1:N_j-1,:)-1),[N_a,N_j-1,T-1]); + elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(2,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(3,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(4,:,1:N_j-1,:)-1),[N_a,N_j-1,T-1]); + end + if simoptions.fastOLG==0 + PolicyaprimePath_slowOLG=PolicyaprimePath; + elseif simoptions.fastOLG==1 + PolicyaprimePath=reshape(permute(reshape(PolicyaprimePath,[N_a,N_j-1,T-1]),[1,2,3]),[N_a*(N_j-1),T-1]); + PolicyaprimejPath=PolicyaprimePath+repelem(N_a*gpuArray(0:1:(N_j-1)-1)',N_a,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_aprime+1,:,1:N_j-1,:),[1,N_a,N_j-1,T-1]); % PolicyPath is of size [l_d+l_aprime+1,N_a,N_j,T] + L2index=reshape(permute(L2index,[2,3,1,4]),[N_a*(N_j-1),1,T-1]); + PolicyaprimejPath=reshape(PolicyaprimejPath,[N_a*(N_j-1),1,T-1]); % reinterpret this as lower grid index + PolicyaprimejPath=repelem(PolicyaprimejPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejPath(:,2,:)=PolicyaprimejPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point + end + end + % Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats + PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,0,n_a,0,N_j,T-1,[],a_grid,vfoptions,1,0); + PolicyValuesPath=permute(PolicyValuesPath,[2,3,1,4]); %[N_a,N_j,l_aprime,T-1] % fastOLG ordering is needed for AggVars - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path - - % Call AgentDist the current periods distn + %% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm + % Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate AgentDist=AgentDist_initial; for tt=1:T-1 - - % Get the current optimal policy - Policy=PolicyPath(1,:,:,tt); - + % Get t-1 PricePath and ParamPath before we update them if use_tminus1price==1 for pp=1:length(tminus1priceNames) @@ -110,17 +161,34 @@ end end + %% Get the current optimal policy, and iterate the agent dist if simoptions.fastOLG==0 AgeWeights=AgeWeights_T(:,:,tt); else % simoptions.fastOLG==1 AgeWeights=AgeWeights_T(:,tt); end - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz(AgentDist.*AgeWeights,[], Policy, FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,0,l_a,l_a,N_a,[],aprime_gridvals,a_gridvals,1); + if transpathoptions.trivialjequalonedist==0 + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + end + + if simoptions.fastOLG==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_Iteration_noz_raw(AgentDist,PolicyaprimePath_slowOLG(:,:,tt),N_a,N_j,II1,II2,jequalOneDist); + else % simoptions.fastOLG==1 + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_raw(AgentDist,PolicyaprimejPath(:,tt),N_a,N_j,II1,II2,jequalOneDist); + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_raw(AgentDist,PolicyaprimejPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_j,II,jequalOneDist); + end + end + + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz(AgentDist.*AgeWeights,[], PolicyValuesPath(:,:,:,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,0,l_a,l_a,N_a,a_gridvals,1); for ii=1:length(AggVarNames) Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; end + %% General Eqm Eqns % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); PricePathNew(tt,:)=PricePathNew_tt; @@ -133,15 +201,7 @@ end end - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - if simoptions.fastOLG==0 - AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_noz_raw(AgentDist,Policy,N_a,N_j,jequalOneDist); - else % simoptions.fastOLG==1 - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_raw(AgentDist,gather(reshape(Policy(1,:,1:end-1),[1,N_a*(N_j-1)])),N_a,N_j,jequalOneDist); - end - + AgentDist=AgentDistnext; end @@ -152,10 +212,8 @@ % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges if transpathoptions.verbose==1 - pathcounter disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) + % Would be nice to have a way to get the iteration count without having the whole printout of path values (I think that would be useful?) pathnametitles{:} [PricePathOld,PricePathNew] end diff --git a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_nod_noz_e.m b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_nod_noz_e.m index f543f50d..6b59f917 100644 --- a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_nod_noz_e.m +++ b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_nod_noz_e.m @@ -1,4 +1,4 @@ -function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_nod_noz_e(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_e,N_j, N_a,N_e, l_a,l_e, aprime_gridvals,a_gridvals,a_grid,e_gridvals_J,e_gridvals_J_fastOLG, pi_e_J,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluate, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) +function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_nod_noz_e(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_a,n_e,N_j, N_a,N_e, l_aprime,l_a,l_e, a_gridvals,a_grid,e_gridvals_J,e_gridvals_J_fastOLG, pi_e_J,pi_e_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) % PricePathOld is matrix of size T-by-'number of prices' % ParamPath is matrix of size T-by-'number of parameters that change over path' @@ -12,10 +12,13 @@ end %% +% interpret jequalOneDist input +if transpathoptions.trivialjequalonedist==0 + jequalOneDist_T=jequalOneDist; + jequalOneDist=jequalOneDist_T(:,1); +end -PricePathDist=Inf; -pathcounter=1; - +%% % Shapes: % V is [N_a,N_e,N_j] % AgentDist for basic is [N_a*N_e,N_j] @@ -23,19 +26,42 @@ PricePathNew=zeros(size(PricePathOld),'gpuArray'); PricePathNew(T,:)=PricePathOld(T,:); -AggVarsPath=zeros(T-1,length(FnsToEvaluate),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect GEcondnPath=zeros(T-1,length(GeneralEqmEqnsCell),'gpuArray'); -if transpathoptions.trivialjequalonedist==0 - jequalOneDist_T=jequalOneDist; - jequalOneDist=jequalOneDist_T(:,1); +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_aprime,N_a,N_e,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + PolicyIndexesPath=zeros(l_aprime+1,N_a,N_e,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +end +if simoptions.gridinterplayer==0 + if simoptions.fastOLG==0 + II1=1:1:N_a*N_e; + II2=ones(N_a*N_e,1); + elseif simoptions.fastOLG==1 + II1=1:1:N_a*(N_j-1)*N_e; + II2=ones(N_a*(N_j-1)*N_e,1); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_e,1)+N_a*N_j*repelem((0:1:N_e-1)',N_a,1); + end +elseif simoptions.gridinterplayer==1 + N_probs=2; + if simoptions.fastOLG==0 + error('Cannot use simoptions.fastOLG=0 with grid interpolation layer') + elseif simoptions.fastOLG==1 + PolicyProbsPath=zeros(N_a*(N_j-1)*N_e,N_probs,T-1,'gpuArray'); % preallocate + II=repelem((1:1:N_a*(N_j-1)*N_e)',1,N_probs); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_e,1)+N_a*N_j*repelem((0:1:N_e-1)',N_a,1); + end end %% +PricePathDist=Inf; +pathcounter=1; while PricePathDist>transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - PolicyPath=zeros(1,N_a,N_e,N_j,T-1,'gpuArray'); % Periods 1 to T-1 - - %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. % Since we won't need to keep the value functions for anything later we just store the current one in V V=V_final; @@ -57,19 +83,47 @@ % The V input is next period value fn, the V output is this period. % Policy is kept in the form where it is just a single-value in (d,a') - PolicyPath(1,:,:,:,T-ttr)=Policy; + PolicyIndexesPath(:,:,:,:,T-ttr)=Policy; end - - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path - - % Call AgentDist the current periods distn + %% Modify PolicyIndexesPath into forms needed for forward iteration + % Create version of PolicyIndexesPath called PolicyaprimePath, which only tracks aprime and has j=1:N_j-1 as we don't use N_j to iterate agent dist (there is no N_j+1) + % For fastOLG we use PolicyaprimejPath, if there is z then PolicyaprimejzPath + % When using grid interpolation layer also PolicyProbsPath + if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,:,1:N_j-1,:),[N_a*N_e,N_j-1,T-1]); % aprime index + elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(2,:,:,1:N_j-1,:)-1),[N_a*N_e,N_j-1,T-1]); + elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(2,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(3,:,:,1:N_j-1,:)-1),[N_a*N_e,N_j-1,T-1]); + elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(2,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(3,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(4,:,:,1:N_j-1,:)-1),[N_a*N_e,N_j-1,T-1]); + end + if simoptions.fastOLG==0 + PolicyaprimePath_slowOLG=PolicyaprimePath; + elseif simoptions.fastOLG==1 + PolicyaprimePath=reshape(permute(reshape(PolicyaprimePath,[N_a,N_e,N_j-1,T-1]),[1,3,2,4]),[N_a*(N_j-1)*N_e,T-1]); + PolicyaprimejPath=PolicyaprimePath+repmat(repelem(N_a*gpuArray(0:1:(N_j-1)-1)',N_a,1),N_e,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_aprime+1,:,:,1:N_j-1,:),[1,N_a,N_e,N_j-1,T-1]); % PolicyIndexesPath is of size [l_d+l_aprime+1,N_a,N_e,N_j,T] + L2index=reshape(permute(L2index,[2,4,3,1,5]),[N_a*(N_j-1)*N_e,1,T-1]); + PolicyaprimejPath=reshape(PolicyaprimejPath,[N_a*(N_j-1)*N_e,1,T-1]); % reinterpret this as lower grid index + PolicyaprimejPath=repelem(PolicyaprimejPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejPath(:,2,:)=PolicyaprimejPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point + end + end + % Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats + PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,0,n_a,n_e,N_j,T-1,[],a_grid,vfoptions,1,0); + PolicyValuesPath=permute(PolicyValuesPath,[2,4,3,1,5]); %[N_a,N_j,N_e,l_aprime,T-1] % fastOLG ordering is needed for AggVars + + %% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm + % Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate AgentDist=AgentDist_initial; for tt=1:T-1 - - % Get the current optimal policy - Policy=PolicyPath(1,:,:,:,tt); - + % Get t-1 PricePath and ParamPath before we update them if use_tminus1price==1 for pp=1:length(tminus1priceNames) @@ -117,8 +171,9 @@ end end - if transpathoptions.zpathtrivial==0 - e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,tt); + %% Get the current optimal policy, and iterate the agent dist + if transpathoptions.epathtrivial==0 + e_gridvals_J_fastOLG=transpathoptions.ze_gridvals_J_fastOLG(:,:,:,tt); if simoptions.fastOLG==0 pi_e_J=transpathoptions.pi_e_J_T(:,:,tt); else @@ -128,12 +183,27 @@ AgeWeights=AgeWeights_T(:,:,tt); % By coincidence, this is same for fastOLG=0,1 - Policy_fastOLG_aprime=reshape(permute(Policy(1,:,:,:),[1,2,4,3]),[1,N_a*N_j*N_e]); - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights,[], Policy_fastOLG_aprime, FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,0,l_a,l_a,l_e,N_a,N_e,[],aprime_gridvals,a_gridvals,e_gridvals_J_fastOLG,1); + if transpathoptions.trivialjequalonedist==0 + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + end + + if simoptions.fastOLG==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_Iteration_noz_e_raw(AgentDist,PolicyaprimePath_slowOLG(:,:,tt),N_a,N_e,N_j,pi_e_J,II1,II2,jequalOneDist); + else % simoptions.fastOLG==1 + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_e_raw(AgentDist,PolicyaprimejPath(:,tt),N_a,N_e,N_j,pi_e_J_sim,II1,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_e_raw(AgentDist,PolicyaprimejPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_e,N_j,pi_e_J_sim,II,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + end + end + + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights,[], PolicyValuesPath(:,:,:,:,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,0,l_a,l_a,l_e,N_a,N_e,a_gridvals,e_gridvals_J_fastOLG,1); for ii=1:length(AggVarNames) Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; end + %% General Eqm Eqns % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); PricePathNew(tt,:)=PricePathNew_tt; @@ -146,14 +216,7 @@ end end - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - if simoptions.fastOLG==0 - AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_noz_e_raw(AgentDist,Policy,N_a,N_e,N_j,pi_e_J,jequalOneDist); - else % simoptions.fastOLG==1 - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_e_raw(AgentDist,Policy_fastOLG_aprime(exceptlastj),N_a,N_e,N_j,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); - end + AgentDist=AgentDistnext; end @@ -164,10 +227,8 @@ % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges if transpathoptions.verbose==1 - pathcounter disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) + % Would be nice to have a way to get the iteration count without having the whole printout of path values (I think that would be useful?) pathnametitles{:} [PricePathOld,PricePathNew] end diff --git a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_noz.m b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_noz.m index f5786bc6..b6e57148 100644 --- a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_noz.m +++ b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_noz.m @@ -1,4 +1,4 @@ -function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_noz(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d, n_a, N_j, N_d,N_a, l_d,l_a, d_gridvals, aprime_gridvals,a_gridvals,a_grid, ReturnFn, FnsToEvaluate, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) +function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_noz(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d, n_a, N_j, N_d,N_a, l_d,l_aprime,l_a, d_gridvals,d_grid, a_gridvals,a_grid, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) % PricePathOld is matrix of size T-by-'number of prices' % ParamPath is matrix of size T-by-'number of parameters that change over path' @@ -12,9 +12,13 @@ end %% -PricePathDist=Inf; -pathcounter=1; +% interpret jequalOneDist input +if transpathoptions.trivialjequalonedist==0 + jequalOneDist_T=jequalOneDist; + jequalOneDist=jequalOneDist_T(:,1); +end +%% % Shapes: % V is [N_a,N_j] % AgentDist for basic is [N_a,N_j] @@ -22,18 +26,36 @@ PricePathNew=zeros(size(PricePathOld),'gpuArray'); PricePathNew(T,:)=PricePathOld(T,:); -AggVarsPath=zeros(T-1,length(FnsToEvaluate),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect GEcondnPath=zeros(T-1,length(GeneralEqmEqnsCell),'gpuArray'); -if transpathoptions.trivialjequalonedist==0 - jequalOneDist_T=jequalOneDist; - jequalOneDist=jequalOneDist_T(:,1); +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_d+l_aprime,N_a,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + PolicyIndexesPath=zeros(l_d+l_aprime+1,N_a,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +end +if simoptions.gridinterplayer==0 + if simoptions.fastOLG==0 + II1=1:1:N_a; + II2=ones(N_a,1); + elseif simoptions.fastOLG==1 + II1=1:1:N_a*(N_j-1); + II2=ones(N_a*(N_j-1),1); + end +elseif simoptions.gridinterplayer==1 + N_probs=2; + if simoptions.fastOLG==0 + error('Cannot use simoptions.fastOLG=0 with grid interpolation layer') + elseif simoptions.fastOLG==1 + PolicyProbsPath=zeros(N_a*(N_j-1),N_probs,T-1,'gpuArray'); % preallocate + II=repelem((1:1:N_a*(N_j-1))',1,N_probs); + end end %% +PricePathDist=Inf; +pathcounter=1; while PricePathDist>transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - PolicyPath=zeros(2,N_a,N_j,T-1,'gpuArray'); %Periods 1 to T-1 - %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. % Since we won't need to keep the value functions for anything later we just store the current one in V V=V_final; @@ -49,20 +71,47 @@ % The V input is next period value fn, the V output is this period. % Policy is kept in the form where it is just a single-value in (d,a') - PolicyPath(:,:,:,T-tt)=Policy; + PolicyIndexesPath(:,:,:,T-tt)=Policy; end + %% Modify PolicyIndexesPath into forms needed for forward iteration + % Create version of PolicyPath called PolicyaprimePath, which only tracks aprime and has j=1:N_j-1 as we don't use N_j to iterate agent dist (there is no N_j+1) + % For fastOLG we use PolicyaprimejPath, if there is z then PolicyaprimejzPath + % When using grid interpolation layer also PolicyProbsPath + if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:),[N_a,N_j-1,T-1]); % aprime index + elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:)-1),[N_a,N_j-1,T-1]); + elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,1:N_j-1,:)-1),[N_a,N_j-1,T-1]); + elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(l_d+4,:,1:N_j-1,:)-1),[N_a,N_j-1,T-1]); + end + if simoptions.fastOLG==0 + PolicyaprimePath_slowOLG=PolicyaprimePath; + elseif simoptions.fastOLG==1 + PolicyaprimePath=reshape(permute(reshape(PolicyaprimePath,[N_a,N_j-1,T-1]),[1,2,3]),[N_a*(N_j-1),T-1]); + PolicyaprimejPath=PolicyaprimePath+repelem(N_a*gpuArray(0:1:(N_j-1)-1)',N_a,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_d+l_aprime+1,:,1:N_j-1,:),[1,N_a,N_j-1,T-1]); % PolicyPath is of size [l_d+l_aprime+1,N_a,N_j,T] + L2index=reshape(permute(L2index,[2,3,1,4]),[N_a*(N_j-1),1,T-1]); + PolicyaprimejPath=reshape(PolicyaprimejPath,[N_a*(N_j-1),1,T-1]); % reinterpret this as lower grid index + PolicyaprimejPath=repelem(PolicyaprimejPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejPath(:,2,:)=PolicyaprimejPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point + end + end + % Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats + PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,n_d,n_a,0,N_j,T-1,d_grid,a_grid,vfoptions,1,0); + PolicyValuesPath=permute(PolicyValuesPath,[2,3,1,4]); %[N_a,N_j,l_d+l_aprime,T-1] % fastOLG ordering is needed for AggVars - - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path - - % Call AgentDist the current periods distn + %% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm + % Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate AgentDist=AgentDist_initial; for tt=1:T-1 - % Get the current optimal policy - Policy=PolicyPath(:,:,:,tt); - % Get t-1 PricePath and ParamPath before we update them if use_tminus1price==1 for pp=1:length(tminus1priceNames) @@ -110,17 +159,34 @@ end end + %% Get the current optimal policy, and iterate the agent dist if simoptions.fastOLG==0 AgeWeights=AgeWeights_T(:,:,tt); else % simoptions.fastOLG==1 AgeWeights=AgeWeights_T(:,tt); end - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz(AgentDist.*AgeWeights,Policy(1,:,:), Policy(2,:,:), FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,N_a,d_gridvals,aprime_gridvals,a_gridvals,1); + if transpathoptions.trivialjequalonedist==0 + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + end + + if simoptions.fastOLG==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_Iteration_noz_raw(AgentDist,PolicyaprimePath_slowOLG(:,:,tt),N_a,N_j,II1,II2,jequalOneDist); + else % simoptions.fastOLG==1 + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_raw(AgentDist,PolicyaprimejPath(:,tt),N_a,N_j,II1,II2,jequalOneDist); + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_raw(AgentDist,PolicyaprimejPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_j,II,jequalOneDist); + end + end + + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz(AgentDist.*AgeWeights,PolicyValuesPath(:,:,1:l_d,tt), PolicyValuesPath(:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,N_a,a_gridvals,1); for ii=1:length(AggVarNames) Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; end + %% General Eqm Eqns % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); PricePathNew(tt,:)=PricePathNew_tt; @@ -133,15 +199,7 @@ end end - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - if simoptions.fastOLG==0 - AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_noz_raw(AgentDist,Policy(2,:,:),N_a,N_j,jequalOneDist); - else % simoptions.fastOLG==1 - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_raw(AgentDist,gather(reshape(Policy(2,:,1:end-1),[1,N_a*(N_j-1)])),N_a,N_j,jequalOneDist); - end - + AgentDist=AgentDistnext; end @@ -152,10 +210,8 @@ % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges if transpathoptions.verbose==1 - pathcounter disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) + % Would be nice to have a way to get the iteration count without having the whole printout of path values (I think that would be useful?) pathnametitles{:} [PricePathOld,PricePathNew] end diff --git a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_noz_e.m b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_noz_e.m index d3a4fc17..1c6aa086 100644 --- a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_noz_e.m +++ b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_noz_e.m @@ -1,4 +1,4 @@ -function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_noz_e(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d,n_a,n_e,N_j, N_d,N_a,N_e, l_d,l_a,l_e, d_gridvals, aprime_gridvals,a_gridvals,a_grid,e_gridvals_J,e_gridvals_J_fastOLG, pi_e_J,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj, ReturnFn, FnsToEvaluate, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) +function [PricePathOld,GEcondnPath]=TransitionPath_FHorz_shooting_noz_e(PricePathOld, PricePathNames, PricePathSizeVec, l_p, ParamPath, ParamPathNames, ParamPathSizeVec, T, V_final, AgentDist_initial, jequalOneDist, n_d,n_a,n_e,N_j, N_d,N_a,N_e, l_d,l_aprime,l_a,l_e, d_gridvals,d_grid, a_gridvals,a_grid,e_gridvals_J,e_gridvals_J_fastOLG, pi_e_J,pi_e_J_sim, ReturnFn, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEeqnNames, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, AgeWeights_T, ReturnFnParamNames, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, vfoptions, simoptions, transpathoptions) % PricePathOld is matrix of size T-by-'number of prices' % ParamPath is matrix of size T-by-'number of parameters that change over path' @@ -12,10 +12,13 @@ end %% +% interpret jequalOneDist input +if transpathoptions.trivialjequalonedist==0 + jequalOneDist_T=jequalOneDist; + jequalOneDist=jequalOneDist_T(:,1); +end -PricePathDist=Inf; -pathcounter=1; - +%% % Shapes: % V is [N_a,N_e,N_j] % AgentDist for basic is [N_a*N_e,N_j] @@ -23,18 +26,43 @@ PricePathNew=zeros(size(PricePathOld),'gpuArray'); PricePathNew(T,:)=PricePathOld(T,:); -AggVarsPath=zeros(T-1,length(FnsToEvaluate),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect GEcondnPath=zeros(T-1,length(GeneralEqmEqnsCell),'gpuArray'); -if transpathoptions.trivialjequalonedist==0 - jequalOneDist_T=jequalOneDist; - jequalOneDist=jequalOneDist_T(:,1); +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_d+l_aprime,N_a,N_e,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + PolicyIndexesPath=zeros(l_d+l_aprime+1,N_a,N_e,N_j,T-1,'gpuArray'); %Periods 1 to T-1 end +if simoptions.gridinterplayer==0 + if simoptions.fastOLG==0 + II1=1:1:N_a*N_e; + II2=ones(N_a*N_e,1); + elseif simoptions.fastOLG==1 + II1=1:1:N_a*(N_j-1)*N_e; + II2=ones(N_a*(N_j-1)*N_e,1); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_e,1)+N_a*N_j*repelem((0:1:N_e-1)',N_a,1); + end +elseif simoptions.gridinterplayer==1 + N_probs=2; + if simoptions.fastOLG==0 + error('Cannot use simoptions.fastOLG=0 with grid interpolation layer') + elseif simoptions.fastOLG==1 + PolicyProbsPath=zeros(N_a*(N_j-1)*N_e,N_probs,T-1,'gpuArray'); % preallocate + II=repelem((1:1:N_a*(N_j-1)*N_e)',1,N_probs); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_e,1)+N_a*N_j*repelem((0:1:N_e-1)',N_a,1); + end +end + %% +PricePathDist=Inf; +pathcounter=1; while PricePathDist>transpathoptions.tolerance && pathcounter<=transpathoptions.maxiter - PolicyPath=zeros(2,N_a,N_e,N_j,T-1,'gpuArray'); % Periods 1 to T-1 - %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. % Since we won't need to keep the value functions for anything later we just store the current one in V @@ -57,19 +85,47 @@ % The V input is next period value fn, the V output is this period. % Policy is kept in the form where it is just a single-value in (d,a') - PolicyPath(:,:,:,:,T-ttr)=Policy; + PolicyIndexesPath(:,:,:,:,T-ttr)=Policy; end - - %% Now we have the PolicyPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path - - % Call AgentDist the current periods distn + %% Modify PolicyIndexesPath into forms needed for forward iteration + % Create version of PolicyIndexesPath called PolicyaprimePath, which only tracks aprime and has j=1:N_j-1 as we don't use N_j to iterate agent dist (there is no N_j+1) + % For fastOLG we use PolicyaprimejPath, if there is z then PolicyaprimejzPath + % When using grid interpolation layer also PolicyProbsPath + if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,1:N_j-1,:),[N_a*N_e,N_j-1,T-1]); % aprime index + elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,:,1:N_j-1,:)-1),[N_a*N_e,N_j-1,T-1]); + elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,:,1:N_j-1,:)-1),[N_a*N_e,N_j-1,T-1]); + elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(l_d+4,:,:,1:N_j-1,:)-1),[N_a*N_e,N_j-1,T-1]); + end + if simoptions.fastOLG==0 + PolicyaprimePath_slowOLG=PolicyaprimePath; + elseif simoptions.fastOLG==1 + PolicyaprimePath=reshape(permute(reshape(PolicyaprimePath,[N_a,N_e,N_j-1,T-1]),[1,3,2,4]),[N_a*(N_j-1)*N_e,T-1]); + PolicyaprimejPath=PolicyaprimePath+repmat(repelem(N_a*gpuArray(0:1:(N_j-1)-1)',N_a,1),N_e,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_d+l_aprime+1,:,:,1:N_j-1,:),[1,N_a,N_e,N_j-1,T-1]); % PolicyIndexesPath is of size [l_d+l_aprime+1,N_a,N_e,N_j,T] + L2index=reshape(permute(L2index,[2,4,3,1,5]),[N_a*(N_j-1)*N_e,1,T-1]); + PolicyaprimejPath=reshape(PolicyaprimejPath,[N_a*(N_j-1)*N_e,1,T-1]); % reinterpret this as lower grid index + PolicyaprimejPath=repelem(PolicyaprimejPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejPath(:,2,:)=PolicyaprimejPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point + end + end + % Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats + PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,n_d,n_a,n_e,N_j,T-1,d_grid,a_grid,vfoptions,1,0); + PolicyValuesPath=permute(PolicyValuesPath,[2,4,3,1,5]); %[N_a,N_j,N_e,l_d+l_aprime,T-1] % fastOLG ordering is needed for AggVars + + %% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm + % Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate AgentDist=AgentDist_initial; for tt=1:T-1 - - % Get the current optimal policy - Policy=PolicyPath(:,:,:,:,tt); - + % Get t-1 PricePath and ParamPath before we update them if use_tminus1price==1 for pp=1:length(tminus1priceNames) @@ -117,8 +173,9 @@ end end - if transpathoptions.zpathtrivial==0 - e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,tt); + %% Get the current optimal policy, and iterate the agent dist + if transpathoptions.epathtrivial==0 + e_gridvals_J_fastOLG=transpathoptions.ze_gridvals_J_fastOLG(:,:,:,tt); if simoptions.fastOLG==0 pi_e_J=transpathoptions.pi_e_J_T(:,:,tt); else @@ -128,13 +185,27 @@ AgeWeights=AgeWeights_T(:,:,tt); % By coincidence, this is same for fastOLG=0,1 - Policy_fastOLG_d=reshape(permute(Policy(1,:,:,:),[1,2,4,3]),[1,N_a*N_j*N_e]); - Policy_fastOLG_aprime=reshape(permute(Policy(2,:,:,:),[1,2,4,3]),[1,N_a*N_j*N_e]); - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights,Policy_fastOLG_d, Policy_fastOLG_aprime, FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_e,N_a,N_e,d_gridvals,aprime_gridvals,a_gridvals,e_gridvals_J_fastOLG,1); + if transpathoptions.trivialjequalonedist==0 + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + end + + if simoptions.fastOLG==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_Iteration_noz_e_raw(AgentDist,PolicyaprimePath_slowOLG(:,:,tt),N_a,N_e,N_j,pi_e_J,II1,II2,jequalOneDist); + else % simoptions.fastOLG==1 + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_e_raw(AgentDist,PolicyaprimejPath(:,tt),N_a,N_e,N_j,pi_e_J_sim,II1,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_e_raw(AgentDist,PolicyaprimejPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_e,N_j,pi_e_J_sim,II,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + end + end + + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights, PolicyValuesPath(:,:,:,1:l_d,tt), PolicyValuesPath(:,:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_e,N_a,N_e,a_gridvals,e_gridvals_J_fastOLG,1); for ii=1:length(AggVarNames) Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; end + %% General Eqm Eqns % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); PricePathNew(tt,:)=PricePathNew_tt; @@ -147,14 +218,7 @@ end end - if transpathoptions.trivialjequalonedist==0 - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - end - if simoptions.fastOLG==0 - AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_noz_e_raw(AgentDist,Policy(2,:,:,:),N_a,N_e,N_j,pi_e_J,jequalOneDist); - else % simoptions.fastOLG==1 - AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_e_raw(AgentDist,Policy_fastOLG_aprime(exceptlastj),N_a,N_e,N_j,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); - end + AgentDist=AgentDistnext; end @@ -165,10 +229,8 @@ % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges if transpathoptions.verbose==1 - pathcounter disp('Old, New') - % Would be nice to have a way to get the iteration count without having the whole - % printout of path values (I think that would be useful?) + % Would be nice to have a way to get the iteration count without having the whole printout of path values (I think that would be useful?) pathnametitles{:} [PricePathOld,PricePathNew] end diff --git a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_noz_e_raw.m b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_noz_e_raw.m deleted file mode 100644 index d52c60af..00000000 --- a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_noz_e_raw.m +++ /dev/null @@ -1,29 +0,0 @@ -function AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_noz_e_raw(AgentDist,Policy_aprime,PolicyProbs,N_a,N_e,N_j,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist) -% Parallelizes over age jj (age weights are handled elsewhere, here all are normalized to one) -% AgentDist is [N_a*N_j,N_e] % To be able to do Step 2 of Tan improvement it needs to be this form (note N_j then N_z,N_e) -% pi_e_J_sim is [N_a*(N_j-1),N_e] -% Policy_aprime is [N_a*(N_j-1)*N_e,2] -% PolicyProbs is [N_a*(N_j-1)*N_e,2] - -% Get AgentDist for periods 1:N_j-1 -% exceptlastj=kron(ones(1,(N_j-1)),1:1:N_a)+kron(N_a*(0:1:N_j-2),ones(1,N_a)); % Note: there is one use of N_j which is because we want to index AgentDist -AgentDist_tt=sparse(gather(reshape(AgentDist(exceptlastj),[N_a*(N_j-1)*N_e,1]))); % avoiding those that correspond to jj=N_j - -firststep=Policy_aprime+N_a*repmat(repelem((0:1:N_j-2)',N_a,1),N_e,2); -II=repelem((1:1:N_a*(N_j-1)*N_e)',1,2); - -Gammatranspose=sparse(firststep,II,PolicyProbs,N_a*(N_j-1),N_a*(N_j-1)*N_e); -% Note: N_j-1, not N_j -% Note that Gamma goes from (a,j,e) to (a',j) [Gammatranspose is has these reversed] - -AgentDist_tt=reshape(Gammatranspose*AgentDist_tt,[N_a*(N_j-1),1]); - -AgentDist_tt=gpuArray(full(AgentDist_tt)).*pi_e_J_sim; % put e' in - -% exceptfirstj=kron(ones(1,(N_j-1)),1:1:N_a)+kron(N_a*(1:1:N_j-1),ones(1,N_a)); % Note: there is one use of N_j which is because we want to index AgentDist -AgentDist(exceptfirstj)=AgentDist_tt; % N_a+1 is avoiding those that correspond to jj=1 - -AgentDist(justfirstj)=jequalOneDist; % age j=1 dist - - -end diff --git a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_noz_raw.m b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_noz_raw.m deleted file mode 100644 index cb9b0a5f..00000000 --- a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_noz_raw.m +++ /dev/null @@ -1,22 +0,0 @@ -function AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_noz_raw(AgentDist,Policy_aprime,PolicyProbs,N_a,N_j,jequalOneDist) -% Parallelizes over age jj (age weights are handled elsewhere, here all are normalized to one) -% AgentDist is [N_a*N_j,1] -% Policy_aprime is [N_a*(N_j-1),2] -% PolicyProbs is [N_a*(N_j-1),2] - - -AgentDist_tt=sparse(gather(reshape(AgentDist(1:end-N_a),[N_a*(N_j-1),1]))); % end-N_a is avoiding those that correspond to jj=N_j - -firststep=Policy_aprime+N_a*repelem((0:1:N_j-2)',N_a,2); -II=repelem((1:1:N_a*(N_j-1))',1,2); - -Gammatranspose=sparse(firststep,II,PolicyProbs,N_a*(N_j-1),N_a*(N_j-1)); % Note: sparse() will accumulate at repeated indices [only relevant at grid end points] -% Note: N_j-1, not N_j - -AgentDist_tt=Gammatranspose*AgentDist_tt; - -AgentDist(N_a+1:end)=gpuArray(full(AgentDist_tt)); % N_a+1 is avoiding those that correspond to jj=1 -AgentDist(1:N_a)=jequalOneDist; % age j=1 dist - - -end diff --git a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_e_raw.m b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_e_raw.m index 05c21516..1985a114 100644 --- a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_e_raw.m @@ -1,17 +1,22 @@ -function AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_e_raw(AgentDist,Policy_aprime,N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist) +function AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_e_raw(AgentDist,Policy_aprimejz,N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,II1,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist) % Parallelizes over age jj (age weights are handled elsewhere, here all are normalized to one) % AgentDist is [N_a*N_j*N_z,N_e] % To be able to do Step 2 of Tan improvement it needs to be this form (note N_j then N_z,N_e) -% pi_z_J_sim is [(N_j-1)*N_z,N_z] (j,z,z') +% pi_z_J_sim is [(N_j-1)*N_z,(N_j-1)*N_z] (j,z,j',z') % pi_e_J_sim is [N_a*(N_j-1)*N_z,N_e] -% Policy_aprime is [1,N_a*(N_j-1)*N_z*N_e] +% Policy_aprimejz is [N_a*(N_j-1)*N_z*N_e,1], already except last j + +% precompute +% II1=1:1:N_a*(N_j-1)*N_z*N_e; +% II2=ones(N_a*(N_j-1)*N_z*N_e,1); +% exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); +% exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); +% justfirstj=repmat((1:1:N_a)',N_z*N_e,1)+N_a*N_j*repelem((0:1:N_z*N_e-1)',N_a,1); % Get AgentDist for periods 1:N_j-1 -% exceptlastj=kron(ones(1,(N_j-1)*N_z),1:1:N_a)+kron(kron(ones(1,N_z),N_a*(0:1:N_j-2)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_z-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist AgentDist_tt=sparse(gather(reshape(AgentDist(exceptlastj),[N_a*(N_j-1)*N_z*N_e,1]))); % avoiding those that correspond to jj=N_j % Tan improvement Step 1 -firststep=Policy_aprime+kron(ones(1,N_e),kron(N_a*(0:1:(N_j-1)*N_z-1),ones(1,N_a))); -Gammatranspose=sparse(firststep,1:1:N_a*(N_j-1)*N_z*N_e,ones(N_a*(N_j-1)*N_z*N_e,1),N_a*(N_j-1)*N_z,N_a*(N_j-1)*N_z*N_e); +Gammatranspose=sparse(Policy_aprimejz,II1,II2,N_a*(N_j-1)*N_z,N_a*(N_j-1)*N_z*N_e); % Note: N_j-1, not N_j % Note that Gamma goes from (a,j,z,e) to (a',j,z) [Gammatranspose is has these reversed] @@ -24,9 +29,8 @@ % on j=2,...,N_j the diagonal for j actually corresponds to deterministic ageing AgentDist_tt=reshape(AgentDist_tt*pi_z_J_sim,[N_a*(N_j-1)*N_z,1]); -AgentDist_tt=gpuArray(full(AgentDist_tt)).*pi_e_J_sim; % put e' in +AgentDist_tt=gpuArray(full(AgentDist_tt.*pi_e_J_sim)); % put e' in -% exceptfirstj=kron(ones(1,(N_j-1)*N_z),1:1:N_a)+kron(kron(ones(1,N_z),N_a*(1:1:N_j-1)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_z-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist AgentDist(exceptfirstj)=AgentDist_tt; % N_a*N_z+1 is avoiding those that correspond to jj=1 AgentDist(justfirstj)=jequalOneDist; % age j=1 dist diff --git a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_e_raw.m b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_e_raw.m similarity index 53% rename from TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_e_raw.m rename to TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_e_raw.m index a4526686..186b626c 100644 --- a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_e_raw.m @@ -1,20 +1,23 @@ -function AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_e_raw(AgentDist,Policy_aprime,PolicyProbs,N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist) +function AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_e_raw(AgentDist,Policy_aprimejz,PolicyProbs,N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,II,exceptlastj,exceptfirstj,justfirstj,jequalOneDist) % Parallelizes over age jj (age weights are handled elsewhere, here all are normalized to one) % AgentDist is [N_a*N_j*N_z,N_e] % To be able to do Step 2 of Tan improvement it needs to be this form (note N_j then N_z,N_e) % pi_z_J_sim is [(N_j-1)*N_z,N_z] (j,z,z') % pi_e_J_sim is [N_a*(N_j-1)*N_z,N_e] -% Policy_aprime is [N_a*(N_j-1)*N_z*N_e,2] -% PolicyProbs is [N_a*(N_j-1)*N_z*N_e,2] +% Policy_aprime is [N_a*(N_j-1)*N_z*N_e,N_probs], already except last j +% PolicyProbs is [N_a*(N_j-1)*N_z*N_e,N_probs], already except last j + +% precomputed: +% II=repelem((1:1:N_a*(N_j-1)*N_z*N_e)',1,N_probs); +% policyexceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e*N_probs,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z*N_e*N_probs,1)+repelem(N_a*N_j*(0:1:N_z*N_e*N_probs-1)',N_a*(N_j-1),1); +% exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); +% exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); +% justfirstj=repmat((1:1:N_a)',N_z*N_e,1)+N_a*N_j*repelem((0:1:N_z*N_e-1)',N_a,1); % Get AgentDist for periods 1:N_j-1 -% exceptlastj=kron(ones(1,(N_j-1)*N_z),1:1:N_a)+kron(kron(ones(1,N_z),N_a*(0:1:N_j-2)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_z-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist AgentDist_tt=sparse(gather(reshape(AgentDist(exceptlastj),[N_a*(N_j-1)*N_z*N_e,1]))); % avoiding those that correspond to jj=N_j % Tan improvement Step 1 -firststep=Policy_aprime+repmat(repelem(N_a*(0:1:(N_j-1)*N_z-1)',N_a,1),N_e,2); -II=repelem((1:1:N_a*(N_j-1)*N_z*N_e)',1,2); - -Gammatranspose=sparse(firststep,II,PolicyProbs,N_a*(N_j-1)*N_z,N_a*(N_j-1)*N_z*N_e); +Gammatranspose=sparse(Policy_aprimejz,II,PolicyProbs,N_a*(N_j-1)*N_z,N_a*(N_j-1)*N_z*N_e); % Note: N_j-1, not N_j % Note that Gamma goes from (a,j,z,e) to (a',j,z) [Gammatranspose is has these reversed] @@ -29,7 +32,6 @@ AgentDist_tt=gpuArray(full(AgentDist_tt)).*pi_e_J_sim; % put e' in -% exceptfirstj=kron(ones(1,(N_j-1)*N_z),1:1:N_a)+kron(kron(ones(1,N_z),N_a*(1:1:N_j-1)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_z-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist AgentDist(exceptfirstj)=AgentDist_tt; % N_a*N_z+1 is avoiding those that correspond to jj=1 AgentDist(justfirstj)=jequalOneDist; % age j=1 dist diff --git a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_e_raw.m b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_e_raw.m new file mode 100644 index 00000000..45c95d74 --- /dev/null +++ b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_e_raw.m @@ -0,0 +1,31 @@ +function AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_e_raw(AgentDist,Policy_aprimej,PolicyProbs,N_a,N_e,N_j,pi_e_J_sim,II,exceptlastj,exceptfirstj,justfirstj,jequalOneDist) +% Parallelizes over age jj (age weights are handled elsewhere, here all are normalized to one) +% AgentDist is [N_a*N_j,N_e] % To be able to do Step 2 of Tan improvement it needs to be this form (note N_j then N_z,N_e) +% pi_e_J_sim is [N_a*(N_j-1),N_e] +% Policy_aprime is [N_a*(N_j-1)*N_e,N_probs], already except last j +% PolicyProbs is [N_a*(N_j-1)*N_e,N_probs], already except last j + +% precomputed +% II=repelem((1:1:N_a*(N_j-1)*N_e)',1,N_probs); +% policyexceptlastj=repmat((1:1:N_a)',(N_j-1)*N_e*N_probs,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_e*N_probs,1)+repelem(N_a*N_j*(0:1:N_e*N_probs-1)',N_a*(N_j-1),1); +% exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); +% exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); +% justfirstj=repmat((1:1:N_a)',N_e,1)+N_a*N_j*repelem((0:1:N_e-1)',N_a,1); + +% Get AgentDist for periods 1:N_j-1 +AgentDist_tt=sparse(gather(reshape(AgentDist(exceptlastj),[N_a*(N_j-1)*N_e,1]))); % avoiding those that correspond to jj=N_j + +Gammatranspose=sparse(Policy_aprimej,II,PolicyProbs,N_a*(N_j-1),N_a*(N_j-1)*N_e); +% Note: N_j-1, not N_j +% Note that Gamma goes from (a,j,e) to (a',j) [Gammatranspose is has these reversed] + +AgentDist_tt=reshape(Gammatranspose*AgentDist_tt,[N_a*(N_j-1),1]); + +AgentDist_tt=gpuArray(full(AgentDist_tt)).*pi_e_J_sim; % put e' in + +AgentDist(exceptfirstj)=AgentDist_tt; % N_a+1 is avoiding those that correspond to jj=1 + +AgentDist(justfirstj)=jequalOneDist; % age j=1 dist + + +end diff --git a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_raw.m b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_raw.m new file mode 100644 index 00000000..193688d9 --- /dev/null +++ b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_raw.m @@ -0,0 +1,22 @@ +function AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_raw(AgentDist,Policy_aprimej,PolicyProbs,N_a,N_j,II,jequalOneDist) +% Parallelizes over age jj (age weights are handled elsewhere, here all are normalized to one) +% AgentDist is [N_a*N_j,1] +% Policy_aprime is [N_a*(N_j-1),N_probs], already except last j +% PolicyProbs is [N_a*(N_j-1),N_probs], already except last j + +% precomputed +% II=repelem((1:1:N_a*(N_j-1))',1,N_probs); +% policyexceptlastj=repmat((1:1:N_a)',(N_j-1)*N_probs,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_probs,1)+repelem(N_a*N_j*(0:1:N_probs-1)',N_a*(N_j-1),1); + +AgentDist_tt=sparse(gather(reshape(AgentDist(1:end-N_a),[N_a*(N_j-1),1]))); % end-N_a is avoiding those that correspond to jj=N_j + +Gammatranspose=sparse(Policy_aprimej,II,PolicyProbs,N_a*(N_j-1),N_a*(N_j-1)); % Note: sparse() will accumulate at repeated indices [only relevant at grid end points] +% Note: N_j-1, not N_j + +AgentDist_tt=Gammatranspose*AgentDist_tt; + +AgentDist(N_a+1:end)=gpuArray(full(AgentDist_tt)); % N_a+1 is avoiding those that correspond to jj=1 +AgentDist(1:N_a)=jequalOneDist; % age j=1 dist + + +end diff --git a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_raw.m b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_raw.m similarity index 51% rename from TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_raw.m rename to TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_raw.m index 4c2ab1bc..3f065ed7 100644 --- a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_raw.m +++ b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_raw.m @@ -1,19 +1,22 @@ -function AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_TwoProbs_raw(AgentDist,Policy_aprime,PolicyProbs,N_a,N_z,N_j,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist) +function AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_raw(AgentDist,Policy_aprimejz,PolicyProbs,N_a,N_z,N_j,pi_z_J_sim,II,exceptlastj,exceptfirstj,justfirstj,jequalOneDist) % Parallelizes over age jj (age weights are handled elsewhere, here all are normalized to one) % AgentDist is [N_a*N_j*N_z,1] % To be able to do Step 2 of Tan improvement it needs to be this form (note N_j then N_z) % pi_z_J_sim is [(N_j-1)*N_z,N_z] (j,z,z') -% Policy_aprime is [N_a*(N_j-1)*N_z,2] -% PolicyProbs is [N_a*(N_j-1)*N_z,2] +% Policy_aprimejz is [N_a*(N_j-1)*N_z,N_probs], already except last j +% PolicyProbs is [N_a*(N_j-1)*N_z,N_probs], already except last j + +% precomputed: +% II=repelem((1:1:N_a*(N_j-1)*N_z)',1,N_probs); +% policyexceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z*N_probs,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z*N_probs,1)+repelem(N_a*N_j*(0:1:N_z*N_probs-1)',N_a*(N_j-1),1); +% exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); +% exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); +% justfirstj=repmat((1:1:N_a)',N_z,1)+N_a*N_j*repelem((0:1:N_z-1)',N_a,1); % Get AgentDist for periods 1:N_j-1 -% exceptlastj=kron(ones(1,(N_j-1)*N_z),1:1:N_a)+kron(kron(ones(1,N_z),N_a*(0:1:N_j-2)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_z-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist AgentDist_tt=sparse(gather(reshape(AgentDist(exceptlastj),[N_a*(N_j-1)*N_z,1]))); % end-N_a*N_z is avoiding those that correspond to jj=N_j % Tan improvement Step 1 -firststep=Policy_aprime+repelem(N_a*(0:1:(N_j-1)*N_z-1)',N_a,2); -II=repelem((1:1:N_a*(N_j-1)*N_z)',1,2); - -Gammatranspose=sparse(firststep,II,PolicyProbs,N_a*(N_j-1)*N_z,N_a*(N_j-1)*N_z); +Gammatranspose=sparse(Policy_aprimejz,II,PolicyProbs,N_a*(N_j-1)*N_z,N_a*(N_j-1)*N_z); % Note: N_j-1, not N_j AgentDist_tt=reshape(Gammatranspose*AgentDist_tt,[N_a,(N_j-1)*N_z]); @@ -22,16 +25,15 @@ % NOTE: Following four lines are precomputed and passed as inputs % pi_z_J_sim=gather(reshape(permute(pi_z_J(:,:,1:end-1),[3,1,2]),[(N_j-1)*N_z,N_z])); -% II1=repmat(1:1:(N_j-1)*N_z,1,N_z); -% II2=repmat(1:1:(N_j-1),1,N_z*N_z)+repelem((N_j-1)*(0:1:N_z-1),1,N_z*(N_j-1)); -% pi_z_J_sim=sparse(II1,II2,pi_z_J_sim,(N_j-1)*N_z,(N_j-1)*N_z); +% II3=repmat(1:1:(N_j-1)*N_z,1,N_z); +% II4=repmat(1:1:(N_j-1),1,N_z*N_z)+repelem((N_j-1)*(0:1:N_z-1),1,N_z*(N_j-1)); +% pi_z_J_sim=sparse(II3,II4,pi_z_J_sim,(N_j-1)*N_z,(N_j-1)*N_z); % Note, we just construct a block-diagonal, the blocks are the (z,z'). The diagonal is j. % Because we are going from an agent dist on j=1,...,N_j-1 to an agent dist % on j=2,...,N_j the diagonal for j actually corresponds to deterministic ageing AgentDist_tt=reshape(AgentDist_tt*pi_z_J_sim,[N_a*(N_j-1)*N_z,1]); -% exceptfirstj=kron(ones(1,(N_j-1)*N_z),1:1:N_a)+kron(kron(ones(1,N_z),N_a*(1:1:N_j-1)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_z-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist AgentDist(exceptfirstj)=gpuArray(full(AgentDist_tt)); % N_a*N_z+1 is avoiding those that correspond to jj=1 AgentDist(justfirstj)=jequalOneDist; % Age j=1 dist diff --git a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_noz_e_raw.m b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_noz_e_raw.m index 56c85d74..94cb8e54 100644 --- a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_noz_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_noz_e_raw.m @@ -1,15 +1,20 @@ -function AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_e_raw(AgentDist,Policy_aprime,N_a,N_e,N_j,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist) +function AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_e_raw(AgentDist,Policy_aprimej,N_a,N_e,N_j,pi_e_J_sim,II1,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist) % Parallelizes over age jj (age weights are handled elsewhere, here all are normalized to one) % AgentDist is [N_a*N_j,N_e] % To be able to do Step 2 of Tan improvement it needs to be this form (note N_j then N_z,N_e) % pi_e_J_sim is [N_a*(N_j-1),N_e] -% Policy_aprime is [1,N_a*(N_j-1)*N_e] +% Policy_aprimej is [N_a*(N_j-1)*N_e,1], already except last j + +% precomputed: +% II1=1:1:N_a*(N_j-1)*N_e; +% II2=ones(N_a*(N_j-1)*N_e,1); +% exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); +% exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); +% justfirstj=repmat((1:1:N_a)',N_e,1)+N_a*N_j*repelem((0:1:N_e-1)',N_a,1); % Get AgentDist for periods 1:N_j-1 -% exceptlastj=kron(ones(1,(N_j-1)),1:1:N_a)+kron(N_a*(0:1:N_j-2),ones(1,N_a)); % Note: there is one use of N_j which is because we want to index AgentDist AgentDist_tt=sparse(gather(reshape(AgentDist(exceptlastj),[N_a*(N_j-1)*N_e,1]))); % avoiding those that correspond to jj=N_j -firststep=Policy_aprime+N_a*repmat(repelem((0:1:N_j-2),1,N_a),1,N_e); -Gammatranspose=sparse(firststep,1:1:N_a*(N_j-1)*N_e,ones(N_a*(N_j-1)*N_e,1),N_a*(N_j-1),N_a*(N_j-1)*N_e); +Gammatranspose=sparse(Policy_aprimej,II1,II2,N_a*(N_j-1),N_a*(N_j-1)*N_e); % Note: N_j-1, not N_j % Note that Gamma goes from (a,j,e) to (a',j) [Gammatranspose is has these reversed] @@ -17,7 +22,6 @@ AgentDist_tt=gpuArray(full(AgentDist_tt)).*pi_e_J_sim; % put e' in -% exceptfirstj=kron(ones(1,(N_j-1)),1:1:N_a)+kron(N_a*(1:1:N_j-1),ones(1,N_a)); % Note: there is one use of N_j which is because we want to index AgentDist AgentDist(exceptfirstj)=AgentDist_tt; % N_a+1 is avoiding those that correspond to jj=1 AgentDist(justfirstj)=jequalOneDist; % age j=1 dist diff --git a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_noz_raw.m b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_noz_raw.m index 44ea6557..4cc64967 100644 --- a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_noz_raw.m +++ b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_noz_raw.m @@ -1,12 +1,16 @@ -function AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_raw(AgentDist,Policy_aprime,N_a,N_j,jequalOneDist) +function AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_raw(AgentDist,Policy_aprimej,N_a,N_j,II1,II2,jequalOneDist) % Parallelizes over age jj (age weights are handled elsewhere, here all are normalized to one) % AgentDist is [N_a*N_j,1] -% Policy_aprime is [1,N_a*(N_j-1)] +% Policy_aprimej is [N_a*(N_j-1),1], already except last j + +% precomputed: +% II1=1:1:N_a*(N_j-1); +% II2=ones(N_a*(N_j-1),1); +% exceptlastj=repmat((1:1:N_a)',N_j-1,1)+repelem(N_a*(0:1:N_j-2)',N_a,1); AgentDist_tt=sparse(gather(reshape(AgentDist(1:end-N_a),[N_a*(N_j-1),1]))); % end-N_a is avoiding those that correspond to jj=N_j -firststep=Policy_aprime+N_a*repelem((0:1:N_j-2),1,N_a); -Gammatranspose=sparse(firststep,1:1:N_a*(N_j-1),ones(N_a*(N_j-1),1),N_a*(N_j-1),N_a*(N_j-1)); +Gammatranspose=sparse(Policy_aprimej,II1,II2,N_a*(N_j-1),N_a*(N_j-1)); % Note: N_j-1, not N_j AgentDist_tt=Gammatranspose*AgentDist_tt; diff --git a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_raw.m b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_raw.m index f00ec7e4..84cd860f 100644 --- a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_raw.m +++ b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_IterFast_raw.m @@ -1,34 +1,38 @@ -function AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_raw(AgentDist,Policy_aprime,N_a,N_z,N_j,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist) +function AgentDist=AgentDist_FHorz_TPath_SingleStep_IterFast_raw(AgentDist,Policy_aprimejz,N_a,N_z,N_j,pi_z_J_sim,II1,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist) % Parallelizes over age jj (age weights are handled elsewhere, here all are normalized to one) % AgentDist is [N_a*N_j*N_z,1] % To be able to do Step 2 of Tan improvement it needs to be this form (note N_j then N_z) -% pi_z_J_sim is [(N_j-1)*N_z,N_z] (j,z,z') -% Policy_aprime is [1,N_a*(N_j-1)*N_z] +% pi_z_J_sim is [(N_j-1)*N_z,(N_j-1)*N_z] (j,z,j',z') +% Policy_aprimejz is [N_a*(N_j-1)*N_z,1], already except last j + +% precomputed: +% II1=1:1:N_a*(N_j-1)*N_z; +% II2=ones(N_a*(N_j-1)*N_z,1); +% exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); +% exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); +% justfirstj=repmat((1:1:N_a)',N_z,1)+N_a*N_j*repelem((0:1:N_z-1)',N_a,1); % Get AgentDist for periods 1:N_j-1 -% exceptlastj=kron(ones(1,(N_j-1)*N_z),1:1:N_a)+kron(kron(ones(1,N_z),N_a*(0:1:N_j-2)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_z-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist AgentDist_tt=sparse(gather(reshape(AgentDist(exceptlastj),[N_a*(N_j-1)*N_z,1]))); % end-N_a*N_z is avoiding those that correspond to jj=N_j % Tan improvement Step 1 -firststep=Policy_aprime+kron(N_a*(0:1:(N_j-1)*N_z-1),ones(1,N_a)); -Gammatranspose=sparse(firststep,1:1:N_a*(N_j-1)*N_z,ones(N_a*(N_j-1)*N_z,1),N_a*(N_j-1)*N_z,N_a*(N_j-1)*N_z); +Gammatranspose=sparse(Policy_aprimejz,II1,II2,N_a*(N_j-1)*N_z,N_a*(N_j-1)*N_z); % Note: N_j-1, not N_j AgentDist_tt=reshape(Gammatranspose*AgentDist_tt,[N_a,(N_j-1)*N_z]); % Tan improvement Step 2 -% NOTE: Following four lines are precomputed and passed as inputs +% NOTE: Following four lines are precomputed and pi_z_J_sim is then passed as input % pi_z_J_sim=gather(reshape(permute(pi_z_J(:,:,1:end-1),[3,1,2]),[(N_j-1)*N_z,N_z])); -% II1=repmat(1:1:(N_j-1)*N_z,1,N_z); -% II2=repmat(1:1:(N_j-1),1,N_z*N_z)+repelem((N_j-1)*(0:1:N_z-1),1,N_z*(N_j-1)); -% pi_z_J_sim=sparse(II1,II2,pi_z_J_sim,(N_j-1)*N_z,(N_j-1)*N_z); +% II3=repmat(1:1:(N_j-1)*N_z,1,N_z); +% II4=repmat(1:1:(N_j-1),1,N_z*N_z)+repelem((N_j-1)*(0:1:N_z-1),1,N_z*(N_j-1)); +% pi_z_J_sim=sparse(II3,II4,pi_z_J_sim,(N_j-1)*N_z,(N_j-1)*N_z); % Note, we just construct a block-diagonal, the blocks are the (z,z'). The diagonal is j. % Because we are going from an agent dist on j=1,...,N_j-1 to an agent dist % on j=2,...,N_j the diagonal for j actually corresponds to deterministic ageing AgentDist_tt=reshape(AgentDist_tt*pi_z_J_sim,[N_a*(N_j-1)*N_z,1]); -% exceptfirstj=kron(ones(1,(N_j-1)*N_z),1:1:N_a)+kron(kron(ones(1,N_z),N_a*(1:1:N_j-1)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_z-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist AgentDist(exceptfirstj)=gpuArray(full(AgentDist_tt)); % N_a*N_z+1 is avoiding those that correspond to jj=1 AgentDist(justfirstj)=jequalOneDist; % Age j=1 dist diff --git a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_Iteration_e_raw.m b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_Iteration_e_raw.m index cd5b5ef2..06179b71 100644 --- a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_Iteration_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_Iteration_e_raw.m @@ -1,15 +1,18 @@ -function AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_e_raw(AgentDist,Policy_aprime,N_a,N_z,N_e,N_j,pi_z_J,pi_e_J,jequaloneDist) +function AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_e_raw(AgentDist,Policy_aprimez,N_a,N_z,N_e,N_j,pi_z_J,pi_e_J,II1,II2,jequaloneDist) % age weights are handled elsewhere, here all are normalized to one % AgentDist=reshape(AgentDist,[N_a*N_z*N_e,N_j]); -% Policy_aprime=gather(reshape(Policy_aprime,[1,N_a*N_z*N_e,N_j])); +% Policy_aprimez=gather(reshape(Policy_aprimez,[N_a*N_z*N_e,N_j])); + +% precompute: +% II1=1:1:N_a*N_z*N_e; +% II2=ones(N_a*N_z*N_e,1); for jjr=1:(N_j-1) jj=N_j-jjr; % It is important that this is in reverse order (due to just overwriting AgentDist) AgentDist_jj=sparse(gather(AgentDist(:,jj))); - firststep=Policy_aprime(1,:,jj+kron(ones(1,N_e),kron(N_a*(0:1:N_z-1),ones(1,N_a))); % Turn into index for (a',z) - Gammatranspose=sparse(firststep,1:1:N_a*N_z*N_e,ones(N_a*N_z*N_e,1),N_a*N_z,N_a*N_z*N_e); + Gammatranspose=sparse(Policy_aprimez(:,jj),II1,II2,N_a*N_z,N_a*N_z*N_e); pi_z=sparse(gather(pi_z_J(:,:,jj))); % Note: this cannot be moved outside the for-loop as Matlab only allows sparse for 2-D arrays (so cannot, e.g., do sparse(pi_z_J)). pi_e=sparse(gather(pi_e_J(:,jj))); diff --git a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_Iteration_noz_e_raw.m b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_Iteration_noz_e_raw.m index 30a182ef..f2cf7620 100644 --- a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_Iteration_noz_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_Iteration_noz_e_raw.m @@ -1,13 +1,17 @@ -function AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_noz_e_raw(AgentDist,Policy_aprime,N_a,N_e,N_j,pi_e_J,jequaloneDist) +function AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_noz_e_raw(AgentDist,Policy_aprime,N_a,N_e,N_j,pi_e_J,II1,II2,jequaloneDist) % age weights are handled elsewhere, here all are normalized to one % AgentDist=reshape(AgentDist,[N_a*N_e,N_j]); -% Policy_aprime=gather(reshape(Policy_aprime,[1,N_a*N_e,N_j])); +% Policy_aprime=gather(reshape(Policy_aprime,[N_a*N_e,N_j])); + +% precomputed: +% II1=1:1:N_a*N_e; +% II2=ones(N_a*N_e,1); for jjr=1:(N_j-1) jj=N_j-jjr; % It is important that this is in reverse order (due to just overwriting AgentDist) AgentDist_jj=sparse(gather(AgentDist(:,jj))); - Gammatranspose=sparse(Policy_aprime(1,:,jj),1:1:N_a*N_e,ones(N_a*N_e,1),N_a,N_a*N_e); + Gammatranspose=sparse(Policy_aprime(:,jj),II1,II2,N_a,N_a*N_e); % Two steps of the Tan improvement AgentDist_jj=Gammatranspose*AgentDist_jj; diff --git a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_Iteration_noz_raw.m b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_Iteration_noz_raw.m index 33b551dd..f3b84a59 100644 --- a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_Iteration_noz_raw.m +++ b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_Iteration_noz_raw.m @@ -1,15 +1,19 @@ -function AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_noz_raw(AgentDist,Policy_aprime,N_a,N_j,jequalOneDist) +function AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_noz_raw(AgentDist,Policy_aprime,N_a,N_j,II1,II2,jequalOneDist) % age weights are handled elsewhere, here all are normalized to one % AgentDist is [N_a,N_j] -% Policy_aprime=gather(reshape(Policy_aprime,[1,N_a,N_j])); +% Policy_aprime=gather(reshape(Policy_aprime,[N_a,N_j])); AgentDist=gather(AgentDist); +% precompute: +% II1=1:1:N_a; +% II2=ones(N_a,1); + for jjr=1:(N_j-1) jj=N_j-jjr; % It is important that this is in reverse order (due to just overwriting AgentDist) AgentDist_jj=sparse(AgentDist(:,jj)); - Gammatranspose=sparse(Policy_aprime(1,:,jj),1:1:N_a,ones(N_a,1),N_a,N_a); + Gammatranspose=sparse(Policy_aprime(:,jj),II1,II2,N_a,N_a); AgentDist_jj=Gammatranspose*AgentDist_jj; diff --git a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_Iteration_raw.m b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_Iteration_raw.m index 0f7c3013..d20a4926 100644 --- a/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_Iteration_raw.m +++ b/TransitionPaths/FHorz/subcodes/AgentDistSingleStep/AgentDist_FHorz_TPath_SingleStep_Iteration_raw.m @@ -1,8 +1,12 @@ -function AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_raw(AgentDist,Policy_aprime,N_a,N_z,N_j,pi_z_J,jequalOneDist) +function AgentDist=AgentDist_FHorz_TPath_SingleStep_Iteration_raw(AgentDist,Policy_aprimez,N_a,N_z,N_j,pi_z_J,II1,II2,jequalOneDist) % age weights are handled elsewhere, here all are normalized to one % AgentDist=reshape(AgentDist,[N_a*N_z,N_j]); -% Policy_aprime=gather(reshape(Policy_aprime,[1,N_a*N_z,N_j])); +% Policy_aprimez=gather(reshape(Policy_aprimez,[N_a*N_z,N_j])); + +% precomputed: +% II1=1:1:N_a*N_z; +% II2=ones(N_a*N_z,1); pi_z_J=gather(pi_z_J); @@ -11,11 +15,8 @@ AgentDist_jj=sparse(gather(AgentDist(:,jj))); pi_z=sparse(pi_z_J(:,:,jj)); - optaprime_jj=Policy_aprime(1,:,jj); - % Tan improvement - firststep=optaprime_jj+kron(N_a*(0:1:N_z-1),ones(1,N_a)); - Gammatranspose=sparse(firststep,1:1:N_a*N_z,ones(N_a*N_z,1),N_a*N_z,N_a*N_z); + Gammatranspose=sparse(Policy_aprimez(:,jj),II1,II2,N_a*N_z,N_a*N_z); % Two steps of the Tan improvement AgentDist_jj=reshape(Gammatranspose*AgentDist_jj,[N_a,N_z]); %No point checking distance every single iteration. Do 100, then check. diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep.m index ef3492c5..71c632e2 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep.m @@ -2,22 +2,27 @@ % The VKron input is next period value fn, the VKron output is this period. N_d=prod(n_d); +N_a=prod(n_a); +N_z=prod(n_z); %% If get to here then not using exoticpreferences nor StateDependentVariables_z % N_z==0 is handled by a different command -if N_d==0 - [VKron,PolicyKron]=ValueFnIter_FHorz_TPath_SingleStep_nod_raw(VKron,n_a, n_z, N_j, a_grid, z_gridvals_J, pi_z_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); +if vfoptions.divideandconquer==0 + if vfoptions.gridinterplayer==0 + if N_d==0 + [VKron,PolicyKron]=ValueFnIter_FHorz_TPath_SingleStep_nod_raw(VKron,n_a, n_z, N_j, a_grid, z_gridvals_J, pi_z_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + else + [VKron, PolicyKron]=ValueFnIter_FHorz_TPath_SingleStep_raw(VKron,n_d,n_a,n_z, N_j, d_gridvals, a_grid, z_gridvals_J, pi_z_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + end + else + error('Have not yet implemented grid interpolation layer for FHorz TPath without fastOLG=1. Ask on forum if you need this.') + end else - [VKron, PolicyKron]=ValueFnIter_FHorz_TPath_SingleStep_raw(VKron,n_d,n_a,n_z, N_j, d_gridvals, a_grid, z_gridvals_J, pi_z_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + error('Have not yet implemented divide and conquer for FHorz TPath without fastOLG=1. Ask on forum if you need this.') end -% Sometimes numerical rounding errors (of the order of 10^(-16) can mean -% that Policy is not integer valued. The following corrects this by converting to int64 and then -% makes the output back into double as Matlab otherwise cannot use it in -% any arithmetical expressions. -if vfoptions.policy_forceintegertype==1 || vfoptions.policy_forceintegertype==2 - PolicyKron=uint64(PolicyKron); - PolicyKron=double(PolicyKron); -end +%% Policy in transition paths +PolicyKron=UnKronPolicyIndexes_Case1_FHorz(PolicyKron,n_d,n_a,N_z,N_j,vfoptions); +PolicyKron=reshape(PolicyKron,[size(PolicyKron,1),N_a,N_z,N_j]); end diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_e.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_e.m index cf1d7b2b..901bbd67 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_e.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_e.m @@ -2,23 +2,28 @@ % The VKron input is next period value fn, the VKron output is this period. N_d=prod(n_d); +N_a=prod(n_a); +N_z=prod(n_z); +N_e=prod(n_e); %% If get to here then not using exoticpreferences nor StateDependentVariables_z % N_z==0 is handled by a different command -if N_d==0 - [VKron, PolicyKron]=ValueFnIter_FHorz_TPath_SingleStep_nod_e_raw(VKron,n_a, n_z,n_e, N_j, a_grid, z_gridvals_J, e_gridvals_J, pi_z_J, pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); +if vfoptions.divideandconquer==0 + if vfoptions.gridinterplayer==0 + if N_d==0 + [VKron, PolicyKron]=ValueFnIter_FHorz_TPath_SingleStep_nod_e_raw(VKron,n_a, n_z,n_e, N_j, a_grid, z_gridvals_J, e_gridvals_J, pi_z_J, pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + else + [VKron, PolicyKron]=ValueFnIter_FHorz_TPath_SingleStep_e_raw(VKron,n_d,n_a,n_z,n_e, N_j, d_gridvals, a_grid, z_gridvals_J, e_gridvals_J, pi_z_J, pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + end + else + error('Have not yet implemented grid interpolation layer for FHorz TPath without fastOLG=1. Ask on forum if you need this.') + end else - [VKron, PolicyKron]=ValueFnIter_FHorz_TPath_SingleStep_e_raw(VKron,n_d,n_a,n_z,n_e, N_j, d_gridvals, a_grid, z_gridvals_J, e_gridvals_J, pi_z_J, pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + error('Have not yet implemented divide and conquer for FHorz TPath without fastOLG=1. Ask on forum if you need this.') end - -% Sometimes numerical rounding errors (of the order of 10^(-16) can mean -% that Policy is not integer valued. The following corrects this by converting to int64 and then -% makes the output back into double as Matlab otherwise cannot use it in -% any arithmetical expressions. -if vfoptions.policy_forceintegertype==1 || vfoptions.policy_forceintegertype==2 - PolicyKron=uint64(PolicyKron); - PolicyKron=double(PolicyKron); -end +%% Policy in transition paths +PolicyKron=UnKronPolicyIndexes_Case1_FHorz_e(PolicyKron,n_d,n_a,N_z,N_e,N_j,vfoptions); +PolicyKron=reshape(PolicyKron,[size(PolicyKron,1),N_a,N_z,N_e,N_j]); end diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG.m index b5a28508..ee6e9484 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG.m @@ -7,6 +7,8 @@ % (fastOLG requires swapping order of j and z) N_d=prod(n_d); +N_a=prod(n_a); +N_z=prod(n_z); % N_z=0 is handled elsewhere % N_e is handled elsewhere @@ -45,16 +47,10 @@ error('Not yet implemented exoticpreferences for transtion paths (email me :)') end +%% Policy in transition paths +% Note: The actual ordering of N_z,N_j is not relevant to how this command works, so can just mix them up. [as long as N_z not n_z] +PolicyKron=UnKronPolicyIndexes_Case1_FHorz(PolicyKron,n_d,n_a,N_j,N_z,vfoptions); +PolicyKron=reshape(PolicyKron,[size(PolicyKron,1),N_a,N_j,N_z]); -%% - -% Sometimes numerical rounding errors (of the order of 10^(-16) can mean -% that Policy is not integer valued. The following corrects this by converting to int64 and then -% makes the output back into double as Matlab otherwise cannot use it in -% any arithmetical expressions. -if vfoptions.policy_forceintegertype==1 || vfoptions.policy_forceintegertype==2 - PolicyKron=uint64(PolicyKron); - PolicyKron=double(PolicyKron); -end end diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_e.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_e.m index 01214877..cee4722c 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_e.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_e.m @@ -7,6 +7,9 @@ % (fastOLG requires swapping order of j and z) N_d=prod(n_d); +N_a=prod(n_a); +N_z=prod(n_z); +N_e=prod(n_e); % N_z=0 is handled elsewhere % N_e=0 is handled elsewhere @@ -44,14 +47,9 @@ error('Not yet implemented exoticpreferences for transtion paths (email me :)') end -%% -% Sometimes numerical rounding errors (of the order of 10^(-16) can mean -% that Policy is not integer valued. The following corrects this by converting to int64 and then -% makes the output back into double as Matlab otherwise cannot use it in -% any arithmetical expressions. -if vfoptions.policy_forceintegertype==1 || vfoptions.policy_forceintegertype==2 - PolicyKron=uint64(PolicyKron); - PolicyKron=double(PolicyKron); -end +%% Policy in transition paths +% Note: The actual ordering of N_z,N_e,N_j is not relevant to how this command works, so can just mix them up. [as long as N_z,N_e not n_z,n_e] +PolicyKron=UnKronPolicyIndexes_Case1_FHorz_e(PolicyKron,n_d,n_a,N_j,N_z,N_e,vfoptions); +PolicyKron=reshape(PolicyKron,[size(PolicyKron,1),N_a,N_j,N_z,N_e]); end diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz.m index 88591a0e..3d888920 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz.m @@ -7,6 +7,7 @@ % (fastOLG is easy without z) N_d=prod(n_d); +N_a=prod(n_a); % z and e are handled elsewhere if strcmp(vfoptions.exoticpreferences,'None') @@ -41,13 +42,8 @@ end end -% Sometimes numerical rounding errors (of the order of 10^(-16) can mean -% that Policy is not integer valued. The following corrects this by converting to int64 and then -% makes the output back into double as Matlab otherwise cannot use it in -% any arithmetical expressions. -if vfoptions.policy_forceintegertype==1 || vfoptions.policy_forceintegertype==2 - PolicyKron=uint64(PolicyKron); - PolicyKron=double(PolicyKron); -end +%% Policy in transition paths +PolicyKron=UnKronPolicyIndexes_Case1_FHorz_noz(PolicyKron,n_d,n_a,N_j,vfoptions); +PolicyKron=reshape(PolicyKron,[size(PolicyKron,1),N_a,N_j]); end diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e.m index 18d3ba53..d67adf56 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e.m @@ -7,6 +7,8 @@ % (fastOLG requires swapping order of j and z) N_d=prod(n_d); +N_a=prod(n_a); +N_e=prod(n_e); % N_z=0 is handled elsewhere % N_e=0 is handled elsewhere @@ -44,14 +46,10 @@ error('Not yet implemented exoticpreferences for transtion paths (email me :)') end -%% -% Sometimes numerical rounding errors (of the order of 10^(-16) can mean -% that Policy is not integer valued. The following corrects this by converting to int64 and then -% makes the output back into double as Matlab otherwise cannot use it in -% any arithmetical expressions. -if vfoptions.policy_forceintegertype==1 || vfoptions.policy_forceintegertype==2 - PolicyKron=uint64(PolicyKron); - PolicyKron=double(PolicyKron); -end +%% Policy in transition paths +% Note: The actual ordering of N_e,N_j is not relevant to how this command works, so can just mix them up. [as long as N_e not n_e] +PolicyKron=UnKronPolicyIndexes_Case1_FHorz(PolicyKron,n_d,n_a,N_j,N_e,vfoptions); +PolicyKron=reshape(PolicyKron,[size(PolicyKron,1),N_a,N_j,N_e]); + end diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_noz.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_noz.m index 8fb650b9..3d09ea5a 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_noz.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_noz.m @@ -2,21 +2,25 @@ % The VKron input is next period value fn, the VKron output is this period. N_d=prod(n_d); +N_a=prod(n_a); %% If get to here then not using exoticpreferences -if N_d==0 - [VKron,PolicyKron]=ValueFnIter_FHorz_TPath_SingleStep_nod_noz_raw(VKron,n_a, N_j, a_grid, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); +if vfoptions.divideandconquer==0 + if vfoptions.gridinterplayer==0 + if N_d==0 + [VKron,PolicyKron]=ValueFnIter_FHorz_TPath_SingleStep_nod_noz_raw(VKron,n_a, N_j, a_grid, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + else + [VKron, PolicyKron]=ValueFnIter_FHorz_TPath_SingleStep_noz_raw(VKron,n_d,n_a, N_j, d_gridvals, a_grid, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + end + else + error('Have not yet implemented grid interpolation layer for FHorz TPath without fastOLG=1. Ask on forum if you need this.') + end else - [VKron, PolicyKron]=ValueFnIter_FHorz_TPath_SingleStep_noz_raw(VKron,n_d,n_a, N_j, d_gridvals, a_grid, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + error('Have not yet implemented divide and conquer for FHorz TPath without fastOLG=1. Ask on forum if you need this.') end -% Sometimes numerical rounding errors (of the order of 10^(-16) can mean -% that Policy is not integer valued. The following corrects this by converting to int64 and then -% makes the output back into double as Matlab otherwise cannot use it in -% any arithmetical expressions. -if vfoptions.policy_forceintegertype==1 || vfoptions.policy_forceintegertype==2 - PolicyKron=uint64(PolicyKron); - PolicyKron=double(PolicyKron); -end +%% Policy in transition paths +PolicyKron=UnKronPolicyIndexes_Case1_FHorz_noz(PolicyKron,n_d,n_a,N_j,vfoptions); +PolicyKron=reshape(PolicyKron,[size(PolicyKron,1),N_a,N_j]); end diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_noz_e.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_noz_e.m index c5247d0f..2dcb4e8c 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_noz_e.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/ValueFnIter_FHorz_TPath_SingleStep_noz_e.m @@ -2,23 +2,27 @@ % The VKron input is next period value fn, the VKron output is this period. N_d=prod(n_d); +N_a=prod(n_a); +N_e=prod(n_e); %% If get to here then not using exoticpreferences nor StateDependentVariables_z % N_z==0 is handled by a different command -if N_d==0 - [VKron, PolicyKron]=ValueFnIter_FHorz_TPath_SingleStep_nod_noz_e_raw(VKron,n_a,n_e, N_j, a_grid, e_gridvals_J, pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); +if vfoptions.divideandconquer==0 + if vfoptions.gridinterplayer==0 + if N_d==0 + [VKron, PolicyKron]=ValueFnIter_FHorz_TPath_SingleStep_nod_noz_e_raw(VKron,n_a,n_e, N_j, a_grid, e_gridvals_J, pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + else + [VKron, PolicyKron]=ValueFnIter_FHorz_TPath_SingleStep_noz_e_raw(VKron,n_d,n_a,n_e, N_j, d_gridvals, a_grid, e_gridvals_J, pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + end + else + error('Have not yet implemented grid interpolation layer for FHorz TPath without fastOLG=1. Ask on forum if you need this.') + end else - [VKron, PolicyKron]=ValueFnIter_FHorz_TPath_SingleStep_noz_e_raw(VKron,n_d,n_a,n_e, N_j, d_gridvals, a_grid, e_gridvals_J, pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + error('Have not yet implemented divide and conquer for FHorz TPath without fastOLG=1. Ask on forum if you need this.') end - -% Sometimes numerical rounding errors (of the order of 10^(-16) can mean -% that Policy is not integer valued. The following corrects this by converting to int64 and then -% makes the output back into double as Matlab otherwise cannot use it in -% any arithmetical expressions. -if vfoptions.policy_forceintegertype==1 || vfoptions.policy_forceintegertype==2 - PolicyKron=uint64(PolicyKron); - PolicyKron=double(PolicyKron); -end +%% Policy in transition paths +PolicyKron=UnKronPolicyIndexes_Case1_FHorz(PolicyKron,n_d,n_a,N_e,N_j,vfoptions); +PolicyKron=reshape(PolicyKron,[size(PolicyKron,1),N_a,N_e,N_j]); end diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_raw.m index 1e3d88f0..d6e35852 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_raw.m @@ -14,7 +14,7 @@ % n-Monotonicity % vfoptions.level1n=5; level1ii=round(linspace(1,n_a,vfoptions.level1n)); -level1iidiff=level1ii(2:end)-level1ii(1:end-1)-1; +% level1iidiff=level1ii(2:end)-level1ii(1:end-1)-1; % Grid interpolation % vfoptions.ngridinterp=9; diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_e_raw.m index 30d625f0..13894663 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_e_raw.m @@ -12,6 +12,8 @@ z_gridvals_J=shiftdim(z_gridvals_J,-3); e_gridvals_J=reshape(e_gridvals_J,[1,1,1,N_j,1,N_e,length(n_e)]); +Policy=zeros(N_a,N_j,N_z,N_e,'gpuArray'); % first dim indexes the optimal choice for d and aprime + %% % n-Monotonicity @@ -51,12 +53,10 @@ EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a end +V=zeros(N_a,N_j,N_z,N_e,'gpuArray'); % V is over (a,j) DiscountedEV=repelem(shiftdim(DiscountFactorParamsVec.*EV,-1),N_d,1,1,1); % [N_d,N_aprime,1,N_j,N_z] -V=zeros(N_a,N_j,N_z,N_e,'gpuArray'); % V is over (a,j) -Policy=zeros(N_a,N_j,N_z,N_e,'gpuArray'); % first dim indexes the optimal choice for d and aprime - if vfoptions.lowmemory==0 % n-Monotonicity @@ -227,7 +227,6 @@ %% fastOLG with z & e, so need output to take certain shapes V=reshape(V,[N_a*N_j,N_z,N_e]); % Policy=reshape(Policy,[N_a,N_j,N_z,N_e]); -% Note that in fastOLG, we do not separate d from aprime in Policy %% Separate d and aprime Policy2=zeros(2,N_a,N_j,N_z,N_e,'gpuArray'); % first dim indexes the optimal choice for d and aprime rest of dimensions a,z diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_e_raw.m index 41e67c56..1547afd5 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_e_raw.m @@ -45,11 +45,10 @@ EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a end +V=zeros(N_a,N_j,N_z,N_e,'gpuArray'); % V is over (a,j) DiscountedEV=DiscountFactorParamsVec.*EV; -V=zeros(N_a,N_j,N_z,N_e,'gpuArray'); % V is over (a,j) - if vfoptions.lowmemory==0 % n-Monotonicity ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_nod_Par2e(ReturnFn, n_z, n_e, N_j, a_grid, a_grid(level1ii), z_gridvals_J, e_gridvals_J, ReturnFnParamsAgeMatrix,1); @@ -183,11 +182,9 @@ %% fastOLG with z & e, so need output to take certain shapes V=reshape(V,[N_a*N_j,N_z,N_e]); % Policy=reshape(Policy,[N_a,N_j,N_z,N_e]); -% Note that in fastOLG, we do not separate d from aprime in Policy - -%% -Policy=shiftdim(Policy,-1); % So first dim is just one point +%% Output shape for policy +Policy=shiftdim(Policy,-1); % so first dim is just one point end \ No newline at end of file diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_e_raw.m index 22b3b040..807976b1 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_e_raw.m @@ -7,7 +7,6 @@ N_a=prod(n_a); N_e=prod(n_e); - % fastOLG, so a-j-e Policy=zeros(N_a,N_j,N_e,'gpuArray'); % first dim indexes the optimal choice for d and aprime @@ -38,9 +37,10 @@ % This is used for 'Matched Expecations Path' EV=[reshape(V,[N_a*N_j,N_e].*pi_e_J,2)]; % input V is already of size [N_a,N_j] and we want to use the whole thing end +V=zeros(N_a,N_j,N_e,'gpuArray'); % V is over (a,j) + discountedEV=DiscountFactorParamsVec.*reshape(EV,[N_a,1,N_j]); % [aprime] -V=zeros(N_a,N_j,N_e,'gpuArray'); % V is over (a,j) if vfoptions.lowmemory==0 @@ -129,11 +129,9 @@ %% fastOLG with e, so need output to take certain shapes V=reshape(V,[N_a*N_j,N_e]); % Policy=reshape(Policy,[N_a,N_j,N_e]); -% Note that in fastOLG, we do not separate d from aprime in Policy - -%% -Policy=shiftdim(Policy,-1); % So first dim is just one point +%% Output shape for policy +Policy=shiftdim(Policy,-1); % so first dim is just one point end \ No newline at end of file diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_raw.m index c43d807e..1de362c1 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_noz_raw.m @@ -3,7 +3,6 @@ % fastOLG just means parallelize over "age" (j) N_a=prod(n_a); -V=zeros(N_a,N_j,'gpuArray'); % V is over (a,j) Policy=zeros(N_a,N_j,'gpuArray'); % first dim indexes the optimal choice for d and aprime %% @@ -33,6 +32,7 @@ % This is used for 'Matched Expecations Path' EV=reshape(V,[N_a,1,N_j]); % input V is of size [N_a,N_j] and we want to use the whole thing end +V=zeros(N_a,N_j,'gpuArray'); % V is over (a,j) % n-Monotonicity ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_nod_noz_Par2(ReturnFn, N_j, a_grid, a_grid(level1ii), ReturnFnParamsAgeMatrix,1); @@ -72,8 +72,8 @@ end -%% -Policy=shiftdim(Policy,-1); % So first dim is just one point +%% Output shape for policy +Policy=shiftdim(Policy,-1); % so first dim is just one point end \ No newline at end of file diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_raw.m index efeb814d..f1edf78f 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_nod_raw.m @@ -45,11 +45,10 @@ EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a end +V=zeros(N_a,N_j,N_z,'gpuArray'); % preallocate: V is over (a,j,z) DiscountedEV=DiscountFactorParamsVec.*EV; -V=zeros(N_a,N_j,N_z,'gpuArray'); % preallocate: V is over (a,j,z) - if vfoptions.lowmemory==0 % n-Monotonicity @@ -137,10 +136,9 @@ %% fastOLG with z, so need to output to take certain shapes V=reshape(V,[N_a*N_j,N_z]); % Policy=reshape(Policy,[N_a,N_j,N_z]); -% Note that in fastOLG, we do not separate d from aprime in Policy -%% -Policy=shiftdim(Policy,-1); % So first dim is just one point +%% Output shape for policy +Policy=shiftdim(Policy,-1); % so first dim is just one point end \ No newline at end of file diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_e_raw.m index a7b27f24..280cc8b3 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_e_raw.m @@ -42,11 +42,10 @@ % This is used for 'Matched Expecations Path' EV=[reshape(V,[N_a*N_j,N_e].*pi_e_J,2)]; % input V is already of size [N_a,N_j] and we want to use the whole thing end +V=zeros(N_a,N_j,N_e,'gpuArray'); % V is over (a,j) discountedEV=repelem(shiftdim(DiscountFactorParamsVec.*reshape(EV,[N_a,1,N_j]),-1),N_d,1); % [N_d,N_aprime,1,N_a,N_j] -V=zeros(N_a,N_j,N_e,'gpuArray'); % V is over (a,j) - if vfoptions.lowmemory==0 @@ -158,7 +157,6 @@ %% fastOLG with e, so need output to take certain shapes V=reshape(V,[N_a*N_j,N_e]); % Policy=reshape(Policy,[N_a,N_j,N_e]); -% Note that in fastOLG, we do not separate d from aprime in Policy %% Separate d and aprime Policy2=zeros(2,N_a,N_j,N_e,'gpuArray'); % first dim indexes the optimal choice for d and aprime rest of dimensions a,z diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_raw.m index 2be3068d..26c79a8b 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_noz_raw.m @@ -4,7 +4,6 @@ N_d=prod(n_d); N_a=prod(n_a); -V=zeros(N_a,N_j,'gpuArray'); % V is over (a,j) Policy=zeros(N_a,N_j,'gpuArray'); % first dim indexes the optimal choice for d and aprime %% @@ -37,9 +36,11 @@ % This is used for 'Matched Expecations Path' EV=reshape(V,[1,N_a,1,N_j]); % input V is of size [N_a,N_j] and we want to use the whole thing end +V=zeros(N_a,N_j,'gpuArray'); % V is over (a,j) entireEV=repmat(EV,N_d,1); % [d,aprime] + % n-Monotonicity ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_noz_Par2(ReturnFn, n_d, N_j, d_gridvals, a_grid, a_grid(level1ii), ReturnFnParamsAgeMatrix,1); diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_raw.m index a43efe85..d2c8daea 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_raw.m @@ -50,11 +50,11 @@ EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) EV=reshape(sum(EV,4),[N_a,1,N_j,N_z]); % (aprime,1,j,z), 2nd dim will be autofilled with a end +V=zeros(N_a,N_j,N_z,'gpuArray'); % V is over (a,j) DiscountedEV=shiftdim(DiscountFactorParamsVec.*EV,-1); % [1,N_a,1,N_j,N_z] 1st dim will autofill d, 3rd dim will autofill a DiscountedEV=repelem(DiscountedEV,N_d,1,1,1,1); -V=zeros(N_a,N_j,N_z,'gpuArray'); % V is over (a,j) if vfoptions.lowmemory==0 @@ -159,7 +159,6 @@ %% fastOLG with z, so need to output to take certain shapes V=reshape(V,[N_a*N_j,N_z]); % Policy=reshape(Policy,[N_a,N_j,N_z]); -% Note that in fastOLG, we do not separate d from aprime in Policy %% Separate d and aprime Policy2=zeros(2,N_a,N_j,N_z,'gpuArray'); % first dim indexes the optimal choice for d and aprime rest of dimensions a,z diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_noz_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_noz_raw.m index 69aa8776..0285b194 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_noz_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_nod_noz_raw.m @@ -60,8 +60,6 @@ Policy(1,:,:)=Policy(1,:,:)-adjust; % lower grid point Policy(2,:,:)=adjust.*Policy(2,:,:)+(1-adjust).*(Policy(2,:,:)-n2short-1); % from 1 (lower grid point) to 1+n2short+1 (upper grid point) -% Leave the first dimension as is -% Policy=squeeze(Policy(1,:,:)+N_a*(Policy(2,:,:)-1)); end diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_raw.m index fece536d..2d91d8fe 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_GI_raw.m @@ -10,6 +10,7 @@ N_a=prod(n_a); N_z=prod(n_z); +% V=zeros(N_a*N_j,N_z,'gpuArray'); Policy=zeros(3,N_a,N_j,N_z,'gpuArray'); %first dim indexes the optimal choice for d and aprime rest of dimensions a,z z_gridvals_J=shiftdim(z_gridvals_J,-3); % [1,1,1,N_j,N_z,l_z] diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_e_raw.m index c1670d3c..4bd8f653 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_e_raw.m @@ -91,7 +91,6 @@ %% fastOLG with z & e, so need output to take certain shapes % V=reshape(V,[N_a*N_j,N_z,N_e]); % Policy=reshape(Policy,[N_a,N_j,N_z,N_e]); -% Note that in fastOLG, we do not separate d from aprime in Policy %% Separate d and aprime Policy2=zeros(2,N_a,N_j,N_z,N_e,'gpuArray'); % first dim indexes the optimal choice for d and aprime rest of dimensions a,z diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_e_raw.m index 59ab7dc1..7c304823 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_e_raw.m @@ -93,10 +93,10 @@ %% fastOLG with z & e, so need to output to take certain shapes % V=reshape(V,[N_a*N_j,N_z,N_e]); % Policy=reshape(Policy,[N_a,N_j,N_z,N_e]); -% Note that in fastOLG, we do not separate d from aprime in Policy - -%% -Policy=shiftdim(Policy,-1); % So first dim is just one point +%% Output shape for policy +if vfoptions.lowmemory>0 + Policy=shiftdim(Policy,-1); % so first dim is just one point +end end diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_noz_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_noz_e_raw.m index b185d4cd..9ff5ab31 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_noz_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_noz_e_raw.m @@ -52,18 +52,16 @@ Policy(:,e_c)=reshape(maxindex,[N_a*N_j,1]); end - Policy=reshape(Policy,[N_a,N_j,N_e]); + Policy=reshape(Policy,[1,N_a,N_j,N_e]); end - %% fastOLG with e, so need to output to take certain shapes % V=reshape(V,[N_a*N_j,N_e]); % Policy=reshape(Policy,[N_a,N_j,N_e]); -% Note that in fastOLG, we do not separate d from aprime in Policy -%% -Policy=shiftdim(Policy,-1); % So first dim is just one point +% % Output shape for policy +% Policy=shiftdim(Policy,-1); % so first dim is just one point end diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_noz_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_noz_raw.m index 667fc0f9..80be021b 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_noz_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_noz_raw.m @@ -28,8 +28,8 @@ V=squeeze(V); Policy=squeeze(Policy); -%% -Policy=shiftdim(Policy,-1); % So first dim is just one point +%% Output shape for policy +Policy=shiftdim(Policy,-1); % so first dim is just one point end diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_raw.m index 14b7352f..4b56f4ab 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_nod_raw.m @@ -75,10 +75,9 @@ %% fastOLG with z, so need to output to take certain shapes % V=reshape(V,[N_a*N_j,N_z]); % Policy=reshape(Policy,[N_a,N_j,N_z]); -% Note that in fastOLG, we do not separate d from aprime in Policy -%% -Policy=shiftdim(Policy,-1); % So first dim is just one point +%% Output shape for policy +Policy=shiftdim(Policy,-1); % so first dim is just one point end diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e_raw.m index 0f21f506..a6204545 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e_raw.m @@ -61,8 +61,6 @@ %% fastOLG with e, so need output to take certain shapes % V=reshape(V,[N_a*N_j,N_e]); Policy=reshape(Policy,[N_a,N_j,N_e]); -% Note that in fastOLG, we do not separate d from aprime in Policy - %% Separate d and aprime Policy2=zeros(2,N_a,N_j,N_e,'gpuArray'); % first dim indexes the optimal choice for d and aprime rest of dimensions a,z diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_raw.m index 64090fde..9caf3347 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_raw.m @@ -78,7 +78,6 @@ %% fastOLG with z, so need to output to take certain shapes % V=reshape(V,[N_a*N_j,N_z]); % Policy=reshape(Policy,[N_a,N_j,N_z]); -% Note that in fastOLG, we do not separate d from aprime in Policy %% Separate d and aprime Policy2=zeros(2,N_a,N_j,N_z,'gpuArray'); % first dim indexes the optimal choice for d and aprime rest of dimensions a,z diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_nod_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_nod_e_raw.m index 30469cc1..880422c0 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_nod_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_nod_e_raw.m @@ -127,9 +127,8 @@ end end -%% -Policy=shiftdim(Policy,-1); % So first dim is just one point - +%% Output shape for policy +Policy=shiftdim(Policy,-1); end diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_nod_noz_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_nod_noz_e_raw.m index 43569d21..07ab4848 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_nod_noz_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_nod_noz_e_raw.m @@ -79,9 +79,8 @@ end end -%% -Policy=shiftdim(Policy,-1); % So first dim is just one point - +%% Output shape for policy +Policy=shiftdim(Policy,-1); end diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_nod_noz_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_nod_noz_raw.m index 9d095f84..95faf0c7 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_nod_noz_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_nod_noz_raw.m @@ -41,9 +41,7 @@ Policy(:,jj)=maxindex; end -%% -Policy=shiftdim(Policy,-1); % So first dim is just one point - - +%% Output shape for policy +Policy=shiftdim(Policy,-1); end diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_nod_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_nod_raw.m index 60251a4e..a5913611 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_nod_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_nod_raw.m @@ -90,7 +90,7 @@ end end -%% -Policy=shiftdim(Policy,-1); % So first dim is just one point +%% Output shape for policy +Policy=shiftdim(Policy,-1); end diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_noz_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_noz_e_raw.m index ae57f949..c242c6bd 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_noz_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_noz_e_raw.m @@ -86,4 +86,5 @@ Policy2(1,:,:,:)=shiftdim(rem(Policy-1,N_d)+1,-1); Policy2(2,:,:,:)=shiftdim(ceil(Policy/N_d),-1); + end diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_noz_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_noz_raw.m index e4729bef..d6dd3ef1 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_noz_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/slowOLG/ValueFnIter_FHorz_TPath_SingleStep_noz_raw.m @@ -47,5 +47,4 @@ Policy2(1,:,:)=shiftdim(rem(Policy-1,N_d)+1,-1); Policy2(2,:,:)=shiftdim(ceil(Policy/N_d),-1); - end diff --git a/TransitionPaths/InfHorz/TransitionPath_InfHorz_shooting.m b/TransitionPaths/InfHorz/TransitionPath_InfHorz_shooting.m index b93fa502..c3bfe1d5 100644 --- a/TransitionPaths/InfHorz/TransitionPath_InfHorz_shooting.m +++ b/TransitionPaths/InfHorz/TransitionPath_InfHorz_shooting.m @@ -209,8 +209,8 @@ % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges if transpathoptions.verbose==1 - fprintf('Number of iteration on the path: %i \n',pathcounter) - + disp('Old, New') + % Would be nice to have a way to get the iteration count without having the whole printout of path values (I think that would be useful?) pathnametitles{:} [PricePathOld,PricePathNew] end diff --git a/TransitionPaths/InfHorz/TransitionPath_InfHorz_shooting_ExpAsset.m b/TransitionPaths/InfHorz/TransitionPath_InfHorz_shooting_ExpAsset.m index eb9ce12e..7d40defc 100644 --- a/TransitionPaths/InfHorz/TransitionPath_InfHorz_shooting_ExpAsset.m +++ b/TransitionPaths/InfHorz/TransitionPath_InfHorz_shooting_ExpAsset.m @@ -257,8 +257,8 @@ % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges if transpathoptions.verbose==1 - fprintf('Number of iteration on the path: %i \n',pathcounter) - + disp('Old, New') + % Would be nice to have a way to get the iteration count without having the whole printout of path values (I think that would be useful?) pathnametitles{:} [PricePathOld,PricePathNew] end diff --git a/TransitionPaths/InfHorz/TransitionPath_InfHorz_shooting_nod.m b/TransitionPaths/InfHorz/TransitionPath_InfHorz_shooting_nod.m index 0be156b1..10ba27cf 100644 --- a/TransitionPaths/InfHorz/TransitionPath_InfHorz_shooting_nod.m +++ b/TransitionPaths/InfHorz/TransitionPath_InfHorz_shooting_nod.m @@ -205,8 +205,7 @@ % Notice that the distance is always calculated ignoring the time t=1 & t=T periods, as these needn't ever converges if transpathoptions.verbose==1 - fprintf('Number of iteration on the path: %i \n',pathcounter) - + disp('Old, New') % Would be nice to have a way to get the iteration count without having the whole printout of path values (I think that would be useful?) pathnametitles{:} [PricePathOld,PricePathNew] diff --git a/TransitionPaths/InfHorz/subcodes/ValueFnSingleStep/DivideAndConquer/GridInterpLayer/ValueFnIter_InfHorz_TPath_SingleStep_DC1_GI_raw.m b/TransitionPaths/InfHorz/subcodes/ValueFnSingleStep/DivideAndConquer/GridInterpLayer/ValueFnIter_InfHorz_TPath_SingleStep_DC1_GI_raw.m index d3a714e7..f89eb1d4 100644 --- a/TransitionPaths/InfHorz/subcodes/ValueFnSingleStep/DivideAndConquer/GridInterpLayer/ValueFnIter_InfHorz_TPath_SingleStep_DC1_GI_raw.m +++ b/TransitionPaths/InfHorz/subcodes/ValueFnSingleStep/DivideAndConquer/GridInterpLayer/ValueFnIter_InfHorz_TPath_SingleStep_DC1_GI_raw.m @@ -41,7 +41,6 @@ V=zeros(N_a,N_z,'gpuArray'); Policy=zeros(3,N_a,N_z,'gpuArray'); %first dim indexes the optimal choice for d and aprime rest of dimensions a,z - %% % Create a vector containing all the return function parameters (in order) ReturnFnParamsVec=CreateVectorFromParams(Parameters, ReturnFnParamNames); diff --git a/TransitionPaths/InfHorz/subcodes/ValueFnSingleStep/DivideAndConquer/ValueFnIter_InfHorz_TPath_SingleStep_DC1_nod_raw.m b/TransitionPaths/InfHorz/subcodes/ValueFnSingleStep/DivideAndConquer/ValueFnIter_InfHorz_TPath_SingleStep_DC1_nod_raw.m index bb66064f..a88905db 100644 --- a/TransitionPaths/InfHorz/subcodes/ValueFnSingleStep/DivideAndConquer/ValueFnIter_InfHorz_TPath_SingleStep_DC1_nod_raw.m +++ b/TransitionPaths/InfHorz/subcodes/ValueFnSingleStep/DivideAndConquer/ValueFnIter_InfHorz_TPath_SingleStep_DC1_nod_raw.m @@ -62,6 +62,6 @@ end %% Policy in transition paths -Policy=UnKronPolicyIndexes_Case1(Policy,n_d,n_a,n_z,vfoptions); +Policy=UnKronPolicyIndexes_Case1(shiftdim(Policy,-1),n_d,n_a,n_z,vfoptions); end diff --git a/TransitionPaths/InfHorz/subcodes/ValueFnSingleStep/ValueFnIter_InfHorz_TPath_SingleStep.m b/TransitionPaths/InfHorz/subcodes/ValueFnSingleStep/ValueFnIter_InfHorz_TPath_SingleStep.m index 5c8a2aed..3427ee74 100644 --- a/TransitionPaths/InfHorz/subcodes/ValueFnSingleStep/ValueFnIter_InfHorz_TPath_SingleStep.m +++ b/TransitionPaths/InfHorz/subcodes/ValueFnSingleStep/ValueFnIter_InfHorz_TPath_SingleStep.m @@ -26,7 +26,6 @@ [VKron, PolicyKron]=ValueFnIter_InfHorz_TPath_SingleStep_raw(VKron,n_d,n_a,n_z, d_grid, a_grid, z_gridvals, pi_z, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); end elseif vfoptions.divideandconquer==1 - if isscalar(n_a) if N_d==0 [VKron,PolicyKron]=ValueFnIter_InfHorz_TPath_SingleStep_DC1_nod_raw(VKron,n_a, n_z, a_grid, z_gridvals, pi_z, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); @@ -54,7 +53,13 @@ end else % vfoptions.gridinterplayer==1 if vfoptions.divideandconquer==0 - error('Have not yet implemented combo of vfoptions.gridinterplayer=1 with vfoptions.divideandconquer=0') + if N_d==0 + error('Have not yet implemented combo of vfoptions.gridinterplayer=1 with vfoptions.divideandconquer=0') + % [VKron,PolicyKron]=ValueFnIter_InfHorz_TPath_SingleStep_GI_nod_raw(VKron,n_a, n_z, a_grid, z_gridvals, pi_z, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + else + error('Have not yet implemented combo of vfoptions.gridinterplayer=1 with vfoptions.divideandconquer=0') + % [VKron, PolicyKron]=ValueFnIter_InfHorz_TPath_SingleStep_GI_raw(VKron,n_d,n_a,n_z, d_grid, a_grid, z_gridvals, pi_z, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + end elseif vfoptions.divideandconquer==1 if isscalar(n_a) if N_d==0 @@ -86,14 +91,4 @@ % [VKron, PolicyKron]=ValueFnIter_InfHorz_TPath_SingleStep_Refine_raw(VKron,n_d,n_a,n_z, d_grid, a_grid, z_grid, pi_z, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); % end -%% -% Sometimes numerical rounding errors (of the order of 10^(-16) can mean -% that Policy is not integer valued. The following corrects this by converting to int64 and then -% makes the output back into double as Matlab otherwise cannot use it in -% any arithmetical expressions. -if vfoptions.policy_forceintegertype==1 || vfoptions.policy_forceintegertype==2 - PolicyKron=uint64(PolicyKron); - PolicyKron=double(PolicyKron); -end - end diff --git a/TransitionPaths/InfHorz/subcodes/ValueFnSingleStep/ValueFnIter_InfHorz_TPath_SingleStep_nod_raw.m b/TransitionPaths/InfHorz/subcodes/ValueFnSingleStep/ValueFnIter_InfHorz_TPath_SingleStep_nod_raw.m index 7da4b9a7..9ee22984 100644 --- a/TransitionPaths/InfHorz/subcodes/ValueFnSingleStep/ValueFnIter_InfHorz_TPath_SingleStep_nod_raw.m +++ b/TransitionPaths/InfHorz/subcodes/ValueFnSingleStep/ValueFnIter_InfHorz_TPath_SingleStep_nod_raw.m @@ -55,6 +55,6 @@ end %% Policy in transition paths -Policy=UnKronPolicyIndexes_Case1(Policy,0,n_a,n_z,vfoptions); +Policy=UnKronPolicyIndexes_Case1(shiftdim(Policy,-1),0,n_a,n_z,vfoptions); end diff --git a/TransitionPaths/Subcodes/updatePricePathNew_TPath_tt.m b/TransitionPaths/Subcodes/updatePricePathNew_TPath_tt.m index 965585ba..5585f87d 100644 --- a/TransitionPaths/Subcodes/updatePricePathNew_TPath_tt.m +++ b/TransitionPaths/Subcodes/updatePricePathNew_TPath_tt.m @@ -9,7 +9,7 @@ if transpathoptions.GEnewprice==1 % The GeneralEqmEqns are not really general eqm eqns, but instead have been given in the form of GEprice updating formulae PricePathNew_tt=p_i; - GEcondnPath_tt=[]; % not being used + GEcondnPath_tt=nan; % not being used [but cannot be left empty] % Note there is no GEnewprice==2, it uses a completely different code elseif transpathoptions.GEnewprice==3 % Version of shooting algorithm where the new value is the current value +- fraction*(GECondn) GEcondnPath_tt=p_i; % Sometimes, want to keep the GE conditions to plot them @@ -19,5 +19,4 @@ PricePathNew_tt=PricePathOld_tt+transpathoptions.GEnewprice3.add.*transpathoptions.GEnewprice3.factor.*p_i-(1-transpathoptions.GEnewprice3.add).*transpathoptions.GEnewprice3.factor.*p_i; end - end \ No newline at end of file diff --git a/ValueFnIter/FHorz/DivideConquer/DC1/ValueFnIter_FHorz_DC1_nod_noz_raw.m b/ValueFnIter/FHorz/DivideConquer/DC1/ValueFnIter_FHorz_DC1_nod_noz_raw.m index 3705c63e..97a318eb 100644 --- a/ValueFnIter/FHorz/DivideConquer/DC1/ValueFnIter_FHorz_DC1_nod_noz_raw.m +++ b/ValueFnIter/FHorz/DivideConquer/DC1/ValueFnIter_FHorz_DC1_nod_noz_raw.m @@ -106,7 +106,4 @@ - - - end diff --git a/ValueFnIter/FHorz/DivideConquer/DC2B/ValueFnIter_FHorz_DC2B_nod_noz_e_raw.m b/ValueFnIter/FHorz/DivideConquer/DC2B/ValueFnIter_FHorz_DC2B_nod_noz_e_raw.m index bf75e5e0..979b225a 100644 --- a/ValueFnIter/FHorz/DivideConquer/DC2B/ValueFnIter_FHorz_DC2B_nod_noz_e_raw.m +++ b/ValueFnIter/FHorz/DivideConquer/DC2B/ValueFnIter_FHorz_DC2B_nod_noz_e_raw.m @@ -226,5 +226,4 @@ - end diff --git a/ValueFnIter/FHorz/DivideConquer/ValueFnIter_FHorz_DC.m b/ValueFnIter/FHorz/DivideConquer/ValueFnIter_FHorz_DC.m index 89d02f09..da328629 100644 --- a/ValueFnIter/FHorz/DivideConquer/ValueFnIter_FHorz_DC.m +++ b/ValueFnIter/FHorz/DivideConquer/ValueFnIter_FHorz_DC.m @@ -39,6 +39,8 @@ [VKron,PolicyKron]=ValueFnIter_FHorz_DC1_nod_raw(n_a, n_z, N_j, a_grid, z_gridvals_J, pi_z_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); end end + % Policy without d + PolicyKron=shiftdim(PolicyKron,-1); else % N_d if isfield(vfoptions,'n_e') if N_z==0 @@ -86,6 +88,8 @@ end end end + % Policy without d + PolicyKron=shiftdim(PolicyKron,-1); else % N_d if isfield(vfoptions,'n_e') if N_z==0 diff --git a/ValueFnIter/FHorz/ExoticPrefs/ValueFnIter_Case1_FHorz_Ambiguity.m b/ValueFnIter/FHorz/ExoticPrefs/ValueFnIter_Case1_FHorz_Ambiguity.m index 9fdb3b79..6dff6752 100644 --- a/ValueFnIter/FHorz/ExoticPrefs/ValueFnIter_Case1_FHorz_Ambiguity.m +++ b/ValueFnIter/FHorz/ExoticPrefs/ValueFnIter_Case1_FHorz_Ambiguity.m @@ -51,6 +51,8 @@ [VKron,PolicyKron]=ValueFnIter_Case1_FHorz_Ambiguity_nod_raw(n_ambiguity, n_a, n_z, N_j, a_grid, z_gridvals_J, vfoptions.ambiguity_pi_z_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); end end + % Policy without d + PolicyKron=shiftdim(PolicyKron,-1); else if isfield(vfoptions,'n_e') if N_z==0 diff --git a/ValueFnIter/FHorz/ExoticPrefs/ValueFnIter_Case1_FHorz_EpsteinZin.m b/ValueFnIter/FHorz/ExoticPrefs/ValueFnIter_Case1_FHorz_EpsteinZin.m index 197a7789..078a65a9 100644 --- a/ValueFnIter/FHorz/ExoticPrefs/ValueFnIter_Case1_FHorz_EpsteinZin.m +++ b/ValueFnIter/FHorz/ExoticPrefs/ValueFnIter_Case1_FHorz_EpsteinZin.m @@ -184,6 +184,8 @@ [VKron,PolicyKron]=ValueFnIter_Case1_FHorz_EpsteinZin_nod_raw(n_a, n_z, N_j, a_grid, z_gridvals_J, pi_z_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions, sj, warmglow, ezc1,ezc2,ezc3,ezc4,ezc5,ezc6,ezc7,ezc8); end end + % Policy without d + PolicyKron=shiftdim(PolicyKron,-1); else if isfield(vfoptions,'n_e') if N_z==0 diff --git a/ValueFnIter/FHorz/ExoticPrefs/ValueFnIter_Case1_FHorz_GulPesendorfer.m b/ValueFnIter/FHorz/ExoticPrefs/ValueFnIter_Case1_FHorz_GulPesendorfer.m index d820af96..ac19b258 100644 --- a/ValueFnIter/FHorz/ExoticPrefs/ValueFnIter_Case1_FHorz_GulPesendorfer.m +++ b/ValueFnIter/FHorz/ExoticPrefs/ValueFnIter_Case1_FHorz_GulPesendorfer.m @@ -69,6 +69,8 @@ [VKron,PolicyKron]=ValueFnIter_Case1_FHorz_GulPesendorfer_nod_raw(n_a, n_z, N_j, a_grid, z_gridvals_J, pi_z_J, ReturnFn, vfoptions.temptationFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, TemptationFnParamNames, vfoptions); end end + % Policy without d + PolicyKron=shiftdim(PolicyKron,-1); else if isfield(vfoptions,'n_e') % UP TO HERE if N_z==0 diff --git a/ValueFnIter/FHorz/ExoticPrefs/ValueFnIter_Case1_FHorz_QuasiHyperbolic.m b/ValueFnIter/FHorz/ExoticPrefs/ValueFnIter_Case1_FHorz_QuasiHyperbolic.m index 66e7a718..81c115c1 100644 --- a/ValueFnIter/FHorz/ExoticPrefs/ValueFnIter_Case1_FHorz_QuasiHyperbolic.m +++ b/ValueFnIter/FHorz/ExoticPrefs/ValueFnIter_Case1_FHorz_QuasiHyperbolic.m @@ -46,6 +46,8 @@ [VKron,PolicyKron,ValtKron]=ValueFnIter_Case1_FHorz_QuasiHyperbolic_nod_raw(n_a, n_z, N_j, a_grid, z_gridvals_J, pi_z_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); end end + % Policy without d + PolicyKron=shiftdim(PolicyKron,-1); else if isfield(vfoptions,'n_e') if N_z==0 diff --git a/ValueFnIter/FHorz/OnCPU/ValueFnIter_FHorz_CPU.m b/ValueFnIter/FHorz/OnCPU/ValueFnIter_FHorz_CPU.m index befd884a..d579cbb7 100644 --- a/ValueFnIter/FHorz/OnCPU/ValueFnIter_FHorz_CPU.m +++ b/ValueFnIter/FHorz/OnCPU/ValueFnIter_FHorz_CPU.m @@ -52,22 +52,12 @@ %% Transforming Value Fn and Optimal Policy Indexes matrices back out of Kronecker Form if vfoptions.outputkron==0 - if isfield(vfoptions,'n_e') - if N_z==0 - V=reshape(VKron,[n_a,vfoptions.n_e,N_j]); - Policy=UnKronPolicyIndexes_Case1_FHorz(PolicyKron, n_d, n_a, vfoptions.n_e, N_j, vfoptions); % Treat e as z (because no z) - else - V=reshape(VKron,[n_a,n_z,vfoptions.n_e,N_j]); - Policy=UnKronPolicyIndexes_Case1_FHorz_e(PolicyKron, n_d, n_a, n_z, vfoptions.n_e, N_j, vfoptions); - end + if N_z==0 + V=reshape(VKron,[n_a,N_j]); + Policy=UnKronPolicyIndexes_FHorz_noz_CPU(PolicyKron, n_d, n_a, N_j); else - if N_z==0 - V=reshape(VKron,[n_a,N_j]); - Policy=UnKronPolicyIndexes_Case1_FHorz_noz(PolicyKron, n_d, n_a, N_j, vfoptions); - else - V=reshape(VKron,[n_a,n_z,N_j]); - Policy=UnKronPolicyIndexes_Case1_FHorz(PolicyKron, n_d, n_a, n_z, N_j, vfoptions); - end + V=reshape(VKron,[n_a,n_z,N_j]); + Policy=UnKronPolicyIndexes_FHorz_CPU(PolicyKron, n_d, n_a, n_z, N_j); end else V=VKron; diff --git a/ValueFnIter/FHorz/SemiExo/DivideAndConquer/ValueFnIter_FHorz_SemiExo_DC.m b/ValueFnIter/FHorz/SemiExo/DivideAndConquer/ValueFnIter_FHorz_SemiExo_DC.m index 344ffa65..a24fd678 100644 --- a/ValueFnIter/FHorz/SemiExo/DivideAndConquer/ValueFnIter_FHorz_SemiExo_DC.m +++ b/ValueFnIter/FHorz/SemiExo/DivideAndConquer/ValueFnIter_FHorz_SemiExo_DC.m @@ -21,29 +21,29 @@ if N_d1==0 if N_e==0 if N_z==0 - [VKron, Policy]=ValueFnIter_FHorz_SemiExo_DC1_nod1_noz_raw(n_d2,n_a,n_semiz, N_j, d2_gridvals, a_grid, semiz_gridvals_J, pi_semiz_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + [VKron, Policy3]=ValueFnIter_FHorz_SemiExo_DC1_nod1_noz_raw(n_d2,n_a,n_semiz, N_j, d2_gridvals, a_grid, semiz_gridvals_J, pi_semiz_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); else - [VKron, Policy]=ValueFnIter_FHorz_SemiExo_DC1_nod1_raw(n_d2,n_a,n_z,n_semiz, N_j, d2_gridvals, a_grid, z_gridvals_J, semiz_gridvals_J, pi_z_J, pi_semiz_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + [VKron, Policy3]=ValueFnIter_FHorz_SemiExo_DC1_nod1_raw(n_d2,n_a,n_z,n_semiz, N_j, d2_gridvals, a_grid, z_gridvals_J, semiz_gridvals_J, pi_z_J, pi_semiz_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); end else if N_z==0 - [VKron, Policy]=ValueFnIter_FHorz_SemiExo_DC1_nod1_noz_e_raw(n_d2,n_a,n_semiz, vfoptions.n_e, N_j, d2_gridvals, a_grid, semiz_gridvals_J, vfoptions.e_gridvals_J, pi_semiz_J, vfoptions.pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + [VKron, Policy3]=ValueFnIter_FHorz_SemiExo_DC1_nod1_noz_e_raw(n_d2,n_a,n_semiz, vfoptions.n_e, N_j, d2_gridvals, a_grid, semiz_gridvals_J, vfoptions.e_gridvals_J, pi_semiz_J, vfoptions.pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); else - [VKron, Policy]=ValueFnIter_FHorz_SemiExo_DC1_nod1_e_raw(n_d2,n_a,n_z,n_semiz, vfoptions.n_e, N_j, d2_gridvals, a_grid, z_gridvals_J, semiz_gridvals_J, vfoptions.e_gridvals_J, pi_z_J, pi_semiz_J, vfoptions.pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + [VKron, Policy3]=ValueFnIter_FHorz_SemiExo_DC1_nod1_e_raw(n_d2,n_a,n_z,n_semiz, vfoptions.n_e, N_j, d2_gridvals, a_grid, z_gridvals_J, semiz_gridvals_J, vfoptions.e_gridvals_J, pi_z_J, pi_semiz_J, vfoptions.pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); end end else if N_e==0 if N_z==0 - [VKron, Policy]=ValueFnIter_FHorz_SemiExo_DC1_noz_raw(n_d1, n_d2,n_a,n_semiz, N_j, d1_gridvals, d2_gridvals, a_grid, semiz_gridvals_J, pi_semiz_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + [VKron, Policy3]=ValueFnIter_FHorz_SemiExo_DC1_noz_raw(n_d1, n_d2,n_a,n_semiz, N_j, d1_gridvals, d2_gridvals, a_grid, semiz_gridvals_J, pi_semiz_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); else - [VKron, Policy]=ValueFnIter_FHorz_SemiExo_DC1_raw(n_d1, n_d2,n_a,n_z,n_semiz, N_j, d1_gridvals, d2_gridvals, a_grid, z_gridvals_J, semiz_gridvals_J, pi_z_J, pi_semiz_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + [VKron, Policy3]=ValueFnIter_FHorz_SemiExo_DC1_raw(n_d1, n_d2,n_a,n_z,n_semiz, N_j, d1_gridvals, d2_gridvals, a_grid, z_gridvals_J, semiz_gridvals_J, pi_z_J, pi_semiz_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); end else if N_z==0 - [VKron, Policy]=ValueFnIter_FHorz_SemiExo_DC1_noz_e_raw(n_d1,n_d2,n_a,vfoptions.n_semiz, vfoptions.n_e, N_j, d1_gridvals, d2_gridvals, a_grid, semiz_gridvals_J, vfoptions.e_gridvals_J, pi_semiz_J, vfoptions.pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + [VKron, Policy3]=ValueFnIter_FHorz_SemiExo_DC1_noz_e_raw(n_d1,n_d2,n_a,vfoptions.n_semiz, vfoptions.n_e, N_j, d1_gridvals, d2_gridvals, a_grid, semiz_gridvals_J, vfoptions.e_gridvals_J, pi_semiz_J, vfoptions.pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); else - [VKron, Policy]=ValueFnIter_FHorz_SemiExo_DC1_e_raw(n_d1,n_d2,n_a,n_z,vfoptions.n_semiz, vfoptions.n_e, N_j, d1_gridvals, d2_gridvals, a_grid, z_gridvals_J, semiz_gridvals_J, vfoptions.e_gridvals_J, pi_z_J, pi_semiz_J, vfoptions.pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + [VKron, Policy3]=ValueFnIter_FHorz_SemiExo_DC1_e_raw(n_d1,n_d2,n_a,n_z,vfoptions.n_semiz, vfoptions.n_e, N_j, d1_gridvals, d2_gridvals, a_grid, z_gridvals_J, semiz_gridvals_J, vfoptions.e_gridvals_J, pi_z_J, pi_semiz_J, vfoptions.pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); end end end @@ -55,10 +55,10 @@ if N_d1==0 if N_e==0 if N_z==0 - [VKron, Policy]=ValueFnIter_FHorz_SemiExo_DC2B_nod1_noz_raw(n_d2,n_a,n_semiz, N_j, d2_gridvals, a_grid, semiz_gridvals_J, pi_semiz_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + [VKron, Policy3]=ValueFnIter_FHorz_SemiExo_DC2B_nod1_noz_raw(n_d2,n_a,n_semiz, N_j, d2_gridvals, a_grid, semiz_gridvals_J, pi_semiz_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); else if vfoptions.lowmemory==0 - [VKron, Policy]=ValueFnIter_FHorz_SemiExo_DC2B_nod1_raw(n_d2,n_a,n_z,n_semiz, N_j, d2_gridvals, a_grid, z_gridvals_J, semiz_gridvals_J, pi_z_J, pi_semiz_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + [VKron, Policy3]=ValueFnIter_FHorz_SemiExo_DC2B_nod1_raw(n_d2,n_a,n_z,n_semiz, N_j, d2_gridvals, a_grid, z_gridvals_J, semiz_gridvals_J, pi_z_J, pi_semiz_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); elseif vfoptions.lowmemory==1 % loop over z end @@ -66,13 +66,13 @@ else if N_z==0 if vfoptions.lowmemory==0 - [VKron, Policy]=ValueFnIter_FHorz_SemiExo_DC2B_nod1_noz_e_raw(n_d2,n_a,n_semiz, vfoptions.n_e, N_j, d2_gridvals, a_grid, semiz_gridvals_J, vfoptions.e_gridvals_J, pi_semiz_J, vfoptions.pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + [VKron, Policy3]=ValueFnIter_FHorz_SemiExo_DC2B_nod1_noz_e_raw(n_d2,n_a,n_semiz, vfoptions.n_e, N_j, d2_gridvals, a_grid, semiz_gridvals_J, vfoptions.e_gridvals_J, pi_semiz_J, vfoptions.pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); elseif vfoptions.lowmemory==1 % loop over e end else if vfoptions.lowmemory==0 - [VKron, Policy]=ValueFnIter_FHorz_SemiExo_DC2B_nod1_e_raw(n_d2,n_a,n_z,n_semiz, vfoptions.n_e, N_j, d2_gridvals, a_grid, z_gridvals_J, semiz_gridvals_J, vfoptions.e_gridvals_J, pi_z_J, pi_semiz_J, vfoptions.pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + [VKron, Policy3]=ValueFnIter_FHorz_SemiExo_DC2B_nod1_e_raw(n_d2,n_a,n_z,n_semiz, vfoptions.n_e, N_j, d2_gridvals, a_grid, z_gridvals_J, semiz_gridvals_J, vfoptions.e_gridvals_J, pi_z_J, pi_semiz_J, vfoptions.pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); elseif vfoptions.lowmemory==1 % loop over e elseif vfoptions.lowmemory==2 % loop over z & e @@ -83,10 +83,10 @@ else if N_e==0 if N_z==0 - [VKron, Policy]=ValueFnIter_FHorz_SemiExo_DC2B_noz_raw(n_d1, n_d2,n_a,n_semiz, N_j, d1_grid, d2_gridvals, a_grid, semiz_gridvals_J, pi_semiz_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + [VKron, Policy3]=ValueFnIter_FHorz_SemiExo_DC2B_noz_raw(n_d1, n_d2,n_a,n_semiz, N_j, d1_grid, d2_gridvals, a_grid, semiz_gridvals_J, pi_semiz_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); else if vfoptions.lowmemory==0 - [VKron, Policy]=ValueFnIter_FHorz_SemiExo_DC2B_raw(n_d1, n_d2,n_a,n_z,n_semiz, N_j, d1_grid, d2_gridvals, a_grid, z_gridvals_J, semiz_gridvals_J, pi_z_J, pi_semiz_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + [VKron, Policy3]=ValueFnIter_FHorz_SemiExo_DC2B_raw(n_d1, n_d2,n_a,n_z,n_semiz, N_j, d1_grid, d2_gridvals, a_grid, z_gridvals_J, semiz_gridvals_J, pi_z_J, pi_semiz_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); elseif vfoptions.lowmemory==1 % loop over z end @@ -94,13 +94,13 @@ else if N_z==0 if vfoptions.lowmemory==0 - [VKron, Policy]=ValueFnIter_FHorz_SemiExo_DC2B_noz_e_raw(n_d1,n_d2,n_a,vfoptions.n_semiz, vfoptions.n_e, N_j, d1_grid, d2_gridvals, a_grid, semiz_gridvals_J, vfoptions.e_gridvals_J, pi_semiz_J, vfoptions.pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + [VKron, Policy3]=ValueFnIter_FHorz_SemiExo_DC2B_noz_e_raw(n_d1,n_d2,n_a,vfoptions.n_semiz, vfoptions.n_e, N_j, d1_grid, d2_gridvals, a_grid, semiz_gridvals_J, vfoptions.e_gridvals_J, pi_semiz_J, vfoptions.pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); elseif vfoptions.lowmemory==1 % loop over e end else if vfoptions.lowmemory==0 - [VKron, Policy]=ValueFnIter_FHorz_SemiExo_DC2B_e_raw(n_d1,n_d2,n_a,n_z,vfoptions.n_semiz, vfoptions.n_e, N_j, d1_grid, d2_gridvals, a_grid, z_gridvals_J, semiz_gridvals_J, vfoptions.e_gridvals_J, pi_z_J, pi_semiz_J, vfoptions.pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + [VKron, Policy3]=ValueFnIter_FHorz_SemiExo_DC2B_e_raw(n_d1,n_d2,n_a,n_z,vfoptions.n_semiz, vfoptions.n_e, N_j, d1_grid, d2_gridvals, a_grid, z_gridvals_J, semiz_gridvals_J, vfoptions.e_gridvals_J, pi_z_J, pi_semiz_J, vfoptions.pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); elseif vfoptions.lowmemory==1 % loop over e elseif vfoptions.lowmemory==2 % loop over z & e @@ -124,19 +124,20 @@ n_bothz=[vfoptions.n_semiz,n_z]; end +% Because of how we have N_semiz*N_z together, use the _noz commands to UnKron if vfoptions.outputkron==0 if isfield(vfoptions,'n_e') V=reshape(VKron,[n_a,n_bothz, vfoptions.n_e,N_j]); - Policy=UnKronPolicyIndexes_Case1_FHorz_semiz_e(Policy, n_d1,n_d2, n_a, n_bothz, vfoptions.n_e, N_j, vfoptions); + Policy=UnKronPolicyIndexes_Case1_FHorz_semiz(Policy3, n_d1,n_d2, n_a, n_bothz, vfoptions.n_e, N_j, vfoptions); % pretend e is z (as z is with semiz) else V=reshape(VKron,[n_a,n_bothz,N_j]); - Policy=UnKronPolicyIndexes_Case1_FHorz_semiz(Policy, n_d1, n_d2, n_a, n_bothz, N_j, vfoptions); + Policy=UnKronPolicyIndexes_Case1_FHorz_semiz_noz(Policy3, n_d1, n_d2, n_a, n_bothz, N_j, vfoptions); end else V=VKron; - % Policy=Policy; + Policy=Policy3; end - + end diff --git a/ValueFnIter/FHorz/SemiExo/ValueFnIter_FHorz_SemiExo.m b/ValueFnIter/FHorz/SemiExo/ValueFnIter_FHorz_SemiExo.m index 2bc619e7..bb3f6010 100644 --- a/ValueFnIter/FHorz/SemiExo/ValueFnIter_FHorz_SemiExo.m +++ b/ValueFnIter/FHorz/SemiExo/ValueFnIter_FHorz_SemiExo.m @@ -65,29 +65,25 @@ %% Transforming Value Fn and Optimal Policy Indexes matrices back out of Kronecker Form % First dimension of Policy3 is (d1,d2,aprime), or if no d1, then (d2,aprime) +if N_z==0 + n_bothz=vfoptions.n_semiz; +else + n_bothz=[vfoptions.n_semiz,n_z]; +end + +% Because of how we have N_semiz*N_z together, use the _noz commands to UnKron if vfoptions.outputkron==0 if isfield(vfoptions,'n_e') - if N_z==0 - V=reshape(VKron,[n_a,vfoptions.n_semiz, vfoptions.n_e,N_j]); - Policy=UnKronPolicyIndexes_Case1_FHorz_semiz_e(Policy3, n_d1,n_d2, n_a, vfoptions.n_semiz, vfoptions.n_e, N_j, vfoptions); - else - V=reshape(VKron,[n_a,vfoptions.n_semiz,n_z,vfoptions.n_e,N_j]); - Policy=UnKronPolicyIndexes_Case1_FHorz_semiz_e(Policy3, n_d1,n_d2, n_a, [vfoptions.n_semiz,n_z], vfoptions.n_e, N_j, vfoptions); - end + V=reshape(VKron,[n_a,n_bothz, vfoptions.n_e,N_j]); + Policy=UnKronPolicyIndexes_Case1_FHorz_semiz(Policy3, n_d1,n_d2, n_a, n_bothz, vfoptions.n_e, N_j, vfoptions); % pretend e is z (as z is with semiz) else - if N_z==0 - V=reshape(VKron,[n_a,vfoptions.n_semiz,N_j]); - Policy=UnKronPolicyIndexes_Case1_FHorz_semiz(Policy3, n_d1, n_d2, n_a, vfoptions.n_semiz, N_j, vfoptions); - else - V=reshape(VKron,[n_a,vfoptions.n_semiz,n_z,N_j]); - Policy=UnKronPolicyIndexes_Case1_FHorz_semiz(Policy3, n_d1, n_d2, n_a, [vfoptions.n_semiz,n_z], N_j, vfoptions); - end + V=reshape(VKron,[n_a,n_bothz,N_j]); + Policy=UnKronPolicyIndexes_Case1_FHorz_semiz_noz(Policy3, n_d1, n_d2, n_a, n_bothz, N_j, vfoptions); end else V=VKron; Policy=Policy3; end - end diff --git a/ValueFnIter/FHorz/ValueFnIter_Case1_FHorz.m b/ValueFnIter/FHorz/ValueFnIter_Case1_FHorz.m index ad7b9e7a..354e227d 100644 --- a/ValueFnIter/FHorz/ValueFnIter_Case1_FHorz.m +++ b/ValueFnIter/FHorz/ValueFnIter_Case1_FHorz.m @@ -453,6 +453,8 @@ if N_d==0 [VKron,PolicyKron]=ValueFnIter_Case1_FHorz_no_d_SDVz_raw(n_a, n_z, N_j, a_grid, z_gridvals_J, pi_z_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + % Policy without d + PolicyKron=shiftdim(PolicyKron,-1); else [VKron, PolicyKron]=ValueFnIter_Case1_FHorz_SDVz_raw(n_d,n_a,n_z, N_j, d_grid, a_grid, z_gridvals_J, pi_z_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); end @@ -476,6 +478,8 @@ if N_d==0 [VKron,PolicyKron]=ValueFnIter_Case1_FHorz_nod_Dynasty_raw(n_a, n_z, N_j, a_grid, z_gridvals_J, pi_z_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + % Policy without d + PolicyKron=shiftdim(PolicyKron,-1); else [VKron, PolicyKron]=ValueFnIter_Case1_FHorz_Dynasty_raw(n_d,n_a,n_z, N_j, d_grid, a_grid, z_gridvals_J, pi_z_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); end @@ -565,6 +569,8 @@ [VKron,PolicyKron]=ValueFnIter_FHorz_nod_raw(n_a, n_z, N_j, a_grid, z_gridvals_J, pi_z_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); end end + % Policy without d + PolicyKron=shiftdim(PolicyKron,-1); else % N_d if isfield(vfoptions,'n_e') if N_z==0 diff --git a/ValueFnIter/FHorz/ValueFnIter_FHorz_nod_noz_e_raw.m b/ValueFnIter/FHorz/ValueFnIter_FHorz_nod_noz_e_raw.m index e55f2f00..ac69932d 100644 --- a/ValueFnIter/FHorz/ValueFnIter_FHorz_nod_noz_e_raw.m +++ b/ValueFnIter/FHorz/ValueFnIter_FHorz_nod_noz_e_raw.m @@ -251,3 +251,6 @@ Policy=reshape(Policy,[N_a,N_e,N_j]); end + + +end diff --git a/ValueFnIter/FHorz/ValueFnIter_FHorz_nod_noz_raw.m b/ValueFnIter/FHorz/ValueFnIter_FHorz_nod_noz_raw.m index cec446da..f742a2ea 100644 --- a/ValueFnIter/FHorz/ValueFnIter_FHorz_nod_noz_raw.m +++ b/ValueFnIter/FHorz/ValueFnIter_FHorz_nod_noz_raw.m @@ -64,4 +64,5 @@ end + end diff --git a/ValueFnIter/InfHorz/CPU/ValueFnIter_nod_Par0_raw.m b/ValueFnIter/InfHorz/CPU/ValueFnIter_nod_Par0_raw.m index 545d357b..7ea7a066 100644 --- a/ValueFnIter/InfHorz/CPU/ValueFnIter_nod_Par0_raw.m +++ b/ValueFnIter/InfHorz/CPU/ValueFnIter_nod_Par0_raw.m @@ -54,6 +54,6 @@ end -Policy=reshape(PolicyIndexes,[N_a,N_z]); +Policy=reshape(PolicyIndexes,[1,N_a,N_z]); end diff --git a/ValueFnIter/InfHorz/CPU/ValueFnIter_nod_Par1_raw.m b/ValueFnIter/InfHorz/CPU/ValueFnIter_nod_Par1_raw.m index 94e71e2b..34ac8f5a 100644 --- a/ValueFnIter/InfHorz/CPU/ValueFnIter_nod_Par1_raw.m +++ b/ValueFnIter/InfHorz/CPU/ValueFnIter_nod_Par1_raw.m @@ -1,6 +1,6 @@ function [VKron, Policy]=ValueFnIter_nod_Par1_raw(VKron, N_a, N_z, pi_z, beta, ReturnMatrix, Howards,Howards2, Tolerance) %Verbose -PolicyIndexes=zeros(N_a,N_z); +Policy=zeros(N_a,N_z); Ftemp=zeros(N_a,N_z); @@ -26,7 +26,7 @@ %Calc the max and it's index [Vtemp,maxindex]=max(entireRHS); VKron(:,z_c)=Vtemp; - PolicyIndexes(:,z_c)=maxindex; + Policy(:,z_c)=maxindex; tempmaxindex=maxindex+(0:1:N_a-1)*N_a; Ftemp(:,z_c)=ReturnMatrix_z(tempmaxindex); @@ -37,7 +37,7 @@ if isfinite(currdist) && tempcounter0); vfoptions.verbose=0; vfoptions.lowmemory=0; + % Model setup vfoptions.exoticpreferences='None'; - vfoptions.endotype=0; - vfoptions.polindorval=1; - vfoptions.policy_forceintegertype=0; else %Check vfoptions for missing fields, if there are some fill them with the defaults if ~isfield(vfoptions,'divideandconquer') @@ -57,35 +48,31 @@ error('You have vfoptions.gridinterplayer, so must also set vfoptions.ngridinterp') end end - if ~isfield(vfoptions,'parallel') - vfoptions.parallel=1+(gpuDeviceCount>0); - end if ~isfield(vfoptions,'lowmemory') vfoptions.lowmemory=0; end if ~isfield(vfoptions,'verbose') vfoptions.verbose=0; end + % Model setup if ~isfield(vfoptions,'exoticpreferences') vfoptions.exoticpreferences='None'; end - if ~isfield(vfoptions,'endotype') - vfoptions.endotype=0; - end - if ~isfield(vfoptions,'polindorval') - vfoptions.polindorval=1; - end - if ~isfield(vfoptions,'policy_forceintegertype') - vfoptions.policy_forceintegertype=0; - end end -vfoptions.preEV=0; % =1 is used by 'Matched Expecations Path', for TPath we want =0 (this relates to details of fastOLG=1 value fn code) +vfoptions.parallel=2; % transition path requires GPU +vfoptions.EVpre=0; % =1 is used by 'Matched Expecations Path', for TPath we want =0 (this relates to details of fastOLG=1 value fn code) %% Internally PricePath is matrix of size T-by-'number of prices'. % ParamPath is matrix of size T-by-'number of parameters that change over the transition path'. [PricePath,ParamPath,PricePathNames,ParamPathNames,PricePathSizeVec,ParamPathSizeVec]=PricePathParamPath_FHorz_StructToMatrix(PricePath,ParamPath,N_j,T); +%% Make sure all the relevant inputs are GPU arrays (not standard arrays) +pi_z=gpuArray(pi_z); +d_grid=gpuArray(d_grid); +a_grid=gpuArray(a_grid); +z_grid=gpuArray(z_grid); +V_final=gpuArray(V_final); %% Check the sizes of some of the inputs N_d=prod(n_d); @@ -98,47 +85,20 @@ end N_e=prod(n_e); - -%% Make sure all the relevant inputs are GPU arrays (not standard arrays) -pi_z=gpuArray(pi_z); -d_grid=gpuArray(d_grid); -a_grid=gpuArray(a_grid); -z_grid=gpuArray(z_grid); -V_final=gpuArray(V_final); - - -%% Handle ReturnFn and FnsToEvaluate structures -l_d=length(n_d); if N_d==0 l_d=0; -end -l_a=length(n_a); -l_z=length(n_z); -if N_z==0 - l_z=0; -end -l_a_temp=l_a; -l_z_temp=l_z; -if max(vfoptions.endotype)==1 - l_a_temp=l_a-sum(vfoptions.endotype); - l_z_temp=l_z+sum(vfoptions.endotype); -end -if N_e==0 - l_e=0; else - l_e=length(vfoptions.n_e); + l_d=length(n_d); end +l_a=length(n_a); +l_aprime=l_a; -% Create ReturnFnParamNames -temp=getAnonymousFnInputNames(ReturnFn); -if length(temp)>(l_d+l_a_temp+l_a_temp+l_z_temp) - ReturnFnParamNames={temp{l_d+l_a_temp+l_a_temp+l_z_temp+l_e+1:end}}; % the first inputs will always be (d,aprime,a,z) -else - ReturnFnParamNames={}; -end + +%% Implement new way of handling ReturnFn inputs +ReturnFnParamNames=ReturnFnParamNamesFn(ReturnFn,n_d,n_a,n_z,N_j,vfoptions,Parameters); %% Set up exogenous shock processes -[z_gridvals_J, pi_z_J, ~, e_gridvals_J, pi_e_J, ~, transpathoptions, vfoptions]=ExogShockSetup_TPath_FHorz(n_z,z_grid,pi_z,N_a,N_j,Parameters,PricePathNames,ParamPathNames,transpathoptions,vfoptions,3); +[z_gridvals_J, pi_z_J, ~, e_gridvals_J, pi_e_J, ~, ~, transpathoptions, vfoptions]=ExogShockSetup_TPath_FHorz(n_z,z_grid,pi_z,N_a,N_j,Parameters,PricePathNames,ParamPathNames,transpathoptions,vfoptions,3); % Convert z and e to age-dependent joint-grids and transtion matrix % output: z_gridvals_J, pi_z_J, e_gridvals_J, pi_e_J, transpathoptions,vfoptions,simoptions @@ -151,7 +111,6 @@ % transpathoptions.gridsinGE=1; % grids depend on a GE parameter and so need to be recomputed every iteration % =0; % grids are exogenous - %% if transpathoptions.verbose>=1 transpathoptions @@ -219,7 +178,7 @@ %% fastOLG=0, no z, no e VPath=zeros(N_a,N_j,T,'gpuArray'); VPath(:,:,T)=V_final; - PolicyPath=zeros((N_d>0)+1+(vfoptions.gridinterplayer>0),N_a,N_j,T,'gpuArray'); %Periods 1 to T-1 + PolicyPath=zeros(l_d+l_aprime+(vfoptions.gridinterplayer>0),N_a,N_j,T,'gpuArray'); %Periods 1 to T-1 PolicyPath(:,:,:,T)=Policy_final; % Go from T-1 to 1 calculating the Value function and Optimal policy function at each step. @@ -244,7 +203,7 @@ VPath=zeros(N_a,N_j,T,'gpuArray'); VPath(:,:,T)=V_final; - PolicyPath=zeros((N_d>0)+1+(vfoptions.gridinterplayer>0),N_a,N_j,T-1,'gpuArray'); %Periods 1 to T-1 + PolicyPath=zeros(l_d+l_aprime+(vfoptions.gridinterplayer>0),N_a,N_j,T-1,'gpuArray'); %Periods 1 to T-1 PolicyPath(:,:,:,T)=Policy_final; % Go from T-1 to 1 calculating the Value function and Optimal policy function at each step. @@ -271,7 +230,7 @@ %% fastOLG=0, z, no e VPath=zeros(N_a,N_z,N_j,T,'gpuArray'); VPath(:,:,:,T)=V_final; - PolicyPath=zeros((N_d>0)+1+(vfoptions.gridinterplayer>0),N_a,N_z,N_j,T,'gpuArray'); %Periods 1 to T-1 + PolicyPath=zeros(l_d+l_aprime+(vfoptions.gridinterplayer>0),N_a,N_z,N_j,T,'gpuArray'); %Periods 1 to T-1 PolicyPath(:,:,:,:,T)=Policy_final; % Go from T-1 to 1 calculating the Value function and Optimal policy function at each step. @@ -303,7 +262,7 @@ % Note: fastOLG with z: use V as (a,j)-by-z and Policy as a-by-j-by-z VPath=zeros(N_a*N_j,N_z,T,'gpuArray'); VPath(:,:,T)=V_final; - PolicyPath=zeros((N_d>0)+1+(vfoptions.gridinterplayer>0),N_a,N_j,N_z,T,'gpuArray'); + PolicyPath=zeros(l_d+l_aprime+(vfoptions.gridinterplayer>0),N_a,N_j,N_z,T,'gpuArray'); PolicyPath(:,:,:,:,T)=Policy_final; %First, go from T-1 to 1 calculating the Value function and Optimal @@ -341,7 +300,7 @@ %% fastOLG=0, no z, e VPath=zeros(N_a,N_e,N_j,T,'gpuArray'); VPath(:,:,:,T)=V_final; - PolicyPath=zeros((N_d>0)+1+(vfoptions.gridinterplayer>0),N_a,N_e,N_j,T,'gpuArray'); %Periods 1 to T-1 + PolicyPath=zeros(l_d+l_aprime+(vfoptions.gridinterplayer>0),N_a,N_e,N_j,T,'gpuArray'); %Periods 1 to T-1 PolicyPath(:,:,:,:,T)=Policy_final; % Go from T-1 to 1 calculating the Value function and Optimal policy function at each step. @@ -373,7 +332,7 @@ % Note: fastOLG with e: use V as (a,j)-by-e and Policy as a-by-j-by-e VPath=zeros(N_a*N_j,N_e,T,'gpuArray'); VPath(:,:,T)=V_final; - PolicyPath=zeros((N_d>0)+1+(vfoptions.gridinterplayer>0),N_a,N_j,N_e,T,'gpuArray'); + PolicyPath=zeros(l_d+l_aprime+(vfoptions.gridinterplayer>0),N_a,N_j,N_e,T,'gpuArray'); PolicyPath(:,:,:,:,T)=Policy_final; %First, go from T-1 to 1 calculating the Value function and Optimal @@ -408,7 +367,7 @@ %% fastOLG=0, z, e VPath=zeros(N_a,N_z,N_e,N_j,T,'gpuArray'); VPath(:,:,:,:,T)=V_final; - PolicyPath=zeros((N_d>0)+1+(vfoptions.gridinterplayer>0),N_a,N_z,N_e,N_j,T,'gpuArray'); %Periods 1 to T-1 + PolicyPath=zeros(l_d+l_aprime+(vfoptions.gridinterplayer>0),N_a,N_z,N_e,N_j,T,'gpuArray'); %Periods 1 to T-1 PolicyPath(:,:,:,:,:,T)=Policy_final; % Go from T-1 to 1 calculating the Value function and Optimal policy function at each step. @@ -443,7 +402,7 @@ %% fastOLG=1, z, e VPath=zeros(N_a*N_j,N_z,N_e,T,'gpuArray'); VPath(:,:,:,T)=V_final; - PolicyPath=zeros((N_d>0)+1+(vfoptions.gridinterplayer>0),N_a,N_j,N_z,N_e,T,'gpuArray'); + PolicyPath=zeros(l_d+l_aprime+(vfoptions.gridinterplayer>0),N_a,N_j,N_z,N_e,T,'gpuArray'); PolicyPath(:,:,:,:,:,T)=Policy_final; %First, go from T-1 to 1 calculating the Value function and Optimal @@ -500,18 +459,18 @@ end -% Then the unkron itself (includes permute() when fastOLG=1) +% Then the unkron itself if N_e==0 if N_z==0 VPath=reshape(VPath,[n_a,N_j,T]); - PolicyPath=UnKronPolicyIndexes_Case1_TransPathFHorz_noz(PolicyPath, n_d, n_a,N_j,T,vfoptions); + PolicyPath=reshape(PolicyPath,[size(PolicyPath,1),n_a,N_j,T]); else if transpathoptions.fastOLG==0 VPath=reshape(VPath,[n_a,n_z,N_j,T]); else VPath=reshape(permute(reshape(VPath,[N_a,N_j,N_z,T]),[1,3,2,4]),[n_a,n_z,N_j,T]); end - PolicyPath=UnKronPolicyIndexes_Case1_TransPathFHorz(PolicyPath, n_d, n_a, n_z, N_j, T,vfoptions); + PolicyPath=reshape(PolicyPath,[size(PolicyPath,1),n_a,n_z,N_j,T]); end else if N_z==0 @@ -520,14 +479,14 @@ else VPath=reshape(permute(reshape(VPath,[N_a,N_j,N_e,T]),[1,3,2,4]),[n_a,n_e,N_j,T]); end - PolicyPath=UnKronPolicyIndexes_Case1_TransPathFHorz(PolicyPath, n_d, n_a, n_e, N_j, T,vfoptions); + PolicyPath=reshape(PolicyPath,[size(PolicyPath,1),n_a,n_e,N_j,T]); else if transpathoptions.fastOLG==0 VPath=reshape(VPath,[n_a,n_z,n_e,N_j,T]); else VPath=reshape(permute(reshape(VPath,[N_a,N_j,N_z,N_e,T]),[1,3,4,2,5]),[n_a,n_z,n_e,N_j,T]); end - PolicyPath=UnKronPolicyIndexes_Case1_TransPathFHorz_e(PolicyPath, n_d, n_a, n_z, n_e, N_j,T,vfoptions); + PolicyPath=reshape(PolicyPath,[size(PolicyPath,1),n_a,n_z,n_e,N_j,T]); end end From 2d722d50a2d42986bbb4252f8f6598dc30ddfcb6 Mon Sep 17 00:00:00 2001 From: Alessandro Di Nola <40523651+aledinola@users.noreply.github.com> Date: Fri, 16 Jan 2026 15:39:12 +0000 Subject: [PATCH 12/67] Added function ValueFnIter_postGI_sparse_nod_raw This function does VFI with grid interplayer for the case of no d variable using sparse matrix in Howard improvement. Also other changes, see forum. --- .../ValueFnIter_GridInterpLayer.m | 2 +- .../ValueFnIter_postGI_sparse_nod_raw.m | 183 ++++++++++++++++++ 2 files changed, 184 insertions(+), 1 deletion(-) create mode 100644 ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_sparse_nod_raw.m diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_GridInterpLayer.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_GridInterpLayer.m index 031206e1..cba22175 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_GridInterpLayer.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_GridInterpLayer.m @@ -133,7 +133,7 @@ if vfoptions.howardssparse==0 [V,Policy]=ValueFnIter_postGI_nod_raw(V0, n_a, n_z, a_grid, z_gridvals, pi_z, DiscountFactorParamsVec, ReturnFn, ReturnFnParamsVec, vfoptions); elseif vfoptions.howardssparse==1 - error('Not yet implemented') + [V,Policy]=ValueFnIter_postGI_sparse_nod_raw(V0, n_a, n_z, a_grid, z_gridvals, pi_z, DiscountFactorParamsVec, ReturnFn, ReturnFnParamsVec, vfoptions); end elseif vfoptions.howardsgreedy==1 [V,Policy]=ValueFnIter_postGI_HowardGreedy_nod_raw(V0, n_a, n_z, a_grid, z_gridvals, pi_z, DiscountFactorParamsVec, ReturnFn, ReturnFnParamsVec, vfoptions); diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_sparse_nod_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_sparse_nod_raw.m new file mode 100644 index 00000000..7021f893 --- /dev/null +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_sparse_nod_raw.m @@ -0,0 +1,183 @@ +function [VKron, Policy] = ValueFnIter_postGI_sparse_nod_raw(VKronold,n_a,n_z,a_grid,z_gridvals,pi_z,DiscountFactorParamsVec,ReturnFn,ReturnFnParamsVec,vfoptions) +% Improved version of ValueFnIter_postGI_nod_raw, using sparse matrix for +% Howard improvement. +% OUTPUTS +% VKron: Value function, size: [N_a,N_z] +% Policy: Policy function, size: [2,N_a,N_z], where +% Policy(1,:,:) is index of lower grid point of a_grid, which is +% an integer from 1 to n_a-1 +% Policy(2,:,:) is index of second layer, which is integer from 1 +% to n2+2, where n2 = ngridinterp +% INPUTS +% VKronold: Initial guess for value function, size: [N_a,N_z] +% n_a,n_z: Grid dimensions +% a_grid: Grid for endogenous state variable +% z_gridvals: Grid for exogenous state variables, size: [prod(n_z),length(n_z)] +% pi_z: Transition matrix for Markov shock, size: [prod(n_z),prod(n_z)] +% DiscountFactorParamsVec +% ReturnFn: Function handle +% ReturnFnParamsVec: Row vector of ReturnFn parameters +% vfoptions: Structure with options for VFI. + +N_a=prod(n_a); +N_z=prod(n_z); + +ParamCell=cell(length(ReturnFnParamsVec),1); +for ii=1:length(ReturnFnParamsVec) + if ~isequal(size(ReturnFnParamsVec(ii)), [1,1]) + error('Using GPU for the return fn does not allow for any of ReturnFnParams to be anything but a scalar') + end + ParamCell(ii,1)={ReturnFnParamsVec(ii)}; +end + +%% Create return function matrix on coarse grid +aprime_gridvals = reshape(a_grid,[n_a,1,1]); % (a',1,1) +a_gridvals = reshape(a_grid,[1,n_a,1]); % (1,a,1) +z_gridvals3 = reshape(z_gridvals,[1,1,n_z]); % (1,1,z) + +% ReturnMatrix(a',a,z) with a' on coarse grid +ReturnMatrix = arrayfun(ReturnFn, aprime_gridvals, a_gridvals, z_gridvals3, ParamCell{:}); + +%NA = gpuArray.colon(1,N_a)'; +%NAZ = gpuArray.colon(1,N_a*N_z)'; + +[a_ind,z_ind] = ndgrid((1:N_a)',(1:N_z)'); +a_ind = a_ind(:); % a varies first, size: [N_a*N_z,1] +z_ind = z_ind(:); % z varies second, size: [N_a*N_z,1] + +pi_z_transpose = pi_z.'; + +Policy = zeros(2,N_a,N_z,'gpuArray'); + +Tolerance = vfoptions.tolerance; +maxiter = vfoptions.maxiter; +howards = vfoptions.howards; +verbose = vfoptions.verbose; +n2short = vfoptions.ngridinterp; % number of (evenly spaced) points to put between each grid point (not counting the two points themselves) + + +%% Create finer grid +aprime_fine=interp1(1:1:N_a,a_grid,linspace(1,N_a,N_a+(N_a-1)*n2short)); + +%% Value function iteration +% ReturnMatrix on coarse grid is precomputed, but ReturnMatrix_fine is +% computed at every iteration in the VFI loop. +tempcounter=1; +currdist=Inf; +while currdist>Tolerance && tempcounter<=maxiter + + % Calc the condl expectation term (except beta), which depends on z but not on control variables + EV = VKronold*pi_z_transpose; % (a',z) + + VKron = zeros(N_a,N_z,'gpuArray'); + Ftemp = zeros(N_a,N_z,'gpuArray'); % useful for Howard + for z_c=1:N_z + EV_z = EV(:,z_c); + z_vals = z_gridvals(z_c,:); + % ReturnMatrix(:,:,z_c) is (a',a), EV_z is (a',1) + % entireRHS is (a',a) due to implicit expansion/broadcasting + entireRHS=ReturnMatrix(:,:,z_c)+DiscountFactorParamsVec*EV_z; % size: [N_a,N_a] + [~,max_ind]=max(entireRHS,[],1); % size: [1,N_a] + + % Refinement with a' on finer grid + % Turn max_ind into the 'midpoint' + midpoint=max(min(max_ind,n_a-1),2); % avoid the top end (inner), and avoid the bottom end (outer) + % midpoint is 1-by-n_a + % aprimeindexes has size [3+2*n2short,n_a] + aprimeindexes=(midpoint+(midpoint-1)*n2short)+(-n2short-1:1:1+n2short)'; % aprime points either side of midpoint + aprime_fine_small = aprime_fine(aprimeindexes); + % ReturnMatrix_fine(a',a) has size: [3+2*n2short,n_a] + ReturnMatrix_fine = CreateReturnFnMatrix_GI_nod(ReturnFn,aprime_fine_small,a_gridvals,z_vals,ParamCell); + EV_z_interp = interp1(a_grid,EV_z,aprime_fine_small,'linear','extrap'); + % entireRHS_fine has size [3+2*n2short,n_a] + entireRHS_fine = ReturnMatrix_fine+DiscountFactorParamsVec*EV_z_interp; + [max_val,maxindexL2]=max(entireRHS_fine,[],1); % (1,N_a) + VKron(:,z_c) = max_val; + % midpoint from 2 to n_a-1 + Policy(1,:,z_c) = midpoint; + % aprimeL2ind from 1 to 3+2*n2short + Policy(2,:,z_c) = maxindexL2; + lin_ind = sub2ind(size(ReturnMatrix_fine), maxindexL2, 1:N_a); + Ftemp(:, z_c) = ReturnMatrix_fine(lin_ind); + end % end z + + %---------------------------------------------------------------------% + % Howard update + % Ftemp(a,z) = ReturnMatrix_fine(g(a,z),a,z) + Ftemp_vec = reshape(Ftemp,[N_a*N_z,1]); + + % Find interp indexes and weights + adjust = (Policy(2,:,:)<1+n2short+1); % if second layer is choosing below midpoint + % (1) lower grid point: from 1 to N_a-1 + aprime_left = Policy(1,:,:)-adjust; + % (2) Index on fine grid: from 1 (lower grid point) to 1+n2short+1 (upper grid point) + ind_L2 = adjust.*Policy(2,:,:)+(1-adjust).*(Policy(2,:,:)-n2short-1); + % (3) Weight on left grid point + weight_left = 1-(ind_L2-1)/(n2short+1); + + % Left grid point + aprime_opt_vec = aprime_left(:); + % Mass on left grid point + weight_opt_vec = weight_left(:); + + ind = a_ind+(z_ind-1)*N_a; + indp = aprime_opt_vec+(z_ind-1)*N_a; + indpp = aprime_opt_vec+1+(z_ind-1)*N_a; + Qmat = sparse(ind,indp,weight_opt_vec,N_a*N_z,N_a*N_z)+... + sparse(ind,indpp,1-weight_opt_vec,N_a*N_z,N_a*N_z); + + for h_c=1:howards + EV_howard = VKron*pi_z_transpose; % (a',z) + EV_howard = reshape(EV_howard,[N_a*N_z,1]); + VKron = Ftemp_vec+DiscountFactorParamsVec*Qmat*EV_howard; + VKron = reshape(VKron,[N_a,N_z]); + end + %---------------------------------------------------------------------% + + VKrondist=VKron(:)-VKronold(:); + currdist=max(abs(VKrondist)); + + if verbose==1 + disp(currdist) + end + + VKronold = VKron; + tempcounter=tempcounter+1; + +end %end while + +% Policy=reshape(Policy,[N_a,N_z]); +% VKron = reshape(VKron,[N_a,N_z]); + +% Currently Policy(1,:) is the midpoint, and Policy(2,:) the second layer +% (which ranges -n2short-1:1:1+n2short). It is much easier to use later if +% we switch Policy(1,:) to 'lower grid point' and then have Policy(2,:) +% counting 0:nshort+1 up from this. +adjust=(Policy(2,:,:)<1+n2short+1); % if second layer is choosing below midpoint +Policy(1,:,:)=Policy(1,:,:)-adjust; % lower grid point +Policy(2,:,:)=adjust.*Policy(2,:,:)+(1-adjust).*(Policy(2,:,:)-n2short-1); % from 1 (lower grid point) to 1+n2short+1 (upper grid point) + +end %end function + +%-------------------------------------------------------------------------% + +function Fmatrix = CreateReturnFnMatrix_GI_nod(ReturnFn,aprime_grid,a_grid,z_gridvals,ParamCell) +% Assumption: z_gridvals has size [1,length(n_z)] + + +%ReturnMatrix_fine = arrayfun(ReturnFn,aprime_grid,a_grid,z_grid,ParamCell{:}); + +l_z = length(z_gridvals); +if l_z>3 + error('ERROR: not allow for more than 3 of z variable (you have length(n_z)>3)') +end + +if l_z==1 + Fmatrix=arrayfun(ReturnFn, aprime_grid, a_grid, z_gridvals(1), ParamCell{:}); +elseif l_z==2 + Fmatrix=arrayfun(ReturnFn, aprime_grid, a_grid, z_gridvals(1), z_gridvals(2), ParamCell{:}); +elseif l_z==3 + Fmatrix=arrayfun(ReturnFn, aprime_grid, a_grid, z_gridvals(1), z_gridvals(2), z_gridvals(3), ParamCell{:}); +end + +end % end subfunction \ No newline at end of file From f2023d7d2e4b06c55576c8361fbcc3aa7f2014d4 Mon Sep 17 00:00:00 2001 From: Alessandro Di Nola <40523651+aledinola@users.noreply.github.com> Date: Fri, 16 Jan 2026 16:46:42 +0000 Subject: [PATCH 13/67] Fix bug if more than one z variable --- .../ValueFnIter_postGI_sparse_nod_raw.m | 28 +++++++++++++++---- 1 file changed, 23 insertions(+), 5 deletions(-) diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_sparse_nod_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_sparse_nod_raw.m index 7021f893..96c05781 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_sparse_nod_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_sparse_nod_raw.m @@ -33,10 +33,10 @@ %% Create return function matrix on coarse grid aprime_gridvals = reshape(a_grid,[n_a,1,1]); % (a',1,1) a_gridvals = reshape(a_grid,[1,n_a,1]); % (1,a,1) -z_gridvals3 = reshape(z_gridvals,[1,1,n_z]); % (1,1,z) % ReturnMatrix(a',a,z) with a' on coarse grid -ReturnMatrix = arrayfun(ReturnFn, aprime_gridvals, a_gridvals, z_gridvals3, ParamCell{:}); +%ReturnMatrix = arrayfun(ReturnFn, aprime_gridvals, a_gridvals, z_gridvals3, ParamCell{:}); +ReturnMatrix = CreateReturnFnMatrix_GI_nod(ReturnFn,aprime_gridvals,a_gridvals,z_gridvals,ParamCell,n_z); %NA = gpuArray.colon(1,N_a)'; %NAZ = gpuArray.colon(1,N_a*N_z)'; @@ -87,7 +87,7 @@ aprimeindexes=(midpoint+(midpoint-1)*n2short)+(-n2short-1:1:1+n2short)'; % aprime points either side of midpoint aprime_fine_small = aprime_fine(aprimeindexes); % ReturnMatrix_fine(a',a) has size: [3+2*n2short,n_a] - ReturnMatrix_fine = CreateReturnFnMatrix_GI_nod(ReturnFn,aprime_fine_small,a_gridvals,z_vals,ParamCell); + ReturnMatrix_fine = CreateReturnFnMatrix_GI_nod_lowmem(ReturnFn,aprime_fine_small,a_gridvals,z_vals,ParamCell,n_z); EV_z_interp = interp1(a_grid,EV_z,aprime_fine_small,'linear','extrap'); % entireRHS_fine has size [3+2*n2short,n_a] entireRHS_fine = ReturnMatrix_fine+DiscountFactorParamsVec*EV_z_interp; @@ -161,13 +161,31 @@ %-------------------------------------------------------------------------% -function Fmatrix = CreateReturnFnMatrix_GI_nod(ReturnFn,aprime_grid,a_grid,z_gridvals,ParamCell) +function Fmatrix = CreateReturnFnMatrix_GI_nod(ReturnFn,aprime_grid,a_grid,z_gridvals,ParamCell,n_z) % Assumption: z_gridvals has size [1,length(n_z)] %ReturnMatrix_fine = arrayfun(ReturnFn,aprime_grid,a_grid,z_grid,ParamCell{:}); -l_z = length(z_gridvals); +l_z = length(n_z); +if l_z>3 + error('ERROR: not allow for more than 3 of z variable (you have length(n_z)>3)') +end + +if l_z==1 + Fmatrix=arrayfun(ReturnFn, aprime_grid, a_grid, shiftdim(z_gridvals(:,1),-2), ParamCell{:}); +elseif l_z==2 + Fmatrix=arrayfun(ReturnFn, aprime_grid, a_grid, shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), ParamCell{:}); +elseif l_z==3 + Fmatrix=arrayfun(ReturnFn, aprime_grid, a_grid, shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(z_gridvals(:,3),-2), ParamCell{:}); +end + +end % end subfunction + +function Fmatrix = CreateReturnFnMatrix_GI_nod_lowmem(ReturnFn,aprime_grid,a_grid,z_gridvals,ParamCell,n_z) +% Assumption: z_gridvals has size [1,length(n_z)] + +l_z = length(n_z); if l_z>3 error('ERROR: not allow for more than 3 of z variable (you have length(n_z)>3)') end From 46907c4027475c3db4e44e2d248c54c2684dda75 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Sat, 17 Jan 2026 13:49:57 +1300 Subject: [PATCH 14/67] GE condn reported to 6 decimal places --- .../EvalFnOnAgentDist_AggVars_FHorz_fastOLG.m | 5 - ...teroAgentStationaryEqm_Case1_FHorz_subfn.m | 2 +- ...HeteroAgentStationaryEqm_FHorz_CPU_subfn.m | 8 +- ...onaryEqm_Case1_FHorz_PType_GEptype_subfn.m | 2 +- ...entStationaryEqm_Case1_FHorz_PType_subfn.m | 2 +- ...AgentStationaryEqm_Case1_EntryExit_subfn.m | 2 +- .../HeteroAgentStationaryEqm_Case1_subfn.m | 2 +- ...teroAgentStationaryEqm_Case1_PType_subfn.m | 2 +- PolicyInd2Val/PolicyInd2Val_FHorz_TPath.m | 133 ++++++++++++++++++ PolicyInd2Val/PolicyInd2Val_InfHorz_TPath.m | 3 + 10 files changed, 143 insertions(+), 18 deletions(-) create mode 100644 PolicyInd2Val/PolicyInd2Val_FHorz_TPath.m diff --git a/EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnAgentDist_AggVars_FHorz_fastOLG.m b/EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnAgentDist_AggVars_FHorz_fastOLG.m index 2bb7d205..520f4271 100644 --- a/EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnAgentDist_AggVars_FHorz_fastOLG.m +++ b/EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnAgentDist_AggVars_FHorz_fastOLG.m @@ -15,11 +15,6 @@ % Note: FnsToEvaluate is already cell (converted from struct) -if l_a~=l_aprime - error('cannot yet handle l_a different from l_aprime, need more if-else statements in main body of EvalFnOnAgentDist_AggVars_FHorz_fastOLG command to handle that ') -end - - %% if outputasstructure==1 AggVars=struct(); diff --git a/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz_subfn.m b/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz_subfn.m index c48db22f..b874d4ed 100644 --- a/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz_subfn.m +++ b/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz_subfn.m @@ -111,7 +111,7 @@ end fprintf('Current GeneralEqmEqns: \n') for gg=1:length(GEeqnNames) - fprintf(' %s: %8.4f \n',GEeqnNames{gg},GeneralEqmConditionsVec(gg)) + fprintf(' %s: %8.6f \n',GEeqnNames{gg},GeneralEqmConditionsVec(gg)) end end diff --git a/HeterogeneousAgent/FHorz/OnCPU/HeteroAgentStationaryEqm_FHorz_CPU_subfn.m b/HeterogeneousAgent/FHorz/OnCPU/HeteroAgentStationaryEqm_FHorz_CPU_subfn.m index 24ce1104..ce117bd6 100644 --- a/HeterogeneousAgent/FHorz/OnCPU/HeteroAgentStationaryEqm_FHorz_CPU_subfn.m +++ b/HeterogeneousAgent/FHorz/OnCPU/HeteroAgentStationaryEqm_FHorz_CPU_subfn.m @@ -73,15 +73,9 @@ fprintf(' %s: %8.4f \n',intEqnnames{aa},intermediateEqnsVec(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix end end - if heteroagentoptions.useCustomModelStats==1 - fprintf('Current CustomModelStats variables: \n') - for ii=1:length(customstatnames) - fprintf(' %s: %8.4f \n',customstatnames{ii},CustomStats.(customstatnames{ii})) - end - end fprintf('Current GeneralEqmEqns: \n') for gg=1:length(GEeqnNames) - fprintf(' %s: %8.4f \n',GEeqnNames{gg},GeneralEqmConditionsVec(gg)) + fprintf(' %s: %8.6f \n',GEeqnNames{gg},GeneralEqmConditionsVec(gg)) end end diff --git a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_GEptype_subfn.m b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_GEptype_subfn.m index 0ba57ae4..694abebd 100644 --- a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_GEptype_subfn.m +++ b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_GEptype_subfn.m @@ -224,7 +224,7 @@ if heteroagentoptions.GEptype(gg)==1 fprintf([' %s:',numberstr,' \n'],GeneralEqmEqnsNames{gg},GeneralEqmConditionsVec(ggindex(gg,1):ggindex(gg,2))) else - fprintf(' %s: %8.4f \n',GeneralEqmEqnsNames{gg},GeneralEqmConditionsVec(ggindex(gg,1):ggindex(gg,2))) + fprintf(' %s: %8.6f \n',GeneralEqmEqnsNames{gg},GeneralEqmConditionsVec(ggindex(gg,1):ggindex(gg,2))) end end end diff --git a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_subfn.m b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_subfn.m index 82406d85..08c40115 100644 --- a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_subfn.m +++ b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_subfn.m @@ -150,7 +150,7 @@ end fprintf('Current GeneralEqmEqns: \n') for gg=1:length(GEeqnNames) - fprintf(' %s: %8.4f \n',GEeqnNames{gg},GeneralEqmConditionsVec(gg)) + fprintf(' %s: %8.6f \n',GEeqnNames{gg},GeneralEqmConditionsVec(gg)) end end diff --git a/HeterogeneousAgent/InfHorz/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit_subfn.m b/HeterogeneousAgent/InfHorz/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit_subfn.m index a84aa3b3..3f4e796d 100644 --- a/HeterogeneousAgent/InfHorz/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit_subfn.m +++ b/HeterogeneousAgent/InfHorz/EntryExit/HeteroAgentStationaryEqm_Case1_EntryExit_subfn.m @@ -237,7 +237,7 @@ fprintf('Current GeneralEqmEqns: \n') GeneralEqmEqnsNames=fieldnames(GeneralEqmEqns2); % Note: uses GeneralEqmEqns2 as this is the full list of general eqm conditions for ii=1:length(GeneralEqmEqnsNames) - fprintf(' %s: %8.4f \n',GeneralEqmEqnsNames{ii},GeneralEqmConditionsVec(ii)) + fprintf(' %s: %8.6f \n',GeneralEqmEqnsNames{ii},GeneralEqmConditionsVec(ii)) end end diff --git a/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1_subfn.m b/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1_subfn.m index 7b264009..2c52a179 100644 --- a/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1_subfn.m +++ b/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1_subfn.m @@ -121,7 +121,7 @@ end fprintf('Current GeneralEqmEqns: \n') for gg=1:length(GEeqnNames) - fprintf(' %s: %8.4f \n',GEeqnNames{gg},GeneralEqmConditionsVec(gg)) + fprintf(' %s: %8.6f \n',GEeqnNames{gg},GeneralEqmConditionsVec(gg)) end end diff --git a/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType_subfn.m b/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType_subfn.m index 252f3e80..4df43a48 100644 --- a/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType_subfn.m +++ b/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType_subfn.m @@ -157,7 +157,7 @@ end fprintf('Current GeneralEqmEqns: \n') for gg=1:length(GEeqnNames) - fprintf(' %s: %8.4f \n',GEeqnNames{gg},GeneralEqmConditionsVec(gg)) + fprintf(' %s: %8.6f \n',GEeqnNames{gg},GeneralEqmConditionsVec(gg)) end end diff --git a/PolicyInd2Val/PolicyInd2Val_FHorz_TPath.m b/PolicyInd2Val/PolicyInd2Val_FHorz_TPath.m new file mode 100644 index 00000000..5cabcb95 --- /dev/null +++ b/PolicyInd2Val/PolicyInd2Val_FHorz_TPath.m @@ -0,0 +1,133 @@ +function PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyPath,n_d,n_a,n_z,N_j,T,d_grid,a_grid,vfoptions,outputkron,fastOLG) +% Note: can use vfoptions or simoptions +% When using this in the fastOLG setting, you must input d_gridvals and aprime_gridvals in place of d_grid and a_grid + +% N_d=prod(n_d); +N_a=prod(n_a); +N_z=prod(n_z); +if N_z==0 + N_z=1; % trick to avoid rewriting the thing + noz=1; % so I know the output should have a different shape +else + noz=0; +end + +% Following two are for internal use, just set to 0 for end user +if ~exist('outputkron','var') + outputkron=0; +end +if ~exist('fastOLG','var') + fastOLG=0; +end + +if ~isfield(vfoptions,'experienceasset') + vfoptions.experienceasset=0; +end + +if fastOLG==0 + l_aprime=length(n_a); + if vfoptions.experienceasset==1 + l_aprime=l_aprime-1; + end + + PolicyPath=reshape(PolicyPath,[size(PolicyPath,1),N_a,N_z,N_j,T]); + + if n_d(1)==0 + PolicyValuesPath=zeros(l_aprime,N_a,N_z,N_j,T,'gpuArray'); + if vfoptions.gridinterplayer==0 + PolicyValuesPath(1,:,:,:,:)=a_grid(PolicyPath(1,:,:,:,:)); + elseif vfoptions.gridinterplayer==1 + N_a1prime=n_a(1)+(n_a(1)-1)*vfoptions.ngridinterp; + temp=interp1(linspace(1,n_a(1),n_a(1)),a_grid(1:n_a(1)),linspace(1,n_a(1),N_a1prime)); % fine grid on a1prime + PolicyValuesPath(1,:,:,:,:)=temp((vfoptions.ngridinterp+1)*(PolicyPath(1,:,:,:,:)-1)+PolicyPath(end,:,:,:,:)); % use fine index + end + if l_aprime>1 + for ii=2:l_aprime + PolicyValuesPath(ii,:,:,:,:)=a_grid(prod(n_a(1:ii-1))+PolicyPath(ii,:,:,:,:)); + end + end + else + l_d=length(n_d); + PolicyValuesPath=zeros(l_d+l_aprime,N_a,N_z,N_j,T,'gpuArray'); + PolicyValuesPath(1,:,:,:,:)=d_grid(PolicyPath(1,:,:,:,:)); + if l_d>1 + if l_d>2 + for ii=2:l_d-1 + PolicyValuesPath(ii,:,:,:,:)=d_grid(sum(n_d(1:ii-1))+PolicyPath(ii,:,:,:,:)); + end + end + PolicyValuesPath(l_d,:,:,:,:)=d_grid(sum(n_d(1:end-1))+PolicyPath(l_d,:,:,:,:)); + end + if vfoptions.gridinterplayer==0 + PolicyValuesPath(l_d+1,:,:,:,:)=a_grid(PolicyPath(l_d+1,:,:,:,:)); + elseif vfoptions.gridinterplayer==1 + N_a1prime=n_a(1)+(n_a(1)-1)*vfoptions.ngridinterp; + temp=interp1(gpuArray(linspace(1,n_a(1),n_a(1)))',a_grid(1:n_a(1)),gpuArray(linspace(1,n_a(1),N_a1prime))'); % fine grid on a1prime + PolicyValuesPath(l_d+1,:,:,:,:)=temp((vfoptions.ngridinterp+1)*(PolicyPath(l_d+1,:,:,:,:)-1)+PolicyPath(end,:,:,:,:)); % use fine index + end + if l_aprime>1 + for ii=2:l_aprime + PolicyValuesPath(l_d+ii,:,:,:,:)=a_grid(sum(n_a(1:ii-1))+PolicyPath(l_d+ii,:,:,:,:)); + end + end + end + + if noz==1 + if outputkron==1 + PolicyValuesPath=reshape(PolicyValuesPath,[size(PolicyValuesPath,1),N_a,N_j,T]); + elseif outputkron==0 + PolicyValuesPath=reshape(PolicyValuesPath,[size(PolicyValuesPath,1),n_a,N_j,T]); + end + elseif outputkron==0 + PolicyValuesPath=reshape(PolicyValuesPath,[size(PolicyValuesPath,1),n_a,n_z,N_j,T]); + end + +else + % fastOLG, so has a different shape + PolicyPath=reshape(PolicyPath,[size(PolicyPath,1),N_a*N_j*N_z*T]); + % When using this in the fastOLG setting, you must input d_gridvals and aprime_gridvals in place of d_grid and a_grid + % If using vfoptions.gridinterplater=1, it should be aprime_gridvals for the fine grid, not the rough grid + + l_aprime=size(a_grid,2);% it is aprime_gridvals, not actually a_grid + + if n_d(1)==0 + PolicyValuesPath=zeros(l_aprime,N_a*N_j*N_z*T,'gpuArray'); % N_a*N_j*N_z*T is because of how indexing gridvals will work + if vfoptions.gridinterplayer==1 + PolicyPath(1,:)=(vfoptions.ngridinterp+1)*(PolicyPath(1,:)-1)+PolicyPath(end,:); % fine index + end + for ii=1:l_aprime + PolicyValuesPath(ii,:)=a_grid(PolicyPath(ii,:),ii); % it is aprime_gridvals, not actually a_grid + end + else + l_d=length(n_d); + PolicyValuesPath=zeros(l_d+l_aprime,N_a*N_j*N_z*T,'gpuArray'); % N_a*N_j*N_z*T is because of how indexing gridvals will work + for ii=1:l_d + PolicyValuesPath(ii,:)=d_grid(PolicyPath(ii,:),ii); % it is d_gridvals, not actually d_grid + end + if vfoptions.gridinterplayer==1 + PolicyPath(l_d+1,:)=(vfoptions.ngridinterp+1)*(PolicyPath(l_d+1,:)-1)+PolicyPath(end,:); % fine index + end + for ii=1:l_aprime + PolicyValuesPath(l_d+ii,:)=a_grid(PolicyPath(l_d+ii,:),ii); + end + end + + if noz==1 + if outputkron==1 + PolicyValuesPath=reshape(PolicyValuesPath,[size(PolicyValuesPath,1),N_a,N_j,T]); + elseif outputkron==0 + PolicyValuesPath=reshape(PolicyValuesPath,[size(PolicyValuesPath,1),n_a,N_j,T]); + end + else + if outputkron==1 + PolicyValuesPath=reshape(PolicyValuesPath,[size(PolicyValuesPath,1),N_a,N_j,N_z,T]); + elseif outputkron==0 + PolicyValuesPath=reshape(PolicyValuesPath,[size(PolicyValuesPath,1),n_a,N_j,n_z,T]); + end + end +end + + + + +end \ No newline at end of file diff --git a/PolicyInd2Val/PolicyInd2Val_InfHorz_TPath.m b/PolicyInd2Val/PolicyInd2Val_InfHorz_TPath.m index 72e7b4d2..3b6da8ed 100644 --- a/PolicyInd2Val/PolicyInd2Val_InfHorz_TPath.m +++ b/PolicyInd2Val/PolicyInd2Val_InfHorz_TPath.m @@ -4,6 +4,9 @@ if ~exist('outputkron','var') outputkron=0; end +if ~isfield(vfoptions,'experienceasset') + vfoptions.experienceasset=0; +end % N_d=prod(n_d); N_a=prod(n_a); From e71fc83b9ad08c61843305b77b0cf8b584656fda Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Sat, 17 Jan 2026 14:01:08 +1300 Subject: [PATCH 15/67] reorg --- ...Dist_AgeConditionalAggVars_FHorz_fastOLG.m | 393 ++++++++++++++++++ .../EvalFnOnAgentDist_AggVars_FHorz_fastOLG.m | 0 ...lFnOnAgentDist_AggVars_FHorz_fastOLG_noz.m | 0 3 files changed, 393 insertions(+) create mode 100644 EvaluateFnOnAgentDist/TransPathFHorz/SubCodes/EvalFnOnAgentDist_AgeConditionalAggVars_FHorz_fastOLG.m rename EvaluateFnOnAgentDist/TransPathFHorz/{ => SubCodes}/EvalFnOnAgentDist_AggVars_FHorz_fastOLG.m (100%) rename EvaluateFnOnAgentDist/TransPathFHorz/{ => SubCodes}/EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz.m (100%) diff --git a/EvaluateFnOnAgentDist/TransPathFHorz/SubCodes/EvalFnOnAgentDist_AgeConditionalAggVars_FHorz_fastOLG.m b/EvaluateFnOnAgentDist/TransPathFHorz/SubCodes/EvalFnOnAgentDist_AgeConditionalAggVars_FHorz_fastOLG.m new file mode 100644 index 00000000..3488d492 --- /dev/null +++ b/EvaluateFnOnAgentDist/TransPathFHorz/SubCodes/EvalFnOnAgentDist_AgeConditionalAggVars_FHorz_fastOLG.m @@ -0,0 +1,393 @@ +function AgeConditionalAggVars=EvalFnOnAgentDist_AgeConditionalAggVars_FHorz_fastOLG(AgentDist,PolicyValues_d, PolicyValues_aprime, FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_aprime,l_a,l_z,N_a,N_z,a_gridvals,z_gridvals_J_fastOLG,outputasstructure) +% fastOLG: so (a,j)-by-z +% Policy can be in fastOLG for or not, use fastOLGpolicy=1 or 0 to indicate this +% No z is treated elsewhere +% If you have e or semiz, just disguise them as z for this command + +% If no d variable, set l_d=0, and then PolicyValues_d=[], d_gridvals=[]. + +% PolicyValues_d is [N_a,N_j,N_z,l_d] +% PolicyValues_aprime is [N_a,N_j,N_z,l_aprime] +% a_gridvals is [N_a,l_a] +% z_gridvals_J_fastOLG is [1,N_j,N_z,l_z] (convert internally to [1,N_j,N_z,l_z]) + +% parameters that depend on age must be [1,N_j] + +% Note: FnsToEvaluate is already cell (converted from struct) + +%% +if outputasstructure==1 + AgeConditionalAggVars=struct(); +else % outputasstructure==0 + AgeConditionalAggVars=zeros(length(FnsToEvaluate),N_j,'gpuArray'); +end + +% AgentDist is [N_a*N_j*N_z,1] or [N_a*N_j,N_e] or [N_a*N_j*N_z,N_e] +% PolicyValues is [N_a,N_j,N_ze] + +for ff=1:length(FnsToEvaluate) + Values=zeros(N_a,N_j,N_z,'gpuArray'); + + + if isempty(FnsToEvaluateParamNames(ff).Names) + ParamCell=cell(0,1); + else + % Create a matrix containing all the return function parameters (in order). + % Each column will be a specific parameter with the values at every age. + FnToEvaluateParamsAgeMatrix=CreateAgeMatrixFromParams(Parameters, FnsToEvaluateParamNames(ff).Names,N_j); % this will be a matrix, row indexes ages and column indexes the parameters (parameters which are not dependent on age appear as a constant valued column) + + nFnToEvaluateParams=size(FnToEvaluateParamsAgeMatrix,2); + + ParamCell=cell(nFnToEvaluateParams,1); + for ii=1:nFnToEvaluateParams + ParamCell(ii,1)={shiftdim(FnToEvaluateParamsAgeMatrix(:,ii),-1)}; % (a,j,z,l_d+l_a), so we want j to be after a (which is N_a) + end + end + + if l_z==1 + if l_d==0 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); + end + elseif l_d==1 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); + end + elseif l_d==2 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); + end + elseif l_d==3 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); + end + elseif l_d==4 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), ParamCell{:}); + end + end + elseif l_z==2 + if l_d==0 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); + end + elseif l_d==1 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); + end + elseif l_d==2 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); + end + elseif l_d==3 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); + end + elseif l_d==4 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), ParamCell{:}); + end + end + elseif l_z==3 + if l_d==0 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); + end + elseif l_d==1 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); + end + elseif l_d==2 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); + end + elseif l_d==3 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); + end + elseif l_d==4 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), ParamCell{:}); + end + end + elseif l_z==4 + if l_d==0 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); + end + elseif l_d==1 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); + end + elseif l_d==2 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); + end + elseif l_d==3 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); + end + elseif l_d==4 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), ParamCell{:}); + end + end + elseif l_z==5 + if l_d==0 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); + end + elseif l_d==1 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); + end + elseif l_d==2 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); + end + elseif l_d==3 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); + end + elseif l_d==4 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), ParamCell{:}); + end + end + elseif l_z==6 + if l_d==0 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); + end + elseif l_d==1 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); + end + elseif l_d==2 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); + end + elseif l_d==3 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); + end + elseif l_d==4 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), ParamCell{:}); + end + end + elseif l_z==7 + if l_d==0 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); + end + elseif l_d==1 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); + end + elseif l_d==2 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); + end + elseif l_d==3 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); + end + elseif l_d==4 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), ParamCell{:}); + end + end + elseif l_z==8 + if l_d==0 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); + end + elseif l_d==1 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); + end + elseif l_d==2 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); + end + elseif l_d==3 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); + end + elseif l_d==4 + if l_aprime==1 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), a_gridvals, z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); + elseif l_aprime==2 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), a_gridvals(:,1), a_gridvals(:,2), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); + elseif l_aprime==3 + Values=arrayfun(FnsToEvaluate{ff}, PolicyValues_d(:,:,:,1), PolicyValues_d(:,:,:,2), PolicyValues_d(:,:,:,3), PolicyValues_d(:,:,:,4), PolicyValues_aprime(:,:,:,1), PolicyValues_aprime(:,:,:,2), PolicyValues_aprime(:,:,:,3), a_gridvals(:,1), a_gridvals(:,2), a_gridvals(:,3), z_gridvals_J_fastOLG(1,:,:,1), z_gridvals_J_fastOLG(1,:,:,2), z_gridvals_J_fastOLG(1,:,:,3), z_gridvals_J_fastOLG(1,:,:,4), z_gridvals_J_fastOLG(1,:,:,5), z_gridvals_J_fastOLG(1,:,:,6), z_gridvals_J_fastOLG(1,:,:,7), z_gridvals_J_fastOLG(1,:,:,8), ParamCell{:}); + end + end + end + + if outputasstructure==1 + AgeConditionalAggVars.(AggVarNames{ff}).Mean=sum(sum(reshape(Values(:).*AgentDist(:),[N_a,N_j,N_z]),3),1); + else % outputasstructure==0 + AgeConditionalAggVars(ff,:)=sum(sum(reshape(Values(:).*AgentDist(:),[N_a,N_j,N_z]),3),1); + end +end + + +end diff --git a/EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnAgentDist_AggVars_FHorz_fastOLG.m b/EvaluateFnOnAgentDist/TransPathFHorz/SubCodes/EvalFnOnAgentDist_AggVars_FHorz_fastOLG.m similarity index 100% rename from EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnAgentDist_AggVars_FHorz_fastOLG.m rename to EvaluateFnOnAgentDist/TransPathFHorz/SubCodes/EvalFnOnAgentDist_AggVars_FHorz_fastOLG.m diff --git a/EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz.m b/EvaluateFnOnAgentDist/TransPathFHorz/SubCodes/EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz.m similarity index 100% rename from EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz.m rename to EvaluateFnOnAgentDist/TransPathFHorz/SubCodes/EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz.m From 81096779e837e87404030cf8edfa33b1cb3af85c Mon Sep 17 00:00:00 2001 From: Michael Tiemann Date: Sat, 17 Jan 2026 14:51:24 +1300 Subject: [PATCH 16/67] Enable LifeCycleModel35semi to run The principle change is to bring across the gridvals changes implemented in commit 347366ccd75ac2203ba4bd62dbb9f0de3c338972. After implementing those changes in `ValueFnIter_FHorz_RiskyAsset_nod1_semiz_raw` and `ValueFnIter_FHorz_RiskyAsset_EpsteinZin_nod1_semiz_raw`, a few incongruities emerged from `StationaryDist_FHorz_RiskyAssetSemiExo` regarding the contents of `refine_d` and/or `l_dsemiz`. Please check that the new test I've put in is sensible. Finally, after running this lifecycle test, it reveals the Out-Of-Memory (OOM) errors mentioned in the comments. Reverting to the commented-out code (which is less aggressive in the use of gpuArray) keeps things within the limits of a 32GB GPU. --- .../StationaryDist_FHorz_RiskyAssetSemiExo.m | 11 +++- ...yDist_FHorz_Iteration_SemiExo_nProbs_raw.m | 12 ++-- ...orz_RiskyAsset_EpsteinZin_nod1_semiz_raw.m | 55 ++++++++++--------- ...ueFnIter_FHorz_RiskyAsset_nod1_semiz_raw.m | 27 +++++---- 4 files changed, 60 insertions(+), 45 deletions(-) diff --git a/StationaryDist/FHorz/RiskyAsset/StationaryDist_FHorz_RiskyAssetSemiExo.m b/StationaryDist/FHorz/RiskyAsset/StationaryDist_FHorz_RiskyAssetSemiExo.m index ac067c27..0dacbf53 100644 --- a/StationaryDist/FHorz/RiskyAsset/StationaryDist_FHorz_RiskyAssetSemiExo.m +++ b/StationaryDist/FHorz/RiskyAsset/StationaryDist_FHorz_RiskyAssetSemiExo.m @@ -16,7 +16,11 @@ if ~isfield(simoptions,'refine_d') error('Cannot use riskyasset+semiz without setting simoptions.refine_d') end -if (sum(simoptions.refine_d)+simoptions.l_dsemiz)~=length(n_d) +if length(simoptions.refine_d)>=4 && simoptions.refine_d(end)==simoptions.l_dsemiz + if sum(simoptions.refine_d)~=length(n_d) + error('simoptions.refine_d (and agreeing simoptions.l_dsemiz) should sum together to length(n_d)') + end +elseif (sum(simoptions.refine_d)+simoptions.l_dsemiz)~=length(n_d) error('simoptions.refine_d and simoptions.l_dsemiz should all sum together to length(n_d)') % Don't actually need simoptions.l_dsemiz here, because it is just what is left over after simoptions.refine_d. But do this check anyway. % Need simoptions.l_dsemiz in all other situations with semi-exo states, so easier to just insist on it here as well. @@ -40,6 +44,11 @@ %% +if isfield(simoptions,'n_e') + N_e=prod(simoptions.n_e); +else + N_e=0; +end if ~isfield(simoptions,'n_u') error('To use an risky asset you must define simoptions.n_u') end diff --git a/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_raw.m b/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_raw.m index b141d2d9..0fd3927e 100644 --- a/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_raw.m +++ b/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_raw.m @@ -8,10 +8,10 @@ % put a&semiz&z together into the 1st dim, semiz'&nprobs into the 2nd dim. % Policy_aprime is currently [N_a,N_semiz*N_z,N_probs,N_j] -Policy_aprimesemizz=repelem(reshape(Policy_aprime,[N_a*N_semiz*N_z,N_probs,N_j]),1,N_semiz)+repmat(N_a*gpuArray(0:1:N_semiz-1),1,N_probs)+repelem(N_a*N_semiz*gpuArray(0:1:N_z-1)',N_a*N_semiz,1); % Note: add semiz' index following the semiz' dimension, add z' index following the z dimension for Tan improvement -Policy_aprimesemizz=gather(Policy_aprimesemizz); % [N_a*N_semiz*N_z,N_semiz*N_probs,N_j] +% Policy_aprimesemizz=repelem(reshape(Policy_aprime,[N_a*N_semiz*N_z,N_probs,N_j]),1,N_semiz)+repmat(N_a*gpuArray(0:1:N_semiz-1),1,N_probs)+repelem(N_a*N_semiz*gpuArray(0:1:N_z-1)',N_a*N_semiz,1); % Note: add semiz' index following the semiz' dimension, add z' index following the z dimension for Tan improvement +% Policy_aprimesemizz=gather(Policy_aprimesemizz); % [N_a*N_semiz*N_z,N_semiz*N_probs,N_j] % % Previous two lines gave out of memory order, so the following line just does gather() earlier. -% Policy_aprimesemizz=repelem(reshape(gather(Policy_aprime),[N_a*N_semiz*N_z,N_probs,N_j]),1,N_semiz)+repmat(N_a*(0:1:N_semiz-1),1,N_probs)+repelem(N_a*N_semiz*(0:1:N_z-1)',N_a*N_semiz,1); % Note: add semiz' index following the semiz' dimension, add z' index following the z dimension for Tan improvement +Policy_aprimesemizz=repelem(reshape(gather(Policy_aprime),[N_a*N_semiz*N_z,N_probs,N_j]),1,N_semiz)+repmat(N_a*(0:1:N_semiz-1),1,N_probs)+repelem(N_a*N_semiz*(0:1:N_z-1)',N_a*N_semiz,1); % Note: add semiz' index following the semiz' dimension, add z' index following the z dimension for Tan improvement Policy_dsemiexo=reshape(Policy_dsemiexo,[N_a*N_semiz*N_z,1,N_j]); % precompute @@ -22,11 +22,11 @@ PolicyProbs=reshape(PolicyProbs,[N_a*N_semiz*N_z,N_probs,N_j]); -PolicyProbs=repelem(PolicyProbs,1,N_semiz).*repmat(pi_semiz_J(semizindex),1,N_probs); -PolicyProbs=gather(PolicyProbs); +% PolicyProbs=repelem(PolicyProbs,1,N_semiz).*repmat(pi_semiz_J(semizindex),1,N_probs); +% PolicyProbs=gather(PolicyProbs); % % Previous two lines gave out of memory order, so the following line just does gather() earlier. % pi_semiz_J=gather(pi_semiz_J); -% PolicyProbs=repelem(gather(PolicyProbs),1,N_semiz).*repmat(pi_semiz_J(semizindex),1,N_probs); +PolicyProbs=repelem(gather(PolicyProbs),1,N_semiz).*repmat(pi_semiz_J(semizindex),1,N_probs); N_bothz=N_semiz*N_z; diff --git a/ValueFnIter/FHorz/RiskyAsset/EpsteinZinSemiExo/ValueFnIter_FHorz_RiskyAsset_EpsteinZin_nod1_semiz_raw.m b/ValueFnIter/FHorz/RiskyAsset/EpsteinZinSemiExo/ValueFnIter_FHorz_RiskyAsset_EpsteinZin_nod1_semiz_raw.m index 05a5f488..94063422 100644 --- a/ValueFnIter/FHorz/RiskyAsset/EpsteinZinSemiExo/ValueFnIter_FHorz_RiskyAsset_EpsteinZin_nod1_semiz_raw.m +++ b/ValueFnIter/FHorz/RiskyAsset/EpsteinZinSemiExo/ValueFnIter_FHorz_RiskyAsset_EpsteinZin_nod1_semiz_raw.m @@ -35,13 +35,16 @@ Policy4=zeros(4,N_a,N_semiz*N_z,N_j,'gpuArray'); % d2, d3, d4 and a1prime %% -d3_grid=gpuArray(d3_grid); -d4_grid=gpuArray(d4_grid); +% d3_grid=gpuArray(d3_grid); +% d4_grid=gpuArray(d4_grid); d23_grid=gpuArray(d23_grid); a1_grid=gpuArray(a1_grid); a2_grid=gpuArray(a2_grid); u_grid=gpuArray(u_grid); +d3d4a1_gridvals=CreateGridvals([n_d3,n_d4,n_a1],[d3_grid;d4_grid;a1_grid],1); +a1a2_gridvals=CreateGridvals([n_a1,n_a2],[a1_grid;a2_grid],1); + if vfoptions.lowmemory>0 special_n_bothz=ones(1,length(n_semiz)+length(n_z)); end @@ -125,7 +128,7 @@ if ~isfield(vfoptions,'V_Jplus1') if vfoptions.lowmemory==0 - ReturnMatrix=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,n_d4,n_a1], [n_a1,n_a2], n_z, [d3_grid; d4_grid; a1_grid], [a1_grid; a2_grid], bothz_gridvals_J(:,:,N_j), ReturnFnParamsVec); + ReturnMatrix=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,n_d4,n_a1], [n_a1,n_a2], n_bothz, d3d4a1_gridvals, a1a2_gridvals, bothz_gridvals_J(:,:,N_j), ReturnFnParamsVec); % Modify the Return Function appropriately for Epstein-Zin Preferences becareful=logical(isfinite(ReturnMatrix).*(ReturnMatrix~=0)); % finite and not zero @@ -164,7 +167,7 @@ for z_c=1:N_bothz z_val=bothz_gridvals_J(z_c,:,N_j); - ReturnMatrix_z=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,n_d4,n_a1], [n_a1,n_a2], special_n_bothz, [d3_grid; d4_grid; a1_grid], [a1_grid; a2_grid], z_val, ReturnFnParamsVec); + ReturnMatrix_z=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,n_d4,n_a1], [n_a1,n_a2], special_n_bothz, d3d4a1_gridvals, a1a2_gridvals, z_val, ReturnFnParamsVec); % Modify the Return Function appropriately for Epstein-Zin Preferences becareful=logical(isfinite(ReturnMatrix_z).*(ReturnMatrix_z~=0)); % finite and not zero @@ -228,8 +231,8 @@ for d4_c=1:N_d4 % Note: By definition V_Jplus1 does not depend on d (only aprime) pi_bothz=kron(pi_z_J(:,:,N_j), pi_semiz(:,:,d4_c)); % reverse order - - ReturnMatrix_d4=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,special_n_d4,n_a1], [n_a1,n_a2], n_z, [d3_grid; d4_gridvals(d4_c,:)'; a1_grid], [a1_grid; a2_grid], bothz_gridvals_J(:,:,N_j), ReturnFnParamsVec); + d3_special_d4_a1_gridvals=gpuArray(CreateGridvals([n_d3,special_n_d4,n_a1], [d3_grid; d4_gridvals(d4_c,:)'; a1_grid], 1)); + ReturnMatrix_d4=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,special_n_d4,n_a1], [n_a1,n_a2], n_bothz, d3_special_d4_a1_gridvals, a1a2_gridvals, bothz_gridvals_J(:,:,N_j), ReturnFnParamsVec); % (d,aprime,a,z) % Modify the Return Function appropriately for Epstein-Zin Preferences @@ -244,17 +247,17 @@ % Seems like interpolation has trouble due to numerical precision rounding errors when the two points being interpolated are equal % So I will add a check for when this happens, and then overwrite those (by setting aprimeProbs to zero) - skipinterp=logical(EV(aprimeIndex+N_a*((1:1:N_z)-1))==EV(aprimeplus1Index+N_a*((1:1:N_z)-1))); % Note, probably just do this off of a2prime values + skipinterp=logical(EV(aprimeIndex+N_a*((1:1:N_bothz)-1))==EV(aprimeplus1Index+N_a*((1:1:N_bothz)-1))); % Note, probably just do this off of a2prime values aprimeProbs=repmat(a2primeProbs,N_a1,1); % [N_d*N_a1,N_u] aprimeProbs(skipinterp)=0; % Switch EV from being in terms of aprime to being in terms of d (in expectation because of the u shocks) - EV1=EV(aprimeIndex+N_a*((1:1:N_z)-1)); % (d,u,z), the lower aprime - EV2=EV((aprimeplus1Index)+N_a*((1:1:N_z)-1)); % (d,u,z), the upper aprime + EV1=EV(aprimeIndex+N_a*((1:1:N_bothz)-1)); % (d,u,z), the lower aprime + EV2=EV((aprimeplus1Index)+N_a*((1:1:N_bothz)-1)); % (d,u,z), the upper aprime % Apply the aprimeProbs - EV1=reshape(EV1,[N_d23*N_a1,N_u,N_z]).*aprimeProbs; % probability of lower grid point - EV2=reshape(EV2,[N_d23*N_a1,N_u,N_z]).*(1-aprimeProbs); % probability of upper grid point + EV1=reshape(EV1,[N_d23*N_a1,N_u,N_bothz]).*aprimeProbs; % probability of lower grid point + EV2=reshape(EV2,[N_d23*N_a1,N_u,N_bothz]).*(1-aprimeProbs); % probability of upper grid point % Expectation over u (using pi_u), and then add the lower and upper EV=sum((EV1.*pi_u'),2)+sum((EV2.*pi_u'),2); % (d,1,z), sum over u @@ -275,7 +278,7 @@ % First: ReturnMatrix, we can refine out d1 % no d1 here % Second: EV, we can refine out d2 - [temp4_onlyd3,d2index]=max(ezc9*ezc3*reshape((~isinf(temp4)).*temp4,[N_d2,N_d3*N_a1,1,N_z]),[],1); + [temp4_onlyd3,d2index]=max(ezc9*ezc3*reshape((~isinf(temp4)).*temp4,[N_d2,N_d3*N_a1,1,N_bothz]),[],1); % Now put together entireRHS, which just depends on d3 entireRHS=ezc1*temp2+DiscountFactorParamsVec*ezc9*shiftdim(temp4_onlyd3,1); % entireRHS=ezc1*temp2+ezc3*DiscountFactorParamsVec*temp4; @@ -305,10 +308,10 @@ for d4_c=1:N_d4 % Note: By definition V_Jplus1 does not depend on d2 (only aprime) pi_bothz=kron(pi_z_J(:,:,N_j),pi_semiz(:,:,d4_c)); % reverse order - + d3_special_d4_a1_gridvals=gpuArray(CreateGridvals([n_d3,special_n_d4,n_a1], [d3_grid; d4_gridvals(d4_c,:)'; a1_grid], 1)); for z_c=1:N_bothz z_val=bothz_gridvals_J(z_c,:,N_j); - ReturnMatrix_d4z=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,special_n_d4,n_a1], [n_a1,n_a2], special_n_bothz, [d3_grid; d4_gridvals(d4_c,:)'; a1_grid], [a1_grid; a2_grid], z_val, ReturnFnParamsVec); + ReturnMatrix_d4z=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,special_n_d4,n_a1], [n_a1,n_a2], special_n_bothz, d3_special_d4_a1_gridvals, a1a2_gridvals, z_val, ReturnFnParamsVec); % Modify the Return Function appropriately for Epstein-Zin Preferences becareful=logical(isfinite(ReturnMatrix_d4z).*(ReturnMatrix_d4z~=0)); % finite and not zero @@ -457,8 +460,8 @@ for d4_c=1:N_d4 % Note: By definition V_Jplus1 does not depend on d (only aprime) pi_bothz=kron(pi_z_J(:,:,jj), pi_semiz(:,:,d4_c)); % reverse order - - ReturnMatrix_d4=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,special_n_d4,n_a1], [n_a1,n_a2], n_z, [d3_grid; d4_gridvals(d4_c,:)'; a1_grid], [a1_grid; a2_grid], bothz_gridvals_J(:,:,jj), ReturnFnParamsVec); + d3_special_d4_a1_gridvals=gpuArray(CreateGridvals([n_d3,special_n_d4,n_a1], [d3_grid; d4_gridvals(d4_c,:)'; a1_grid], 1)); + ReturnMatrix_d4=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,special_n_d4,n_a1], [n_a1,n_a2], n_bothz, d3_special_d4_a1_gridvals, a1a2_gridvals, bothz_gridvals_J(:,:,jj), ReturnFnParamsVec); % (d,aprime,a,z) % Modify the Return Function appropriately for Epstein-Zin Preferences @@ -473,18 +476,18 @@ % Seems like interpolation has trouble due to numerical precision rounding errors when the two points being interpolated are equal % So I will add a check for when this happens, and then overwrite those (by setting aprimeProbs to zero) - skipinterp=logical(EV(aprimeIndex(:)+N_a*((1:1:N_z)-1))==EV(aprimeplus1Index(:)+N_a*((1:1:N_z)-1))); % Note, probably just do this off of a2prime values - aprimeProbs=repmat(a2primeProbs,N_a1,N_z); % [N_d*N_a1,N_u] + skipinterp=logical(EV(aprimeIndex(:)+N_a*((1:1:N_bothz)-1))==EV(aprimeplus1Index(:)+N_a*((1:1:N_bothz)-1))); % Note, probably just do this off of a2prime values + aprimeProbs=repmat(a2primeProbs,N_a1,N_bothz); % [N_d*N_a1,N_u] aprimeProbs(skipinterp)=0; - aprimeProbs=reshape(aprimeProbs,[N_d23*N_a1,N_u,N_z]); + aprimeProbs=reshape(aprimeProbs,[N_d23*N_a1,N_u,N_bothz]); % Switch EV from being in terms of aprime to being in terms of d (in expectation because of the u shocks) - EV1=EV(aprimeIndex(:)+N_a*((1:1:N_z)-1)); % (d,u,z), the lower aprime - EV2=EV(aprimeplus1Index(:)+N_a*((1:1:N_z)-1)); % (d,u,z), the upper aprime + EV1=EV(aprimeIndex(:)+N_a*((1:1:N_bothz)-1)); % (d,u,z), the lower aprime + EV2=EV(aprimeplus1Index(:)+N_a*((1:1:N_bothz)-1)); % (d,u,z), the upper aprime % Apply the aprimeProbs - EV1=reshape(EV1,[N_d23*N_a1,N_u,N_z]).*aprimeProbs; % probability of lower grid point - EV2=reshape(EV2,[N_d23*N_a1,N_u,N_z]).*(1-aprimeProbs); % probability of upper grid point + EV1=reshape(EV1,[N_d23*N_a1,N_u,N_bothz]).*aprimeProbs; % probability of lower grid point + EV2=reshape(EV2,[N_d23*N_a1,N_u,N_bothz]).*(1-aprimeProbs); % probability of upper grid point % Expectation over u (using pi_u), and then add the lower and upper EV=sum((EV1.*pi_u'),2)+sum((EV2.*pi_u'),2); % (d,1,z), sum over u @@ -505,7 +508,7 @@ % First: ReturnMatrix, we can refine out d1 % no d1 here % Second: EV, we can refine out d2 - [temp4_onlyd3,d2index]=max(ezc9*ezc3*reshape((~isinf(temp4)).*temp4,[N_d2,N_d3*N_a1,1,N_z]),[],1); + [temp4_onlyd3,d2index]=max(ezc9*ezc3*reshape((~isinf(temp4)).*temp4,[N_d2,N_d3*N_a1,1,N_bothz]),[],1); % Now put together entireRHS, which just depends on d3 entireRHS=ezc1*temp2+DiscountFactorParamsVec*ezc9*shiftdim(temp4_onlyd3,1); % entireRHS=ezc1*temp2+ezc3*DiscountFactorParamsVec*temp4; @@ -535,10 +538,10 @@ for d4_c=1:N_d4 % Note: By definition V_Jplus1 does not depend on d2 (only aprime) pi_bothz=kron(pi_z_J(:,:,jj),pi_semiz(:,:,d4_c)); % reverse order - + d3_special_d4_a1_gridvals=gpuArray(CreateGridvals([n_d3,special_n_d4,n_a1], [d3_grid; d4_gridvals(d4_c,:)'; a1_grid], 1)); for z_c=1:N_bothz z_val=bothz_gridvals_J(z_c,:,jj); - ReturnMatrix_d4z=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,special_n_d4,n_a1], [n_a1,n_a2], special_n_bothz, [d3_grid; d4_gridvals(d4_c,:)'; a1_grid], [a1_grid; a2_grid], z_val, ReturnFnParamsVec); + ReturnMatrix_d4z=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,special_n_d4,n_a1], [n_a1,n_a2], special_n_bothz, d3_special_d4_a1_gridvals, a1a2_gridvals, z_val, ReturnFnParamsVec); % Modify the Return Function appropriately for Epstein-Zin Preferences becareful=logical(isfinite(ReturnMatrix_d4z).*(ReturnMatrix_d4z~=0)); % finite and not zero diff --git a/ValueFnIter/FHorz/RiskyAsset/SemiExo/ValueFnIter_FHorz_RiskyAsset_nod1_semiz_raw.m b/ValueFnIter/FHorz/RiskyAsset/SemiExo/ValueFnIter_FHorz_RiskyAsset_nod1_semiz_raw.m index ff9bc5a5..b8b82120 100644 --- a/ValueFnIter/FHorz/RiskyAsset/SemiExo/ValueFnIter_FHorz_RiskyAsset_nod1_semiz_raw.m +++ b/ValueFnIter/FHorz/RiskyAsset/SemiExo/ValueFnIter_FHorz_RiskyAsset_nod1_semiz_raw.m @@ -35,13 +35,16 @@ Policy4=zeros(4,N_a,N_semiz*N_z,N_j,'gpuArray'); % d2, d3, d4 and a1prime %% -d3_grid=gpuArray(d3_grid); -d4_grid=gpuArray(d4_grid); +% d3_grid=gpuArray(d3_grid); +% d4_grid=gpuArray(d4_grid); d23_grid=gpuArray(d23_grid); a2_grid=gpuArray(a2_grid); a1_grid=gpuArray(a1_grid); u_grid=gpuArray(u_grid); +d3d4a1_gridvals=gpuArray(CreateGridvals([n_d3,n_d4,n_a1],[d3_grid;d4_grid;a1_grid],1)); +a1a2_gridvals=gpuArray(CreateGridvals([n_a1,n_a2],[a1_grid;a2_grid],1)); + if vfoptions.lowmemory>0 special_n_bothz=ones(1,length(n_semiz)+length(n_z)); end @@ -64,7 +67,7 @@ if ~isfield(vfoptions,'V_Jplus1') if vfoptions.lowmemory==0 - ReturnMatrix=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,n_d4,n_a1], [n_a1,n_a2], n_bothz, [d3_grid; d4_grid; a1_grid], [a1_grid; a2_grid], bothz_gridvals_J(:,:,N_j), ReturnFnParamsVec); + ReturnMatrix=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,n_d4,n_a1], [n_a1,n_a2], n_bothz, d3d4a1_gridvals, a1a2_gridvals, bothz_gridvals_J(:,:,N_j), ReturnFnParamsVec); %Calc the max and it's index [Vtemp,maxindex]=max(ReturnMatrix,[],1); V(:,:,N_j)=Vtemp; @@ -78,7 +81,7 @@ for z_c=1:N_bothz z_val=bothz_gridvals_J(z_c,:,N_j); - ReturnMatrix_z=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,n_d4,n_a1], [n_a1,n_a2], special_n_bothz, [d3_grid; d4_grid; a1_grid], [a1_grid; a2_grid], z_val, ReturnFnParamsVec); + ReturnMatrix_z=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,n_d4,n_a1], [n_a1,n_a2], special_n_bothz, d3d4a1_gridvals, a1a2_gridvals, z_val, ReturnFnParamsVec); %Calc the max and it's index [Vtemp,maxindex]=max(ReturnMatrix_z,[],1); V(:,z_c,N_j)=Vtemp; @@ -116,8 +119,8 @@ for d4_c=1:N_d4 % Note: By definition V_Jplus1 does not depend on d (only aprime) pi_bothz=kron(pi_z_J(:,:,N_j), pi_semiz(:,:,d4_c)); % reverse order - - ReturnMatrix_d4=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,special_n_d4,n_a1], [n_a1,n_a2], n_bothz, [d3_grid; d4_gridvals(d4_c,:)'; a1_grid], [a1_grid; a2_grid], bothz_gridvals_J(:,:,N_j), ReturnFnParamsVec); + d3_special_d4_a1_gridvals=gpuArray(CreateGridvals([n_d3,special_n_d4,n_a1], [d3_grid; d4_gridvals(d4_c,:)'; a1_grid], 1)); + ReturnMatrix_d4=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,special_n_d4,n_a1], [n_a1,n_a2], n_bothz, d3_special_d4_a1_gridvals, a1a2_gridvals, bothz_gridvals_J(:,:,N_j), ReturnFnParamsVec); % (d,aprime,a,z) EV=V_Jplus1.*shiftdim(pi_bothz',-1); @@ -172,10 +175,10 @@ for d4_c=1:N_d4 % Note: By definition V_Jplus1 does not depend on d2 (only aprime) pi_bothz=kron(pi_z_J(:,:,N_j),pi_semiz(:,:,d4_c)); % reverse order - + d3_special_d4_a1_gridvals=gpuArray(CreateGridvals([n_d3,special_n_d4,n_a1], [d3_grid; d4_gridvals(d4_c,:)'; a1_grid], 1)); for z_c=1:N_bothz z_val=bothz_gridvals_J(z_c,:,N_j); - ReturnMatrix_d4z=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,special_n_d4,n_a1], [n_a1,n_a2], special_n_bothz, [d3_grid; d4_gridvals(d4_c,:)'; a1_grid], [a1_grid; a2_grid], z_val, ReturnFnParamsVec); + ReturnMatrix_d4z=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,special_n_d4,n_a1], [n_a1,n_a2], special_n_bothz, d3_special_d4_a1_gridvals, a1a2_gridvals, z_val, ReturnFnParamsVec); %Calc the condl expectation term (except beta), which depends on z but %not on control variables @@ -264,8 +267,8 @@ for d4_c=1:N_d4 % Note: By definition V_Jplus1 does not depend on d (only aprime) pi_bothz=kron(pi_z_J(:,:,jj), pi_semiz(:,:,d4_c)); % reverse order - - ReturnMatrix_d4=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,special_n_d4,n_a1], [n_a1,n_a2], n_bothz, [d3_grid; d4_gridvals(d4_c,:)'; a1_grid], [a1_grid; a2_grid], bothz_gridvals_J(:,:,jj), ReturnFnParamsVec); + d3_special_d4_a1_gridvals=gpuArray(CreateGridvals([n_d3,special_n_d4,n_a1], [d3_grid; d4_gridvals(d4_c,:)'; a1_grid], 1)); + ReturnMatrix_d4=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,special_n_d4,n_a1], [n_a1,n_a2], n_bothz, d3_special_d4_a1_gridvals, a1a2_gridvals, bothz_gridvals_J(:,:,jj), ReturnFnParamsVec); % (d,aprime,a,z) EV=VKronNext_j.*shiftdim(pi_bothz',-1); @@ -321,10 +324,10 @@ for d4_c=1:N_d4 % Note: By definition V_Jplus1 does not depend on d2 (only aprime) pi_bothz=kron(pi_z_J(:,:,jj),pi_semiz(:,:,d4_c)); % reverse order - + d3_special_d4_a1_gridvals=gpuArray(CreateGridvals([n_d3,special_n_d4,n_a1], [d3_grid; d4_gridvals(d4_c,:)'; a1_grid], 1)); for z_c=1:N_bothz z_val=bothz_gridvals_J(z_c,:,jj); - ReturnMatrix_d4z=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,special_n_d4,n_a1], [n_a1,n_a2], special_n_bothz, [d3_grid; d4_gridvals(d4_c,:)'; a1_grid], [a1_grid; a2_grid], z_val, ReturnFnParamsVec); + ReturnMatrix_d4z=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn, [n_d3,special_n_d4,n_a1], [n_a1,n_a2], special_n_bothz, d3_special_d4_a1_gridvals, a1a2_gridvals, z_val, ReturnFnParamsVec); %Calc the condl expectation term (except beta), which depends on z but %not on control variables From 7f9a025bf7a702842e1294f380d250b524bd8e63 Mon Sep 17 00:00:00 2001 From: Alessandro Di Nola <40523651+aledinola@users.noreply.github.com> Date: Sat, 17 Jan 2026 14:37:45 +0000 Subject: [PATCH 17/67] Added two new functions I have added ValueFnIter_postGI_sparse_raw to do Howards sparse for the case of d variable. Moreover, I have improved the existing function ValueFnIter_Refine_postGI_raw using Claude code. The trick was to replace interp1 with matrix multiplication: gives 25% speed-up, quite consistent across versions and computers --- .../ValueFnIter_GridInterpLayer.m | 4 +- .../ValueFnIter_Refine_postGI_raw.m | 236 ++++++++---------- .../ValueFnIter_postGI_sparse_raw.m | 219 ++++++++++++++++ 3 files changed, 328 insertions(+), 131 deletions(-) create mode 100644 ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_sparse_raw.m diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_GridInterpLayer.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_GridInterpLayer.m index cba22175..03ceef42 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_GridInterpLayer.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_GridInterpLayer.m @@ -146,9 +146,9 @@ % Nowadays, I know that only Refine is worth doing, so just skip to that. if vfoptions.howardsgreedy==0 if vfoptions.howardssparse==0 - [V,Policy]=ValueFnIter_Refine_postGI_raw(V0, n_d, n_a, n_z, d_gridvals, a_grid, z_gridvals, pi_z, ReturnFn, DiscountFactorParamsVec, ReturnFnParamsVec, vfoptions); + [V,Policy]=ValueFnIter_Refine_postGI_raw( V0, n_d, n_a, n_z, d_gridvals, a_grid, z_gridvals, pi_z, ReturnFn, DiscountFactorParamsVec, ReturnFnParamsVec, vfoptions); elseif vfoptions.howardssparse==1 - error('Not yet implemented') + [V,Policy] = ValueFnIter_postGI_sparse_raw(V0, n_d, n_a, n_z, d_gridvals, a_grid, z_gridvals, pi_z, ReturnFn, DiscountFactorParamsVec, ReturnFnParamsVec, vfoptions); end elseif vfoptions.howardsgreedy==1 [V,Policy]=ValueFnIter_Refine_postGI_HowardGreedy_raw(V0, n_d, n_a, n_z, d_gridvals, a_grid, z_gridvals, pi_z, ReturnFn, DiscountFactorParamsVec, ReturnFnParamsVec, vfoptions); diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_raw.m index ffa53b42..0f71e926 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_raw.m @@ -1,30 +1,25 @@ function [VKron,Policy]=ValueFnIter_Refine_postGI_raw(VKron,n_d,n_a,n_z,d_gridvals,a_grid,z_gridvals,pi_z,ReturnFn,DiscountFactorParamsVec,ReturnFnParams,vfoptions) -% When using refinement, lowmemory is implemented in the first stage (return fn) but not the second (the actual iteration). -% Refine, so there is at least one d variable +% Optimized version: Replaces interp1 with pre-computed interpolation matrix +% OPTIMIZATION: Line 177 bottleneck fixed with matrix multiplication approach N_d=prod(n_d); N_a=prod(n_a); N_z=prod(n_z); +N_aNz = N_a*N_z; n_da=[n_d,n_a]; -da_gridvals=[repmat(d_gridvals,N_a,1),repelem(a_grid,N_d,1)]; % only one aprime +da_gridvals=[repmat(d_gridvals,N_a,1),repelem(a_grid,N_d,1)]; %% CreateReturnFnMatrix_Case1_Disc creates a matrix of dimension (d and aprime)-by-a-by-z. -% Since the return function is independent of time creating it once and -% then using it every iteration is good for speed, but it does use a -% lot of memory. - if vfoptions.lowmemory==0 ReturnMatrixraw=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn,n_da, n_a, n_z, da_gridvals, a_grid, z_gridvals, ReturnFnParams); ReturnMatrixraw=reshape(ReturnMatrixraw,[N_d,N_a,N_a,N_z]); - - % For refinement, now we solve for d*(aprime,a,z) that maximizes the ReturnFn + [ReturnMatrix,~]=max(ReturnMatrixraw,[],1); ReturnMatrix=shiftdim(ReturnMatrix,1); -elseif vfoptions.lowmemory==1 % loop over z - %% Refinement: calculate ReturnMatrix and 'remove' the d dimension - ReturnMatrix=zeros(N_a,N_a,N_z,'gpuArray'); % 'refined' return matrix +elseif vfoptions.lowmemory==1 + ReturnMatrix=zeros(N_a,N_a,N_z,'gpuArray'); dstar=zeros(N_a,N_a,N_z,'gpuArray'); l_z=length(n_z); special_n_z=ones(1,l_z); @@ -32,14 +27,12 @@ zvals=z_gridvals(z_c,:); ReturnMatrix_z=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn,n_da, n_a, special_n_z, da_gridvals, a_grid, zvals, ReturnFnParams); ReturnMatrix_z=reshape(ReturnMatrix_z,[N_d,N_a,N_a]); - [ReturnMatrix_z,dstar_z]=max(ReturnMatrix_z,[],1); % solve for dstar + [ReturnMatrix_z,dstar_z]=max(ReturnMatrix_z,[],1); ReturnMatrix(:,:,z_c)=shiftdim(ReturnMatrix_z,1); dstar(:,:,z_c)=shiftdim(dstar_z,1); end end - -%% The rest, except putting d back into Policy at the end, is all just copy-paste from ValueFnIter_preGI_nod_raw() pi_z_alt=shiftdim(pi_z',-1); pi_z_howards=repelem(pi_z,N_a,1); @@ -51,75 +44,56 @@ while currdist>(vfoptions.multigridswitch*vfoptions.tolerance) && tempcounter<=vfoptions.maxiter VKronold=VKron; - % Calc the condl expectation term (except beta), which depends on z but not on control variables EV=VKronold.*pi_z_alt; - EV(isnan(EV))=0; % multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV=sum(EV,2); % sum over z', leaving a singular second dimension + EV(isnan(EV))=0; + EV=sum(EV,2); - entireRHS=ReturnMatrix+DiscountFactorParamsVec*EV; % aprime by a by z + entireRHS=ReturnMatrix+DiscountFactorParamsVec*EV; - % Calc the max and it's index [VKron,Policy_a]=max(entireRHS,[],1); - VKron=shiftdim(VKron,1); % a by z + VKron=shiftdim(VKron,1); VKrondist=VKron(:)-VKronold(:); VKrondist(isnan(VKrondist))=0; currdist=max(abs(VKrondist)); - % Use Howards Policy Fn Iteration Improvement (except for first few and last few iterations, as it is not a good idea there) if isfinite(currdist) && currdist/vfoptions.tolerance>10 && tempcountervfoptions.tolerance && tempcounter<=vfoptions.maxiter VKronold=VKron; - % Switch VKron into being over vfoptions.maxaprimediff - EVpre=reshape(VKron(aprimeindex,:),[N_aprimediff,N_a,N_z,N_z]); % last dimension is zprime - % Calc the condl expectation term (except beta), which depends on z but not on control variables + EVpre=reshape(VKron(aprimeindex,:),[N_aprimediff,N_a,N_z,N_z]); EV=EVpre.*pi_z_alt2; - EV(isnan(EV))=0; % multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV=squeeze(sum(EV,4)); % sum over z', leaving a singular second dimension - % EV is now [N_aprimediff,N_a,N_z] - % Interpolate EV over aprime_grid - - EVinterp=interp1(EVinterpindex1,EV,EVinterpindex2); - - entireRHS=ReturnMatrixfine+DiscountFactorParamsVec*EVinterp; % aprime by a by z + EV(isnan(EV))=0; + EV=squeeze(sum(EV,4)); - % Calc the max and it's index + % OPTIMIZED: Matrix multiplication instead of interp1 + EVinterp = reshape(interpMatrix * reshape(EV, N_aprimediff, N_aNz), N_aprime, N_a, N_z); + + entireRHS=ReturnMatrixfine+DiscountFactorParamsVec*EVinterp; + [VKron,Policy_a]=max(entireRHS,[],1); - VKron=shiftdim(VKron,1); % a by z + VKron=shiftdim(VKron,1); VKrondist=VKron(:)-VKronold(:); VKrondist(isnan(VKrondist))=0; currdist=max(abs(VKrondist)); - % Use Howards Policy Fn Iteration Improvement (except for first few and last few iterations, as it is not a good idea there) if isfinite(currdist) && currdist/vfoptions.tolerance>10 && tempcounter0 vfoptions.postGIrepeat=vfoptions.postGIrepeat-1; - % Current optimal aprime is Policy_a - % So create an aprime_grid that is just an interpolation within +-vfoptions.maxaprimediff - - % First, we switch Policy_a to be the nearest point on the rough grid - Policy_a=reshape(Policy_a,[1,N_a,N_z]); % Howards can mess with the size + Policy_a=reshape(Policy_a,[1,N_a,N_z]); Policy_a=ceil((Policy_a-1)/(n2short+1))-vfoptions.maxaprimediff+aprimeshifter; - % ceil((Policy_a-1)/(n2short+1))-vfoptions.maxaprimediff ranges -vfoptions.maxaprimediff:1:vfoptions.maxaprimediff - % First, create an aprime_grid that is just the +-vfoptions.maxaprimediff - % Note: this code is for models with a single endogenous state n_aprimediff=1+2*vfoptions.maxaprimediff; N_aprimediff=prod(n_aprimediff); aprimeshifter=min(max(Policy_a,1+vfoptions.maxaprimediff),N_a-vfoptions.maxaprimediff); - aprimeindex=(-vfoptions.maxaprimediff:1:vfoptions.maxaprimediff)' +aprimeshifter; % size n_aprime-by-n_a + aprimeindex=(-vfoptions.maxaprimediff:1:vfoptions.maxaprimediff)' +aprimeshifter; aprime_grid=a_grid(aprimeindex); - % Second, interpolate this - % Grid interpolation - % vfoptions.ngridinterp=9; - n2short=vfoptions.ngridinterp; % number of (evenly spaced) points to put between each grid point (not counting the two points themselves) + + n2short=vfoptions.ngridinterp; n_aprime=n_aprimediff+(n_aprimediff-1)*vfoptions.ngridinterp; N_aprime=prod(n_aprime); aprime_grid=interp1((1:1:N_aprimediff)',aprime_grid,linspace(1,N_aprimediff,N_aprimediff+(N_aprimediff-1)*vfoptions.ngridinterp)'); - % Note: aprime_grid is N_aprime-by-N_a-by-N_z if vfoptions.lowmemory==0 ReturnMatrixfine=CreateReturnFnMatrix_Case1_Disc_DC1_Par2(ReturnFn, n_d, n_z, d_gridvals, aprime_grid, a_grid, z_gridvals, ReturnFnParams,1); - % ReturnMatrixfineraw=reshape(ReturnMatrixfineraw,[N_d,N_aprime,N_a,N_z]); - % For refinement, now we solve for d*(aprime,a,z) that maximizes the ReturnFn [ReturnMatrixfine,dstar]=max(ReturnMatrixfine,[],1); ReturnMatrixfine=shiftdim(ReturnMatrixfine,1); - elseif vfoptions.lowmemory==1 % loop over z - % Refinement: calculate ReturnMatrix and 'remove' the d dimension - ReturnMatrixfine=zeros(N_aprime,N_a,N_z,'gpuArray'); % 'refined' return matrix + elseif vfoptions.lowmemory==1 + ReturnMatrixfine=zeros(N_aprime,N_a,N_z,'gpuArray'); dstar=zeros(N_aprime,N_a,N_z,'gpuArray'); l_z=length(n_z); special_n_z=ones(1,l_z); @@ -236,55 +206,66 @@ zvals=z_gridvals(z_c,:); ReturnMatrixfine_z=CreateReturnFnMatrix_Case1_Disc_DC1_Par2(ReturnFn, n_d, special_n_z, d_gridvals, aprime_grid(:,:,z_c), a_grid, zvals, ReturnFnParams,1); ReturnMatrixfine_z=reshape(ReturnMatrixfine_z,[N_d,N_aprime,N_a]); - [ReturnMatrixfine_z,dstar_z]=max(ReturnMatrixfine_z,[],1); % solve for dstar + [ReturnMatrixfine_z,dstar_z]=max(ReturnMatrixfine_z,[],1); ReturnMatrixfine(:,:,z_c)=shiftdim(ReturnMatrixfine_z,1); dstar(:,:,z_c)=shiftdim(dstar_z,1); end end - EVinterpindex1=(1:1:N_aprimediff)'; - EVinterpindex2=linspace(1,N_aprimediff,N_aprimediff+(N_aprimediff-1)*vfoptions.ngridinterp)'; + EVinterpindex2=gpuArray.linspace(1,N_aprimediff,N_aprimediff+(N_aprimediff-1)*vfoptions.ngridinterp)'; + + % OPTIMIZATION: Recompute interpolation matrix (all on GPU) + idx_low = floor(EVinterpindex2); + idx_low = max(1, min(idx_low, N_aprimediff-1)); + idx_high = idx_low + 1; + weight_high = EVinterpindex2 - idx_low; + weight_low = 1 - weight_high; + + i_indices = [gpuArray.colon(1,N_aprime)'; gpuArray.colon(1,N_aprime)']; + j_indices = [idx_low; idx_high]; + weights = [weight_low; weight_high]; + interpMatrix_sparse = sparse(i_indices, j_indices, weights, N_aprime, N_aprimediff); + interpMatrix = full(interpMatrix_sparse); % Keep on GPU - % For Howards we need addindexforazfine=gpuArray(N_aprime*(0:1:N_a-1)'+N_aprime*N_a*(0:1:N_z-1)); pi_z_alt2=shiftdim(pi_z,-2); - %% Now switch to considering the fine/interpolated aprime_grid - currdist=1; % force going into the next while loop at least one iteration + currdist=1; while currdist>vfoptions.tolerance && tempcounter<=vfoptions.maxiter VKronold=VKron; - % Switch VKron into being over vfoptions.maxaprimediff - EVpre=reshape(VKron(aprimeindex,:),[N_aprimediff,N_a,N_z,N_z]); % last dimension is zprime - % Calc the condl expectation term (except beta), which depends on z but not on control variables + EVpre=reshape(VKron(aprimeindex,:),[N_aprimediff,N_a,N_z,N_z]); EV=EVpre.*pi_z_alt2; - EV(isnan(EV))=0; % multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV=squeeze(sum(EV,4)); % sum over z', leaving a singular second dimension - % EV is now [N_aprimediff,N_a,N_z] - % Interpolate EV over aprime_grid + EV(isnan(EV))=0; + EV=squeeze(sum(EV,4)); - EVinterp=interp1(EVinterpindex1,EV,EVinterpindex2); + % OPTIMIZED: Matrix multiplication + EVinterp = reshape(interpMatrix * reshape(EV, N_aprimediff, N_aNz), N_aprime, N_a, N_z); - entireRHS=ReturnMatrixfine+DiscountFactorParamsVec*EVinterp; % aprime by a by z + entireRHS=ReturnMatrixfine+DiscountFactorParamsVec*EVinterp; - % Calc the max and it's index [VKron,Policy_a]=max(entireRHS,[],1); - VKron=shiftdim(VKron,1); % a by z + VKron=shiftdim(VKron,1); VKrondist=VKron(:)-VKronold(:); VKrondist(isnan(VKrondist))=0; currdist=max(abs(VKrondist)); - % Use Howards Policy Fn Iteration Improvement (except for first few and last few iterations, as it is not a good idea there) if isfinite(currdist) && currdist/vfoptions.tolerance>10 && tempcounterTolerance && tempcounter<=maxiter + + %% Given VKronold, obtain VKron + + + % Calc the condl expectation term (except beta), which depends on z but not on control variables + EV = VKronold*pi_z_transpose; % (a',z) + + for z_c=1:N_z + z_val = z_gridvals(z_c,:); % scalars z1,z2,etc. + EV_z = EV(:,z_c); % (a',1) + + ReturnMatrix_z=ReturnMatrix(:,:,z_c); % (a',a) a' on coarse grid + + entireRHS_z=ReturnMatrix_z+DiscountFactorParamsVec*EV_z; %(a',a) + + % No need to compute the maximum value in first layer + [~,maxindex]=max(entireRHS_z,[],1); + + % Turn this into the 'midpoint' + midpoint=max(min(maxindex,n_a-1),2); % avoid the top end (inner), and avoid the bottom end (outer) + % midpoint is 1-by-n_a + % % aprimeindexes has size [n2long,n_a] + aprimeindexes=(midpoint+(midpoint-1)*n2short)+(-n2short-1:1:1+n2short)'; % aprime points either side of midpoint + % aprime possibilities are n_d-by-n2long-by-n_a + aprime_ii = aprime_grid(aprimeindexes); + % ReturnMatrix_ii_z is (N_d,n2long,n_a) + ReturnMatrix_ii_z = CreateReturnFnMatrix_GI_lowmem(ReturnFn,d_gridvals,aprime_ii,a_gridvals,z_val,ParamCell,n_z); + % EV_z_interp is (n2long,n_a) + EV_z_interp = interp1(a_grid,EV_z,aprime_ii,'linear','extrap'); + + % entireRHS_ii_z is (N_d,n2long,n_a) + entireRHS_ii_z = ReturnMatrix_ii_z + DiscountFactorParamsVec*reshape(EV_z_interp,[1,n2long,n_a]); + [Vtempii,maxindexL2]=max(reshape(entireRHS_ii_z,[n_d*n2long,n_a]),[],1); + VKron(:,z_c) = Vtempii; + [maxindexL2_d, maxindexL2_a] = ind2sub([n_d,n2long],maxindexL2); + Policy(1,:,z_c) = maxindexL2_d; % d + Policy(2,:,z_c) = midpoint; % midpoint + Policy(3,:,z_c) = maxindexL2_a; % aprimeL2ind from 1 to n2long=3+2*n2short + lin_ind = sub2ind(size(ReturnMatrix_ii_z), maxindexL2_d, maxindexL2_a, 1:N_a); + Ftemp(:, z_c) = ReturnMatrix_ii_z(lin_ind); + end % end z + + %---------------------------------------------------------------------% + % Howard update + % Ftemp(a,z) = ReturnMatrix_fine(g(a,z),a,z) + Ftemp_vec = reshape(Ftemp,[N_a*N_z,1]); + + % Find interp indexes and weights + adjust = (Policy(3,:,:)<1+n2short+1); % if second layer is choosing below midpoint + % (1) lower grid point: from 1 to N_a-1 + aprime_left = Policy(2,:,:)-adjust; + % (2) Index on fine grid: from 1 (lower grid point) to 1+n2short+1 (upper grid point) + ind_L2 = adjust.*Policy(3,:,:)+(1-adjust).*(Policy(3,:,:)-n2short-1); + % (3) Weight on left grid point + weight_left = 1-(ind_L2-1)/(n2short+1); + + % Left grid point + aprime_opt_vec = aprime_left(:); + % Mass on left grid point + weight_opt_vec = weight_left(:); + + ind = a_ind+(z_ind-1)*N_a; + indp = aprime_opt_vec+(z_ind-1)*N_a; + indpp = aprime_opt_vec+1+(z_ind-1)*N_a; + Qmat = sparse(ind,indp,weight_opt_vec,N_a*N_z,N_a*N_z)+... + sparse(ind,indpp,1-weight_opt_vec,N_a*N_z,N_a*N_z); + + for h_c=1:howards + EV_howard = VKron*pi_z_transpose; % (a',z) + EV_howard = reshape(EV_howard,[N_a*N_z,1]); + VKron = Ftemp_vec+DiscountFactorParamsVec*Qmat*EV_howard; + VKron = reshape(VKron,[N_a,N_z]); + end + %---------------------------------------------------------------------% + + + %% Compute distance and update + VKrondist=VKron(:)-VKronold(:); + currdist=max(abs(VKrondist)); + + if verbose==1 + disp(currdist) + end + + VKronold = VKron; + tempcounter=tempcounter+1; + +end %end while + +% Currently Policy(2,:) is the midpoint, and Policy(3,:) the second layer +% (which ranges -n2short-1:1:1+n2short). It is much easier to use later if +% we switch Policy(2,:) to 'lower grid point' and then have Policy(3,:) +% counting 0:nshort+1 up from this. +adjust=(Policy(3,:,:)<1+n2short+1); % if second layer is choosing below midpoint +Policy(2,:,:)=Policy(2,:,:)-adjust; % lower grid point +Policy(3,:,:)=adjust.*Policy(3,:,:)+(1-adjust).*(Policy(3,:,:)-n2short-1); % from 1 (lower grid point) to 1+n2short+1 (upper grid point) + +%Policy=Policy(1,:,:)+N_d*(Policy(2,:,:)-1)+N_d*N_a*(Policy(3,:,:)-1); + + + +end %end function + +%-------------------------------------------------------------------------% + +function Fmatrix = CreateReturnFnMatrix_GI(ReturnFn,d_gridvals,aprime_grid,a_grid,z_gridvals,ParamCell,n_z) +% Assumption: z_gridvals has size [1,length(n_z)] + + +%ReturnMatrix_fine = arrayfun(ReturnFn,aprime_grid,a_grid,z_grid,ParamCell{:}); + +l_z = length(n_z); +if l_z>3 + error('ERROR: not allow for more than 3 of z variable (you have length(n_z)>3)') +end + +if l_z==1 + Fmatrix=arrayfun(ReturnFn, d_gridvals,aprime_grid, a_grid, shiftdim(z_gridvals(:,1),-3), ParamCell{:}); +elseif l_z==2 + Fmatrix=arrayfun(ReturnFn, d_gridvals,aprime_grid, a_grid, shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), ParamCell{:}); +elseif l_z==3 + Fmatrix=arrayfun(ReturnFn, d_gridvals,aprime_grid, a_grid, shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), ParamCell{:}); +end + +end % end subfunction + +function Fmatrix = CreateReturnFnMatrix_GI_lowmem(ReturnFn,d_gridvals,aprime_grid,a_grid,z_gridvals,ParamCell,n_z) +% Assumption: z_gridvals has size [1,length(n_z)] + +l_z = length(n_z); +if l_z>3 + error('ERROR: not allow for more than 3 of z variable (you have length(n_z)>3)') +end + +if l_z==1 + Fmatrix=arrayfun(ReturnFn,d_gridvals,shiftdim(aprime_grid,-1),a_grid, z_gridvals(1), ParamCell{:}); +elseif l_z==2 + Fmatrix=arrayfun(ReturnFn,d_gridvals,shiftdim(aprime_grid,-1),a_grid, z_gridvals(1), z_gridvals(2), ParamCell{:}); +elseif l_z==3 + Fmatrix=arrayfun(ReturnFn,d_gridvals,shiftdim(aprime_grid,-1),a_grid, z_gridvals(1), z_gridvals(2), z_gridvals(3), ParamCell{:}); +end + +end % end subfunction \ No newline at end of file From e80afd680d5ab2c98793db0b5514d540d6aac4ce Mon Sep 17 00:00:00 2001 From: Alessandro Di Nola <40523651+aledinola@users.noreply.github.com> Date: Sat, 17 Jan 2026 16:58:44 +0000 Subject: [PATCH 18/67] Small fix Eliminated blank space before V0 as suggested by Michael --- .../InfHorz/GridInterpLayer/ValueFnIter_GridInterpLayer.m | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_GridInterpLayer.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_GridInterpLayer.m index 03ceef42..b8abc787 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_GridInterpLayer.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_GridInterpLayer.m @@ -146,7 +146,7 @@ % Nowadays, I know that only Refine is worth doing, so just skip to that. if vfoptions.howardsgreedy==0 if vfoptions.howardssparse==0 - [V,Policy]=ValueFnIter_Refine_postGI_raw( V0, n_d, n_a, n_z, d_gridvals, a_grid, z_gridvals, pi_z, ReturnFn, DiscountFactorParamsVec, ReturnFnParamsVec, vfoptions); + [V,Policy]=ValueFnIter_Refine_postGI_raw(V0, n_d, n_a, n_z, d_gridvals, a_grid, z_gridvals, pi_z, ReturnFn, DiscountFactorParamsVec, ReturnFnParamsVec, vfoptions); elseif vfoptions.howardssparse==1 [V,Policy] = ValueFnIter_postGI_sparse_raw(V0, n_d, n_a, n_z, d_gridvals, a_grid, z_gridvals, pi_z, ReturnFn, DiscountFactorParamsVec, ReturnFnParamsVec, vfoptions); end From 90e2af933e87d0a7925bfef05470e1a9332dfa37 Mon Sep 17 00:00:00 2001 From: Alessandro Di Nola <40523651+aledinola@users.noreply.github.com> Date: Sat, 17 Jan 2026 17:12:33 +0000 Subject: [PATCH 19/67] Minor changes --- .../InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_raw.m | 3 ++- .../InfHorz/GridInterpLayer/ValueFnIter_postGI_sparse_raw.m | 6 +----- 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_raw.m index 0f71e926..bddcc730 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_raw.m @@ -120,7 +120,8 @@ j_indices = [idx_low; idx_high]; weights = [weight_low; weight_high]; interpMatrix_sparse = sparse(i_indices, j_indices, weights, N_aprime, N_aprimediff); -interpMatrix = full(interpMatrix_sparse); % Keep on GPU, convert to dense for fast multiplication +%interpMatrix = full(interpMatrix_sparse); % Keep on GPU, convert to dense for fast multiplication +interpMatrix = interpMatrix_sparse; addindexforazfine=gpuArray(N_aprime*(0:1:N_a-1)'+N_aprime*N_a*(0:1:N_z-1)); diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_sparse_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_sparse_raw.m index 61fb8efb..249d1362 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_sparse_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_sparse_raw.m @@ -1,9 +1,5 @@ function [VKron, Policy] = ValueFnIter_postGI_sparse_raw(VKronold,n_d,n_a,n_z,d_gridvals,a_grid,z_gridvals,pi_z,ReturnFn,DiscountFactorParamsVec,ReturnFnParamsVec,vfoptions) -% TODO: - Fix create return matrix with more than one z variables -% - Ftemp needed for Howard -% - Howard algorithm -% - Compare gridinterplayer=1 and howardssparse=0 vs gridinterplayer=1 and -% howardssparse=1 + % Improved version of ValueFnIter_postGI_nod_raw, using sparse matrix for % Howard improvement. % OUTPUTS From a7684473f839d2e4896b6ad8f57081a025f37eaf Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Tue, 20 Jan 2026 16:23:55 +1300 Subject: [PATCH 20/67] minor --- .../FHorz/HeteroAgentStationaryEqm_Case1_FHorz_subfn.m | 2 +- .../PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_subfn.m | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz_subfn.m b/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz_subfn.m index b874d4ed..2718e07f 100644 --- a/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz_subfn.m +++ b/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz_subfn.m @@ -81,7 +81,7 @@ elseif heteroagentoptions.outputGEform==2 % structure clear GeneralEqmConditions for gg=1:length(GEeqnNames) - GeneralEqmConditions.(GEeqnNames{gg})=gather(GEeqnNames(gg)); + GeneralEqmConditions.(GEeqnNames{gg})=gather(GeneralEqmConditionsVec(gg)); end end diff --git a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_subfn.m b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_subfn.m index 08c40115..0545da68 100644 --- a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_subfn.m +++ b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_subfn.m @@ -121,7 +121,7 @@ elseif heteroagentoptions.outputGEform==2 % structure clear GeneralEqmConditions for gg=1:length(GEeqnNames) - GeneralEqmConditions.(GEeqnNames{gg})=GEeqnNames(gg); + GeneralEqmConditions.(GEeqnNames{gg})=GeneralEqmConditionsVec(gg); end end From 6f28a14afd889b1c6d6b2cc8b945964f10c8f53e Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Wed, 21 Jan 2026 11:07:47 +1300 Subject: [PATCH 21/67] GEnewprice3 setup moved to a subfunction --- Optimization/setupGEnewprice3_shooting.m | 164 ++++++++++++++++++ PolicyInd2Val/PolicyInd2Val_FHorz.m | 2 +- .../PType/TransitionPath_Case1_FHorz_PType.m | 6 +- ...ransitionPath_Case1_FHorz_PType_shooting.m | 97 ----------- .../FHorz/TransitionPath_Case1_FHorz.m | 56 +----- .../PType/TransitionPath_Case1_PType.m | 56 +----- .../InfHorz/TransitionPath_Case1.m | 56 +----- 7 files changed, 175 insertions(+), 262 deletions(-) create mode 100644 Optimization/setupGEnewprice3_shooting.m diff --git a/Optimization/setupGEnewprice3_shooting.m b/Optimization/setupGEnewprice3_shooting.m new file mode 100644 index 00000000..ed668c34 --- /dev/null +++ b/Optimization/setupGEnewprice3_shooting.m @@ -0,0 +1,164 @@ +function options=setupGEnewprice3_shooting(options,GeneralEqmEqns,GEPriceParamNames) +% options can be heteroagentoptions or transpathoptions +% transpathoptions: GEPriceParamNames will be PricePathNames + +GEeqnNames=fieldnames(GeneralEqmEqns); +nGeneralEqmEqns=length(GEeqnNames); + +%% Set up GEnewprice==3 (if relevant) +if options.GEnewprice~=3 + return +end + +options.weightscheme=0; + +if ~isfield(options,'updateaccuracycutoff') + options.updateaccuracycutoff=0; % No cut-off (only changes in the price larger in magnitude that this will be made (can be set to, e.g., 10^(-6) to help avoid changes at overly high precision)) +end + +if ~isstruct(GeneralEqmEqns) + error('Cannot call this unless GeneralEqmEqns is struct') +end + +%% +if ~isfield(options,'GEptype') % For models without permanent type + + % Need to make sure that order of rows in options.GEnewprice3.howtoupdate + % Is same as order of fields in GeneralEqmEqns + % I do this by just reordering rows of options.GEnewprice3.howtoupdate + temp=options.GEnewprice3.howtoupdate; + GEeqnNames=fieldnames(GeneralEqmEqns); + for ii=1:length(GEeqnNames) + for jj=1:size(temp,1) + if strcmp(temp{jj,1},GEeqnNames{ii}) % Names match + options.GEnewprice3.howtoupdate{ii,1}=temp{jj,1}; + options.GEnewprice3.howtoupdate{ii,2}=temp{jj,2}; + options.GEnewprice3.howtoupdate{ii,3}=temp{jj,3}; + options.GEnewprice3.howtoupdate{ii,4}=temp{jj,4}; + end + end + end + + options.GEnewprice3.add=[options.GEnewprice3.howtoupdate{:,3}]; + options.GEnewprice3.factor=[options.GEnewprice3.howtoupdate{:,4}]; + options.GEnewprice3.keepold=ones(size(options.GEnewprice3.factor)); + options.GEnewprice3.keepold=ones(size(options.GEnewprice3.factor)); + tempweight=options.oldpathweight; + options.oldpathweight=zeros(size(options.GEnewprice3.factor)); + for ii=1:length(options.GEnewprice3.factor) + if options.GEnewprice3.factor(ii)==Inf + options.GEnewprice3.factor(ii)=1; + options.GEnewprice3.keepold(ii)=0; + options.oldpathweight(ii)=tempweight; + end + end + if size(options.GEnewprice3.howtoupdate,1)==nGeneralEqmEqns % Note: inputs were already testted + % do nothing, this is how things should be + else + error('options.GEnewprice3.howtoupdate does not fit with GeneralEqmEqns (number of rows is different to the number of GeneralEqmEqns fields) \n') + end + options.GEnewprice3.permute=zeros(size(options.GEnewprice3.howtoupdate,1),1); + for ii=1:size(options.GEnewprice3.howtoupdate,1) % number of rows is the number of prices (and number of GE conditions) + for jj=1:length(GEPriceParamNames) + if strcmp(options.GEnewprice3.howtoupdate{ii,2},GEPriceParamNames{jj}) + options.GEnewprice3.permute(ii)=jj; + end + end + end + +else + %% Model with permanent type: allow for options.GEptype + % Before starting, make sure that GE that depend on ptype match up with PricePaths that depend on ptype + for gg=1:nGeneralEqmEqns + if options.GEptype(gg)==1 + for gg2=1:size(options.GEnewprice3.howtoupdate,1) + if strcmp(options.GEnewprice3.howtoupdate{gg2,1},GEPriceParamNames{gg}) + pricename_gg=options.GEnewprice3.howtoupdate{gg2,2}; + end + end + for pp=1:length(GEPriceParamNames) + if strcmp(pricename_gg,GEPriceParamNames{pp}) + if PricePathSizeVec(2,pp)-PricePathSizeVec(1,pp)+1~=N_i + fprintf('Following error relates to GE condition %s and to price %s \n',GEeqnNames{gg},GEPriceParamNames{pp}) + error('You declared a GE condition to depend on permenent type, but the price that relates to it (in options.GEnewprice3.howtoupdate) does not depend on ptype') + end + end + end + end + end + + % Need to make sure that order of rows in options.GEnewprice3.howtoupdate + % Is same as order of fields in GeneralEqmEqns + % I do this by just reordering rows of options.GEnewprice3.howtoupdate + temp=options.GEnewprice3.howtoupdate; + % GEeqnNames=fieldnames(GeneralEqmEqns); + gg_index=zeros(1,nGeneralEqmEqns+(N_i-1)*sum(options.GEptype==1)); + gg_c=0; + for gg=1:nGeneralEqmEqns + for jj=1:size(temp,1) + if strcmp(temp{jj,1},GEeqnNames{gg}) % Names match + for ii=1:(1+options.GEptype(gg)*(N_i-1)) % Note: 1 or N_i, depending on options.GEptype(gg) + gg_c=gg_c+1; + options.GEnewprice3.howtoupdate{gg_c,1}=temp{jj,1}; + options.GEnewprice3.howtoupdate{gg_c,2}=temp{jj,2}; + options.GEnewprice3.howtoupdate{gg_c,3}=temp{jj,3}; + options.GEnewprice3.howtoupdate{gg_c,4}=temp{jj,4}; + gg_index(gg_c)=gg; + end + end + end + end + % Note: options.GEnewprice3.howtoupdate will have extra repeated rows whenever options.GEptype(gg)=1 + + options.GEnewprice3.add=[options.GEnewprice3.howtoupdate{:,3}]; + options.GEnewprice3.factor=[options.GEnewprice3.howtoupdate{:,4}]; + options.GEnewprice3.keepold=ones(size(options.GEnewprice3.factor)); + options.GEnewprice3.keepold=ones(size(options.GEnewprice3.factor)); + tempweight=options.oldpathweight; + options.oldpathweight=zeros(size(options.GEnewprice3.factor)); + for ii=1:length(options.GEnewprice3.factor) + if options.GEnewprice3.factor(ii)==Inf + options.GEnewprice3.factor(ii)=1; + options.GEnewprice3.keepold(ii)=0; + options.oldpathweight(ii)=tempweight; + end + end + if size(options.GEnewprice3.howtoupdate,1)==nGeneralEqmEqns_acrossptypes + % do nothing, this is how things should be + else + error('options.GEnewprice3.howtoupdate does not fit with GeneralEqmEqns (different number of conditions) \n') + end + options.GEnewprice3.permute=zeros(size(options.GEnewprice3.howtoupdate,1),1); + + gg_c=1; + for gg=1:nGeneralEqmEqns % number of GE conditions + if options.GEptype(gg)==0 + for pp=1:length(GEPriceParamNames) + if strcmp(options.GEnewprice3.howtoupdate{gg_c,2},GEPriceParamNames{pp}) % Take advantage that options.GEnewprice3.howtoupdate has been set to same order as GEeqnNames + options.GEnewprice3.permute(PricePathSizeVec(1,pp))=gg_c; + end + end + gg_c=gg_c+1; + elseif options.GEptype(gg)==1 + for pp=1:length(GEPriceParamNames) + if strcmp(options.GEnewprice3.howtoupdate{gg_c,2},GEPriceParamNames{pp}) % Take advantage that options.GEnewprice3.howtoupdate has been set to same order as GEeqnNames + for ii=PricePathSizeVec(1,pp):PricePathSizeVec(2,pp) + options.GEnewprice3.permute(PricePathSizeVec(1,pp):PricePathSizeVec(2,pp))=gg_c+(0:1:N_i-1); + end + end + end + gg_c=gg_c+N_i; + end + end + + % Note: if some GE conditions are done conditional on ptype then + % options.GEnewprice3.howtoupdate + % options.GEnewprice3.permute + % reflect this. +end + + + + + +end \ No newline at end of file diff --git a/PolicyInd2Val/PolicyInd2Val_FHorz.m b/PolicyInd2Val/PolicyInd2Val_FHorz.m index 213d0916..00b46c07 100644 --- a/PolicyInd2Val/PolicyInd2Val_FHorz.m +++ b/PolicyInd2Val/PolicyInd2Val_FHorz.m @@ -197,7 +197,7 @@ PolicyValues=reshape(PolicyValues,[l_aprime,N_a,N_z,N_j]); end else - Policy=reshape(Policy,[l_d+l_aprime,N_a*N_z*N_j]); + Policy=reshape(Policy,[l_d+l_aprime,N_a*N_z*N_j]); % +1 is the L2index PolicyValues=zeros(l_d+l_aprime,N_a*N_z*N_j,'gpuArray'); temp_d_grid=d_grid(1:cumsum_n_d(1)); diff --git a/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType.m b/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType.m index 0bffd136..2918d68a 100644 --- a/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType.m +++ b/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType.m @@ -1020,6 +1020,9 @@ end +%% If using a shooting algorithm, set that up +transpathoptions=setupGEnewprice3_shooting(transpathoptions,GeneralEqmEqns,PricePathNames); + %% Check if using _tminus1 and/or _tplus1 variables. if isstruct(FnsToEvaluate) && isstruct(GeneralEqmEqns) [tplus1priceNames,tminus1priceNames,tminus1AggVarsNames,tminus1paramNames,tplus1pricePathkk]=inputsFindtplus1tminus1(FnsToEvaluate,GeneralEqmEqns,PricePathNames,ParamPathNames); @@ -1073,7 +1076,7 @@ end -if transpathoptions.verbose==1 +if transpathoptions.verbose>=1 transpathoptions end @@ -1125,6 +1128,7 @@ if transpathoptions.GEnewprice==2 % Function minimization % Have not attempted implementing this for PType yet, no point until I % get it to be useful without PType + error('Have not yet implemented transpathoptions.GEnewprice=2') if nargout==1 varargout={PricePath}; diff --git a/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType_shooting.m b/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType_shooting.m index bb2f5c01..daa284a3 100644 --- a/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType_shooting.m +++ b/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType_shooting.m @@ -49,103 +49,6 @@ % GeneralEqmEqnsCell is cell % GeneralEqmEqnParamNames(ff).Names contains the names -%% Set up GEnewprice==3 (if relevant) [More complex than normal as have to allow for transpathoptions.GEptype] -if transpathoptions.GEnewprice==3 - % Before starting, make sure that GE that depend on ptype match up with PricePaths that depend on ptype - for gg=1:nGeneralEqmEqns - if transpathoptions.GEptype(gg)==1 - for gg2=1:size(transpathoptions.GEnewprice3.howtoupdate,1) - if strcmp(transpathoptions.GEnewprice3.howtoupdate{gg2,1},GEeqnNames{gg}) - pricename_gg=transpathoptions.GEnewprice3.howtoupdate{gg2,2}; - end - end - for pp=1:length(PricePathNames) - if strcmp(pricename_gg,PricePathNames{pp}) - if PricePathSizeVec(2,pp)-PricePathSizeVec(1,pp)+1~=N_i - fprintf('Following error relates to GE condition %s and to price %s \n',GEeqnNames{gg},PricePathNames{pp}) - error('You declared a GE condition to depend on permenent type, but the price that relates to it (in transpathoptions.GEnewprice3.howtoupdate) does not depend on ptype') - end - end - end - end - end - - transpathoptions.weightscheme=0; - - % Need to make sure that order of rows in transpathoptions.GEnewprice3.howtoupdate - % Is same as order of fields in GeneralEqmEqns - % I do this by just reordering rows of transpathoptions.GEnewprice3.howtoupdate - temp=transpathoptions.GEnewprice3.howtoupdate; - % GEeqnNames=fieldnames(GeneralEqmEqns); - gg_index=zeros(1,nGeneralEqmEqns+(N_i-1)*sum(transpathoptions.GEptype==1)); - gg_c=0; - for gg=1:nGeneralEqmEqns - for jj=1:size(temp,1) - if strcmp(temp{jj,1},GEeqnNames{gg}) % Names match - for ii=1:(1+transpathoptions.GEptype(gg)*(N_i-1)) % Note: 1 or N_i, depending on transpathoptions.GEptype(gg) - gg_c=gg_c+1; - transpathoptions.GEnewprice3.howtoupdate{gg_c,1}=temp{jj,1}; - transpathoptions.GEnewprice3.howtoupdate{gg_c,2}=temp{jj,2}; - transpathoptions.GEnewprice3.howtoupdate{gg_c,3}=temp{jj,3}; - transpathoptions.GEnewprice3.howtoupdate{gg_c,4}=temp{jj,4}; - gg_index(gg_c)=gg; - end - end - end - end - % Note: transpathoptions.GEnewprice3.howtoupdate will have extra repeated rows whenever transpathoptions.GEptype(gg)=1 - - transpathoptions.GEnewprice3.add=[transpathoptions.GEnewprice3.howtoupdate{:,3}]; - transpathoptions.GEnewprice3.factor=[transpathoptions.GEnewprice3.howtoupdate{:,4}]; - transpathoptions.GEnewprice3.keepold=ones(size(transpathoptions.GEnewprice3.factor)); - transpathoptions.GEnewprice3.keepold=ones(size(transpathoptions.GEnewprice3.factor)); - tempweight=transpathoptions.oldpathweight; - transpathoptions.oldpathweight=zeros(size(transpathoptions.GEnewprice3.factor)); - for ii=1:length(transpathoptions.GEnewprice3.factor) - if transpathoptions.GEnewprice3.factor(ii)==Inf - transpathoptions.GEnewprice3.factor(ii)=1; - transpathoptions.GEnewprice3.keepold(ii)=0; - transpathoptions.oldpathweight(ii)=tempweight; - end - end - if size(transpathoptions.GEnewprice3.howtoupdate,1)==nGeneralEqmEqns_acrossptypes - % do nothing, this is how things should be - else - error('transpathoptions.GEnewprice3.howtoupdate does not fit with GeneralEqmEqns (different number of conditions) \n') - end - transpathoptions.GEnewprice3.permute=zeros(size(transpathoptions.GEnewprice3.howtoupdate,1),1); - - gg_c=1; - for gg=1:nGeneralEqmEqns % number of GE conditions - if transpathoptions.GEptype(gg)==0 - for pp=1:length(PricePathNames) - if strcmp(transpathoptions.GEnewprice3.howtoupdate{gg_c,2},PricePathNames{pp}) % Take advantage that transpathoptions.GEnewprice3.howtoupdate has been set to same order as GEeqnNames - transpathoptions.GEnewprice3.permute(PricePathSizeVec(1,pp))=gg_c; - end - end - gg_c=gg_c+1; - elseif transpathoptions.GEptype(gg)==1 - for pp=1:length(PricePathNames) - if strcmp(transpathoptions.GEnewprice3.howtoupdate{gg_c,2},PricePathNames{pp}) % Take advantage that transpathoptions.GEnewprice3.howtoupdate has been set to same order as GEeqnNames - for ii=PricePathSizeVec(1,pp):PricePathSizeVec(2,pp) - transpathoptions.GEnewprice3.permute(PricePathSizeVec(1,pp):PricePathSizeVec(2,pp))=gg_c+(0:1:N_i-1); - end - end - end - gg_c=gg_c+N_i; - end - end - - if isfield(transpathoptions,'updateaccuracycutoff')==0 - transpathoptions.updateaccuracycutoff=0; % No cut-off (only changes in the price larger in magnitude that this will be made (can be set to, e.g., 10^(-6) to help avoid changes at overly high precision)) - end -end -% Note: if some GE conditions are done conditional on ptype then -% transpathoptions.GEnewprice3.howtoupdate -% transpathoptions.GEnewprice3.permute -% reflect this. - - %% Setup used for graphs % For graph of the Prices if length(PricePathNames)>12 diff --git a/TransitionPaths/FHorz/TransitionPath_Case1_FHorz.m b/TransitionPaths/FHorz/TransitionPath_Case1_FHorz.m index 8043b535..5a0c14f8 100644 --- a/TransitionPaths/FHorz/TransitionPath_Case1_FHorz.m +++ b/TransitionPaths/FHorz/TransitionPath_Case1_FHorz.m @@ -609,60 +609,8 @@ end -%% Set up GEnewprice==3 (if relevant) -if transpathoptions.GEnewprice==3 - transpathoptions.weightscheme=0; - - if isstruct(GeneralEqmEqns) - % Need to make sure that order of rows in transpathoptions.GEnewprice3.howtoupdate - % Is same as order of fields in GeneralEqmEqns - % I do this by just reordering rows of transpathoptions.GEnewprice3.howtoupdate - temp=transpathoptions.GEnewprice3.howtoupdate; - GEeqnNames=fieldnames(GeneralEqmEqns); - for ii=1:length(GEeqnNames) - for jj=1:size(temp,1) - if strcmp(temp{jj,1},GEeqnNames{ii}) % Names match - transpathoptions.GEnewprice3.howtoupdate{ii,1}=temp{jj,1}; - transpathoptions.GEnewprice3.howtoupdate{ii,2}=temp{jj,2}; - transpathoptions.GEnewprice3.howtoupdate{ii,3}=temp{jj,3}; - transpathoptions.GEnewprice3.howtoupdate{ii,4}=temp{jj,4}; - end - end - end - nGeneralEqmEqns=length(GEeqnNames); - else - nGeneralEqmEqns=length(GeneralEqmEqns); - end - transpathoptions.GEnewprice3.add=[transpathoptions.GEnewprice3.howtoupdate{:,3}]; - transpathoptions.GEnewprice3.factor=[transpathoptions.GEnewprice3.howtoupdate{:,4}]; - transpathoptions.GEnewprice3.keepold=ones(size(transpathoptions.GEnewprice3.factor)); - transpathoptions.GEnewprice3.keepold=ones(size(transpathoptions.GEnewprice3.factor)); - tempweight=transpathoptions.oldpathweight; - transpathoptions.oldpathweight=zeros(size(transpathoptions.GEnewprice3.factor)); - for ii=1:length(transpathoptions.GEnewprice3.factor) - if transpathoptions.GEnewprice3.factor(ii)==Inf - transpathoptions.GEnewprice3.factor(ii)=1; - transpathoptions.GEnewprice3.keepold(ii)=0; - transpathoptions.oldpathweight(ii)=tempweight; - end - end - if size(transpathoptions.GEnewprice3.howtoupdate,1)==nGeneralEqmEqns % Note: inputs were already testted - % do nothing, this is how things should be - else - error('transpathoptions.GEnewprice3.howtoupdate does not fit with GeneralEqmEqns (number of rows is different to the number of GeneralEqmEqns fields) \n') - end - transpathoptions.GEnewprice3.permute=zeros(size(transpathoptions.GEnewprice3.howtoupdate,1),1); - for ii=1:size(transpathoptions.GEnewprice3.howtoupdate,1) % number of rows is the number of prices (and number of GE conditions) - for jj=1:length(PricePathNames) - if strcmp(transpathoptions.GEnewprice3.howtoupdate{ii,2},PricePathNames{jj}) - transpathoptions.GEnewprice3.permute(ii)=jj; - end - end - end - if isfield(transpathoptions,'updateaccuracycutoff')==0 - transpathoptions.updateaccuracycutoff=0; % No cut-off (only changes in the price larger in magnitude that this will be made (can be set to, e.g., 10^(-6) to help avoid changes at overly high precision)) - end -end +%% If using a shooting algorithm, set that up +transpathoptions=setupGEnewprice3_shooting(transpathoptions,GeneralEqmEqns,PricePathNames); %% Check if using _tminus1 and/or _tplus1 variables. diff --git a/TransitionPaths/InfHorz/PType/TransitionPath_Case1_PType.m b/TransitionPaths/InfHorz/PType/TransitionPath_Case1_PType.m index 9865c829..b3bb1c20 100644 --- a/TransitionPaths/InfHorz/PType/TransitionPath_Case1_PType.m +++ b/TransitionPaths/InfHorz/PType/TransitionPath_Case1_PType.m @@ -529,61 +529,9 @@ fprintf('Completed setup, beginning transition computination \n') end -%% Set up GEnewprice==3 (if relevant) -if transpathoptions.GEnewprice==3 - transpathoptions.weightscheme=0; % Don't do any weightscheme, is already taken care of by GEnewprice=3 - - if isstruct(GeneralEqmEqns) - % Need to make sure that order of rows in transpathoptions.GEnewprice3.howtoupdate - % Is same as order of fields in GeneralEqmEqns - % I do this by just reordering rows of transpathoptions.GEnewprice3.howtoupdate - temp=transpathoptions.GEnewprice3.howtoupdate; - GEeqnNames=fieldnames(GeneralEqmEqns); - for tt=1:length(GEeqnNames) - for jj=1:size(temp,1) - if strcmp(temp{jj,1},GEeqnNames{tt}) % Names match - transpathoptions.GEnewprice3.howtoupdate{tt,1}=temp{jj,1}; - transpathoptions.GEnewprice3.howtoupdate{tt,2}=temp{jj,2}; - transpathoptions.GEnewprice3.howtoupdate{tt,3}=temp{jj,3}; - transpathoptions.GEnewprice3.howtoupdate{tt,4}=temp{jj,4}; - end - end - end - nGeneralEqmEqns=length(GEeqnNames); - else - nGeneralEqmEqns=length(GeneralEqmEqns); - end - transpathoptions.GEnewprice3.add=[transpathoptions.GEnewprice3.howtoupdate{:,3}]; - transpathoptions.GEnewprice3.factor=[transpathoptions.GEnewprice3.howtoupdate{:,4}]; - transpathoptions.GEnewprice3.keepold=ones(size(transpathoptions.GEnewprice3.factor)); - transpathoptions.GEnewprice3.keepold=ones(size(transpathoptions.GEnewprice3.factor)); - tempweight=transpathoptions.oldpathweight; - transpathoptions.oldpathweight=zeros(size(transpathoptions.GEnewprice3.factor)); - for tt=1:length(transpathoptions.GEnewprice3.factor) - if transpathoptions.GEnewprice3.factor(tt)==Inf - transpathoptions.GEnewprice3.factor(tt)=1; - transpathoptions.GEnewprice3.keepold(tt)=0; - transpathoptions.oldpathweight(tt)=tempweight; - end - end - if size(transpathoptions.GEnewprice3.howtoupdate,1)==nGeneralEqmEqns && nGeneralEqmEqns==length(PricePathNames) - % do nothing, this is how things should be - else - fprintf('ERROR: transpathoptions.GEnewprice3.howtoupdate does not fit with GeneralEqmEqns (different number of conditions/prices) \n') - end - transpathoptions.GEnewprice3.permute=zeros(size(transpathoptions.GEnewprice3.howtoupdate,1),1); - for tt=1:size(transpathoptions.GEnewprice3.howtoupdate,1) % number of rows is the number of prices (and number of GE conditions) - for jj=1:length(PricePathNames) - if strcmp(transpathoptions.GEnewprice3.howtoupdate{tt,2},PricePathNames{jj}) - transpathoptions.GEnewprice3.permute(tt)=jj; - end - end - end - if isfield(transpathoptions,'updateaccuracycutoff')==0 - transpathoptions.updateaccuracycutoff=0; % No cut-off (only changes in the price larger in magnitude that this will be made (can be set to, e.g., 10^(-6) to help avoid changes at overly high precision)) - end -end +%% If using a shooting algorithm, set that up +transpathoptions=setupGEnewprice3_shooting(options,GeneralEqmEqns,PricePathNames); %% if transpathoptions.verbose==1 diff --git a/TransitionPaths/InfHorz/TransitionPath_Case1.m b/TransitionPaths/InfHorz/TransitionPath_Case1.m index aa45494c..9cc1428b 100644 --- a/TransitionPaths/InfHorz/TransitionPath_Case1.m +++ b/TransitionPaths/InfHorz/TransitionPath_Case1.m @@ -318,61 +318,7 @@ %% If using a shooting algorithm, set that up -% Set up GEnewprice==3 (if relevant) -if transpathoptions.GEnewprice==3 - transpathoptions.weightscheme=0; % Don't do any weightscheme, is already taken care of by GEnewprice=3 - - if isstruct(GeneralEqmEqns) - % Need to make sure that order of rows in transpathoptions.GEnewprice3.howtoupdate - % Is same as order of fields in GeneralEqmEqns - % I do this by just reordering rows of transpathoptions.GEnewprice3.howtoupdate - temp=transpathoptions.GEnewprice3.howtoupdate; - GEeqnNames=fieldnames(GeneralEqmEqns); - for tt=1:length(GEeqnNames) - for jj=1:size(temp,1) - if strcmp(temp{jj,1},GEeqnNames{tt}) % Names match - transpathoptions.GEnewprice3.howtoupdate{tt,1}=temp{jj,1}; - transpathoptions.GEnewprice3.howtoupdate{tt,2}=temp{jj,2}; - transpathoptions.GEnewprice3.howtoupdate{tt,3}=temp{jj,3}; - transpathoptions.GEnewprice3.howtoupdate{tt,4}=temp{jj,4}; - end - end - end - nGeneralEqmEqns=length(GEeqnNames); - else - nGeneralEqmEqns=length(GeneralEqmEqns); - end - transpathoptions.GEnewprice3.add=[transpathoptions.GEnewprice3.howtoupdate{:,3}]; - transpathoptions.GEnewprice3.factor=[transpathoptions.GEnewprice3.howtoupdate{:,4}]; - transpathoptions.GEnewprice3.keepold=ones(size(transpathoptions.GEnewprice3.factor)); - transpathoptions.GEnewprice3.keepold=ones(size(transpathoptions.GEnewprice3.factor)); - tempweight=transpathoptions.oldpathweight; - transpathoptions.oldpathweight=zeros(size(transpathoptions.GEnewprice3.factor)); - for tt=1:length(transpathoptions.GEnewprice3.factor) - if transpathoptions.GEnewprice3.factor(tt)==Inf - transpathoptions.GEnewprice3.factor(tt)=1; - transpathoptions.GEnewprice3.keepold(tt)=0; - transpathoptions.oldpathweight(tt)=tempweight; - end - end - if size(transpathoptions.GEnewprice3.howtoupdate,1)==nGeneralEqmEqns && nGeneralEqmEqns==length(PricePathNames) - % do nothing, this is how things should be - else - error('transpathoptions.GEnewprice3.howtoupdate does not fit with GeneralEqmEqns (different number of conditions/prices) \n') - end - transpathoptions.GEnewprice3.permute=zeros(size(transpathoptions.GEnewprice3.howtoupdate,1),1); - for tt=1:size(transpathoptions.GEnewprice3.howtoupdate,1) % number of rows is the number of prices (and number of GE conditions) - for jj=1:length(PricePathNames) - if strcmp(transpathoptions.GEnewprice3.howtoupdate{tt,2},PricePathNames{jj}) - transpathoptions.GEnewprice3.permute(tt)=jj; - end - end - end - if isfield(transpathoptions,'updateaccuracycutoff')==0 - transpathoptions.updateaccuracycutoff=0; % No cut-off (only changes in the price larger in magnitude that this will be made (can be set to, e.g., 10^(-6) to help avoid changes at overly high precision)) - end -end - +transpathoptions=setupGEnewprice3_shooting(transpathoptions,GeneralEqmEqns,PricePathNames); %% Check if using _tminus1 and/or _tplus1 variables. [tplus1priceNames,tminus1priceNames,tminus1AggVarsNames,tminus1paramNames,tplus1pricePathkk]=inputsFindtplus1tminus1(FnsToEvaluate,GeneralEqmEqns,PricePathNames,ParamPathNames); From d1919e75781d6b4e528457ad978f78631455b2cd Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Wed, 21 Jan 2026 11:10:09 +1300 Subject: [PATCH 22/67] clean --- PolicyInd2Val/PolicyInd2Val_FHorz.m | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PolicyInd2Val/PolicyInd2Val_FHorz.m b/PolicyInd2Val/PolicyInd2Val_FHorz.m index 00b46c07..213d0916 100644 --- a/PolicyInd2Val/PolicyInd2Val_FHorz.m +++ b/PolicyInd2Val/PolicyInd2Val_FHorz.m @@ -197,7 +197,7 @@ PolicyValues=reshape(PolicyValues,[l_aprime,N_a,N_z,N_j]); end else - Policy=reshape(Policy,[l_d+l_aprime,N_a*N_z*N_j]); % +1 is the L2index + Policy=reshape(Policy,[l_d+l_aprime,N_a*N_z*N_j]); PolicyValues=zeros(l_d+l_aprime,N_a*N_z*N_j,'gpuArray'); temp_d_grid=d_grid(1:cumsum_n_d(1)); From ff41d91310352dceceefa79d69d46d1bf4da5b6a Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Wed, 21 Jan 2026 14:03:21 +1300 Subject: [PATCH 23/67] minor fixes --- .../HeteroAgentStationaryEqm_Case1_FHorz.m | 45 +--- ...teroAgentStationaryEqm_Case1_FHorz_PType.m | 47 +--- .../InfHorz/HeteroAgentStationaryEqm_Case1.m | 46 +--- .../HeteroAgentStationaryEqm_Case1_PType.m | 47 +--- Optimization/setupGEnewprice3_shooting.m | 6 +- .../PType/TransitionPath_Case1_FHorz_PType.m | 158 ++---------- .../TransitionPath_FHorz_PType_singlepath.m | 2 +- .../PType/TransitionPath_Case1_PType.m | 55 ++--- .../TransitionPath_InfHorz_PType_shooting.m | 14 +- .../PricePathParamPath_FHorz_StructToMatrix.m | 231 ++++++++++++++---- .../PricePathParamPath_StructToMatrix.m | 202 ++++++++++++--- 11 files changed, 397 insertions(+), 456 deletions(-) diff --git a/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m b/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m index bebd868d..e0584700 100644 --- a/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m +++ b/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m @@ -305,50 +305,9 @@ %% Enough setup, Time to do the actual finding the HeteroAgentStationaryEqm: %% If using fminalgo=5, then need some further setup - if heteroagentoptions.fminalgo==5 - heteroagentoptions.weightscheme=0; % Don't do any weightscheme, is already taken care of by GEnewprice=3 - - if isstruct(GeneralEqmEqns) - % Need to make sure that order of rows in transpathoptions.GEnewprice3.howtoupdate - % Is same as order of fields in GeneralEqmEqns - % I do this by just reordering rows of transpathoptions.GEnewprice3.howtoupdate - temp=heteroagentoptions.fminalgo5.howtoupdate; - GEeqnNames=fieldnames(GeneralEqmEqns); - for tt=1:length(GEeqnNames) - for jj=1:size(temp,1) - if strcmp(temp{jj,1},GEeqnNames{tt}) % Names match - heteroagentoptions.fminalgo5.howtoupdate{tt,1}=temp{jj,1}; - heteroagentoptions.fminalgo5.howtoupdate{tt,2}=temp{jj,2}; - heteroagentoptions.fminalgo5.howtoupdate{tt,3}=temp{jj,3}; - heteroagentoptions.fminalgo5.howtoupdate{tt,4}=temp{jj,4}; - end - end - end - nGeneralEqmEqns=length(GEeqnNames); - else - nGeneralEqmEqns=length(GeneralEqmEqns); - end - heteroagentoptions.fminalgo5.add=[heteroagentoptions.fminalgo5.howtoupdate{:,3}]; - heteroagentoptions.fminalgo5.factor=[heteroagentoptions.fminalgo5.howtoupdate{:,4}]; - heteroagentoptions.fminalgo5.keepold=ones(size(heteroagentoptions.fminalgo5.factor)); - - if size(heteroagentoptions.fminalgo5.howtoupdate,1)==nGeneralEqmEqns && nGeneralEqmEqns==length(GEPriceParamNames) - % do nothing, this is how things should be - else - fprintf('ERROR: heteroagentoptions.fminalgo5..howtoupdate does not fit with GeneralEqmEqns (different number of conditions/prices) \n') - end - heteroagentoptions.fminalgo5.permute=zeros(size(heteroagentoptions.fminalgo5.howtoupdate,1),1); - for tt=1:size(heteroagentoptions.fminalgo5.howtoupdate,1) % number of rows is the number of prices (and number of GE conditions) - for jj=1:length(GEPriceParamNames) - if strcmp(heteroagentoptions.fminalgo5.howtoupdate{tt,2},GEPriceParamNames{jj}) - heteroagentoptions.fminalgo5.permute(tt)=jj; - end - end - end - if isfield(heteroagentoptions,'updateaccuracycutoff')==0 - heteroagentoptions.updateaccuracycutoff=0; % No cut-off (only changes in the price larger in magnitude that this will be made (can be set to, e.g., 10^(-6) to help avoid changes at overly high precision)) - end + % If using a shooting algorithm, set that up + heteroagentoptions=setupGEnewprice3_shooting(heteroagentoptions,GeneralEqmEqns,GEPriceParamNames); end diff --git a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m index 6445cdb7..790279f1 100644 --- a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m +++ b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m @@ -690,54 +690,13 @@ %% Have now finished creating PTypeStructure. Time to do the actual finding the HeteroAgentStationaryEqm: %% If using fminalgo=5, then need some further setup - if heteroagentoptions.fminalgo==5 - heteroagentoptions.weightscheme=0; % Don't do any weightscheme, is already taken care of by GEnewprice=3 - - if isstruct(GeneralEqmEqns) - % Need to make sure that order of rows in transpathoptions.GEnewprice3.howtoupdate - % Is same as order of fields in GeneralEqmEqns - % I do this by just reordering rows of transpathoptions.GEnewprice3.howtoupdate - temp=heteroagentoptions.fminalgo5.howtoupdate; - GEeqnNames=fieldnames(GeneralEqmEqns); - for tt=1:length(GEeqnNames) - for jj=1:size(temp,1) - if strcmp(temp{jj,1},GEeqnNames{tt}) % Names match - heteroagentoptions.fminalgo5.howtoupdate{tt,1}=temp{jj,1}; - heteroagentoptions.fminalgo5.howtoupdate{tt,2}=temp{jj,2}; - heteroagentoptions.fminalgo5.howtoupdate{tt,3}=temp{jj,3}; - heteroagentoptions.fminalgo5.howtoupdate{tt,4}=temp{jj,4}; - end - end - end - nGeneralEqmEqns=length(GEeqnNames); - else - nGeneralEqmEqns=length(GeneralEqmEqns); - end - heteroagentoptions.fminalgo5.add=[heteroagentoptions.fminalgo5.howtoupdate{:,3}]; - heteroagentoptions.fminalgo5.factor=[heteroagentoptions.fminalgo5.howtoupdate{:,4}]; - heteroagentoptions.fminalgo5.keepold=ones(size(heteroagentoptions.fminalgo5.factor)); - heteroagentoptions.fminalgo5.keepold=ones(size(heteroagentoptions.fminalgo5.factor)); - - if size(heteroagentoptions.fminalgo5.howtoupdate,1)==nGeneralEqmEqns && nGeneralEqmEqns==length(GEPriceParamNames) - % do nothing, this is how things should be - else - fprintf('ERROR: heteroagentoptions.fminalgo5..howtoupdate does not fit with GeneralEqmEqns (different number of conditions/prices) \n') - end - heteroagentoptions.fminalgo5.permute=zeros(size(heteroagentoptions.fminalgo5.howtoupdate,1),1); - for tt=1:size(heteroagentoptions.fminalgo5.howtoupdate,1) % number of rows is the number of prices (and number of GE conditions) - for jj=1:length(GEPriceParamNames) - if strcmp(heteroagentoptions.fminalgo5.howtoupdate{tt,2},GEPriceParamNames{jj}) - heteroagentoptions.fminalgo5.permute(tt)=jj; - end - end - end - if isfield(heteroagentoptions,'updateaccuracycutoff')==0 - heteroagentoptions.updateaccuracycutoff=0; % No cut-off (only changes in the price larger in magnitude that this will be made (can be set to, e.g., 10^(-6) to help avoid changes at overly high precision)) - end + % If using a shooting algorithm, set that up + heteroagentoptions=setupGEnewprice3_shooting(heteroagentoptions,GeneralEqmEqns,GEPriceParamNames); end + %% if heteroagentoptions.maxiter>0 % Can use heteroagentoptions.maxiter=0 to just evaluate the current general eqm eqns diff --git a/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1.m b/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1.m index 354623b8..29cdc341 100644 --- a/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1.m +++ b/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1.m @@ -361,54 +361,12 @@ %% Enough setup, Time to do the actual finding the HeteroAgentStationaryEqm: %% If using fminalgo=5, then need some further setup - if heteroagentoptions.fminalgo==5 - heteroagentoptions.weightscheme=0; % Don't do any weightscheme, is already taken care of by GEnewprice=3 - - if isstruct(GeneralEqmEqns) - % Need to make sure that order of rows in transpathoptions.GEnewprice3.howtoupdate - % Is same as order of fields in GeneralEqmEqns - % I do this by just reordering rows of transpathoptions.GEnewprice3.howtoupdate - temp=heteroagentoptions.fminalgo5.howtoupdate; - GEeqnNames=fieldnames(GeneralEqmEqns); - for tt=1:length(GEeqnNames) - for jj=1:size(temp,1) - if strcmp(temp{jj,1},GEeqnNames{tt}) % Names match - heteroagentoptions.fminalgo5.howtoupdate{tt,1}=temp{jj,1}; - heteroagentoptions.fminalgo5.howtoupdate{tt,2}=temp{jj,2}; - heteroagentoptions.fminalgo5.howtoupdate{tt,3}=temp{jj,3}; - heteroagentoptions.fminalgo5.howtoupdate{tt,4}=temp{jj,4}; - end - end - end - nGeneralEqmEqns=length(GEeqnNames); - else - nGeneralEqmEqns=length(GeneralEqmEqns); - end - heteroagentoptions.fminalgo5.add=[heteroagentoptions.fminalgo5.howtoupdate{:,3}]; - heteroagentoptions.fminalgo5.factor=[heteroagentoptions.fminalgo5.howtoupdate{:,4}]; - heteroagentoptions.fminalgo5.keepold=ones(size(heteroagentoptions.fminalgo5.factor)); - - if size(heteroagentoptions.fminalgo5.howtoupdate,1)==nGeneralEqmEqns && nGeneralEqmEqns==length(GEPriceParamNames) - % do nothing, this is how things should be - else - error('heteroagentoptions.fminalgo5..howtoupdate does not fit with GeneralEqmEqns (different number of conditions/prices) \n') - end - heteroagentoptions.fminalgo5.permute=zeros(size(heteroagentoptions.fminalgo5.howtoupdate,1),1); - for tt=1:size(heteroagentoptions.fminalgo5.howtoupdate,1) % number of rows is the number of prices (and number of GE conditions) - for jj=1:length(GEPriceParamNames) - if strcmp(heteroagentoptions.fminalgo5.howtoupdate{tt,2},GEPriceParamNames{jj}) - heteroagentoptions.fminalgo5.permute(tt)=jj; - end - end - end - if isfield(heteroagentoptions,'updateaccuracycutoff')==0 - heteroagentoptions.updateaccuracycutoff=0; % No cut-off (only changes in the price larger in magnitude that this will be made (can be set to, e.g., 10^(-6) to help avoid changes at overly high precision)) - end + % If using a shooting algorithm, set that up + heteroagentoptions=setupGEnewprice3_shooting(heteroagentoptions,GeneralEqmEqns,GEPriceParamNames); end - %% If there is entry and exit, then send to relevant command if isfield(simoptions,'agententryandexit')==1 if simoptions.agententryandexit>=1 diff --git a/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m b/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m index fa281ff8..e2dce293 100644 --- a/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m +++ b/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m @@ -640,55 +640,12 @@ %% If using fminalgo=5, then need some further setup - if heteroagentoptions.fminalgo==5 - heteroagentoptions.weightscheme=0; % Don't do any weightscheme, is already taken care of by GEnewprice=3 - - if isstruct(GeneralEqmEqns) - % Need to make sure that order of rows in transpathoptions.GEnewprice3.howtoupdate - % Is same as order of fields in GeneralEqmEqns - % I do this by just reordering rows of transpathoptions.GEnewprice3.howtoupdate - temp=heteroagentoptions.fminalgo5.howtoupdate; - GEeqnNames=fieldnames(GeneralEqmEqns); - for tt=1:length(GEeqnNames) - for jj=1:size(temp,1) - if strcmp(temp{jj,1},GEeqnNames{tt}) % Names match - heteroagentoptions.fminalgo5.howtoupdate{tt,1}=temp{jj,1}; - heteroagentoptions.fminalgo5.howtoupdate{tt,2}=temp{jj,2}; - heteroagentoptions.fminalgo5.howtoupdate{tt,3}=temp{jj,3}; - heteroagentoptions.fminalgo5.howtoupdate{tt,4}=temp{jj,4}; - end - end - end - nGeneralEqmEqns=length(GEeqnNames); - else - nGeneralEqmEqns=length(GeneralEqmEqns); - end - heteroagentoptions.fminalgo5.add=[heteroagentoptions.fminalgo5.howtoupdate{:,3}]; - heteroagentoptions.fminalgo5.factor=[heteroagentoptions.fminalgo5.howtoupdate{:,4}]; - heteroagentoptions.fminalgo5.keepold=ones(size(heteroagentoptions.fminalgo5.factor)); - heteroagentoptions.fminalgo5.keepold=ones(size(heteroagentoptions.fminalgo5.factor)); - - if size(heteroagentoptions.fminalgo5.howtoupdate,1)==nGeneralEqmEqns && nGeneralEqmEqns==length(GEPriceParamNames) - % do nothing, this is how things should be - else - fprintf('ERROR: heteroagentoptions.fminalgo5..howtoupdate does not fit with GeneralEqmEqns (different number of conditions/prices) \n') - end - heteroagentoptions.fminalgo5.permute=zeros(size(heteroagentoptions.fminalgo5.howtoupdate,1),1); - for tt=1:size(heteroagentoptions.fminalgo5.howtoupdate,1) % number of rows is the number of prices (and number of GE conditions) - for jj=1:length(GEPriceParamNames) - if strcmp(heteroagentoptions.fminalgo5.howtoupdate{tt,2},GEPriceParamNames{jj}) - heteroagentoptions.fminalgo5.permute(tt)=jj; - end - end - end - if isfield(heteroagentoptions,'updateaccuracycutoff')==0 - heteroagentoptions.updateaccuracycutoff=0; % No cut-off (only changes in the price larger in magnitude that this will be made (can be set to, e.g., 10^(-6) to help avoid changes at overly high precision)) - end + % If using a shooting algorithm, set that up + heteroagentoptions=setupGEnewprice3_shooting(heteroagentoptions,GeneralEqmEqns,GEPriceParamNames); end - %% if heteroagentoptions.maxiter>0 % Can use heteroagentoptions.maxiter=0 to just evaluate the current general eqm eqns diff --git a/Optimization/setupGEnewprice3_shooting.m b/Optimization/setupGEnewprice3_shooting.m index ed668c34..a2cd79d1 100644 --- a/Optimization/setupGEnewprice3_shooting.m +++ b/Optimization/setupGEnewprice3_shooting.m @@ -1,6 +1,8 @@ -function options=setupGEnewprice3_shooting(options,GeneralEqmEqns,GEPriceParamNames) +function options=setupGEnewprice3_shooting(options,GeneralEqmEqns,GEPriceParamNames,N_i,PricePathSizeVec) % options can be heteroagentoptions or transpathoptions % transpathoptions: GEPriceParamNames will be PricePathNames +% N_i is an optional input, only needed for models with permanent types +% PricePathSizeVec is an optional input, only needed for models with permanent types GEeqnNames=fieldnames(GeneralEqmEqns); nGeneralEqmEqns=length(GEeqnNames); @@ -68,6 +70,8 @@ else %% Model with permanent type: allow for options.GEptype + nGeneralEqmEqns_acrossptypes=sum(options.GEptype==0)+N_i*sum(options.GEptype==1); + % Before starting, make sure that GE that depend on ptype match up with PricePaths that depend on ptype for gg=1:nGeneralEqmEqns if options.GEptype(gg)==1 diff --git a/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType.m b/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType.m index 2918d68a..b94d6591 100644 --- a/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType.m +++ b/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType.m @@ -1,4 +1,4 @@ -function varargout=TransitionPath_Case1_FHorz_PType(PricePathOld, ParamPath, T, V_final, AgentDist_init, jequalOneDist, n_d, n_a, n_z, N_j, Names_i, d_grid,a_grid,z_grid, pi_z, ReturnFn, FnsToEvaluate, GeneralEqmEqns, Parameters, DiscountFactorParamNames, AgeWeightsParamNames, PTypeDistParamNames, transpathoptions, simoptions, vfoptions) +function varargout=TransitionPath_Case1_FHorz_PType(PricePath0, ParamPath, T, V_final, AgentDist_init, jequalOneDist, n_d, n_a, n_z, N_j, Names_i, d_grid,a_grid,z_grid, pi_z, ReturnFn, FnsToEvaluate, GeneralEqmEqns, Parameters, DiscountFactorParamNames, AgeWeightsParamNames, PTypeDistParamNames, transpathoptions, simoptions, vfoptions) % This code will work for all transition paths except those that involve at % change in the transition matrix pi_z (can handle a change in pi_z, but % only if it is a 'surprise', not anticipated changes) @@ -137,16 +137,9 @@ %% Some internal commands require a few vfoptions and simoptions to be set -if exist('vfoptions','var')==0 - vfoptions.policy_forceintegertype=0; +vfoptions.EVpre=0; % Not actually an option that can be used here +if isfield(vfoptions,'lowmemory')==0 vfoptions.lowmemory=0; -else - if isfield(vfoptions,'policy_forceintegertype')==0 - vfoptions.policy_forceintegertype=0; - end - if isfield(vfoptions,'lowmemory')==0 - vfoptions.lowmemory=0; - end end %% Get AgeWeights from Parameters @@ -160,107 +153,8 @@ %% ptype just hardcodes that this is non-trivial, so I will use jequalOneDist_T=struct(); -%% Note: Internally PricePathOld is matrix of size T-by-'number of prices'. -% ParamPath is matrix of size T-by-'number of parameters that change over the transition path'. -% Actually, some of those prices are 1-by-N_j, so is more subtle than this. -PricePathNames=fieldnames(PricePathOld); -PricePathStruct=PricePathOld; -PricePathSizeVec=zeros(1,length(PricePathNames)); % Allows for a given price param to depend on age (or permanent type) -for pp=1:length(PricePathNames) - if isstruct(PricePathStruct.(PricePathNames{pp})) - tempptypenames=fieldnames(PricePathStruct.(PricePathNames{pp})); - temp=PricePathStruct.(PricePathNames{pp}).(tempptypenames{1}); - tempsize=size(temp); - PricePathSizeVec(pp)=length(tempptypenames)*tempsize(tempsize~=T); % Get the dimension which is not T - if ~any(PricePathSizeVec(pp)==[1,N_i,N_j,N_i*N_j]) - error(['PricePath for ', PricePathNames{pp}, ' appears to be the wrong size (should be 1-by-T or N_j-by-T or N_i-by-T)']) - end - else - temp=PricePathStruct.(PricePathNames{pp}); - tempsize=size(temp); - PricePathSizeVec(pp)=tempsize(tempsize~=T); % Get the dimension which is not T - if ~any(PricePathSizeVec(pp)==[1,N_i,N_j]) - error(['PricePath for ', PricePathNames{pp}, ' appears to be the wrong size (should be 1-by-T or N_j-by-T or N_i-by-T)']) - end - end -end -PricePathSizeVec_ii=PricePathSizeVec;% Also need what size these are conditional on ptype (as some of PricePath/ParamPath may differ by ptype) [deal with this below] -PricePathSizeVec=cumsum(PricePathSizeVec); -if length(PricePathNames)>1 - PricePathSizeVec=[[1,PricePathSizeVec(1:end-1)+1];PricePathSizeVec]; -else - PricePathSizeVec=[1;PricePathSizeVec]; -end -PricePathOld=zeros(T,PricePathSizeVec(2,end)); % Do this seperately afterwards so that can preallocate the memory -for pp=1:length(PricePathNames) - if isstruct(PricePathStruct.(PricePathNames{pp})) % depends on ptype as structure - tempptypenames=fieldnames(PricePathStruct.(PricePathNames{pp})); - for ii=1:length(tempptypenames) - if size(PricePathStruct.(PricePathNames{pp}).(tempptypenames{ii}),1)==T % Note: size(PricePathStruct.(PricePathNames{pp}),2) will be 1 or N_j - PricePathOld(:,PricePathSizeVec(1,pp)+(ii-1)*size(PricePathStruct.(PricePathNames{pp}).(tempptypenames{ii}),2):PricePathSizeVec(1,pp)-1+ii*size(PricePathStruct.(PricePathNames{pp}).(tempptypenames{ii}),2))=PricePathStruct.(PricePathNames{pp}).(tempptypenames{ii}); - else % Need to transpose - PricePathOld(:,PricePathSizeVec(1,pp)+(ii-1)*size(PricePathStruct.(PricePathNames{pp}).(tempptypenames{ii}),1):PricePathSizeVec(1,pp)-1+ii*size(PricePathStruct.(PricePathNames{pp}).(tempptypenames{ii}),1))=PricePathStruct.(PricePathNames{pp}).(tempptypenames{ii})'; - end - end - else - if size(PricePathStruct.(PricePathNames{pp}),1)==T - PricePathOld(:,PricePathSizeVec(1,pp):PricePathSizeVec(2,pp))=PricePathStruct.(PricePathNames{pp}); - else % Need to transpose - PricePathOld(:,PricePathSizeVec(1,pp):PricePathSizeVec(2,pp))=PricePathStruct.(PricePathNames{pp})'; - end - end -end - -ParamPathNames=fieldnames(ParamPath); -ParamPathStruct=ParamPath; -ParamPathSizeVec=zeros(1,length(ParamPathNames)); % Allows for a given price param to depend on age (or permanent type) -for pp=1:length(ParamPathNames) - if isstruct(ParamPathStruct.(ParamPathNames{pp})) - tempptypenames=fieldnames(PricePathStruct.(PricePathNames{pp})); - temp=ParamPathStruct.(ParamPathNames{pp}).*(tempptypenames{1}); - tempsize=size(temp); - ParamPathSizeVec(pp)=length(tempptypenames)*tempsize(tempsize~=T); % Get the dimension which is not T - if ~any(ParamPathSizeVec(pp)==[1,N_i,N_j,N_i*N_j]) - error(['ParamPath for ', ParamPathNames{pp}, ' appears to be the wrong size (should be 1-by-T or N_j-by-T or N_i-by-T)']) - end - - else - temp=ParamPathStruct.(ParamPathNames{pp}); - tempsize=size(temp); - ParamPathSizeVec(pp)=tempsize(tempsize~=T); % Get the dimension which is not T - if ~any(ParamPathSizeVec(pp)==[1,N_i,N_j]) - error(['ParamPath for ', ParamPathNames{pp}, ' appears to be the wrong size (should be 1-by-T or N_j-by-T or N_i-by-T)']) - end - end -end -ParamPathSizeVec_ii=ParamPathSizeVec;% Also need what size these are conditional on ptype (as some of PricePath/ParamPath may differ by ptype) [deal with this below] -ParamPathSizeVec=cumsum(ParamPathSizeVec); -if length(ParamPathNames)>1 - ParamPathSizeVec=[[1,ParamPathSizeVec(1:end-1)+1];ParamPathSizeVec]; -else - ParamPathSizeVec=[1;ParamPathSizeVec]; -end -ParamPath=zeros(T,ParamPathSizeVec(2,end));% Do this seperately afterwards so that can preallocate the memory -for pp=1:length(ParamPathNames) - if isstruct(ParamPathStruct.(ParamPathNames{pp})) - tempptypenames=fieldnames(ParamPathStruct.(ParamPathNames{pp})); - for ii=1:length(tempptypenames) - if size(ParamPathStruct.(ParamPathNames{pp}).(tempptypenames{ii}),1)==T % Note: size(PricePathStruct.(PricePathNames{pp}),2) will be 1 or N_j - ParamPath(:,ParamPathSizeVec(1,pp)+(ii-1)*size(ParamPathStruct.(ParamPathNames{pp}).(tempptypenames{ii}),2):ParamPathSizeVec(1,pp)-1+ii*size(ParamPathStruct.(ParamPathNames{pp}).(tempptypenames{ii}),2))=ParamPathStruct.(ParamPathNames{pp}).(tempptypenames{ii}); - else % Need to transpose - ParamPath(:,ParamPathSizeVec(1,pp)+(ii-1)*size(ParamPathStruct.(ParamPathNames{pp}).(tempptypenames{ii}),1):ParamPathSizeVec(1,pp)-1+ii*size(ParamPathStruct.(ParamPathNames{pp}).(tempptypenames{ii}),1))=ParamPathStruct.(ParamPathNames{pp}).(tempptypenames{ii})'; - end - end - else - if size(ParamPathStruct.(ParamPathNames{pp}),1)==T - ParamPath(:,ParamPathSizeVec(1,pp):ParamPathSizeVec(2,pp))=ParamPathStruct.(ParamPathNames{pp}); - else % Need to transpose - ParamPath(:,ParamPathSizeVec(1,pp):ParamPathSizeVec(2,pp))=ParamPathStruct.(ParamPathNames{pp})'; - end - end -end - -PricePath=struct(); +%% +[PricePath0,ParamPath,PricePathNames,ParamPathNames,PricePathSizeVec,ParamPathSizeVec,PricePathSizeVec_ii,ParamPathSizeVec_ii]=PricePathParamPath_FHorz_StructToMatrix(PricePath0,ParamPath,N_j,T,N_i); if transpathoptions.verbose>1 PricePathNames @@ -303,23 +197,6 @@ end end -%% -% PricePathSizeVec_ii=PricePathSizeVec;% Also need what size these are conditional on ptype (as some of PricePath/ParamPath may differ by ptype) [deal with this below] -PricePathSizeVec_ii(PricePathSizeVec_ii==PTypeStructure.N_i)=1; % Just use one of a price that depends on ptype -PricePathSizeVec_ii=cumsum(PricePathSizeVec_ii); -if length(PricePathNames)>1 - PricePathSizeVec_ii=[[1,PricePathSizeVec_ii(1:end-1)+1];PricePathSizeVec_ii]; -else - PricePathSizeVec_ii=[1;PricePathSizeVec_ii]; -end -% ParamPathSizeVec_ii=ParamPathSizeVec;% Also need what size these are conditional on ptype (as some of PricePath/ParamPath may differ by ptype) [deal with this below] -ParamPathSizeVec_ii(ParamPathSizeVec_ii==PTypeStructure.N_i)=1; % Just use one of a price that depends on ptype -ParamPathSizeVec_ii=cumsum(ParamPathSizeVec_ii); -if length(ParamPathNames)>1 - ParamPathSizeVec_ii=[[1,ParamPathSizeVec_ii(1:end-1)+1];ParamPathSizeVec_ii]; -else - ParamPathSizeVec_ii=[1;ParamPathSizeVec_ii]; -end %% Fill out all of PTypeStructure PTypeStructure.FnsAndPTypeIndicator=zeros(length(FnsToEvaluate),PTypeStructure.N_i,'gpuArray'); @@ -963,7 +840,7 @@ %% Which parts of ParamPath and PricePath relate to ptype ii % Some ParamPath and PricePath parameters may depend on ptype - PTypeStructure.(iistr).RelevantPricePath=ones(1,size(PricePathOld,2)); % start will all relevant + PTypeStructure.(iistr).RelevantPricePath=ones(1,size(PricePath0,2)); % start will all relevant for pp=1:length(PricePathNames) if PricePathSizeVec(2,pp)-PricePathSizeVec(1,pp)+1==PTypeStructure.N_i % This depends on ii, so only keep the ii-th one @@ -1000,11 +877,6 @@ end -%% -if transpathoptions.parallel==2 - PricePathOld=gpuArray(PricePathOld); -end - % GeneralEqmEqnNames=fieldnames(GeneralEqmEqns); % for gg=1:length(GeneralEqmEqnNames) % GeneralEqmEqnParamNames{gg}=getAnonymousFnInputNames(GeneralEqmEqns.(GeneralEqmEqnNames{gg})); @@ -1021,7 +893,7 @@ %% If using a shooting algorithm, set that up -transpathoptions=setupGEnewprice3_shooting(transpathoptions,GeneralEqmEqns,PricePathNames); +transpathoptions=setupGEnewprice3_shooting(transpathoptions,GeneralEqmEqns,PricePathNames,N_i,PricePathSizeVec); %% Check if using _tminus1 and/or _tplus1 variables. if isstruct(FnsToEvaluate) && isstruct(GeneralEqmEqns) @@ -1084,7 +956,7 @@ if transpathoptions.GEnewprice~=2 % For permanent type, there is just one shooting command, % because things like z,e, and fastOLG are handled on a per-PType basis (to permit that they differ across ptype) - [PricePathOld,GEcondnPath]=TransitionPath_Case1_FHorz_PType_shooting(PricePathOld, PricePathNames, ParamPath, ParamPathNames, T, V_final, AgentDist_init, jequalOneDist_T, AgeWeights_T, FnsToEvaluate, GeneralEqmEqns, PricePathSizeVec, ParamPathSizeVec, PricePathSizeVec_ii, ParamPathSizeVec_ii, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, PTypeStructure); + [PricePath,GEcondnPath]=TransitionPath_Case1_FHorz_PType_shooting(PricePath0, PricePathNames, ParamPath, ParamPathNames, T, V_final, AgentDist_init, jequalOneDist_T, AgeWeights_T, FnsToEvaluate, GeneralEqmEqns, PricePathSizeVec, ParamPathSizeVec, PricePathSizeVec_ii, ParamPathSizeVec_ii, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, PTypeStructure); % Switch the solution into structure for output. pp_indexinpricepath=zeros(1,length(PricePathNames)); @@ -1102,22 +974,22 @@ for pp=1:length(PricePathNames) if PTypeStructure.PricePath_Idependsonptype(pp)==0 - PricePath.(PricePathNames{pp})=PricePathOld(:,pp_indexinpricepath(pp)); + PricePathStruct.(PricePathNames{pp})=PricePath(:,pp_indexinpricepath(pp)); else if transpathoptions.PricePathptype_vectoroutput==1 - PricePath.(PricePathNames{pp})=PricePathOld(:,pp_indexinpricepath(pp):pp_indexinpricepath(pp)+PTypeStructure.N_i-1); + PricePathStruct.(PricePathNames{pp})=PricePath(:,pp_indexinpricepath(pp):pp_indexinpricepath(pp)+PTypeStructure.N_i-1); elseif transpathoptions.PricePathptype_vectoroutput==0 for ii=1:N_i - PricePath.(PricePathNames{pp}).(Names_i{ii})=PricePathOld(:,pp_indexinpricepath(pp)+ii-1); + PricePathStruct.(PricePathNames{pp}).(Names_i{ii})=PricePath(:,pp_indexinpricepath(pp)+ii-1); end end end end if nargout==1 - varargout={PricePath}; + varargout={PricePathStruct}; elseif nargout==2 - varargout={PricePath,GEcondnPath}; + varargout={PricePathStruct,GEcondnPath}; end return @@ -1131,9 +1003,9 @@ error('Have not yet implemented transpathoptions.GEnewprice=2') if nargout==1 - varargout={PricePath}; + varargout={PricePathStruct}; elseif nargout==2 - varargout={PricePath,GEcondnPath}; + varargout={PricePathStruct,GEcondnPath}; end end diff --git a/TransitionPaths/FHorz/PType/TransitionPath_FHorz_PType_singlepath.m b/TransitionPaths/FHorz/PType/TransitionPath_FHorz_PType_singlepath.m index bbaa6a47..4c06a4c4 100644 --- a/TransitionPaths/FHorz/PType/TransitionPath_FHorz_PType_singlepath.m +++ b/TransitionPaths/FHorz/PType/TransitionPath_FHorz_PType_singlepath.m @@ -484,7 +484,7 @@ end % transpathoptions.zpathtrivial==1 % Does not depend on tt - [V, Policy]=ValueFnIter_Case1_FHorz_TPath_SingleStep_fastOLG(V,n_d,n_a,n_z,N_j,d_grid, a_grid, z_gridvals_J, pi_z_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + [V, Policy]=ValueFnIter_FHorz_TPath_SingleStep_fastOLG(V,n_d,n_a,n_z,N_j,d_grid, a_grid, z_gridvals_J, pi_z_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); % The VKron input is next period value fn, the VKron output is this period. % Policy in fastOLG is [N_a,N_j,N_z] and contains the joint-index for (d,aprime) diff --git a/TransitionPaths/InfHorz/PType/TransitionPath_Case1_PType.m b/TransitionPaths/InfHorz/PType/TransitionPath_Case1_PType.m index b3bb1c20..37902699 100644 --- a/TransitionPaths/InfHorz/PType/TransitionPath_Case1_PType.m +++ b/TransitionPaths/InfHorz/PType/TransitionPath_Case1_PType.m @@ -1,27 +1,9 @@ -function varargout=TransitionPath_Case1_PType(PricePathOld, ParamPath, T, V_final, StationaryDist_init, n_d, n_a, n_z, Names_i, d_grid,a_grid,z_grid, pi_z, ReturnFn, FnsToEvaluate, GeneralEqmEqns, Parameters, DiscountFactorParamNames, transpathoptions, simoptions, vfoptions) +function varargout=TransitionPath_Case1_PType(PricePath0, ParamPath, T, V_final, StationaryDist_init, n_d, n_a, n_z, Names_i, d_grid,a_grid,z_grid, pi_z, ReturnFn, FnsToEvaluate, GeneralEqmEqns, Parameters, DiscountFactorParamNames, transpathoptions, simoptions, vfoptions) % PricePathOld is a structure with fields names being the Prices and each field containing a T-by-1 path. % ParamPath is a structure with fields names being the parameter names of those parameters which change over the path and each field containing a T-by-1 path. % Remark to self: No real need for T as input, as this is anyway the length of PricePathOld -% Note: Internally PricePathOld is matrix of size T-by-'number of prices'. -% ParamPath is matrix of size T-by-'number of parameters that change over the transition path'. -PricePathNames=fieldnames(PricePathOld); -PricePathStruct=PricePathOld; -PricePathOld=zeros(T,length(PricePathNames)); -for ii=1:length(PricePathNames) - PricePathOld(:,ii)=PricePathStruct.(PricePathNames{ii}); -end -ParamPathNames=fieldnames(ParamPath); -ParamPathStruct=ParamPath; -ParamPath=zeros(T,length(ParamPathNames)); -for ii=1:length(ParamPathNames) - ParamPath(:,ii)=ParamPathStruct.(ParamPathNames{ii}); -end - -PricePath=struct(); - - % PricePathOld, ParamPath, T, V_final, StationaryDist_init, GeneralEqmEqns, GeneralEqmEqnParamNames %% Check which transpathoptions have been used, set all others to defaults @@ -133,6 +115,11 @@ end end +%% Internally PricePath is matrix of size T-by-'number of prices'. +% ParamPath is matrix of size T-by-'number of parameters that change over the transition path'. +[PricePath0,ParamPath,PricePathNames,ParamPathNames,PricePathSizeVec,ParamPathSizeVec,PricePathSizeVec_ii,ParamPathSizeVec_ii]=PricePathParamPath_StructToMatrix(PricePath0,ParamPath,T, N_i); + + %% Create PTypeStructure % PTypeStructure.Names_i never really gets used. Just makes things easier @@ -525,48 +512,40 @@ error('transpathoptions.usestockvars=1 not yet implemented with PType \n') end -if transpathoptions.verbose==1 - fprintf('Completed setup, beginning transition computination \n') -end - %% If using a shooting algorithm, set that up -transpathoptions=setupGEnewprice3_shooting(options,GeneralEqmEqns,PricePathNames); +transpathoptions=setupGEnewprice3_shooting(options,GeneralEqmEqns,PricePathNames,N_i,PricePathSizeVec); %% if transpathoptions.verbose==1 transpathoptions + fprintf('Completed setup, beginning transition computation \n') end %% if transpathoptions.GEnewprice~=2 - if transpathoptions.parallel==2 - if transpathoptions.usestockvars==0 - if ~isfield(vfoptions,'n_e') - [PricePathOld,GEcondnPath]=TransitionPath_InfHorz_PType_shooting(PricePathOld, PricePathNames, ParamPath, ParamPathNames, T, V_final, StationaryDist_init, FnsToEvaluate, GeneralEqmEqns, transpathoptions, PTypeStructure); - else - error('Cannot use e variables with infinite horizon (contact me if you need this)') - % PricePathOld=TransitionPath_Case1_PType_e_shooting(PricePathOld, PricePathNames, ParamPath, ParamPathNames, T, V_final, StationaryDist_init, FnsToEvaluate, GeneralEqmEqns, transpathoptions, PTypeStructure); - end + if transpathoptions.usestockvars==0 + if ~isfield(vfoptions,'n_e') + [PricePath,GEcondnPath]=TransitionPath_InfHorz_PType_shooting(PricePath0, PricePathNames, ParamPath, ParamPathNames, T, V_final, StationaryDist_init, FnsToEvaluate, GeneralEqmEqns, transpathoptions, PTypeStructure); + else + error('Cannot use e variables with infinite horizon (contact me if you need this)') + % PricePathOld=TransitionPath_Case1_PType_e_shooting(PricePathOld, PricePathNames, ParamPath, ParamPathNames, T, V_final, StationaryDist_init, FnsToEvaluate, GeneralEqmEqns, transpathoptions, PTypeStructure); end - else - error('transpathoptions can only be used on GPU (transpathoptions.parallel=2) \n') end % Switch the solution into structure for output. for ii=1:length(PricePathNames) - PricePath.(PricePathNames{ii})=PricePathOld(:,ii); + PricePathStruct.(PricePathNames{ii})=PricePath(:,ii); end if nargout==1 - varargout={PricePath}; + varargout={PricePathStruct}; elseif nargout==2 - varargout={PricePath,GEcondnPath}; + varargout={PricePathStruct,GEcondnPath}; end return end - if transpathoptions.GEnewprice==2 % NOT IMPLEMENTED diff --git a/TransitionPaths/InfHorz/PType/TransitionPath_InfHorz_PType_shooting.m b/TransitionPaths/InfHorz/PType/TransitionPath_InfHorz_PType_shooting.m index cccc7190..ffa4987c 100644 --- a/TransitionPaths/InfHorz/PType/TransitionPath_InfHorz_PType_shooting.m +++ b/TransitionPaths/InfHorz/PType/TransitionPath_InfHorz_PType_shooting.m @@ -19,13 +19,8 @@ title('Price Path') plot(PricePathOld) legend(PricePathNames{:}) - -% timeperiodstoplot=[1,2,3,round(T/3),round(T/2),round(2*T/3),T-2,T-1,T]; end -PricePathDist=Inf; -pathcounter=1; - AgentDist_initial.ptweights=StationaryDist_init.ptweights; for ii=1:PTypeStructure.N_i iistr=PTypeStructure.Names_i{ii}; @@ -38,15 +33,12 @@ PricePathNew=zeros(size(PricePathOld),'gpuArray'); PricePathNew(T,:)=PricePathOld(T,:); GEcondnPath=zeros(T-1,length(GEeqnNames),'gpuArray'); -if transpathoptions.verbose==1 - ParamPathNames - PricePathNames -end +%% Iterate on the transition path +PricePathDist=Inf; +pathcounter=1; while PricePathDist>transpathoptions.tolerance && pathcounter1 - PricePathSizeVec=[[1,PricePathSizeVec(1:end-1)+1];PricePathSizeVec]; -else - PricePathSizeVec=[1;PricePathSizeVec]; -end -PricePath=zeros(T,PricePathSizeVec(2,end));% Do this seperately afterwards so that can preallocate the memory -for pp=1:length(PricePathNames) - if size(PricePathStruct.(PricePathNames{pp}),1)==T - PricePath(:,PricePathSizeVec(1,pp):PricePathSizeVec(2,pp))=PricePathStruct.(PricePathNames{pp}); - else % Need to transpose - PricePath(:,PricePathSizeVec(1,pp):PricePathSizeVec(2,pp))=PricePathStruct.(PricePathNames{pp})'; + PricePathSizeVec=cumsum(PricePathSizeVec); + if length(PricePathNames)>1 + PricePathSizeVec=[[1,PricePathSizeVec(1:end-1)+1];PricePathSizeVec]; + else + PricePathSizeVec=[1;PricePathSizeVec]; end -end -% ParamPath is matrix of size T-by-'number of parameters that change over the transition path'. -% Actually, some of those prices may be 1-by-N_j, so is more subtle than this. -ParamPathNames=fieldnames(ParamPathStruct); -ParamPathSizeVec=zeros(1,length(ParamPathNames)); % Allows for a given price param to depend on age (or permanent type) -for pp=1:length(ParamPathNames) - temp=ParamPathStruct.(ParamPathNames{pp}); - tempsize=size(temp); - ParamPathSizeVec(pp)=tempsize(tempsize~=T); % Get the dimension which is not T - if ~any(ParamPathSizeVec(pp)==[1,N_j]) - error(['ParamPath for ', ParamPathNames{pp}, ' appears to be the wrong size (should be 1-by-T or N_j-by-T)']) + PricePath=zeros(T,PricePathSizeVec(2,end));% Do this seperately afterwards so that can preallocate the memory + for pp=1:length(PricePathNames) + if size(PricePathStruct.(PricePathNames{pp}),1)==T + PricePath(:,PricePathSizeVec(1,pp):PricePathSizeVec(2,pp))=PricePathStruct.(PricePathNames{pp}); + else % Need to transpose + PricePath(:,PricePathSizeVec(1,pp):PricePathSizeVec(2,pp))=PricePathStruct.(PricePathNames{pp})'; + end end -end -ParamPathSizeVec=cumsum(ParamPathSizeVec); -if length(ParamPathNames)>1 - ParamPathSizeVec=[[1,ParamPathSizeVec(1:end-1)+1];ParamPathSizeVec]; + % ParamPath is matrix of size T-by-'number of parameters that change over the transition path'. + % Actually, some of those prices may be 1-by-N_j, so is more subtle than this. + ParamPathNames=fieldnames(ParamPathStruct); + ParamPathSizeVec=zeros(1,length(ParamPathNames)); % Allows for a given price param to depend on age (or permanent type) + for pp=1:length(ParamPathNames) + temp=ParamPathStruct.(ParamPathNames{pp}); + tempsize=size(temp); + ParamPathSizeVec(pp)=tempsize(tempsize~=T); % Get the dimension which is not T + if ~any(ParamPathSizeVec(pp)==[1,N_j]) + error(['ParamPath for ', ParamPathNames{pp}, ' appears to be the wrong size (should be 1-by-T or N_j-by-T)']) + end + end + ParamPathSizeVec=cumsum(ParamPathSizeVec); + if length(ParamPathNames)>1 + ParamPathSizeVec=[[1,ParamPathSizeVec(1:end-1)+1];ParamPathSizeVec]; + else + ParamPathSizeVec=[1;ParamPathSizeVec]; + end + ParamPath=zeros(T,ParamPathSizeVec(2,end));% Do this seperately afterwards so that can preallocate the memory + for pp=1:length(ParamPathNames) + if size(ParamPathStruct.(ParamPathNames{pp}),1)==T + ParamPath(:,ParamPathSizeVec(1,pp):ParamPathSizeVec(2,pp))=ParamPathStruct.(ParamPathNames{pp}); + else % Need to transpose + ParamPath(:,ParamPathSizeVec(1,pp):ParamPathSizeVec(2,pp))=ParamPathStruct.(ParamPathNames{pp})'; + end + end + + varargout={PricePath,ParamPath,PricePathNames,ParamPathNames,PricePathSizeVec,ParamPathSizeVec}; + else - ParamPathSizeVec=[1;ParamPathSizeVec]; -end -ParamPath=zeros(T,ParamPathSizeVec(2,end));% Do this seperately afterwards so that can preallocate the memory -for pp=1:length(ParamPathNames) - if size(ParamPathStruct.(ParamPathNames{pp}),1)==T - ParamPath(:,ParamPathSizeVec(1,pp):ParamPathSizeVec(2,pp))=ParamPathStruct.(ParamPathNames{pp}); - else % Need to transpose - ParamPath(:,ParamPathSizeVec(1,pp):ParamPathSizeVec(2,pp))=ParamPathStruct.(ParamPathNames{pp})'; + %% With permanent types (need to allow for parameters to depend on permanent type) + % Note: Internally PricePathOld is matrix of size T-by-'number of prices'. + % ParamPath is matrix of size T-by-'number of parameters that change over the transition path'. + % Actually, some of those prices are 1-by-N_j or N_i or both, so is more subtle than this. + PricePathNames=fieldnames(PricePathStruct); + PricePathSizeVec=zeros(1,length(PricePathNames)); % Allows for a given price param to depend on age (or permanent type) + for pp=1:length(PricePathNames) + if isstruct(PricePathStruct.(PricePathNames{pp})) + tempptypenames=fieldnames(PricePathStruct.(PricePathNames{pp})); + temp=PricePathStruct.(PricePathNames{pp}).(tempptypenames{1}); + tempsize=size(temp); + PricePathSizeVec(pp)=length(tempptypenames)*tempsize(tempsize~=T); % Get the dimension which is not T + if ~any(PricePathSizeVec(pp)==[1,N_i,N_j,N_i*N_j]) + error(['PricePath for ', PricePathNames{pp}, ' appears to be the wrong size (should be 1-by-T or N_j-by-T or N_i-by-T)']) + end + else + temp=PricePathStruct.(PricePathNames{pp}); + tempsize=size(temp); + PricePathSizeVec(pp)=tempsize(tempsize~=T); % Get the dimension which is not T + if ~any(PricePathSizeVec(pp)==[1,N_i,N_j]) + error(['PricePath for ', PricePathNames{pp}, ' appears to be the wrong size (should be 1-by-T or N_j-by-T or N_i-by-T)']) + end + end end -end + % Also need what size these are conditional on ptype (as some of PricePath/ParamPath may differ by ptype) + PricePathSizeVec_ii=PricePathSizeVec; + PricePathSizeVec_ii(PricePathSizeVec_ii==N_i)=1; % Just use one of a price that depends on ptype + PricePathSizeVec_ii=cumsum(PricePathSizeVec_ii); + if length(PricePathNames)>1 + PricePathSizeVec_ii=[[1,PricePathSizeVec_ii(1:end-1)+1];PricePathSizeVec_ii]; + else + PricePathSizeVec_ii=[1;PricePathSizeVec_ii]; + end + + PricePathSizeVec=cumsum(PricePathSizeVec); + if length(PricePathNames)>1 + PricePathSizeVec=[[1,PricePathSizeVec(1:end-1)+1];PricePathSizeVec]; + else + PricePathSizeVec=[1;PricePathSizeVec]; + end + PricePath=zeros(T,PricePathSizeVec(2,end)); % Do this seperately afterwards so that can preallocate the memory + for pp=1:length(PricePathNames) + if isstruct(PricePathStruct.(PricePathNames{pp})) % depends on ptype as structure + tempptypenames=fieldnames(PricePathStruct.(PricePathNames{pp})); + for ii=1:length(tempptypenames) + if size(PricePathStruct.(PricePathNames{pp}).(tempptypenames{ii}),1)==T % Note: size(PricePathStruct.(PricePathNames{pp}),2) will be 1 or N_j + PricePath(:,PricePathSizeVec(1,pp)+(ii-1)*size(PricePathStruct.(PricePathNames{pp}).(tempptypenames{ii}),2):PricePathSizeVec(1,pp)-1+ii*size(PricePathStruct.(PricePathNames{pp}).(tempptypenames{ii}),2))=PricePathStruct.(PricePathNames{pp}).(tempptypenames{ii}); + else % Need to transpose + PricePath(:,PricePathSizeVec(1,pp)+(ii-1)*size(PricePathStruct.(PricePathNames{pp}).(tempptypenames{ii}),1):PricePathSizeVec(1,pp)-1+ii*size(PricePathStruct.(PricePathNames{pp}).(tempptypenames{ii}),1))=PricePathStruct.(PricePathNames{pp}).(tempptypenames{ii})'; + end + end + else + if size(PricePathStruct.(PricePathNames{pp}),1)==T + PricePath(:,PricePathSizeVec(1,pp):PricePathSizeVec(2,pp))=PricePathStruct.(PricePathNames{pp}); + else % Need to transpose + PricePath(:,PricePathSizeVec(1,pp):PricePathSizeVec(2,pp))=PricePathStruct.(PricePathNames{pp})'; + end + end + end + + ParamPathNames=fieldnames(ParamPathStruct); + ParamPathSizeVec=zeros(1,length(ParamPathNames)); % Allows for a given price param to depend on age (or permanent type) + for pp=1:length(ParamPathNames) + if isstruct(ParamPathStruct.(ParamPathNames{pp})) + tempptypenames=fieldnames(PricePathStruct.(PricePathNames{pp})); + temp=ParamPathStruct.(ParamPathNames{pp}).*(tempptypenames{1}); + tempsize=size(temp); + ParamPathSizeVec(pp)=length(tempptypenames)*tempsize(tempsize~=T); % Get the dimension which is not T + if ~any(ParamPathSizeVec(pp)==[1,N_i,N_j,N_i*N_j]) + error(['ParamPath for ', ParamPathNames{pp}, ' appears to be the wrong size (should be 1-by-T or N_j-by-T or N_i-by-T)']) + end + + else + temp=ParamPathStruct.(ParamPathNames{pp}); + tempsize=size(temp); + ParamPathSizeVec(pp)=tempsize(tempsize~=T); % Get the dimension which is not T + if ~any(ParamPathSizeVec(pp)==[1,N_i,N_j]) + error(['ParamPath for ', ParamPathNames{pp}, ' appears to be the wrong size (should be 1-by-T or N_j-by-T or N_i-by-T)']) + end + end + end + + % Also need what size these are conditional on ptype (as some of PricePath/ParamPath may differ by ptype) + ParamPathSizeVec_ii=ParamPathSizeVec; + ParamPathSizeVec_ii(ParamPathSizeVec_ii==N_i)=1; % Just use one of a price that depends on ptype + ParamPathSizeVec_ii=cumsum(ParamPathSizeVec_ii); + if length(ParamPathNames)>1 + ParamPathSizeVec_ii=[[1,ParamPathSizeVec_ii(1:end-1)+1];ParamPathSizeVec_ii]; + else + ParamPathSizeVec_ii=[1;ParamPathSizeVec_ii]; + end + + ParamPathSizeVec=cumsum(ParamPathSizeVec); + if length(ParamPathNames)>1 + ParamPathSizeVec=[[1,ParamPathSizeVec(1:end-1)+1];ParamPathSizeVec]; + else + ParamPathSizeVec=[1;ParamPathSizeVec]; + end + ParamPath=zeros(T,ParamPathSizeVec(2,end));% Do this seperately afterwards so that can preallocate the memory + for pp=1:length(ParamPathNames) + if isstruct(ParamPathStruct.(ParamPathNames{pp})) + tempptypenames=fieldnames(ParamPathStruct.(ParamPathNames{pp})); + for ii=1:length(tempptypenames) + if size(ParamPathStruct.(ParamPathNames{pp}).(tempptypenames{ii}),1)==T % Note: size(PricePathStruct.(PricePathNames{pp}),2) will be 1 or N_j + ParamPath(:,ParamPathSizeVec(1,pp)+(ii-1)*size(ParamPathStruct.(ParamPathNames{pp}).(tempptypenames{ii}),2):ParamPathSizeVec(1,pp)-1+ii*size(ParamPathStruct.(ParamPathNames{pp}).(tempptypenames{ii}),2))=ParamPathStruct.(ParamPathNames{pp}).(tempptypenames{ii}); + else % Need to transpose + ParamPath(:,ParamPathSizeVec(1,pp)+(ii-1)*size(ParamPathStruct.(ParamPathNames{pp}).(tempptypenames{ii}),1):ParamPathSizeVec(1,pp)-1+ii*size(ParamPathStruct.(ParamPathNames{pp}).(tempptypenames{ii}),1))=ParamPathStruct.(ParamPathNames{pp}).(tempptypenames{ii})'; + end + end + else + if size(ParamPathStruct.(ParamPathNames{pp}),1)==T + ParamPath(:,ParamPathSizeVec(1,pp):ParamPathSizeVec(2,pp))=ParamPathStruct.(ParamPathNames{pp}); + else % Need to transpose + ParamPath(:,ParamPathSizeVec(1,pp):ParamPathSizeVec(2,pp))=ParamPathStruct.(ParamPathNames{pp})'; + end + end + end + + varargout={PricePath,ParamPath,PricePathNames,ParamPathNames,PricePathSizeVec,ParamPathSizeVec,PricePathSizeVec_ii,ParamPathSizeVec_ii}; +end end \ No newline at end of file diff --git a/TransitionPaths/Subcodes/PricePathParamPath_StructToMatrix.m b/TransitionPaths/Subcodes/PricePathParamPath_StructToMatrix.m index 447bb36a..a92e861e 100644 --- a/TransitionPaths/Subcodes/PricePathParamPath_StructToMatrix.m +++ b/TransitionPaths/Subcodes/PricePathParamPath_StructToMatrix.m @@ -1,39 +1,160 @@ -function [PricePath,ParamPath,PricePathNames,ParamPathNames,PricePathSizeVec,ParamPathSizeVec]=PricePathParamPath_StructToMatrix(PricePathStruct,ParamPathStruct,T) - +function varargout=PricePathParamPath_StructToMatrix(PricePathStruct,ParamPathStruct,T,N_i) +% varargout={PricePath,ParamPath,PricePathNames,ParamPathNames,PricePathSizeVec,ParamPathSizeVec} +% but for models with permanent types, include N_i as input and get +% varargout={PricePath,ParamPath,PricePathNames,ParamPathNames,PricePathSizeVec,ParamPathSizeVec,PricePathSizeVec_ii,ParamPathSizeVec_ii} +% +% N_i is an optional input, only used for models with permanent type +% PricePathSizeVec_ii,ParamPathSizeVec_ii are only output for models with permanent type +% +% N_i is an optional input, only used for models with permanent types % Note: Internally PricePath is matrix of size T-by-'number of prices'. % ParamPath is matrix of size T-by-'number of parameters that change over the transition path'. -PricePathNames=fieldnames(PricePathStruct); -PricePathSizeVec=zeros(1,length(PricePathNames)); % Allows for a given price param to depend on age (or permanent type) -for pp=1:length(PricePathNames) - temp=PricePathStruct.(PricePathNames{pp}); - tempsize=size(temp); - PricePathSizeVec(pp)=tempsize(tempsize~=T); % Get the dimension which is not T -end -PricePathSizeVec=cumsum(PricePathSizeVec); -if length(PricePathNames)>1 - PricePathSizeVec=[[1,PricePathSizeVec(1:end-1)+1];PricePathSizeVec]; +if ~exist('N_i','var') + PricePathNames=fieldnames(PricePathStruct); + PricePathSizeVec=zeros(1,length(PricePathNames)); % Allows for a given price param to depend on age (or permanent type) + for pp=1:length(PricePathNames) + temp=PricePathStruct.(PricePathNames{pp}); + tempsize=size(temp); + PricePathSizeVec(pp)=tempsize(tempsize~=T); % Get the dimension which is not T + end + PricePathSizeVec=cumsum(PricePathSizeVec); + if length(PricePathNames)>1 + PricePathSizeVec=[[1,PricePathSizeVec(1:end-1)+1];PricePathSizeVec]; + else + PricePathSizeVec=[1;PricePathSizeVec]; + end + PricePath=zeros(T,PricePathSizeVec(2,end));% Do this seperately afterwards so that can preallocate the memory + for pp=1:length(PricePathNames) + if size(PricePathStruct.(PricePathNames{pp}),1)==T + PricePath(:,PricePathSizeVec(1,pp):PricePathSizeVec(2,pp))=PricePathStruct.(PricePathNames{pp}); + else % Need to transpose + PricePath(:,PricePathSizeVec(1,pp):PricePathSizeVec(2,pp))=PricePathStruct.(PricePathNames{pp})'; + end + end + + ParamPathNames=fieldnames(ParamPathStruct); + if ~isempty(ParamPathNames) + ParamPathSizeVec=zeros(1,length(ParamPathNames)); % Allows for a given price param to depend on age (or permanent type) + for pp=1:length(ParamPathNames) + temp=ParamPathStruct.(ParamPathNames{pp}); + tempsize=size(temp); + ParamPathSizeVec(pp)=tempsize(tempsize~=T); % Get the dimension which is not T + end + ParamPathSizeVec=cumsum(ParamPathSizeVec); + if length(ParamPathNames)>1 + ParamPathSizeVec=[[1,ParamPathSizeVec(1:end-1)+1];ParamPathSizeVec]; + else + ParamPathSizeVec=[1;ParamPathSizeVec]; + end + ParamPath=zeros(T,ParamPathSizeVec(2,end));% Do this seperately afterwards so that can preallocate the memory + for pp=1:length(ParamPathNames) + if size(ParamPathStruct.(ParamPathNames{pp}),1)==T + ParamPath(:,ParamPathSizeVec(1,pp):ParamPathSizeVec(2,pp))=ParamPathStruct.(ParamPathNames{pp}); + else % Need to transpose + ParamPath(:,ParamPathSizeVec(1,pp):ParamPathSizeVec(2,pp))=ParamPathStruct.(ParamPathNames{pp})'; + end + end + else + ParamPathSizeVec=[]; + ParamPath=[]; + end + + varargout={PricePath,ParamPath,PricePathNames,ParamPathNames,PricePathSizeVec,ParamPathSizeVec}; else - PricePathSizeVec=[1;PricePathSizeVec]; -end -PricePath=zeros(T,PricePathSizeVec(2,end));% Do this seperately afterwards so that can preallocate the memory -for pp=1:length(PricePathNames) - if size(PricePathStruct.(PricePathNames{pp}),1)==T - PricePath(:,PricePathSizeVec(1,pp):PricePathSizeVec(2,pp))=PricePathStruct.(PricePathNames{pp}); - else % Need to transpose - PricePath(:,PricePathSizeVec(1,pp):PricePathSizeVec(2,pp))=PricePathStruct.(PricePathNames{pp})'; - end - % PricePath(:,ii)=PricePathStruct.(PricePathNames{ii}); -end + %% With permanent types (need to allow for parameters to depend on permanent type) + % Note: Internally PricePathOld is matrix of size T-by-'number of prices'. + % ParamPath is matrix of size T-by-'number of parameters that change over the transition path'. + % Actually, some of those prices are 1-by-N_i, so is more subtle than this. + PricePathNames=fieldnames(PricePathStruct); + PricePathSizeVec=zeros(1,length(PricePathNames)); % Allows for a given price param to depend on age (or permanent type) + for pp=1:length(PricePathNames) + if isstruct(PricePathStruct.(PricePathNames{pp})) + tempptypenames=fieldnames(PricePathStruct.(PricePathNames{pp})); + temp=PricePathStruct.(PricePathNames{pp}).(tempptypenames{1}); + tempsize=size(temp); + PricePathSizeVec(pp)=length(tempptypenames)*tempsize(tempsize~=T); % Get the dimension which is not T + if ~any(PricePathSizeVec(pp)==[1,N_i]) + error(['PricePath for ', PricePathNames{pp}, ' appears to be the wrong size (should be 1-by-T or N_i-by-T)']) + end + else + temp=PricePathStruct.(PricePathNames{pp}); + tempsize=size(temp); + PricePathSizeVec(pp)=tempsize(tempsize~=T); % Get the dimension which is not T + if ~any(PricePathSizeVec(pp)==[1,N_i]) + error(['PricePath for ', PricePathNames{pp}, ' appears to be the wrong size (should be 1-by-T or N_i-by-T)']) + end + end + end -ParamPathNames=fieldnames(ParamPathStruct); -if ~isempty(ParamPathNames) + % Also need what size these are conditional on ptype (as some of PricePath/ParamPath may differ by ptype) + PricePathSizeVec_ii=PricePathSizeVec; + PricePathSizeVec_ii(PricePathSizeVec_ii==N_i)=1; % Just use one of a price that depends on ptype + PricePathSizeVec_ii=cumsum(PricePathSizeVec_ii); + if length(PricePathNames)>1 + PricePathSizeVec_ii=[[1,PricePathSizeVec_ii(1:end-1)+1];PricePathSizeVec_ii]; + else + PricePathSizeVec_ii=[1;PricePathSizeVec_ii]; + end + + PricePathSizeVec=cumsum(PricePathSizeVec); + if length(PricePathNames)>1 + PricePathSizeVec=[[1,PricePathSizeVec(1:end-1)+1];PricePathSizeVec]; + else + PricePathSizeVec=[1;PricePathSizeVec]; + end + PricePath=zeros(T,PricePathSizeVec(2,end)); % Do this seperately afterwards so that can preallocate the memory + for pp=1:length(PricePathNames) + if isstruct(PricePathStruct.(PricePathNames{pp})) % depends on ptype as structure + tempptypenames=fieldnames(PricePathStruct.(PricePathNames{pp})); + for ii=1:length(tempptypenames) + if size(PricePathStruct.(PricePathNames{pp}).(tempptypenames{ii}),1)==T % Note: size(PricePathStruct.(PricePathNames{pp}),2) will be 1 or N_i + PricePath(:,PricePathSizeVec(1,pp)+(ii-1)*size(PricePathStruct.(PricePathNames{pp}).(tempptypenames{ii}),2):PricePathSizeVec(1,pp)-1+ii*size(PricePathStruct.(PricePathNames{pp}).(tempptypenames{ii}),2))=PricePathStruct.(PricePathNames{pp}).(tempptypenames{ii}); + else % Need to transpose + PricePath(:,PricePathSizeVec(1,pp)+(ii-1)*size(PricePathStruct.(PricePathNames{pp}).(tempptypenames{ii}),1):PricePathSizeVec(1,pp)-1+ii*size(PricePathStruct.(PricePathNames{pp}).(tempptypenames{ii}),1))=PricePathStruct.(PricePathNames{pp}).(tempptypenames{ii})'; + end + end + else + if size(PricePathStruct.(PricePathNames{pp}),1)==T + PricePath(:,PricePathSizeVec(1,pp):PricePathSizeVec(2,pp))=PricePathStruct.(PricePathNames{pp}); + else % Need to transpose + PricePath(:,PricePathSizeVec(1,pp):PricePathSizeVec(2,pp))=PricePathStruct.(PricePathNames{pp})'; + end + end + end + + ParamPathNames=fieldnames(ParamPathStruct); ParamPathSizeVec=zeros(1,length(ParamPathNames)); % Allows for a given price param to depend on age (or permanent type) for pp=1:length(ParamPathNames) - temp=ParamPathStruct.(ParamPathNames{pp}); - tempsize=size(temp); - ParamPathSizeVec(pp)=tempsize(tempsize~=T); % Get the dimension which is not T + if isstruct(ParamPathStruct.(ParamPathNames{pp})) + tempptypenames=fieldnames(PricePathStruct.(PricePathNames{pp})); + temp=ParamPathStruct.(ParamPathNames{pp}).*(tempptypenames{1}); + tempsize=size(temp); + ParamPathSizeVec(pp)=length(tempptypenames)*tempsize(tempsize~=T); % Get the dimension which is not T + if ~any(ParamPathSizeVec(pp)==[1,N_i]) + error(['ParamPath for ', ParamPathNames{pp}, ' appears to be the wrong size (should be 1-by-T or N_i-by-T)']) + end + + else + temp=ParamPathStruct.(ParamPathNames{pp}); + tempsize=size(temp); + ParamPathSizeVec(pp)=tempsize(tempsize~=T); % Get the dimension which is not T + if ~any(ParamPathSizeVec(pp)==[1,N_i]) + error(['ParamPath for ', ParamPathNames{pp}, ' appears to be the wrong size (should be 1-by-T or N_i-by-T)']) + end + end + end + + % Also need what size these are conditional on ptype (as some of PricePath/ParamPath may differ by ptype) + ParamPathSizeVec_ii=ParamPathSizeVec; + ParamPathSizeVec_ii(ParamPathSizeVec_ii==N_i)=1; % Just use one of a price that depends on ptype + ParamPathSizeVec_ii=cumsum(ParamPathSizeVec_ii); + if length(ParamPathNames)>1 + ParamPathSizeVec_ii=[[1,ParamPathSizeVec_ii(1:end-1)+1];ParamPathSizeVec_ii]; + else + ParamPathSizeVec_ii=[1;ParamPathSizeVec_ii]; end + ParamPathSizeVec=cumsum(ParamPathSizeVec); if length(ParamPathNames)>1 ParamPathSizeVec=[[1,ParamPathSizeVec(1:end-1)+1];ParamPathSizeVec]; @@ -42,16 +163,25 @@ end ParamPath=zeros(T,ParamPathSizeVec(2,end));% Do this seperately afterwards so that can preallocate the memory for pp=1:length(ParamPathNames) - if size(ParamPathStruct.(ParamPathNames{pp}),1)==T - ParamPath(:,ParamPathSizeVec(1,pp):ParamPathSizeVec(2,pp))=ParamPathStruct.(ParamPathNames{pp}); - else % Need to transpose - ParamPath(:,ParamPathSizeVec(1,pp):ParamPathSizeVec(2,pp))=ParamPathStruct.(ParamPathNames{pp})'; + if isstruct(ParamPathStruct.(ParamPathNames{pp})) + tempptypenames=fieldnames(ParamPathStruct.(ParamPathNames{pp})); + for ii=1:length(tempptypenames) + if size(ParamPathStruct.(ParamPathNames{pp}).(tempptypenames{ii}),1)==T % Note: size(PricePathStruct.(PricePathNames{pp}),2) will be 1 or N_i + ParamPath(:,ParamPathSizeVec(1,pp)+(ii-1)*size(ParamPathStruct.(ParamPathNames{pp}).(tempptypenames{ii}),2):ParamPathSizeVec(1,pp)-1+ii*size(ParamPathStruct.(ParamPathNames{pp}).(tempptypenames{ii}),2))=ParamPathStruct.(ParamPathNames{pp}).(tempptypenames{ii}); + else % Need to transpose + ParamPath(:,ParamPathSizeVec(1,pp)+(ii-1)*size(ParamPathStruct.(ParamPathNames{pp}).(tempptypenames{ii}),1):ParamPathSizeVec(1,pp)-1+ii*size(ParamPathStruct.(ParamPathNames{pp}).(tempptypenames{ii}),1))=ParamPathStruct.(ParamPathNames{pp}).(tempptypenames{ii})'; + end + end + else + if size(ParamPathStruct.(ParamPathNames{pp}),1)==T + ParamPath(:,ParamPathSizeVec(1,pp):ParamPathSizeVec(2,pp))=ParamPathStruct.(ParamPathNames{pp}); + else % Need to transpose + ParamPath(:,ParamPathSizeVec(1,pp):ParamPathSizeVec(2,pp))=ParamPathStruct.(ParamPathNames{pp})'; + end end - % ParamPath(:,pp)=ParamPathStruct.(ParamPathNames{pp}); end -else - ParamPathSizeVec=[]; - ParamPath=[]; + + varargout={PricePath,ParamPath,PricePathNames,ParamPathNames,PricePathSizeVec,ParamPathSizeVec,PricePathSizeVec_ii,ParamPathSizeVec_ii}; end From 08462f1f3fbe974c456794b40e8838c18e4699d1 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Thu, 22 Jan 2026 11:09:47 +1300 Subject: [PATCH 24/67] minor --- .../HeteroAgentStationaryEqm_Case1_FHorz.m | 10 +- Optimization/setupGEnewprice3_shooting.m | 15 +- .../PType/TransitionPath_Case1_FHorz_PType.m | 33 +- ...ransitionPath_Case1_FHorz_PType_shooting.m | 5 +- .../TransitionPath_FHorz_PType_singlepath.m | 715 +----------------- ...nsitionPath_FHorz_PType_singlepath_e_raw.m | 208 +++++ ...ath_FHorz_PType_singlepath_fastOLG_e_raw.m | 172 +++++ ...FHorz_PType_singlepath_fastOLG_noz_e_raw.m | 163 ++++ ...h_FHorz_PType_singlepath_fastOLG_noz_raw.m | 151 ++++ ...nPath_FHorz_PType_singlepath_fastOLG_raw.m | 163 ++++ ...ionPath_FHorz_PType_singlepath_noz_e_raw.m | 191 +++++ ...itionPath_FHorz_PType_singlepath_noz_raw.m | 174 +++++ ...ransitionPath_FHorz_PType_singlepath_raw.m | 201 +++++ 13 files changed, 1491 insertions(+), 710 deletions(-) create mode 100644 TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_e_raw.m create mode 100644 TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_e_raw.m create mode 100644 TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_noz_e_raw.m create mode 100644 TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_noz_raw.m create mode 100644 TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_raw.m create mode 100644 TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_noz_e_raw.m create mode 100644 TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_noz_raw.m create mode 100644 TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_raw.m diff --git a/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m b/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m index e0584700..b1ebae79 100644 --- a/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m +++ b/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m @@ -304,13 +304,6 @@ %% Enough setup, Time to do the actual finding the HeteroAgentStationaryEqm: -%% If using fminalgo=5, then need some further setup -if heteroagentoptions.fminalgo==5 - % If using a shooting algorithm, set that up - heteroagentoptions=setupGEnewprice3_shooting(heteroagentoptions,GeneralEqmEqns,GEPriceParamNames); -end - - %% if heteroagentoptions.maxiter>0 % Can use heteroagentoptions.maxiter=0 to just evaluate the current general eqm eqns @@ -385,6 +378,9 @@ [p_eqm_vec,GeneralEqmConditions,counteval,stopflag,out,bestever] = cmaes_vfitoolkit(GeneralEqmConditionsFnOpt,GEparamsvec0,heteroagentoptions.insigma,heteroagentoptions.inopts); % ,varargin); elseif heteroagentoptions.fminalgo==5 % Update based on rules in heteroagentoptions.fminalgo5.howtoupdate + % Set up the howtoupdate rules in the format needed + heteroagentoptions=setupGEnewprice3_shooting(heteroagentoptions,GeneralEqmEqns,GEPriceParamNames); + % Get initial prices, p p=nan(1,length(GEPriceParamNames)); for ii=1:length(GEPriceParamNames) diff --git a/Optimization/setupGEnewprice3_shooting.m b/Optimization/setupGEnewprice3_shooting.m index a2cd79d1..91afcd23 100644 --- a/Optimization/setupGEnewprice3_shooting.m +++ b/Optimization/setupGEnewprice3_shooting.m @@ -8,7 +8,12 @@ nGeneralEqmEqns=length(GEeqnNames); %% Set up GEnewprice==3 (if relevant) -if options.GEnewprice~=3 +if isfield(options,'fminalgo5') % in stationary general eqm, fminalgo5 is shooting + fminalgo5=1; + % options.GEnewprice=3; + options.GEnewprice3=options.fminalgo5; + options.oldpathweight=0; % Not actually used for anything +elseif options.GEnewprice~=3 return end @@ -67,7 +72,7 @@ end end end - + else %% Model with permanent type: allow for options.GEptype nGeneralEqmEqns_acrossptypes=sum(options.GEptype==0)+N_i*sum(options.GEptype==1); @@ -162,6 +167,12 @@ end +%% If doing stationary general eqm, call output fminalgo5 instead of GEnewprice3 +if fminalgo5==1 + options.fminalgo5=options.GEnewprice3; + options=rmfield(options,'GEnewprice3'); + options=rmfield(options,'oldpathweight'); +end diff --git a/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType.m b/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType.m index b94d6591..d73ed6b1 100644 --- a/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType.m +++ b/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType.m @@ -235,6 +235,9 @@ PTypeStructure.(iistr).vfoptions.level1n=ceil(n_a/50); % default end end + if ~isfield(PTypeStructure.(iistr).vfoptions,'gridinterplayer') + PTypeStructure.(iistr).vfoptions.gridinterplayer=0; %default + end if ~isfield(PTypeStructure.(iistr).vfoptions,'exoticpreferences') PTypeStructure.(iistr).vfoptions.exoticpreferences='None'; % not yet implemented, so hardcodes None else @@ -313,11 +316,29 @@ end % to be able to EvalFnsOnAgentDist using fastOLG we also need PTypeStructure.(iistr).a_gridvals=gpuArray(CreateGridvals(PTypeStructure.(iistr).n_a,PTypeStructure.(iistr).a_grid,1)); % a_grivdals is [N_a,l_a] - if N_d==0 - PTypeStructure.(iistr).daprime_gridvals=gpuArray(PTypeStructure.(iistr).a_gridvals); - else - PTypeStructure.(iistr).daprime_gridvals=gpuArray([kron(ones(N_a,1),CreateGridvals(PTypeStructure.(iistr).n_d,PTypeStructure.(iistr).d_grid,1)), kron(PTypeStructure.(iistr).a_gridvals,ones(PTypeStructure.(iistr).N_d,1))]); % daprime_gridvals is [N_d*N_aprime,l_d+l_aprime] + % use fine grid for aprime_gridvals + if PTypeStructure.(iistr).vfoptions.gridinterplayer==0 + PTypeStructure.(iistr).aprime_gridvals=PTypeStructure.(iistr).a_gridvals; + elseif PTypeStructure.(iistr).vfoptions.gridinterplayer==1 + if isscalar(PTypeStructure.(iistr).n_a) + n_aprime=PTypeStructure.(iistr).n_a+(PTypeStructure.(iistr).n_a-1)*PTypeStructure.(iistr).vfoptions.ngridinterp; + aprime_grid=interp1(gpuArray(1:1:PTypeStructure.(iistr).N_a)',PTypeStructure.(iistr).a_grid,gpuArray(linspace(1,PTypeStructure.(iistr).N_a,n_aprime))'); + PTypeStructure.(iistr).aprime_gridvals=CreateGridvals(n_aprime,aprime_grid,1); + else + a1_grid=PTypeStructure.(iistr).a_grid(1:PTypeStructure.(iistr).n_a(1)); + n_a1prime=PTypeStructure.(iistr).n_a(1)+(PTypeStructure.(iistr).n_a(1)-1)*PTypeStructure.(iistr).vfoptions.ngridinterp; + n_aprime=[n_a1prime,PTypeStructure.(iistr).n_a(2:end)]; + a1prime_grid=interp1(gpuArray(1:1:PTypeStructure.(iistr).n_a(1))',a1_grid,gpuArray(linspace(1,PTypeStructure.(iistr).n_a(1),n_a1prime))'); + aprime_grid=[a1prime_grid; PTypeStructure.(iistr).a_grid(PTypeStructure.(iistr).n_a(1)+1:end)]; + PTypeStructure.(iistr).aprime_gridvals=CreateGridvals(n_aprime,aprime_grid,1); + end end + PTypeStructure.(iistr).d_gridvals=CreateGridvals(PTypeStructure.(iistr).n_d,gpuArray(PTypeStructure.(iistr).d_grid),1); + % if N_d==0 + % PTypeStructure.(iistr).daprime_gridvals=gpuArray(PTypeStructure.(iistr).a_gridvals); + % else + % PTypeStructure.(iistr).daprime_gridvals=gpuArray([kron(ones(N_a,1),CreateGridvals(PTypeStructure.(iistr).n_d,PTypeStructure.(iistr).d_grid,1)), kron(PTypeStructure.(iistr).a_gridvals,ones(PTypeStructure.(iistr).N_d,1))]); % daprime_gridvals is [N_d*N_aprime,l_d+l_aprime] + % end if isa(pi_z,'struct') PTypeStructure.(iistr).pi_z=pi_z.(Names_i{ii}); % Different grids by permanent type, but not depending on age. (same as the case just above; this case can occour with or without the existence of vfoptions, as long as there is no vfoptions.agedependentgrids) @@ -656,7 +677,7 @@ % pi_e_J and e_gridvals_J are both gpuArrays end - %% When using z (and e), we can precompute some things that the fastOLG needs for the agent dist + %% We can precompute some things that the fastOLG needs for the agent dist if N_z>0 && N_e==0 pi_z_J_sim=gather(reshape(transpathoptions.(iistr).pi_z_J_alt(1:end-1,:,:),[(N_j-1)*N_z,N_z])); @@ -688,7 +709,7 @@ PTypeStructure.(iistr).pi_e_J_sim=pi_e_J_sim; end - + %% Organise V_final and AgentDist_initial % Reshape V_final if transpathoptions.fastOLG==0 diff --git a/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType_shooting.m b/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType_shooting.m index daa284a3..2c32d93c 100644 --- a/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType_shooting.m +++ b/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType_shooting.m @@ -155,7 +155,8 @@ d_grid=PTypeStructure.(iistr).d_grid; a_grid=PTypeStructure.(iistr).a_grid; a_gridvals=PTypeStructure.(iistr).a_gridvals; - daprime_gridvals=PTypeStructure.(iistr).daprime_gridvals; + d_gridvals=PTypeStructure.(iistr).d_gridvals; + aprime_gridvals=PTypeStructure.(iistr).aprime_gridvals; if N_z>0 z_gridvals_J=PTypeStructure.(iistr).z_gridvals_J; pi_z_J=PTypeStructure.(iistr).pi_z_J; @@ -198,7 +199,7 @@ % PricePathSizeVec_ii, ParamPathSizeVec_ii % For current ptype, do the backward iteration of V and Policy, then forward iterate agent dist and get the AggVarsPath - AggVarsPath=TransitionPath_FHorz_PType_singlepath(PricePathOld_ii, ParamPath_ii, PricePathNames,ParamPathNames,T,V_final.(iistr),AgentDist_init.(iistr),jequalOneDist_T.(iistr),AgeWeights_T.(iistr),l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,daprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluate, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec_ii, ParamPathSizeVec_ii, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions); + AggVarsPath=TransitionPath_FHorz_PType_singlepath(PricePathOld_ii, ParamPath_ii, PricePathNames,ParamPathNames,T,V_final.(iistr),AgentDist_init.(iistr),jequalOneDist_T.(iistr),AgeWeights_T.(iistr),l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluate, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec_ii, ParamPathSizeVec_ii, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions); % AggVarsPath=zeros(length(FnsToEvaluate),T-1); AggVarsFullPath(PTypeStructure.(iistr).WhichFnsForCurrentPType,:,ii)=AggVarsPath; diff --git a/TransitionPaths/FHorz/PType/TransitionPath_FHorz_PType_singlepath.m b/TransitionPaths/FHorz/PType/TransitionPath_FHorz_PType_singlepath.m index 4c06a4c4..91b77f99 100644 --- a/TransitionPaths/FHorz/PType/TransitionPath_FHorz_PType_singlepath.m +++ b/TransitionPaths/FHorz/PType/TransitionPath_FHorz_PType_singlepath.m @@ -1,709 +1,38 @@ -function AggVarsPath=TransitionPath_FHorz_PType_singlepath(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,daprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluate, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions) -% When doing shooting alogrithm on TPath FHorz PType, this is for a given -% ptype, and does the steps of back-iterate to get policy, then forward to -% get agent dist and agg vars. +function AggVarsPath=TransitionPath_FHorz_PType_singlepath(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions) +% When doing shooting alogrithm on TPath FHorz PType, this is for a given ptype, and does the steps of back-iterate to get policy, then forward to get agent dist and agg vars. % The only output is the agg vars path. -% Note: the input AgentDist, is AgentDist_init - -% Note: use AgeWeights_T as transpathoptions.ageweightstrivial==0 is hardcoded -AgeWeights=AgeWeights_T(:,1); % AgeWeights_T is (a,j,z)-by-T (if z) - -AggVarsPath=zeros(length(FnsToEvaluate),T-1); - +% AggVarsPath=zeros(length(FnsToEvaluate),T-1,'gpuArray'); if transpathoptions.fastOLG==0 if N_z==0 if N_e==0 - %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. - PolicyIndexesPath=zeros(N_a,N_j,T-1,'gpuArray'); %Periods 1 to T-1 - % Note that we don't need to keep V for anything - V=V_final; - for ttr=1:T-1 % so tt=T-ttr - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(T-ttr,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(T-ttr,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - [V, Policy]=ValueFnIter_Case1_FHorz_TPath_SingleStep_noz(V,n_d,n_a,N_j,d_grid, a_grid, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); - % The VKron input is next period value fn, the VKron output is this period. - % Policy is kept in the form where it is just a single-value in (d,a') - - PolicyIndexesPath(:,:,T-ttr)=Policy; - end - % Free up space on GPU by deleting things no longer needed - clear V - - - %% Now we have the full PolicyIndexesPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path - % Call AgentDist the current periods distn - for tt=1:T-1 - - %Get the current optimal policy - Policy=PolicyIndexesPath(:,:,tt); - - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(tt,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(tt,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - if use_tminus1price==1 - for pp=1:length(tminus1priceNames) - if tt>1 - Parameters.([tminus1priceNames{pp},'_tminus1'])=Parameters.(tminus1priceNames{pp}); - else - Parameters.([tminus1priceNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1priceNames{pp}); - end - end - end - if use_tminus1params==1 - for pp=1:length(tminus1paramNames) - if tt>1 - Parameters.([tminus1paramNames{pp},'_tminus1'])=Parameters.(tminus1paramNames{pp}); - else - Parameters.([tminus1paramNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1paramNames{pp}); - end - end - end - if use_tplus1price==1 - for pp=1:length(tplus1priceNames) - kk=tplus1pricePathkk(pp); - Parameters.([tplus1priceNames{pp},'_tplus1'])=PricePathOld(tt+1,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); % Make is so that the time t+1 variables can be used - end - end - if use_tminus1AggVars==1 - for pp=1:length(tminus1AggVarsNames) - if tt>1 - % The AggVars have not yet been updated, so they still contain previous period values - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=Parameters.(tminus1AggVarsNames{pp}); - else - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1AggVarsNames{pp}); - end - end - end - - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz(AgentDist,Policy, FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,l_d,n_a,N_j,daprime_gridvals,a_gridvals,0); - - AggVarsPath(:,tt)=AggVars; - - % AgentDistPath(:,tt)=AgentDist; - - % if transpathoptions.ageweightstrivial==0 is hardcoded - AgeWeightsOld=AgeWeights; - AgeWeights=AgeWeights_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - % if transpathoptions.trivialjequalonedist==0 is hardcoded - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - % if simoptions.fastOLG=1 is hardcoded - if N_d==0 - AgentDist=StationaryDist_FHorz_Case1_TPath_SingleStep_IterFast_noz_raw(AgentDist,AgeWeights,AgeWeightsOld,gather(reshape(Policy(:,1:end-1),[1,N_a*(N_j-1)])),N_a,N_j,jequalOneDist); - else - % Note, difference is that we do ceil(Policy/N_d) so as to just pass optaprime - AgentDist=StationaryDist_FHorz_Case1_TPath_SingleStep_IterFast_noz_raw(AgentDist,AgeWeights,AgeWeightsOld,gather(reshape(ceil(Policy(:,1:end-1)/N_d),[1,N_a*(N_j-1)])),N_a,N_j,jequalOneDist); - end - - % Sometimes, we need AggVars to be kept as structure in Parameters (when doing PType_singlepath AggVars is a vector, whereas the rest of the time it is a structure, hence this bit is only needed in PType_singlepath) - if use_tminus1AggVars==1 - for aa=1:length(AggVarNames) - Parameters.(AggVarNames{aa})=AggVars(aa); - end - end - - end - - else % N_e>0 - error('e without z not yet implemented for TPath with FHorz') + AggVarsPath=TransitionPath_FHorz_PType_singlepath_noz_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, vfoptions, simoptions); + else + AggVarsPath=TransitionPath_FHorz_PType_singlepath_noz_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, vfoptions, simoptions); end - else % N_z>0 - if N_e==0 % z, no e, fastOLG=0 - %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. - PolicyIndexesPath=zeros(N_a,N_z,N_j,T-1,'gpuArray'); %Periods 1 to T-1 - % Note that we don't need to keep V for anything - V=V_final; - for ttr=1:T-1 % so tt=T-ttr - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(T-ttr,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(T-ttr,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - if transpathoptions.zpathtrivial==0 - z_gridvals_J=transpathoptions.z_gridvals_J_T(:,:,:,T-ttr); - pi_z_J=transpathoptions.pi_z_J_T(:,:,:,T-ttr); - end - % transpathoptions.zpathtrivial==1 % Does not depend on T, so is just in vfoptions already - - - [V, Policy]=ValueFnIter_Case1_FHorz_TPath_SingleStep(V,n_d,n_a,n_z,N_j,d_grid, a_grid,z_gridvals_J,pi_z_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); - % The VKron input is next period value fn, the VKron output is this period. - % Policy is kept in the form where it is just a single-value in (d,a') - - PolicyIndexesPath(:,:,:,T-ttr)=Policy; - end - % Free up space on GPU by deleting things no longer needed - clear V - - - %% Now we have the full PolicyIndexesPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path - % Call AgentDist the current periods distn - for tt=1:T-1 - - %Get the current optimal policy - Policy=PolicyIndexesPath(:,:,:,tt); - - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(tt,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(tt,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - if use_tminus1price==1 - for pp=1:length(tminus1priceNames) - if tt>1 - Parameters.([tminus1priceNames{pp},'_tminus1'])=Parameters.(tminus1priceNames{pp}); - else - Parameters.([tminus1priceNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1priceNames{pp}); - end - end - end - if use_tminus1params==1 - for pp=1:length(tminus1paramNames) - if tt>1 - Parameters.([tminus1paramNames{pp},'_tminus1'])=Parameters.(tminus1paramNames{pp}); - else - Parameters.([tminus1paramNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1paramNames{pp}); - end - end - end - if use_tplus1price==1 - for pp=1:length(tplus1priceNames) - kk=tplus1pricePathkk(pp); - Parameters.([tplus1priceNames{pp},'_tplus1'])=PricePathOld(tt+1,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); % Make is so that the time t+1 variables can be used - end - end - if use_tminus1AggVars==1 - for pp=1:length(tminus1AggVarsNames) - if tt>1 - % The AggVars have not yet been updated, so they still contain previous period values - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=Parameters.(tminus1AggVarsNames{pp}); - else - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1AggVarsNames{pp}); - end - end - end - - if transpathoptions.zpathtrivial==0 - z_gridvals_J=transpathoptions.z_gridvals_J_T(:,:,:,tt); - pi_z_J_sim=transpathoptions.pi_z_J_sim_T(:,:,:,tt); - end - % transpathoptions.zpathtrivial==0 % Does not depend on tt - - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist,Policy, FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,l_d,n_a,n_z,N_j,daprime_gridvals,a_gridvals,z_gridvals_J,0,0); - - AggVarsPath(:,tt)=AggVars; - - % AgentDistPath(:,tt)=AgentDist; - - % if transpathoptions.ageweightstrivial==0 is hardcoded - AgeWeightsOld=AgeWeights; - AgeWeights=AgeWeights_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - % if transpathoptions.trivialjequalonedist==0 is hardcoded - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - % if simoptions.fastOLG=1 is hardcoded - if N_d==0 - AgentDist=StationaryDist_FHorz_Case1_TPath_SingleStep_IterFast_raw(AgentDist,AgeWeights,AgeWeightsOld,gather(reshape(Policy(:,:,1:end-1),[1,N_a*N_z*(N_j-1)])),N_a,N_z,N_j,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); - else - % Note, difference is that we do ceil(Policy/N_d) so as to just pass optaprime - AgentDist=StationaryDist_FHorz_Case1_TPath_SingleStep_IterFast_raw(AgentDist,AgeWeights,AgeWeightsOld,gather(reshape(ceil(Policy(:,:,1:end-1)/N_d),[1,N_a*N_z*(N_j-1)])),N_a,N_z,N_j,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); - end - - % Sometimes, we need AggVars to be kept as structure in Parameters (when doing PType_singlepath AggVars is a vector, whereas the rest of the time it is a structure, hence this bit is only needed in PType_singlepath) - if use_tminus1AggVars==1 - for aa=1:length(AggVarNames) - Parameters.(AggVarNames{aa})=AggVars(aa); - end - end - - end - else % z, e, fastOLG=0 - %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. - PolicyIndexesPath=zeros(N_a,N_z,N_e,N_j,T-1,'gpuArray'); %Periods 1 to T-1 - % Note that we don't need to keep V for anything - V=V_final; - for ttr=1:T-1 % so tt=T-ttr - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(T-ttr,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(T-ttr,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - if transpathoptions.zpathtrivial==0 - z_gridvals_J=transpathoptions.z_gridvals_J_T(:,:,:,T-ttr); - pi_z_J=transpathoptions.pi_z_J_T(:,:,:,T-ttr); - end - if transpathoptions.epathtrivial==0 - e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,T-ttr); - pi_e_J=transpathoptions.pi_e_J_T(:,:,T-ttr); - end - - [V, Policy]=ValueFnIter_Case1_FHorz_TPath_SingleStep_e(V,n_d,n_a,n_z,n_e,N_j,d_grid, a_grid, z_gridvals_J, e_gridvals_J, pi_z_J, pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); - % The VKron input is next period value fn, the VKron output is this period. - % Policy is kept in the form where it is just a single-value in (d,a') - - PolicyIndexesPath(:,:,:,:,T-ttr)=Policy; - end - % Free up space on GPU by deleting things no longer needed - clear V - - - %% Now we have the full PolicyIndexesPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path - % Call AgentDist the current periods distn - for tt=1:T-1 - - %Get the current optimal policy - Policy=PolicyIndexesPath(:,:,:,:,tt); - - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(tt,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(tt,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - if use_tminus1price==1 - for pp=1:length(tminus1priceNames) - if tt>1 - Parameters.([tminus1priceNames{pp},'_tminus1'])=Parameters.(tminus1priceNames{pp}); - else - Parameters.([tminus1priceNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1priceNames{pp}); - end - end - end - if use_tminus1params==1 - for pp=1:length(tminus1paramNames) - if tt>1 - Parameters.([tminus1paramNames{pp},'_tminus1'])=Parameters.(tminus1paramNames{pp}); - else - Parameters.([tminus1paramNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1paramNames{pp}); - end - end - end - if use_tplus1price==1 - for pp=1:length(tplus1priceNames) - kk=tplus1pricePathkk(pp); - Parameters.([tplus1priceNames{pp},'_tplus1'])=PricePathOld(tt+1,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); % Make is so that the time t+1 variables can be used - end - end - if use_tminus1AggVars==1 - for pp=1:length(tminus1AggVarsNames) - if tt>1 - % The AggVars have not yet been updated, so they still contain previous period values - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=Parameters.(tminus1AggVarsNames{pp}); - else - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1AggVarsNames{pp}); - end - end - end - - if transpathoptions.zpathtrivial==0 - z_gridvals_J=transpathoptions.z_gridvals_J_T(:,:,:,tt); - pi_z_J_sim=transpathoptions.pi_z_J_sim_T(:,:,:,tt); - end - % transpathoptions.zpathtrivial==1 % Does not depend on tt - if transpathoptions.epathtrivial==0 - e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,tt); - pi_e_J_sim=transpathoptions.pi_e_J_sim_T(:,:,tt); - end - % transpathoptions.epathtrivial==1 % Does not depend on tt - - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLGe(AgentDist,Policy, FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,l_d,n_a,n_z,n_e,N_j,daprime_gridvals,a_gridvals,permute(z_gridvals_J,[3,1,2]),permute(e_gridvals_J,[3,4,1,2]),0,1); - - AggVarsPath(:,tt)=AggVars; - - % AgentDistPath(:,tt)=AgentDist; - - % if transpathoptions.ageweightstrivial==0 is hardcoded - AgeWeightsOld=AgeWeights; - AgeWeights=AgeWeights_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - % if transpathoptions.trivialjequalonedist==0 is hardcoded - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - if N_d==0 - AgentDist=StationaryDist_FHorz_Case1_TPath_SingleStep_IterFast_e_raw(AgentDist,AgeWeights,AgeWeightsOld,gather(reshape(permute(Policy(:,:,:,1:end-1),[1,4,2,3]),[1,N_a*(N_j-1)*N_z*N_e])),N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); - else - % Note, difference is that we do ceil(Policy/N_d) so as to just pass optaprime - AgentDist=StationaryDist_FHorz_Case1_TPath_SingleStep_IterFast_e_raw(AgentDist,AgeWeights,AgeWeightsOld,gather(reshape(permute(ceil(Policy(:,:,:,1:end-1)/N_d),[1,4,2,3]),[1,N_a*(N_j-1)*N_z*N_e])),N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); - end - - % Sometimes, we need AggVars to be kept as structure in Parameters (when doing PType_singlepath AggVars is a vector, whereas the rest of the time it is a structure, hence this bit is only needed in PType_singlepath) - if use_tminus1AggVars==1 - for aa=1:length(AggVarNames) - Parameters.(AggVarNames{aa})=AggVars(aa); - end - end - - end + else + if N_e==0 + AggVarsPath=TransitionPath_FHorz_PType_singlepath_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, vfoptions, simoptions); + else + AggVarsPath=TransitionPath_FHorz_PType_singlepath_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, vfoptions, simoptions); end end - - - - - - elseif transpathoptions.fastOLG==1 if N_z==0 if N_e==0 - PolicyIndexesPath=zeros(N_a,N_j,T-1,'gpuArray'); %Periods 1 to T-1 - - %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. - % Since we won't need to keep the value functions for anything later we just overwrite V - V=V_final; - for ttr=1:T-1 % so tt=T-ttr - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(T-ttr,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(T-ttr,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - [V, Policy]=ValueFnIter_Case1_FHorz_TPath_SingleStep_fastOLG_noz(V,n_d,n_a,N_j,d_grid, a_grid, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); - % The V input is next period value fn, the V output is this period. - % Policy is kept in the form where it is just a single-value in (d,a') - - PolicyIndexesPath(:,:,T-ttr)=Policy; - end - % Free up space on GPU by deleting things no longer needed - clear V - - %% Now we have the full PolicyIndexesPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path - - % AgentDistPath=zeros([N_a*N_j,T]); - - % Call AgentDist the current periods distn - for tt=1:T-1 - - %Get the current optimal policy - Policy=PolicyIndexesPath(:,:,tt); - - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(tt,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(tt,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - if use_tminus1price==1 - for pp=1:length(tminus1priceNames) - if tt>1 - Parameters.([tminus1priceNames{pp},'_tminus1'])=Parameters.(tminus1priceNames{pp}); - else - Parameters.([tminus1priceNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1priceNames{pp}); - end - end - end - if use_tminus1params==1 - for pp=1:length(tminus1paramNames) - if tt>1 - Parameters.([tminus1paramNames{pp},'_tminus1'])=Parameters.(tminus1paramNames{pp}); - else - Parameters.([tminus1paramNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1paramNames{pp}); - end - end - end - if use_tplus1price==1 - for pp=1:length(tplus1priceNames) - kk=tplus1pricePathkk(pp); - Parameters.([tplus1priceNames{pp},'_tplus1'])=PricePathOld(tt+1,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); % Make is so that the time t+1 variables can be used - end - end - if use_tminus1AggVars==1 - for pp=1:length(tminus1AggVarsNames) - if tt>1 - % The AggVars have not yet been updated, so they still contain previous period values - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=Parameters.(tminus1AggVarsNames{pp}); - else - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1AggVarsNames{pp}); - end - end - end - - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz(gpuArray(AgentDist),Policy, FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,l_d,n_a,N_j,daprime_gridvals,a_gridvals,0); - - AggVarsPath(:,tt)=AggVars; - - % AgentDistPath(:,tt)=AgentDist; - - % if transpathoptions.ageweightstrivial==0 is hardcoded - AgeWeightsOld=AgeWeights; - AgeWeights=AgeWeights_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - % if transpathoptions.trivialjequalonedist==0 is hardcoded - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - % if simoptions.fastOLG=1 is hardcoded - if N_d==0 - AgentDist=StationaryDist_FHorz_Case1_TPath_SingleStep_IterFast_noz_raw(AgentDist,AgeWeights,AgeWeightsOld,gather(reshape(Policy(:,1:end-1),[1,N_a*(N_j-1)])),N_a,N_j,jequalOneDist); - else - % Note, difference is that we do ceil(Policy/N_d) so as to just pass optaprime - AgentDist=StationaryDist_FHorz_Case1_TPath_SingleStep_IterFast_noz_raw(AgentDist,AgeWeights,AgeWeightsOld,gather(reshape(ceil(Policy(:,1:end-1)/N_d),[1,N_a*(N_j-1)])),N_a,N_j,jequalOneDist); - end - - % Sometimes, we need AggVars to be kept as structure in Parameters (when doing PType_singlepath AggVars is a vector, whereas the rest of the time it is a structure, hence this bit is only needed in PType_singlepath) - if use_tminus1AggVars==1 - for aa=1:length(AggVarNames) - Parameters.(AggVarNames{aa})=AggVars(aa); - end - end - - end - - else % N_e>0 - error('e without z not yet implemented for TPath with FHorz') + AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_noz_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions); + else + AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_noz_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions); end - else % N_z>0 - if N_e==0 % z, no e, fastOLG=1 - PolicyIndexesPath=zeros(N_a,N_j,N_z,T-1,'gpuArray'); %Periods 1 to T-1 - - %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. - % Since we won't need to keep the value functions for anything later we just overwrite V - V=V_final; - for ttr=1:T-1 % so tt=T-ttr - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(T-ttr,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(T-ttr,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - if transpathoptions.zpathtrivial==0 - z_gridvals_J=transpathoptions.z_gridvals_J(:,:,T-ttr); - pi_z_J=transpathoptions.pi_z_J_T(:,:,:,T-ttr); % fastOLG value function uses (j,z,z') - end - % transpathoptions.zpathtrivial==1 % Does not depend on tt - - [V, Policy]=ValueFnIter_FHorz_TPath_SingleStep_fastOLG(V,n_d,n_a,n_z,N_j,d_grid, a_grid, z_gridvals_J, pi_z_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); - % The VKron input is next period value fn, the VKron output is this period. - % Policy in fastOLG is [N_a,N_j,N_z] and contains the joint-index for (d,aprime) - - PolicyIndexesPath(:,:,:,T-ttr)=Policy; % fastOLG: so a-by-j-by-z - end - % Free up space on GPU by deleting things no longer needed - clear V - - %% Now we have the full PolicyIndexesPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path - - % AgentDistPath=zeros([N_a*N_j*N_z,T]); - - % Call AgentDist the current periods distn - for tt=1:T-1 - - %Get the current optimal policy - Policy=PolicyIndexesPath(:,:,:,tt); - - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(tt,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(tt,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - if use_tminus1price==1 - for pp=1:length(tminus1priceNames) - if tt>1 - Parameters.([tminus1priceNames{pp},'_tminus1'])=Parameters.(tminus1priceNames{pp}); - else - Parameters.([tminus1priceNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1priceNames{pp}); - end - end - end - if use_tminus1params==1 - for pp=1:length(tminus1paramNames) - if tt>1 - Parameters.([tminus1paramNames{pp},'_tminus1'])=Parameters.(tminus1paramNames{pp}); - else - Parameters.([tminus1paramNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1paramNames{pp}); - end - end - end - if use_tplus1price==1 - for pp=1:length(tplus1priceNames) - kk=tplus1pricePathkk(pp); - Parameters.([tplus1priceNames{pp},'_tplus1'])=PricePathOld(tt+1,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); % Make is so that the time t+1 variables can be used - end - end - if use_tminus1AggVars==1 - for pp=1:length(tminus1AggVarsNames) - if tt>1 - % The AggVars have not yet been updated, so they still contain previous period values - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=Parameters.(tminus1AggVarsNames{pp}); - else - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1AggVarsNames{pp}); - end - end - end - - if transpathoptions.zpathtrivial==0 - z_gridvals_J=transpathoptions.z_gridvals_J_T(:,:,:,tt); - pi_z_J_sim=transpathoptions.pi_z_J_sim_T(:,:,:,tt); - end - % transpathoptions.zpathtrivial==1 % Does not depend on tt - - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist,Policy, FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,l_d,n_a,n_z,N_j,daprime_gridvals,a_gridvals,z_gridvals_J,1,0); - - AggVarsPath(:,tt)=AggVars; - - % AgentDistPath(:,tt)=AgentDist; - - % if transpathoptions.ageweightstrivial==0 is hardcoded - AgeWeightsOld=AgeWeights; - AgeWeights=AgeWeights_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - % if transpathoptions.trivialjequalonedist==0 is hardcoded - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - % if simoptions.fastOLG=1 is hardcoded - if N_d==0 - AgentDist=StationaryDist_FHorz_Case1_TPath_SingleStep_IterFast_raw(AgentDist,AgeWeights,AgeWeightsOld,gather(reshape(Policy(:,1:end-1,:),[1,N_a*(N_j-1)*N_z])),N_a,N_z,N_j,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % Policy for jj=1:N_j-1 - else - % Note, difference is that we do ceil(Policy/N_d) so as to just pass optaprime - AgentDist=StationaryDist_FHorz_Case1_TPath_SingleStep_IterFast_raw(AgentDist,AgeWeights,AgeWeightsOld,gather(reshape(ceil(Policy(:,1:end-1,:)/N_d),[1,N_a*(N_j-1)*N_z])),N_a,N_z,N_j,pi_z_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % Policy for jj=1:N_j-1 - end - - % Sometimes, we need AggVars to be kept as structure in Parameters (when doing PType_singlepath AggVars is a vector, whereas the rest of the time it is a structure, hence this bit is only needed in PType_singlepath) - if use_tminus1AggVars==1 - for aa=1:length(AggVarNames) - Parameters.(AggVarNames{aa})=AggVars(aa); - end - end - - end - - - else % N_e>0 - %% z, e, fastOLG=1 - PolicyIndexesPath=zeros(N_a,N_j,N_z,N_e,T-1,'gpuArray'); %Periods 1 to T-1 - - %% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. - % Since we won't need to keep the value functions for anything later we just overwrite V - V=V_final; - for ttr=1:T-1 % so tt=T-ttr - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(T-ttr,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(T-ttr,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - - if transpathoptions.zpathtrivial==0 - z_gridvals_J=transpathoptions.z_gridvals_J(:,:,T-ttr); - pi_z_J=transpathoptions.pi_z_J_T(:,:,:,T-ttr); % fastOLG value function uses (j,z,z') - end - % transpathoptions.zpathtrivial==1 % Does not depend on tt - if transpathoptions.epathtrivial==0 - e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,:,T-ttr); - pi_e_J=transpathoptions.pi_e_J_T(:,:,T-ttr); % (a,j,z)-by-e - end - % transpathoptions.epathtrivial==1 % Does not depend on tt - - [V, Policy]=ValueFnIter_Case1_FHorz_TPath_SingleStep_fastOLG_e(V,n_d,n_a,n_z,n_e,N_j,d_grid, a_grid, z_gridvals_J, e_gridvals_J, pi_z_J, pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); - % The VKron input is next period value fn, the VKron output is this period. - % Policy in fastOLG is [N_a,N_j,N_z,N_e] and contains the joint-index for (d,aprime) - - PolicyIndexesPath(:,:,:,:,T-ttr)=Policy; % fastOLG: so a-by-j-by-z-by-e - end - % Free up space on GPU by deleting things no longer needed - clear V - - %% Now we have the full PolicyIndexesPath, we go forward in time from 1 to T using the policies to update the agents distribution generating a new price path - - % AgentDistPath=zeros([N_a*N_j*N_z,N_e,T]); - - % Call AgentDist the current periods distn - for tt=1:T-1 - - %Get the current optimal policy - Policy=PolicyIndexesPath(:,:,:,tt); - - for kk=1:length(PricePathNames) - Parameters.(PricePathNames{kk})=PricePathOld(tt,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); - end - for kk=1:length(ParamPathNames) - Parameters.(ParamPathNames{kk})=ParamPath(tt,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); - end - if use_tminus1price==1 - for pp=1:length(tminus1priceNames) - if tt>1 - Parameters.([tminus1priceNames{pp},'_tminus1'])=Parameters.(tminus1priceNames{pp}); - else - Parameters.([tminus1priceNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1priceNames{pp}); - end - end - end - if use_tminus1params==1 - for pp=1:length(tminus1paramNames) - if tt>1 - Parameters.([tminus1paramNames{pp},'_tminus1'])=Parameters.(tminus1paramNames{pp}); - else - Parameters.([tminus1paramNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1paramNames{pp}); - end - end - end - if use_tplus1price==1 - for pp=1:length(tplus1priceNames) - kk=tplus1pricePathkk(pp); - Parameters.([tplus1priceNames{pp},'_tplus1'])=PricePathOld(tt+1,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); % Make is so that the time t+1 variables can be used - end - end - if use_tminus1AggVars==1 - for pp=1:length(tminus1AggVarsNames) - if tt>1 - % The AggVars have not yet been updated, so they still contain previous period values - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=Parameters.(tminus1AggVarsNames{pp}); - else - Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1AggVarsNames{pp}); - end - end - end - - if transpathoptions.zpathtrivial==0 - z_gridvals_J=transpathoptions.z_gridvals_J(:,:,tt); - pi_z_J_sim=transpathoptions.pi_z_J_sim_T(:,:,:,tt); - end - % transpathoptions.zpathtrivial==1 % Does not depend on tt - if transpathoptions.epathtrivial==0 - e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,:,tt); - pi_e_J_sim=transpathoptions.pi_e_J_sim_T(:,:,tt); % (a,j,z)-by-e - end - % transpathoptions.epathtrivial==1 % Does not depend on tt - - AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLGe(AgentDist,Policy, FnsToEvaluate,FnsToEvaluateParamNames,AggVarNames,Parameters,l_d,n_a,n_z,n_e,N_j,daprime_gridvals,a_gridvals,z_gridvals_J,e_gridvals_J,1,0); - - AggVarsPath(:,tt)=AggVars; - - % AgentDistPath(:,:,tt)=AgentDist; - - % if transpathoptions.ageweightstrivial==0 is hardcoded - AgeWeightsOld=AgeWeights; - AgeWeights=AgeWeights_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - % if transpathoptions.trivialjequalonedist==0 is hardcoded - jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist - % if simoptions.fastOLG=1 is hardcoded - if N_d==0 - AgentDist=StationaryDist_FHorz_Case1_TPath_SingleStep_IterFast_e_raw(AgentDist,AgeWeights,AgeWeightsOld,gather(reshape(Policy(:,1:end-1,:),[1,N_a*(N_j-1)*N_z*N_e])),N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); - else - % Note, difference is that we do ceil(Policy/N_d) so as to just pass optaprime - AgentDist=StationaryDist_FHorz_Case1_TPath_SingleStep_IterFast_e_raw(AgentDist,AgeWeights,AgeWeightsOld,gather(reshape(ceil(Policy(:,1:end-1,:)/N_d),[1,N_a*(N_j-1)*N_z*N_e])),N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); - end - - % Sometimes, we need AggVars to be kept as structure in Parameters (when doing PType_singlepath AggVars is a vector, whereas the rest of the time it is a structure, hence this bit is only needed in PType_singlepath) - if use_tminus1AggVars==1 - for aa=1:length(AggVarNames) - Parameters.(AggVarNames{aa})=AggVars(aa); - end - end - - end - + else + if N_e==0 + AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions); + else + AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions); end end end + + +end diff --git a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_e_raw.m b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_e_raw.m new file mode 100644 index 00000000..efadbe2f --- /dev/null +++ b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_e_raw.m @@ -0,0 +1,208 @@ +function AggVarsPath=TransitionPath_FHorz_PType_singlepath_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,daprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, vfoptions, simoptions) +% When doing shooting alogrithm on TPath FHorz PType, this is for a given ptype, and does the steps of back-iterate to get policy, then forward to get agent dist and agg vars. +% The only output is the agg vars path. + +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect + +if N_d==0 + l_d=0; +else + l_d=length(n_d); +end +l_aprime=length(n_a); + +%% +% Shapes: +% V is [N_a,N_z,N_e,N_j] +% AgentDist for basic is [N_a*N_z*N_e,N_j] +% AgentDist for fastOLG is [N_a*N_j*N_z,N_e] + +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_d+l_aprime,N_a,N_z,N_e,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + PolicyIndexesPath=zeros(l_d+l_aprime+1,N_a,N_z,N_e,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +end +if simoptions.gridinterplayer==0 + if simoptions.fastOLG==0 + II1=1:1:N_a*N_z*N_e; + II2=ones(N_a*N_z*N_e,1); + elseif simoptions.fastOLG==1 + II1=1:1:N_a*(N_j-1)*N_z*N_e; + II2=ones(N_a*(N_j-1)*N_z*N_e,1); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_z*N_e,1)+N_a*N_j*repelem((0:1:N_z*N_e-1)',N_a,1); + end +elseif simoptions.gridinterplayer==1 + N_probs=2; + if simoptions.fastOLG==0 + error('Cannot use simoptions.fastOLG=0 with grid interpolation layer') + elseif simoptions.fastOLG==1 + PolicyProbsPath=zeros(N_a*(N_j-1)*N_z*N_e,N_probs,T-1,'gpuArray'); % preallocate + II=repelem((1:1:N_a*(N_j-1)*N_z*N_e)',1,N_probs); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_z*N_e,1)+N_a*N_j*repelem((0:1:N_z*N_e-1)',N_a,1); + end +end +%% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. +% Since we won't need to keep the value functions for anything later we just store the current one in V +V=V_final; +for ttr=1:T-1 %so tt=T-ttr + + for kk=1:length(PricePathNames) + Parameters.(PricePathNames{kk})=PricePathOld(T-ttr,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); + end + for kk=1:length(ParamPathNames) + Parameters.(ParamPathNames{kk})=ParamPath(T-ttr,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); + end + + if transpathoptions.zpathtrivial==0 + z_gridvals_J=transpathoptions.z_gridvals_J_T(:,:,:,T-ttr); + pi_z_J=transpathoptions.pi_z_J_T(:,:,:,T-ttr); + end + if transpathoptions.epathtrivial==0 + e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,T-ttr); + pi_e_J=transpathoptions.pi_e_J_T(:,:,T-ttr); + end + + [V, Policy]=ValueFnIter_FHorz_TPath_SingleStep_e(V,n_d,n_a,n_z,n_e,N_j,d_gridvals, a_grid, z_gridvals_J, e_gridvals_J, pi_z_J, pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + % The V input is next period value fn, the V output is this period. + % Policy is kept in the form where it is just a single-value in (d,a') + + PolicyIndexesPath(:,:,:,:,:,T-ttr)=Policy; +end + +%% Modify PolicyIndexesPath into forms needed for forward iteration +% Create version of PolicyIndexesPath called PolicyaprimePath, which only tracks aprime and has j=1:N_j-1 as we don't use N_j to iterate agent dist (there is no N_j+1) +% For fastOLG we use PolicyaprimejPath, if there is z then PolicyaprimejzPath +% When using grid interpolation layer also PolicyProbsPath +if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,:,1:N_j-1,:),[N_a*N_z*N_e,N_j-1,T-1]); % aprime index +elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,:,:,1:N_j-1,:)-1),[N_a*N_z*N_e,N_j-1,T-1]); +elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,:,:,1:N_j-1,:)-1),[N_a*N_z*N_e,N_j-1,T-1]); +elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(l_d+4,:,:,:,1:N_j-1,:)-1),[N_a*N_z*N_e,N_j-1,T-1]); +end +if simoptions.fastOLG==0 + PolicyaprimezPath_slowOLG=PolicyaprimePath+repmat(repelem(N_a*gpuArray(0:1:N_z-1)',N_a,1),N_e,1); +elseif simoptions.fastOLG==1 + PolicyaprimePath=reshape(permute(reshape(PolicyaprimePath,[N_a,N_z*N_e,N_j-1,T-1]),[1,3,2,4]),[N_a*(N_j-1)*N_z*N_e,T-1]); + PolicyaprimejzPath=PolicyaprimePath+repmat(repelem(N_a*gpuArray(0:1:(N_j-1)*N_z-1)',N_a,1),N_e,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_d+l_aprime+1,:,:,:,1:N_j-1,:),[1,N_a,N_z*N_e,N_j-1,T-1]); % PolicyIndexesPath is of size [l_d+l_aprime+1,N_a,N_z,N_e,N_j,T] + L2index=reshape(permute(L2index,[2,4,3,1,5]),[N_a*(N_j-1)*N_z*N_e,1,T-1]); + PolicyaprimejzPath=reshape(PolicyaprimejzPath,[N_a*(N_j-1)*N_z*N_e,1,T-1]); % reinterpret this as lower grid index + PolicyaprimejzPath=repelem(PolicyaprimejzPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejzPath(:,2,:)=PolicyaprimejzPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point + end +end +% Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats +PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,n_d,n_a,[n_z,n_e],N_j,T-1,d_grid,a_grid,vfoptions,1,0); +PolicyValuesPath=permute(PolicyValuesPath,[2,4,3,1,5]); %[N_a,N_j,N_z*N_e,l_d+l_aprime,T-1] % fastOLG ordering is needed for AggVars + +%% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm +% Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate +AgentDist=AgentDist_initial; +for tt=1:T-1 + + % Get t-1 PricePath and ParamPath before we update them + if use_tminus1price==1 + for pp=1:length(tminus1priceNames) + if tt>1 + Parameters.([tminus1priceNames{pp},'_tminus1'])=Parameters.(tminus1priceNames{pp}); + else + Parameters.([tminus1priceNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1priceNames{pp}); + end + end + end + if use_tminus1params==1 + for pp=1:length(tminus1paramNames) + if tt>1 + Parameters.([tminus1paramNames{pp},'_tminus1'])=Parameters.(tminus1paramNames{pp}); + else + Parameters.([tminus1paramNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1paramNames{pp}); + end + end + end + % Get t-1 AggVars before we update them + if use_tminus1AggVars==1 + for pp=1:length(tminus1AggVarsNames) + if tt>1 + % The AggVars have not yet been updated, so they still contain previous period values + Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=Parameters.(tminus1AggVarsNames{pp}); + else + Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1AggVarsNames{pp}); + end + end + end + + % Update current PricePath and ParamPath + for kk=1:length(PricePathNames) + Parameters.(PricePathNames{kk})=PricePathOld(tt,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); + end + for kk=1:length(ParamPathNames) + Parameters.(ParamPathNames{kk})=ParamPath(tt,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); + end + + % Get t+1 PricePath + if use_tplus1price==1 + for pp=1:length(tplus1priceNames) + kk=tplus1pricePathkk(pp); + Parameters.([tplus1priceNames{pp},'_tplus1'])=PricePathOld(tt+1,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); % Make is so that the time t+1 variables can be used + end + end + + %% Get the current optimal policy, and iterate the agent dist + if transpathoptions.zepathtrivial==0 + ze_gridvals_J_fastOLG=transpathoptions.ze_gridvals_J_T_fastOLG(:,:,:,:,tt); + end + if transpathoptions.zpathtrivial==0 + if simoptions.fastOLG==0 + pi_z_J=transpathoptions.pi_z_J_T(:,:,:,tt); + else + pi_z_J_sim=transpathoptions.pi_z_J_sim_T(:,:,:,tt); + end + end + if transpathoptions.epathtrivial==0 + if simoptions.fastOLG==0 + pi_e_J=transpathoptions.pi_e_J_T(:,:,tt); + else + pi_e_J_sim=transpathoptions.pi_e_J_sim_T(:,:,tt); + end + end + + AgeWeights=AgeWeights_T(:,:,tt); % by coincidence this is for fastOLG=0,1 + + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + + if simoptions.fastOLG==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_Iteration_e_raw(AgentDist,PolicyaprimezPath_slowOLG(:,:,tt),N_a,N_z,N_e,N_j,pi_z_J,pi_e_J,II1,II2,jequalOneDist); + else % simoptions.fastOLG==1 + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_e_raw(AgentDist,PolicyaprimejzPath(:,tt),N_a,N_z,N_e,N_j,pi_z_J_sim, pi_e_J_sim,II1,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_e_raw(AgentDist,PolicyaprimejzPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,II,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + end + end + + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights, PolicyValuesPath(:,:,:,1:l_d,tt), PolicyValuesPath(:,:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_ze,N_a,N_ze,a_gridvals,ze_gridvals_J_fastOLG,1); + for ii=1:length(AggVarNames) + Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; + end + % Keep AggVars in the AggVarsPath + for ii=1:length(AggVarNames) + AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; + end + + AgentDist=AgentDistnext; +end + + +end \ No newline at end of file diff --git a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_e_raw.m b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_e_raw.m new file mode 100644 index 00000000..7f663d2d --- /dev/null +++ b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_e_raw.m @@ -0,0 +1,172 @@ +function AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,daprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions) +% When doing shooting alogrithm on TPath FHorz PType, this is for a given ptype, and does the steps of back-iterate to get policy, then forward to get agent dist and agg vars. +% The only output is the agg vars path. + +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect + +if N_d==0 + l_d=0; +else + l_d=length(n_d); +end +l_aprime=length(n_a); + +%% +% fastOLG so everything is (a,j,z,e) +% Shapes: +% V is [N_a,N_j,N_z,N_e] +% AgentDist for fastOLG is [N_a*N_j*N_z,N_e] + +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_d+l_aprime,N_a,N_j,N_z,N_e,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + N_probs=2; + PolicyIndexesPath=zeros(l_d+l_aprime+1,N_a,N_j,N_z,N_e,T-1,'gpuArray'); %Periods 1 to T-1 + PolicyProbsPath=zeros(N_a*(N_j-1)*N_z*N_e,N_probs,T-1,'gpuArray'); % preallocate +end + +%% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. +% Since we won't need to keep the value functions for anything later we just store the current one in V +V=V_final; +for ttr=1:T-1 %so tt=T-ttr + + for kk=1:length(PricePathNames) + Parameters.(PricePathNames{kk})=PricePathOld(T-ttr,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); + end + for kk=1:length(ParamPathNames) + Parameters.(ParamPathNames{kk})=ParamPath(T-ttr,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); + end + + if transpathoptions.zpathtrivial==0 + pi_z_J=transpathoptions.pi_z_J_T(:,:,:,T-ttr); % fastOLG value function uses (j,z',z) + z_gridvals_J=transpathoptions.z_gridvals_J(:,:,T-ttr); + end + if transpathoptions.epathtrivial==0 + pi_e_J=transpathoptions.pi_e_J_T(:,1,:,T-ttr); + e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,:,T-ttr); + end + + [V, Policy]=ValueFnIter_FHorz_TPath_SingleStep_fastOLG_e(V,n_d,n_a,n_z,n_e,N_j,d_grid, a_grid, z_gridvals_J, e_gridvals_J, pi_z_J, pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + % The V input is next period value fn, the V output is this period. + % Policy in fastOLG is [N_a,N_j,N_z,N_e] and contains the joint-index for (d,aprime) + + PolicyIndexesPath(:,:,:,:,:,T-ttr)=Policy; % fastOLG: so a-by-j-by-z-by-e + +end + +%% Modify PolicyIndexesPath into forms needed for forward iteration +% Create version of PolicyIndexesPath in form we want for the agent distribution iteration +% Creates PolicyaprimejzPath (omits j=N_j), and when using grid interpolation layer also PolicyProbsPath +if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:,:),[N_a*(N_j-1)*N_z*N_e,T-1]); % aprime index +elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:,:,:)-1),[N_a*(N_j-1)*N_z*N_e,T-1]); +elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:,:,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,1:N_j-1,:,:,:)-1),[N_a*(N_j-1)*N_z*N_e,T-1]); +elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:,:,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,1:N_j-1,:,:,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(l_d+4,:,1:N_j-1,:,:,:)-1),[N_a*(N_j-1)*N_z*N_e,T-1]); +end +PolicyaprimejzPath=PolicyaprimePath+repmat(repelem(N_a*gpuArray(0:1:(N_j-1)*N_z-1)',N_a,1),N_e,1); +if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_d+l_aprime+1,:,1:N_j-1,:,:,:),[N_a*(N_j-1)*N_z*N_e,1,T-1]); % PolicyIndexesPath is of size [l_d+l_aprime+1,N_a,N_j,N_z,N_e,T-1] + PolicyaprimejzPath=reshape(PolicyaprimejzPath,[N_a*(N_j-1)*N_z*N_e,1,T-1]); % reinterpret this as lower grid index + PolicyaprimejzPath=repelem(PolicyaprimejzPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejzPath(:,2,:)=PolicyaprimejzPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point +end +% Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats +PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,n_d,n_a,[n_z,n_e],N_j,T-1,d_gridvals,aprime_gridvals,vfoptions,1,1); % [size(PolicyValuesPath,1),N_a,N_j,N_z*N_e,T] +PolicyValuesPath=permute(PolicyValuesPath,[2,3,4,1,5]); %[N_a,N_j,N_z*N_e,l_d+l_aprime,T-1] % fastOLG ordering is needed for AggVars + + +%% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm +% Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate +AgentDist=AgentDist_initial; +for tt=1:T-1 + + % Get t-1 PricePath and ParamPath before we update them + if use_tminus1price==1 + for pp=1:length(tminus1priceNames) + if tt>1 + Parameters.([tminus1priceNames{pp},'_tminus1'])=Parameters.(tminus1priceNames{pp}); + else + Parameters.([tminus1priceNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1priceNames{pp}); + end + end + end + if use_tminus1params==1 + for pp=1:length(tminus1paramNames) + if tt>1 + Parameters.([tminus1paramNames{pp},'_tminus1'])=Parameters.(tminus1paramNames{pp}); + else + Parameters.([tminus1paramNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1paramNames{pp}); + end + end + end + % Get t-1 AggVars before we update them + if use_tminus1AggVars==1 + for pp=1:length(tminus1AggVarsNames) + if tt>1 + % The AggVars have not yet been updated, so they still contain previous period values + Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=Parameters.(tminus1AggVarsNames{pp}); + else + Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1AggVarsNames{pp}); + end + end + end + + % Update current PricePath and ParamPath + for kk=1:length(PricePathNames) + Parameters.(PricePathNames{kk})=PricePathOld(tt,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); + end + for kk=1:length(ParamPathNames) + Parameters.(ParamPathNames{kk})=ParamPath(tt,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); + end + + % Get t+1 PricePath + if use_tplus1price==1 + for pp=1:length(tplus1priceNames) + kk=tplus1pricePathkk(pp); + Parameters.([tplus1priceNames{pp},'_tplus1'])=PricePathOld(tt+1,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); % Make is so that the time t+1 variables can be used + end + end + + %% Get the current optimal policy, and iterate the agent dist + if transpathoptions.zepathtrivial==0 + ze_gridvals_J_fastOLG=transpathoptions.ze_gridvals_J_T_fastOLG(:,:,:,:,tt); + end + if transpathoptions.zpathtrivial==0 + pi_z_J_sim=transpathoptions.pi_z_J_sim_T(:,:,:,tt); + end + if transpathoptions.epathtrivial==0 + pi_e_J_sim=transpathoptions.pi_e_J_sim_T(:,:,tt); % (a,j,z)-by-e + end + + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + + AgeWeights=AgeWeights_T(:,:,tt); % by coincidence this is for fastOLG=0,1 + + % simoptions.fastOLG=1 is hardcoded + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_e_raw(AgentDist,PolicyaprimejzPath(:,tt),N_a,N_z,N_e,N_j,pi_z_J_sim, pi_e_J_sim,II1orII,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % II1orII is II1 + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_e_raw(AgentDist,PolicyaprimejzPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,II1orII,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % II1orII is II + end + + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights, PolicyValuesPath(:,:,:,1:l_d,tt), PolicyValuesPath(:,:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_ze,N_a,N_ze,a_gridvals,ze_gridvals_J_fastOLG,1); + for ii=1:length(AggVarNames) + Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; + end + % Keep AggVars in the AggVarsPath + for ii=1:length(AggVarNames) + AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; + end + + AgentDist=AgentDistnext; +end + + +end diff --git a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_noz_e_raw.m b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_noz_e_raw.m new file mode 100644 index 00000000..aeed811a --- /dev/null +++ b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_noz_e_raw.m @@ -0,0 +1,163 @@ +function AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_noz_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_e,n_e,N_j,d_grid,a_grid,daprime_gridvals,a_gridvals,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions) +% When doing shooting alogrithm on TPath FHorz PType, this is for a given ptype, and does the steps of back-iterate to get policy, then forward to get agent dist and agg vars. +% The only output is the agg vars path. + +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect + +if N_d==0 + l_d=0; +else + l_d=length(n_d); +end +l_aprime=length(n_a); + +%% +% fastOLG so everything is (a,j,e) +% Shapes: +% V is [N_a,N_j,N_e] +% AgentDist for fastOLG is [N_a*N_j,N_e] + +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_d+l_aprime,N_a,N_j,N_e,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + N_probs=2; + PolicyIndexesPath=zeros(l_d+l_aprime+1,N_a,N_j,N_e,T-1,'gpuArray'); %Periods 1 to T-1 + PolicyProbsPath=zeros(N_a*(N_j-1)*N_e,N_probs,T-1,'gpuArray'); % preallocate +end + +%% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. +% Since we won't need to keep the value functions for anything later we just store the current one in V +V=V_final; +for ttr=1:T-1 %so tt=T-ttr + + for kk=1:length(PricePathNames) + Parameters.(PricePathNames{kk})=PricePathOld(T-ttr,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); + end + for kk=1:length(ParamPathNames) + Parameters.(ParamPathNames{kk})=ParamPath(T-ttr,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); + end + + if transpathoptions.zpathtrivial==0 + e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,T-ttr); + pi_e_J=transpathoptions.pi_e_J_T(:,:,T-ttr); % fastOLG value function uses (j,z',z) + end + + [V, Policy]=ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz_e(V,n_d,n_a,n_e,N_j,d_grid, a_grid, e_gridvals_J, pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + % The V input is next period value fn, the V output is this period. + % Policy in fastOLG is [N_a,N_j,N_e] and contains the joint-index for (d,aprime) + + PolicyIndexesPath(:,:,:,:,T-ttr)=Policy; % fastOLG: so a-by-j-by-z + +end + + +%% Modify PolicyIndexesPath into forms needed for forward iteration +% Create version of PolicyIndexesPath in form we want for the agent distribution iteration +% Creates PolicyaprimejzPath (omits j=N_j), and when using grid interpolation layer also PolicyProbsPath +if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:),[N_a*(N_j-1)*N_e,T-1]); % aprime index +elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:,:)-1),[N_a*(N_j-1)*N_e,T-1]); +elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,1:N_j-1,:,:)-1),[N_a*(N_j-1)*N_e,T-1]); +elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,1:N_j-1,:,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(l_d+4,:,1:N_j-1,:,:)-1),[N_a*(N_j-1)*N_e,T-1]); +end +PolicyaprimejPath=PolicyaprimePath+repmat(repelem(N_a*gpuArray(0:1:(N_j-1)-1)',N_a,1),N_e,1); +if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_d+l_aprime+1,:,1:N_j-1,:,:),[N_a*(N_j-1)*N_e,1,T-1]); % PolicyIndexesPath is of size [l_d+l_aprime+1,N_a,N_j,N_e,T-1] + PolicyaprimejPath=reshape(PolicyaprimejPath,[N_a*(N_j-1)*N_e,1,T-1]); % reinterpret this as lower grid index + PolicyaprimejPath=repelem(PolicyaprimejPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejPath(:,2,:)=PolicyaprimejPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point +end +% Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats +PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,n_d,n_a,n_e,N_j,T-1,d_gridvals,aprime_gridvals,vfoptions,1,1); % [size(PolicyValuesPath,1),N_a,N_j,N_e,T] +PolicyValuesPath=permute(PolicyValuesPath,[2,3,4,1,5]); %[N_a,N_j,N_e,l_d+l_aprime,T-1] % fastOLG ordering is needed for AggVars + + +%% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm +% Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate +AgentDist=AgentDist_initial; +for tt=1:T-1 + + % Get t-1 PricePath and ParamPath before we update them + if use_tminus1price==1 + for pp=1:length(tminus1priceNames) + if tt>1 + Parameters.([tminus1priceNames{pp},'_tminus1'])=Parameters.(tminus1priceNames{pp}); + else + Parameters.([tminus1priceNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1priceNames{pp}); + end + end + end + if use_tminus1params==1 + for pp=1:length(tminus1paramNames) + if tt>1 + Parameters.([tminus1paramNames{pp},'_tminus1'])=Parameters.(tminus1paramNames{pp}); + else + Parameters.([tminus1paramNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1paramNames{pp}); + end + end + end + % Get t-1 AggVars before we update them + if use_tminus1AggVars==1 + for pp=1:length(tminus1AggVarsNames) + if tt>1 + % The AggVars have not yet been updated, so they still contain previous period values + Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=Parameters.(tminus1AggVarsNames{pp}); + else + Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1AggVarsNames{pp}); + end + end + end + + % Update current PricePath and ParamPath + for kk=1:length(PricePathNames) + Parameters.(PricePathNames{kk})=PricePathOld(tt,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); + end + for kk=1:length(ParamPathNames) + Parameters.(ParamPathNames{kk})=ParamPath(tt,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); + end + + % Get t+1 PricePath + if use_tplus1price==1 + for pp=1:length(tplus1priceNames) + kk=tplus1pricePathkk(pp); + Parameters.([tplus1priceNames{pp},'_tplus1'])=PricePathOld(tt+1,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); % Make is so that the time t+1 variables can be used + end + end + + %% Get the current optimal policy, and iterate the agent dist + if transpathoptions.zpathtrivial==0 + e_gridvals_J_fastOLG=transpathoptions.ze_gridvals_J_fastOLG(:,:,:,tt); + pi_e_J_sim=transpathoptions.pi_e_J_sim_T(:,:,tt); % fastOLG value function uses (j,z,z') + end + + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + + AgeWeights=AgeWeights_T(:,:,tt); % By coincidence, this is same for fastOLG=0,1 + + % simoptions.fastOLG=1 is hardcoded + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_e_raw(AgentDist,PolicyaprimejPath(:,tt),N_a,N_e,N_j,pi_e_J_sim,II1orII,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % II1orII is II1 + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_e_raw(AgentDist,PolicyaprimejPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_e,N_j,pi_e_J_sim,II1orII,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % II1orII is II + end + + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights, PolicyValuesPath(:,:,:,1:l_d,tt), PolicyValuesPath(:,:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_e,N_a,N_e,a_gridvals,e_gridvals_J_fastOLG,1); + for ii=1:length(AggVarNames) + Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; + end + % Keep AggVars in the AggVarsPath + for ii=1:length(AggVarNames) + AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; + end + + AgentDist=AgentDistnext; +end + +end diff --git a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_noz_raw.m b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_noz_raw.m new file mode 100644 index 00000000..c3b4b555 --- /dev/null +++ b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_noz_raw.m @@ -0,0 +1,151 @@ +function AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_noz_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_j,d_grid,a_grid,daprime_gridvals,a_gridvals,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions) +% When doing shooting alogrithm on TPath FHorz PType, this is for a given ptype, and does the steps of back-iterate to get policy, then forward to get agent dist and agg vars. +% The only output is the agg vars path. + +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect + +if N_d==0 + l_d=0; +else + l_d=length(n_d); +end +l_aprime=length(n_a); + +%% +% fastOLG so everything is (a,j) +% Shapes: +% V is [N_a,N_j] +% AgentDist for fastOLG is [N_a*N_j,1] + +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_d+l_aprime,N_a,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + N_probs=2; + PolicyIndexesPath=zeros(l_d+l_aprime+1,N_a,N_j,T-1,'gpuArray'); %Periods 1 to T-1 + PolicyProbsPath=zeros(N_a*(N_j-1),N_probs,T-1,'gpuArray'); % preallocate +end + + +%% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. +% Since we won't need to keep the value functions for anything later we just store the current one in V +V=V_final; +for ttr=1:T-1 % so tt=T-ttr + for kk=1:length(PricePathNames) + Parameters.(PricePathNames{kk})=PricePathOld(T-ttr,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); + end + for kk=1:length(ParamPathNames) + Parameters.(ParamPathNames{kk})=ParamPath(T-ttr,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); + end + + [V, Policy]=ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz(V,n_d,n_a,N_j,d_grid, a_grid, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + % The V input is next period value fn, the V output is this period. + % Policy is kept in the form where it is just a single-value in (d,a') + + PolicyIndexesPath(:,:,:,T-ttr)=Policy; +end + +%% Modify PolicyIndexesPath into forms needed for forward iteration +% Create version of PolicyIndexesPath in form we want for the agent distribution iteration +% Creates PolicyaprimejPath (omits j=N_j), and when using grid interpolation layer also PolicyProbsPath +if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:),[N_a*(N_j-1),T-1]); % aprime index +elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:)-1),[N_a*(N_j-1),T-1]); +elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,1:N_j-1,:)-1),[N_a*(N_j-1),T-1]); +elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(l_d+4,:,1:N_j-1,:)-1),[N_a*(N_j-1),T-1]); +end +PolicyaprimejPath=PolicyaprimePath+repelem(N_a*gpuArray(0:1:(N_j-1)-1)',N_a,1); +if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_d+l_aprime+1,:,1:N_j-1,:),[N_a*(N_j-1),1,T-1]); % PolicyIndexesPath is of size [l_d+l_aprime+1,N_a,N_j,T-1] + PolicyaprimejPath=reshape(PolicyaprimejPath,[N_a*(N_j-1),1,T-1]); % reinterpret this as lower grid index + PolicyaprimejPath=repelem(PolicyaprimejPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejPath(:,2,:)=PolicyaprimejPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point +end +% Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats +PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,n_d,n_a,0,N_j,T-1,d_gridvals,aprime_gridvals,vfoptions,1,1); % [size(PolicyValuesPath,1),N_a,N_j,T] +PolicyValuesPath=permute(PolicyValuesPath,[2,3,1,4]); %[N_a,N_j,l_d+l_aprime,T-1] % fastOLG ordering is needed for AggVars + +%% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm +% Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate +AgentDist=AgentDist_initial; +for tt=1:T-1 + + % Get t-1 PricePath and ParamPath before we update them + if use_tminus1price==1 + for pp=1:length(tminus1priceNames) + if tt>1 + Parameters.([tminus1priceNames{pp},'_tminus1'])=Parameters.(tminus1priceNames{pp}); + else + Parameters.([tminus1priceNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1priceNames{pp}); + end + end + end + if use_tminus1params==1 + for pp=1:length(tminus1paramNames) + if tt>1 + Parameters.([tminus1paramNames{pp},'_tminus1'])=Parameters.(tminus1paramNames{pp}); + else + Parameters.([tminus1paramNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1paramNames{pp}); + end + end + end + % Get t-1 AggVars before we update them + if use_tminus1AggVars==1 + for pp=1:length(tminus1AggVarsNames) + if tt>1 + % The AggVars have not yet been updated, so they still contain previous period values + Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=Parameters.(tminus1AggVarsNames{pp}); + else + Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1AggVarsNames{pp}); + end + end + end + + % Update current PricePath and ParamPath + for kk=1:length(PricePathNames) + Parameters.(PricePathNames{kk})=PricePathOld(tt,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); + end + for kk=1:length(ParamPathNames) + Parameters.(ParamPathNames{kk})=ParamPath(tt,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); + end + + % Get t+1 PricePath + if use_tplus1price==1 + for pp=1:length(tplus1priceNames) + kk=tplus1pricePathkk(pp); + Parameters.([tplus1priceNames{pp},'_tplus1'])=PricePathOld(tt+1,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); % Make is so that the time t+1 variables can be used + end + end + + %% Get the current optimal policy, and iterate the agent dist + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + + AgeWeights=AgeWeights_T(:,tt); + + % simoptions.fastOLG=1 is hardcoded + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_raw(AgentDist,PolicyaprimejPath(:,tt),N_a,N_j,II1orII,II2,jequalOneDist); % II1orII is II1 + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_raw(AgentDist,PolicyaprimejPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_j,II1orII,jequalOneDist); % II1orII is II + end + + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz(AgentDist.*AgeWeights,PolicyValuesPath(:,:,1:l_d,tt), PolicyValuesPath(:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,N_a,a_gridvals,1); + for ii=1:length(AggVarNames) + Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; + end + % Keep AggVars in the AggVarsPath + for ii=1:length(AggVarNames) + AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; + end + + AgentDist=AgentDistnext; +end + + +end diff --git a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_raw.m b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_raw.m new file mode 100644 index 00000000..41c6bca6 --- /dev/null +++ b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_raw.m @@ -0,0 +1,163 @@ +function AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions) +% When doing shooting alogrithm on TPath FHorz PType, this is for a given ptype, and does the steps of back-iterate to get policy, then forward to get agent dist and agg vars. +% The only output is the agg vars path. + +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect + +if N_d==0 + l_d=0; +else + l_d=length(n_d); +end +l_aprime=length(n_a); + +%% +% fastOLG so everything is (a,j,z) +% Shapes: +% V is [N_a,N_j,N_z] +% AgentDist for fastOLG is [N_a*N_j*N_z,1] + +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_d+l_aprime,N_a,N_j,N_z,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + N_probs=2; + PolicyIndexesPath=zeros(l_d+l_aprime+1,N_a,N_j,N_z,T-1,'gpuArray'); % Periods 1 to T-1 + PolicyProbsPath=zeros(N_a*(N_j-1)*N_z,N_probs,T-1,'gpuArray'); % preallocate +end + + +%% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. +% Since we won't need to keep the value functions for anything later we just store the current one in V +V=V_final; +for ttr=1:T-1 %so tt=T-ttr + + for kk=1:length(PricePathNames) + Parameters.(PricePathNames{kk})=PricePathOld(T-ttr,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); + end + for kk=1:length(ParamPathNames) + Parameters.(ParamPathNames{kk})=ParamPath(T-ttr,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); + end + + if transpathoptions.zpathtrivial==0 + z_gridvals_J=transpathoptions.z_gridvals_J_T(:,:,:,T-ttr); + pi_z_J=transpathoptions.pi_z_J_T(:,:,:,T-ttr); % fastOLG value function uses (j,z',z) + end + + [V, Policy]=ValueFnIter_FHorz_TPath_SingleStep_fastOLG(V,n_d,n_a,n_z,N_j,d_grid, a_grid, z_gridvals_J, pi_z_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + % The V input is next period value fn, the V output is this period. + % Policy in fastOLG is [N_a,N_j,N_z] and contains the joint-index for (d,aprime) + + PolicyIndexesPath(:,:,:,:,T-ttr)=Policy; % fastOLG: so a-by-j-by-z + +end + +%% Modify PolicyIndexesPath into forms needed for forward iteration +% Create version of PolicyIndexesPath in form we want for the agent distribution iteration +% Creates PolicyaprimejzPath (omits j=N_j), and when using grid interpolation layer also PolicyProbsPath +if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:),[N_a*(N_j-1)*N_z,T-1]); % aprime index +elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:,:)-1),[N_a*(N_j-1)*N_z,T-1]); +elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,1:N_j-1,:,:)-1),[N_a*(N_j-1)*N_z,T-1]); +elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,1:N_j-1,:,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(l_d+4,:,1:N_j-1,:,:)-1),[N_a*(N_j-1)*N_z,T-1]); +end +PolicyaprimejzPath=PolicyaprimePath+repelem(N_a*gpuArray(0:1:(N_j-1)*N_z-1)',N_a,1); +if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_d+l_aprime+1,:,1:N_j-1,:,:),[N_a*(N_j-1)*N_z,1,T-1]); % PolicyIndexesPath is of size [l_d+l_aprime+1,N_a,N_j,N_z,T-1] + PolicyaprimejzPath=reshape(PolicyaprimejzPath,[N_a*(N_j-1)*N_z,1,T-1]); % reinterpret this as lower grid index + PolicyaprimejzPath=repelem(PolicyaprimejzPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejzPath(:,2,:)=PolicyaprimejzPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point +end +% Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats +PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,n_d,n_a,n_z,N_j,T-1,d_gridvals,aprime_gridvals,vfoptions,1,1); % [size(PolicyValuesPath,1),N_a,N_j,N_z,T] +PolicyValuesPath=permute(PolicyValuesPath,[2,3,4,1,5]); %[N_a,N_j,N_z,l_d+l_aprime,T-1] % fastOLG ordering is needed for AggVars + +%% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm +% Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate +AgentDist=AgentDist_initial; +for tt=1:T-1 + + % Get t-1 PricePath and ParamPath before we update them + if use_tminus1price==1 + for pp=1:length(tminus1priceNames) + if tt>1 + Parameters.([tminus1priceNames{pp},'_tminus1'])=Parameters.(tminus1priceNames{pp}); + else + Parameters.([tminus1priceNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1priceNames{pp}); + end + end + end + if use_tminus1params==1 + for pp=1:length(tminus1paramNames) + if tt>1 + Parameters.([tminus1paramNames{pp},'_tminus1'])=Parameters.(tminus1paramNames{pp}); + else + Parameters.([tminus1paramNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1paramNames{pp}); + end + end + end + % Get t-1 AggVars before we update them + if use_tminus1AggVars==1 + for pp=1:length(tminus1AggVarsNames) + if tt>1 + % The AggVars have not yet been updated, so they still contain previous period values + Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=Parameters.(tminus1AggVarsNames{pp}); + else + Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1AggVarsNames{pp}); + end + end + end + + % Update current PricePath and ParamPath + for kk=1:length(PricePathNames) + Parameters.(PricePathNames{kk})=PricePathOld(tt,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); + end + for kk=1:length(ParamPathNames) + Parameters.(ParamPathNames{kk})=ParamPath(tt,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); + end + + % Get t+1 PricePath + if use_tplus1price==1 + for pp=1:length(tplus1priceNames) + kk=tplus1pricePathkk(pp); + Parameters.([tplus1priceNames{pp},'_tplus1'])=PricePathOld(tt+1,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); % Make is so that the time t+1 variables can be used + end + end + + %% Get the current optimal policy, and iterate the agent dist + if transpathoptions.zpathtrivial==0 + z_gridvals_J_fastOLG=transpathoptions.ze_gridvals_J_fastOLG(:,:,:,tt); + pi_z_J_sim=transpathoptions.pi_z_J_sim_T(:,:,:,tt); % fastOLG value function uses (j,z,z') + end + + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + + AgeWeights=AgeWeights_T(:,tt); + + % simoptions.fastOLG=1 is hardcoded + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_raw(AgentDist,PolicyaprimejzPath(:,tt),N_a,N_z,N_j,pi_z_J_sim,II1orII,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % II1orII,II2 are II1 and II2 + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_raw(AgentDist,PolicyaprimejzPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_z,N_j,pi_z_J_sim,II1orII,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % II1orII is II + end + + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights, PolicyValuesPath(:,:,:,1:l_d,tt), PolicyValuesPath(:,:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_z,N_a,N_z,a_gridvals,z_gridvals_J_fastOLG,1); + for ii=1:length(AggVarNames) + Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; + end + % Keep AggVars in the AggVarsPath + for ii=1:length(AggVarNames) + AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; + end + + AgentDist=AgentDistnext; +end + + +end diff --git a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_noz_e_raw.m b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_noz_e_raw.m new file mode 100644 index 00000000..c926bef7 --- /dev/null +++ b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_noz_e_raw.m @@ -0,0 +1,191 @@ +function AggVarsPath=TransitionPath_FHorz_PType_singlepath_noz_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_e,n_e,N_j,d_grid,a_grid,daprime_gridvals,a_gridvals,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, vfoptions, simoptions) +% When doing shooting alogrithm on TPath FHorz PType, this is for a given ptype, and does the steps of back-iterate to get policy, then forward to get agent dist and agg vars. +% The only output is the agg vars path. + +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect + +if N_d==0 + l_d=0; +else + l_d=length(n_d); +end +l_aprime=length(n_a); + +%% e, No z +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_d+l_aprime,N_a,N_e,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + PolicyIndexesPath=zeros(l_d+l_aprime+1,N_a,N_e,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +end +if simoptions.gridinterplayer==0 + if simoptions.fastOLG==0 + II1=1:1:N_a*N_e; + II2=ones(N_a*N_e,1); + elseif simoptions.fastOLG==1 + II1=1:1:N_a*(N_j-1)*N_e; + II2=ones(N_a*(N_j-1)*N_e,1); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_e,1)+N_a*N_j*repelem((0:1:N_e-1)',N_a,1); + end +elseif simoptions.gridinterplayer==1 + N_probs=2; + if simoptions.fastOLG==0 + error('Cannot use simoptions.fastOLG=0 with grid interpolation layer') + elseif simoptions.fastOLG==1 + PolicyProbsPath=zeros(N_a*(N_j-1)*N_e,N_probs,T-1,'gpuArray'); % preallocate + II=repelem((1:1:N_a*(N_j-1)*N_e)',1,N_probs); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_e,1)+N_a*N_j*repelem((0:1:N_e-1)',N_a,1); + end +end + +%% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. +% Since we won't need to keep the value functions for anything later we just store the current one in V +V=V_final; +for ttr=1:T-1 %so tt=T-ttr + + for kk=1:length(PricePathNames) + Parameters.(PricePathNames{kk})=PricePathOld(T-ttr,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); + end + for kk=1:length(ParamPathNames) + Parameters.(ParamPathNames{kk})=ParamPath(T-ttr,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); + end + + if transpathoptions.zpathtrivial==0 + e_gridvals_J=transpathoptions.e_gridvals_J_T(:,:,:,T-ttr); + pi_e_J=transpathoptions.pi_e_J_T(:,:,T-ttr); + end + + [V, Policy]=ValueFnIter_FHorz_TPath_SingleStep_noz_e(V,n_d,n_a,n_e,N_j,d_gridvals, a_grid, e_gridvals_J, pi_e_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + % The V input is next period value fn, the V output is this period. + % Policy is kept in the form where it is just a single-value in (d,a') + + PolicyIndexesPath(:,:,:,:,T-ttr)=Policy; +end + +%% Modify PolicyIndexesPath into forms needed for forward iteration +% Create version of PolicyIndexesPath called PolicyaprimePath, which only tracks aprime and has j=1:N_j-1 as we don't use N_j to iterate agent dist (there is no N_j+1) +% For fastOLG we use PolicyaprimejPath, if there is z then PolicyaprimejzPath +% When using grid interpolation layer also PolicyProbsPath +if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,1:N_j-1,:),[N_a*N_e,N_j-1,T-1]); % aprime index +elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,:,1:N_j-1,:)-1),[N_a*N_e,N_j-1,T-1]); +elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,:,1:N_j-1,:)-1),[N_a*N_e,N_j-1,T-1]); +elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(l_d+4,:,:,1:N_j-1,:)-1),[N_a*N_e,N_j-1,T-1]); +end +if simoptions.fastOLG==0 + PolicyaprimePath_slowOLG=PolicyaprimePath; +elseif simoptions.fastOLG==1 + PolicyaprimePath=reshape(permute(reshape(PolicyaprimePath,[N_a,N_e,N_j-1,T-1]),[1,3,2,4]),[N_a*(N_j-1)*N_e,T-1]); + PolicyaprimejPath=PolicyaprimePath+repmat(repelem(N_a*gpuArray(0:1:(N_j-1)-1)',N_a,1),N_e,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_d+l_aprime+1,:,:,1:N_j-1,:),[1,N_a,N_e,N_j-1,T-1]); % PolicyIndexesPath is of size [l_d+l_aprime+1,N_a,N_e,N_j,T] + L2index=reshape(permute(L2index,[2,4,3,1,5]),[N_a*(N_j-1)*N_e,1,T-1]); + PolicyaprimejPath=reshape(PolicyaprimejPath,[N_a*(N_j-1)*N_e,1,T-1]); % reinterpret this as lower grid index + PolicyaprimejPath=repelem(PolicyaprimejPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejPath(:,2,:)=PolicyaprimejPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point + end +end +% Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats +PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,n_d,n_a,n_e,N_j,T-1,d_grid,a_grid,vfoptions,1,0); +PolicyValuesPath=permute(PolicyValuesPath,[2,4,3,1,5]); %[N_a,N_j,N_e,l_d+l_aprime,T-1] % fastOLG ordering is needed for AggVars + +%% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm +% Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate +AgentDist=AgentDist_initial; +for tt=1:T-1 + + % Get t-1 PricePath and ParamPath before we update them + if use_tminus1price==1 + for pp=1:length(tminus1priceNames) + if tt>1 + Parameters.([tminus1priceNames{pp},'_tminus1'])=Parameters.(tminus1priceNames{pp}); + else + Parameters.([tminus1priceNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1priceNames{pp}); + end + end + end + if use_tminus1params==1 + for pp=1:length(tminus1paramNames) + if tt>1 + Parameters.([tminus1paramNames{pp},'_tminus1'])=Parameters.(tminus1paramNames{pp}); + else + Parameters.([tminus1paramNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1paramNames{pp}); + end + end + end + % Get t-1 AggVars before we update them + if use_tminus1AggVars==1 + for pp=1:length(tminus1AggVarsNames) + if tt>1 + % The AggVars have not yet been updated, so they still contain previous period values + Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=Parameters.(tminus1AggVarsNames{pp}); + else + Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1AggVarsNames{pp}); + end + end + end + + % Update current PricePath and ParamPath + for kk=1:length(PricePathNames) + Parameters.(PricePathNames{kk})=PricePathOld(tt,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); + end + for kk=1:length(ParamPathNames) + Parameters.(ParamPathNames{kk})=ParamPath(tt,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); + end + + % Get t+1 PricePath + if use_tplus1price==1 + for pp=1:length(tplus1priceNames) + kk=tplus1pricePathkk(pp); + Parameters.([tplus1priceNames{pp},'_tplus1'])=PricePathOld(tt+1,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); % Make is so that the time t+1 variables can be used + end + end + + %% Get the current optimal policy, and iterate the agent dist + if transpathoptions.epathtrivial==0 + e_gridvals_J_fastOLG=transpathoptions.ze_gridvals_J_fastOLG(:,:,:,tt); + if simoptions.fastOLG==0 + pi_e_J=transpathoptions.pi_e_J_T(:,:,tt); + else + pi_e_J_sim=transpathoptions.pi_e_J_sim_T(:,:,tt); + end + end + + AgeWeights=AgeWeights_T(:,:,tt); % By coincidence, this is same for fastOLG=0,1 + + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + + if simoptions.fastOLG==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_Iteration_noz_e_raw(AgentDist,PolicyaprimePath_slowOLG(:,:,tt),N_a,N_e,N_j,pi_e_J,II1,II2,jequalOneDist); + else % simoptions.fastOLG==1 + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_e_raw(AgentDist,PolicyaprimejPath(:,tt),N_a,N_e,N_j,pi_e_J_sim,II1,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_e_raw(AgentDist,PolicyaprimejPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_e,N_j,pi_e_J_sim,II,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + end + end + + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights, PolicyValuesPath(:,:,:,1:l_d,tt), PolicyValuesPath(:,:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_e,N_a,N_e,a_gridvals,e_gridvals_J_fastOLG,1); + for ii=1:length(AggVarNames) + Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; + end + % Keep AggVars in the AggVarsPath + for ii=1:length(AggVarNames) + AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; + end + + AgentDist=AgentDistnext; +end + + +end diff --git a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_noz_raw.m b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_noz_raw.m new file mode 100644 index 00000000..55ab5685 --- /dev/null +++ b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_noz_raw.m @@ -0,0 +1,174 @@ +function AggVarsPath=TransitionPath_FHorz_PType_singlepath_noz_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_j,d_grid,a_grid,daprime_gridvals,a_gridvals,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, vfoptions, simoptions) +% When doing shooting alogrithm on TPath FHorz PType, this is for a given ptype, and does the steps of back-iterate to get policy, then forward to get agent dist and agg vars. +% The only output is the agg vars path. + +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect + +if N_d==0 + l_d=0; +else + l_d=length(n_d); +end +l_aprime=length(n_a); + +%% No e, no z +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_d+l_aprime,N_a,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + PolicyIndexesPath=zeros(l_d+l_aprime+1,N_a,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +end +if simoptions.gridinterplayer==0 + if simoptions.fastOLG==0 + II1=1:1:N_a; + II2=ones(N_a,1); + elseif simoptions.fastOLG==1 + II1=1:1:N_a*(N_j-1); + II2=ones(N_a*(N_j-1),1); + end +elseif simoptions.gridinterplayer==1 + N_probs=2; + if simoptions.fastOLG==0 + error('Cannot use simoptions.fastOLG=0 with grid interpolation layer') + elseif simoptions.fastOLG==1 + PolicyProbsPath=zeros(N_a*(N_j-1),N_probs,T-1,'gpuArray'); % preallocate + II=repelem((1:1:N_a*(N_j-1))',1,N_probs); + end +end + +%% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. +% Since we won't need to keep the value functions for anything later we just overwrite V +V=V_final; +for ttr=1:T-1 % so tt=T-ttr + for kk=1:length(PricePathNames) + Parameters.(PricePathNames{kk})=PricePathOld(T-ttr,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); + end + for kk=1:length(ParamPathNames) + Parameters.(ParamPathNames{kk})=ParamPath(T-ttr,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); + end + + [V, Policy]=ValueFnIter_FHorz_TPath_SingleStep_fastOLG_noz(V,n_d,n_a,N_j,d_grid, a_grid, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + % The V input is next period value fn, the V output is this period. + % Policy is kept in the form where it is just a single-value in (d,a') + + PolicyIndexesPath(:,:,:,T-ttr)=Policy; +end + +%% Modify PolicyIndexesPath into forms needed for forward iteration +% Create version of PolicyPath called PolicyaprimePath, which only tracks aprime and has j=1:N_j-1 as we don't use N_j to iterate agent dist (there is no N_j+1) +% For fastOLG we use PolicyaprimejPath, if there is z then PolicyaprimejzPath +% When using grid interpolation layer also PolicyProbsPath +if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:),[N_a,N_j-1,T-1]); % aprime index +elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:)-1),[N_a,N_j-1,T-1]); +elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,1:N_j-1,:)-1),[N_a,N_j-1,T-1]); +elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(l_d+4,:,1:N_j-1,:)-1),[N_a,N_j-1,T-1]); +end +if simoptions.fastOLG==0 + PolicyaprimePath_slowOLG=PolicyaprimePath; +elseif simoptions.fastOLG==1 + PolicyaprimePath=reshape(permute(reshape(PolicyaprimePath,[N_a,N_j-1,T-1]),[1,2,3]),[N_a*(N_j-1),T-1]); + PolicyaprimejPath=PolicyaprimePath+repelem(N_a*gpuArray(0:1:(N_j-1)-1)',N_a,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_d+l_aprime+1,:,1:N_j-1,:),[1,N_a,N_j-1,T-1]); % PolicyPath is of size [l_d+l_aprime+1,N_a,N_j,T] + L2index=reshape(permute(L2index,[2,3,1,4]),[N_a*(N_j-1),1,T-1]); + PolicyaprimejPath=reshape(PolicyaprimejPath,[N_a*(N_j-1),1,T-1]); % reinterpret this as lower grid index + PolicyaprimejPath=repelem(PolicyaprimejPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejPath(:,2,:)=PolicyaprimejPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point + end +end +% Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats +PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,n_d,n_a,0,N_j,T-1,d_grid,a_grid,vfoptions,1,0); +PolicyValuesPath=permute(PolicyValuesPath,[2,3,1,4]); %[N_a,N_j,l_d+l_aprime,T-1] % fastOLG ordering is needed for AggVars + +%% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm +% Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate +AgentDist=AgentDist_initial; +for tt=1:T-1 + + % Get t-1 PricePath and ParamPath before we update them + if use_tminus1price==1 + for pp=1:length(tminus1priceNames) + if tt>1 + Parameters.([tminus1priceNames{pp},'_tminus1'])=Parameters.(tminus1priceNames{pp}); + else + Parameters.([tminus1priceNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1priceNames{pp}); + end + end + end + if use_tminus1params==1 + for pp=1:length(tminus1paramNames) + if tt>1 + Parameters.([tminus1paramNames{pp},'_tminus1'])=Parameters.(tminus1paramNames{pp}); + else + Parameters.([tminus1paramNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1paramNames{pp}); + end + end + end + % Get t-1 AggVars before we update them + if use_tminus1AggVars==1 + for pp=1:length(tminus1AggVarsNames) + if tt>1 + % The AggVars have not yet been updated, so they still contain previous period values + Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=Parameters.(tminus1AggVarsNames{pp}); + else + Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1AggVarsNames{pp}); + end + end + end + + % Update current PricePath and ParamPath + for kk=1:length(PricePathNames) + Parameters.(PricePathNames{kk})=PricePathOld(tt,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); + end + for kk=1:length(ParamPathNames) + Parameters.(ParamPathNames{kk})=ParamPath(tt,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); + end + + % Get t+1 PricePath + if use_tplus1price==1 + for pp=1:length(tplus1priceNames) + kk=tplus1pricePathkk(pp); + Parameters.([tplus1priceNames{pp},'_tplus1'])=PricePathOld(tt+1,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); % Make is so that the time t+1 variables can be used + end + end + + %% Get the current optimal policy, and iterate the agent dist + if simoptions.fastOLG==0 + AgeWeights=AgeWeights_T(:,:,tt); + else % simoptions.fastOLG==1 + AgeWeights=AgeWeights_T(:,tt); + end + + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + + if simoptions.fastOLG==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_Iteration_noz_raw(AgentDist,PolicyaprimePath_slowOLG(:,:,tt),N_a,N_j,II1,II2,jequalOneDist); + else % simoptions.fastOLG==1 + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_noz_raw(AgentDist,PolicyaprimejPath(:,tt),N_a,N_j,II1,II2,jequalOneDist); + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_noz_raw(AgentDist,PolicyaprimejPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_j,II,jequalOneDist); + end + end + + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz(AgentDist.*AgeWeights,PolicyValuesPath(:,:,1:l_d,tt), PolicyValuesPath(:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,N_a,a_gridvals,1); + for ii=1:length(AggVarNames) + Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; + end + % Keep AggVars in the AggVarsPath + for ii=1:length(AggVarNames) + AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; + end + + AgentDist=AgentDistnext; +end + + +end \ No newline at end of file diff --git a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_raw.m b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_raw.m new file mode 100644 index 00000000..31ae29ae --- /dev/null +++ b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_raw.m @@ -0,0 +1,201 @@ +function AggVarsPath=TransitionPath_FHorz_PType_singlepath_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_j,d_grid,a_grid,daprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, vfoptions, simoptions) +% When doing shooting alogrithm on TPath FHorz PType, this is for a given ptype, and does the steps of back-iterate to get policy, then forward to get agent dist and agg vars. +% The only output is the agg vars path. + +AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect + +if N_d==0 + l_d=0; +else + l_d=length(n_d); +end +l_aprime=length(n_a); + +%% +% Shapes: +% V is [N_a,N_z,N_j] +% AgentDist for basic is [N_a*N_z,N_j] +% AgentDist for fastOLG is [N_a*N_j*N_z,1] + +if vfoptions.gridinterplayer==0 + PolicyIndexesPath=zeros(l_d+l_aprime,N_a,N_z,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +elseif vfoptions.gridinterplayer==1 + PolicyIndexesPath=zeros(l_d+l_aprime+1,N_a,N_z,N_j,T-1,'gpuArray'); %Periods 1 to T-1 +end +if simoptions.gridinterplayer==0 + if simoptions.fastOLG==0 + II1=1:1:N_a*N_z; + II2=ones(N_a*N_z,1); + elseif simoptions.fastOLG==1 + II1=1:1:N_a*(N_j-1)*N_z; + II2=ones(N_a*(N_j-1)*N_z,1); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_z,1)+N_a*N_j*repelem((0:1:N_z-1)',N_a,1); + end +elseif simoptions.gridinterplayer==1 + N_probs=2; + if simoptions.fastOLG==0 + error('Cannot use simoptions.fastOLG=0 with grid interpolation layer') + elseif simoptions.fastOLG==1 + PolicyProbsPath=zeros(N_a*(N_j-1)*N_z,N_probs,T-1,'gpuArray'); % preallocate + II=repelem((1:1:N_a*(N_j-1)*N_z)',1,N_probs); + exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + justfirstj=repmat((1:1:N_a)',N_z,1)+N_a*N_j*repelem((0:1:N_z-1)',N_a,1); + end +end + + +%% First, go from T-1 to 1 calculating the Value function and Optimal policy function at each step. +% Since we won't need to keep the value functions for anything later we just store the current one in V +V=V_final; +for ttr=1:T-1 %so tt=T-ttr + + for kk=1:length(PricePathNames) + Parameters.(PricePathNames{kk})=PricePathOld(T-ttr,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); + end + for kk=1:length(ParamPathNames) + Parameters.(ParamPathNames{kk})=ParamPath(T-ttr,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); + end + + if transpathoptions.zpathtrivial==0 + z_gridvals_J=transpathoptions.z_gridvals_J_T(:,:,:,T-ttr); + pi_z_J=transpathoptions.pi_z_J_T(:,:,:,T-ttr); + end + + [V, Policy]=ValueFnIter_FHorz_TPath_SingleStep(V,n_d,n_a,n_z,N_j,d_gridvals, a_grid, z_gridvals_J, pi_z_J, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + % The V input is next period value fn, the V output is this period. + % Policy is kept in the form where it is just a single-value in (d,a') + + PolicyIndexesPath(:,:,:,:,T-ttr)=Policy; +end + +%% Modify PolicyIndexesPath into forms needed for forward iteration +% Create version of PolicyIndexesPath called PolicyaprimePath, which only tracks aprime and has j=1:N_j-1 as we don't use N_j to iterate agent dist (there is no N_j+1) +% For fastOLG we use PolicyaprimejPath, if there is z then PolicyaprimejzPath +% When using grid interpolation layer also PolicyProbsPath +if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,1:N_j-1,:),[N_a*N_z,N_j-1,T-1]); % aprime index +elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,:,1:N_j-1,:)-1),[N_a*N_z,N_j-1,T-1]); +elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,:,1:N_j-1,:)-1),[N_a*N_z,N_j-1,T-1]); +elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,:,1:N_j-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,:,1:N_j-1,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(l_d+4,:,:,1:N_j-1,:)-1),[N_a*N_z,N_j-1,T-1]); +end +if simoptions.fastOLG==0 + PolicyaprimezPath_slowOLG=PolicyaprimePath+repelem(N_a*gpuArray(0:1:N_z-1)',N_a,1); +elseif simoptions.fastOLG==1 + PolicyaprimePath=reshape(permute(reshape(PolicyaprimePath,[N_a,N_z,N_j-1,T-1]),[1,3,2,4]),[N_a*(N_j-1)*N_z,T-1]); + PolicyaprimejzPath=PolicyaprimePath+repelem(N_a*gpuArray(0:1:(N_j-1)*N_z-1)',N_a,1); + if simoptions.gridinterplayer==1 + L2index=reshape(PolicyIndexesPath(l_d+l_aprime+1,:,:,1:N_j-1,:),[1,N_a,N_z,N_j-1,T-1]); % PolicyIndexesPath is of size [l_d+l_aprime+1,N_a,N_z,N_j,T] + L2index=reshape(permute(L2index,[2,4,3,1,5]),[N_a*(N_j-1)*N_z,1,T-1]); + PolicyaprimejzPath=reshape(PolicyaprimejzPath,[N_a*(N_j-1)*N_z,1,T-1]); % reinterpret this as lower grid index + PolicyaprimejzPath=repelem(PolicyaprimejzPath,1,2,1); % create copy that will be the upper grid index + PolicyaprimejzPath(:,2,:)=PolicyaprimejzPath(:,2,:)+1; % upper grid index + PolicyProbsPath(:,2,:)=L2index; % L2 index + PolicyProbsPath(:,2,:)=(PolicyProbsPath(:,2,:)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1,:)=1-PolicyProbsPath(:,2,:); % probability of lower grid point + end +end +% Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats +PolicyValuesPath=PolicyInd2Val_FHorz_TPath(PolicyIndexesPath,n_d,n_a,n_z,N_j,T-1,d_grid,a_grid,vfoptions,1,0); +PolicyValuesPath=permute(PolicyValuesPath,[2,4,3,1,5]); %[N_a,N_j,N_z,l_d+l_aprime,T-1] % fastOLG ordering is needed for AggVars + +%% Iterate forward over t: iterate agent dist, calculate aggvars, evaluate general eqm +% Call AgentDist the current periods distn and AgentDistnext the next periods distn which we must calculate +AgentDist=AgentDist_initial; +for tt=1:T-1 + + % Get t-1 PricePath and ParamPath before we update them + if use_tminus1price==1 + for pp=1:length(tminus1priceNames) + if tt>1 + Parameters.([tminus1priceNames{pp},'_tminus1'])=Parameters.(tminus1priceNames{pp}); + else + Parameters.([tminus1priceNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1priceNames{pp}); + end + end + end + if use_tminus1params==1 + for pp=1:length(tminus1paramNames) + if tt>1 + Parameters.([tminus1paramNames{pp},'_tminus1'])=Parameters.(tminus1paramNames{pp}); + else + Parameters.([tminus1paramNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1paramNames{pp}); + end + end + end + % Get t-1 AggVars before we update them + if use_tminus1AggVars==1 + for pp=1:length(tminus1AggVarsNames) + if tt>1 + % The AggVars have not yet been updated, so they still contain previous period values + Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=Parameters.(tminus1AggVarsNames{pp}); + else + Parameters.([tminus1AggVarsNames{pp},'_tminus1'])=transpathoptions.initialvalues.(tminus1AggVarsNames{pp}); + end + end + end + + % Update current PricePath and ParamPath + for kk=1:length(PricePathNames) + Parameters.(PricePathNames{kk})=PricePathOld(tt,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); + end + for kk=1:length(ParamPathNames) + Parameters.(ParamPathNames{kk})=ParamPath(tt,ParamPathSizeVec(1,kk):ParamPathSizeVec(2,kk)); + end + + % Get t+1 PricePath + if use_tplus1price==1 + for pp=1:length(tplus1priceNames) + kk=tplus1pricePathkk(pp); + Parameters.([tplus1priceNames{pp},'_tplus1'])=PricePathOld(tt+1,PricePathSizeVec(1,kk):PricePathSizeVec(2,kk)); % Make is so that the time t+1 variables can be used + end + end + + %% Get the current optimal policy, and iterate the agent dist + if transpathoptions.zpathtrivial==0 + z_gridvals_J_fastOLG=transpathoptions.ze_gridvals_J_fastOLG(:,:,:,tt); + if simoptions.fastOLG==0 + pi_z_J=transpathoptions.pi_z_J_T(:,:,:,tt); + else + pi_z_J_sim=transpathoptions.pi_z_J_sim_T(:,:,:,tt); + end + end + + if simoptions.fastOLG==0 + AgeWeights=AgeWeights_T(:,:,tt); + else % simoptions.fastOLG==1 + AgeWeights=AgeWeights_T(:,tt); + end + + jequalOneDist=jequalOneDist_T(:,tt+1); % Note: t+1 as we are about to create the next period AgentDist + + if simoptions.fastOLG==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_Iteration_raw(AgentDist,PolicyaprimezPath_slowOLG(:,:,tt),N_a,N_z,N_j,pi_z_J,II1,II2,jequalOneDist); + else % simoptions.fastOLG==1 + if simoptions.gridinterplayer==0 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_raw(AgentDist,PolicyaprimejzPath(:,tt),N_a,N_z,N_j,pi_z_J_sim,II1,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + elseif simoptions.gridinterplayer==1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_raw(AgentDist,PolicyaprimejzPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_z,N_j,pi_z_J_sim,II,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); + end + end + + %% AggVars + AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights, PolicyValuesPath(:,:,:,1:l_d,tt), PolicyValuesPath(:,:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_z,N_a,N_z,a_gridvals,z_gridvals_J_fastOLG,1); + for ii=1:length(AggVarNames) + Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; + end + % Keep AggVars in the AggVarsPath + for ii=1:length(AggVarNames) + AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; + end + + + AgentDist=AgentDistnext; +end + +end \ No newline at end of file From c63bbf9103486119365ae70b5e1e110ccfb2ac63 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Thu, 22 Jan 2026 12:27:25 +1300 Subject: [PATCH 25/67] clean --- .../PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m | 9 ++------- .../InfHorz/HeteroAgentStationaryEqm_Case1.m | 8 ++------ .../InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m | 9 ++------- 3 files changed, 6 insertions(+), 20 deletions(-) diff --git a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m index 790279f1..51a4ceca 100644 --- a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m +++ b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m @@ -689,13 +689,6 @@ %% Have now finished creating PTypeStructure. Time to do the actual finding the HeteroAgentStationaryEqm: -%% If using fminalgo=5, then need some further setup -if heteroagentoptions.fminalgo==5 - % If using a shooting algorithm, set that up - heteroagentoptions=setupGEnewprice3_shooting(heteroagentoptions,GeneralEqmEqns,GEPriceParamNames); -end - - %% if heteroagentoptions.maxiter>0 % Can use heteroagentoptions.maxiter=0 to just evaluate the current general eqm eqns @@ -785,6 +778,8 @@ [p_eqm_vec,GeneralEqmConditions,counteval,stopflag,out,bestever] = cmaes_vfitoolkit(GeneralEqmConditionsFnOpt,GEparamsvec0,heteroagentoptions.insigma,heteroagentoptions.inopts); % ,varargin); elseif heteroagentoptions.fminalgo==5 % Update based on rules in heteroagentoptions.fminalgo5.howtoupdate + % Set up the howtoupdate rules in the format needed + heteroagentoptions=setupGEnewprice3_shooting(heteroagentoptions,GeneralEqmEqns,GEPriceParamNames); % Get initial prices, p p=nan(1,length(GEPriceParamNames)); for ii=1:length(GEPriceParamNames) diff --git a/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1.m b/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1.m index 29cdc341..fb90b94d 100644 --- a/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1.m +++ b/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1.m @@ -360,12 +360,6 @@ %% Enough setup, Time to do the actual finding the HeteroAgentStationaryEqm: -%% If using fminalgo=5, then need some further setup -if heteroagentoptions.fminalgo==5 - % If using a shooting algorithm, set that up - heteroagentoptions=setupGEnewprice3_shooting(heteroagentoptions,GeneralEqmEqns,GEPriceParamNames); -end - %% If there is entry and exit, then send to relevant command if isfield(simoptions,'agententryandexit')==1 @@ -452,6 +446,8 @@ [p_eqm_vec,GeneralEqmConditions,counteval,stopflag,out,bestever] = cmaes_vfitoolkit(GeneralEqmConditionsFnOpt,GEparamsvec0,heteroagentoptions.insigma,heteroagentoptions.inopts); % ,varargin); elseif heteroagentoptions.fminalgo==5 % Update based on rules in heteroagentoptions.fminalgo5.howtoupdate + % Set up the howtoupdate rules in the format needed + heteroagentoptions=setupGEnewprice3_shooting(heteroagentoptions,GeneralEqmEqns,GEPriceParamNames); % Get initial prices, p p=nan(1,length(GEPriceParamNames)); for ii=1:length(GEPriceParamNames) diff --git a/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m b/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m index e2dce293..002945c3 100644 --- a/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m +++ b/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m @@ -639,13 +639,6 @@ %% Have now finished creating PTypeStructure. Time to do the actual finding the HeteroAgentStationaryEqm: -%% If using fminalgo=5, then need some further setup -if heteroagentoptions.fminalgo==5 - % If using a shooting algorithm, set that up - heteroagentoptions=setupGEnewprice3_shooting(heteroagentoptions,GeneralEqmEqns,GEPriceParamNames); -end - - %% if heteroagentoptions.maxiter>0 % Can use heteroagentoptions.maxiter=0 to just evaluate the current general eqm eqns @@ -723,6 +716,8 @@ [p_eqm_vec,GeneralEqmConditions,counteval,stopflag,out,bestever] = cmaes_vfitoolkit(GeneralEqmConditionsFnOpt,GEparamsvec0,heteroagentoptions.insigma,heteroagentoptions.inopts); % ,varargin); elseif heteroagentoptions.fminalgo==5 % Update based on rules in heteroagentoptions.fminalgo5.howtoupdate + % Set up the howtoupdate rules in the format needed + heteroagentoptions=setupGEnewprice3_shooting(heteroagentoptions,GeneralEqmEqns,GEPriceParamNames); % Get initial prices, p p=nan(1,length(GEPriceParamNames)); for ii=1:length(GEPriceParamNames) From 6cae6d432e07699ceb32f7f2e7d8725ba3fb52af Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Thu, 22 Jan 2026 15:17:24 +1300 Subject: [PATCH 26/67] minor --- Optimization/setupGEnewprice3_shooting.m | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Optimization/setupGEnewprice3_shooting.m b/Optimization/setupGEnewprice3_shooting.m index 91afcd23..3d8eea0e 100644 --- a/Optimization/setupGEnewprice3_shooting.m +++ b/Optimization/setupGEnewprice3_shooting.m @@ -8,13 +8,14 @@ nGeneralEqmEqns=length(GEeqnNames); %% Set up GEnewprice==3 (if relevant) +fminalgo5=0; if isfield(options,'fminalgo5') % in stationary general eqm, fminalgo5 is shooting fminalgo5=1; % options.GEnewprice=3; options.GEnewprice3=options.fminalgo5; options.oldpathweight=0; % Not actually used for anything elseif options.GEnewprice~=3 - return + return % Not being used end options.weightscheme=0; @@ -168,7 +169,7 @@ %% If doing stationary general eqm, call output fminalgo5 instead of GEnewprice3 -if fminalgo5==1 +if fminalgo5==1 options.fminalgo5=options.GEnewprice3; options=rmfield(options,'GEnewprice3'); options=rmfield(options,'oldpathweight'); From c387dba6fe89aac08024d201337a3bf599be2f95 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Thu, 22 Jan 2026 16:07:26 +1300 Subject: [PATCH 27/67] fix FHorz TPath PType --- .../PType/TransitionPath_Case1_FHorz_PType.m | 315 ++++-------------- ...ransitionPath_Case1_FHorz_PType_shooting.m | 42 +-- .../TransitionPath_FHorz_PType_singlepath.m | 16 +- ...nsitionPath_FHorz_PType_singlepath_e_raw.m | 12 +- ...ath_FHorz_PType_singlepath_fastOLG_e_raw.m | 14 +- ...FHorz_PType_singlepath_fastOLG_noz_e_raw.m | 13 +- ...h_FHorz_PType_singlepath_fastOLG_noz_raw.m | 13 +- ...nPath_FHorz_PType_singlepath_fastOLG_raw.m | 14 +- ...ionPath_FHorz_PType_singlepath_noz_e_raw.m | 12 +- ...itionPath_FHorz_PType_singlepath_noz_raw.m | 12 +- ...ransitionPath_FHorz_PType_singlepath_raw.m | 14 +- 11 files changed, 154 insertions(+), 323 deletions(-) diff --git a/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType.m b/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType.m index d73ed6b1..5670e520 100644 --- a/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType.m +++ b/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType.m @@ -453,260 +453,85 @@ PTypeStructure.(iistr).AggVarNames=FnNames; - %% Check if pi_z and z_grid can be precomputed - % Note: cannot handle that whether not not they can be precomputed differs across ptypes - transpathoptions.zpathprecomputed=0; - if N_z>0 - if ndims(PTypeStructure.(iistr).pi_z)==2 - transpathoptions.zpathprecomputed=1; - transpathoptions.zpathtrivial=1; % z_grid_J and pi_z_J are not varying over the path - z_gridvals_J=CreateGridvals(PTypeStructure.(iistr).n_z,gpuArray(PTypeStructure.(iistr).z_grid),1).*ones(1,1,PTypeStructure.(iistr).N_j); - pi_z_J=gpuArray(PTypeStructure.(iistr).pi_z.*ones(1,1,PTypeStructure.(iistr).N_j)); - elseif ndims(PTypeStructure.(iistr).pi_z)==3 - transpathoptions.zpathprecomputed=1; - transpathoptions.zpathtrivial=1; % z_grid_J and pi_z_J are not varying over the path - z_gridvals_J=gpuArray(PTypeStructure.(iistr).z_grid); - pi_z_J=gpuArray(PTypeStructure.(iistr).pi_z); - end - if isfield(PTypeStructure.(iistr).vfoptions,'ExogShockFn') - % Note: If ExogShockFn depends on the path, it must be done via a parameter - % that depends on the path (i.e., via ParamPath or PricePath) - PTypeStructure.(iistr).vfoptions.ExogShockFnParamNames=getAnonymousFnInputNames(PTypeStructure.(iistr).vfoptions.ExogShockFn); - overlap=0; - for pp=1:length(PTypeStructure.(iistr).vfoptions.ExogShockFnParamNames) - if strcmp(PTypeStructure.(iistr).vfoptions.ExogShockFnParamNames{pp},PricePathNames) - overlap=1; - end - end - if overlap==0 - transpathoptions.zpathprecomputed=1; - % If ExogShockFn does not depend on any of the prices (in PricePath), then - % we can simply create it now rather than within each 'subfn' or 'p_grid' - - % Check if it depends on the ParamPath - transpathoptions.zpathtrivial=1; - for pp=1:length(PTypeStructure.(iistr).vfoptions.ExogShockFnParamNames) - if strcmp(PTypeStructure.(iistr).vfoptions.ExogShockFnParamNames{pp},ParamPathNames) - transpathoptions.zpathtrivial=0; - end - end - if transpathoptions.zpathtrivial==1 - pi_z_J=zeros(N_z,N_z,N_j,'gpuArray'); - z_gridvals_J=zeros(sum(n_z),length(n_z),N_j,'gpuArray'); - for jj=1:N_j - ExogShockFnParamsVec=CreateVectorFromParams(PTypeStructure.(iistr).Parameters, PTypeStructure.(iistr).vfoptions.ExogShockFnParamNames,jj); - ExogShockFnParamsCell=cell(length(ExogShockFnParamsVec),1); - for pp=1:length(ExogShockFnParamsVec) - ExogShockFnParamsCell(pp,1)={ExogShockFnParamsVec(pp)}; - end - [z_grid,pi_z]=vfoptions.ExogShockFn(ExogShockFnParamsCell{:}); - pi_z_J(:,:,jj)=gpuArray(pi_z); - z_gridvals_J(:,jj)=CreateGridVals(n_z,gpuArray(z_grid),1); - end - elseif transpathoptions.zpathtrivial==0 - % z_grid_J and/or pi_z_J varies along the transition path (but only depending on ParamPath, not PricePath - transpathoptions.(iistr).pi_z_J_T=zeros(N_z,N_z,N_j,T,'gpuArray'); - transpathoptions.(iistr).z_grid_J_T=zeros(sum(n_z),length(n_z),N_j,T,'gpuArray'); - pi_z_J=zeros(N_z,N_z,N_j,'gpuArray'); - z_gridvals_J=zeros(sum(n_z),length(n_z),N_j,'gpuArray'); - for tt=1:T - for pp=1:length(ParamPathNames) - PTypeStructure.(iistr).Parameters.(ParamPathNames{pp})=ParamPathStruct.(ParamPathNames{pp}); - end - % Note, we know the PricePath is irrelevant for the current purpose - for jj=1:N_j - ExogShockFnParamsVec=CreateVectorFromParams(PTypeStructure.(iistr).Parameters, PTypeStructure.(iistr).vfoptions.ExogShockFnParamNames,jj); - ExogShockFnParamsCell=cell(length(ExogShockFnParamsVec),1); - for pp=1:length(ExogShockFnParamsVec) - ExogShockFnParamsCell(pp,1)={ExogShockFnParamsVec(pp)}; - end - [z_grid,pi_z]=PTypeStructure.(iistr).vfoptions.ExogShockFn(ExogShockFnParamsCell{:}); - pi_z_J(:,:,jj)=gpuArray(pi_z); - z_gridvals_J(:,jj)=CreateGridVals(n_z,gpuArray(z_grid),1); - end - transpathoptions.(iistr).pi_z_J_T(:,:,:,tt)=pi_z_J; - transpathoptions.(iistr).z_gridvals_J_T(:,:,:,tt)=z_gridvals_J; - end - end - end + %% Set up exogenous shock processes + [PTypeStructure.(iistr).z_gridvals_J, PTypeStructure.(iistr).pi_z_J, PTypeStructure.(iistr).pi_z_J_sim, PTypeStructure.(iistr).e_gridvals_J, PTypeStructure.(iistr).pi_e_J, PTypeStructure.(iistr).pi_e_J_sim, PTypeStructure.(iistr).ze_gridvals_J_fastOLG, transpathoptions, simoptions]=ExogShockSetup_TPath_FHorz(PTypeStructure.(iistr).n_z,PTypeStructure.(iistr).z_grid,PTypeStructure.(iistr).pi_z,PTypeStructure.(iistr).N_a,PTypeStructure.(iistr).N_j,PTypeStructure.(iistr).Parameters,PricePathNames,ParamPathNames,transpathoptions,PTypeStructure.(iistr).simoptions,4); + % Convert z and e to age-dependent joint-grids and transtion matrix + % output: z_gridvals_J, pi_z_J, e_gridvals_J, pi_e_J, transpathoptions,vfoptions,simoptions + + %% We can precompute some things that the fastOLG needs for the agent dist + % But only bother with this when using fastOLG=1 + if transpathoptions.fastOLG==1 + if PTypeStructure.(iistr).simoptions.gridinterplayer==1 + N_probs=2; + else + N_probs=1; end - - if transpathoptions.fastOLG==1 % Reshape grid and transtion matrix for use with fastOLG - z_gridvals_J=permute(z_gridvals_J,[3,1,2]); % Give it the size required for CreateReturnFnMatrix_Case1_Disc_Par2_fastOLG(): N_j-by-N_z-by-l_z - pi_z_J=permute(pi_z_J,[3,2,1]); % We want it to be (j,z',z) for value function - transpathoptions.(iistr).pi_z_J_alt=permute(pi_z_J,[1,3,2]); % But is (j,z,z') for agent dist with fastOLG [note, this permute is off the previous one] - if transpathoptions.zpathtrivial==0 - temp=transpathoptions.(iistr).z_grid_J_T; - transpathoptions=rmfield(transpathoptions,'z_grid_J_T'); - transpathoptions.(iistr).z_gridvals_J_T=zeros(N_z,l_z,N_j,T,'gpuArray'); - for tt=1:T - for jj=1:N_j - transpathoptions.(iistr).z_gridvals_J_T(:,:,jj,tt)=CreateGridvals(n_z,temp(:,jj,tt),1); - end + if N_z==0 + if N_e==0 % no z, no e + if PTypeStructure.(iistr).simoptions.gridinterplayer==0 + II1=1:1:N_a*(N_j-1); + PTypeStructure.(iistr).II2=ones(N_a*(N_j-1),1); + PTypeStructure.(iistr).exceptlastj=repmat((1:1:N_a)',N_j-1,1)+repelem(N_a*(0:1:N_j-2)',N_a,1); % Note: there is one use of N_j which is because we want to index AgentDist + PTypeStructure.(iistr).exceptfirstj=[]; % not needed + PTypeStructure.(iistr).justfirstj=[]; % not needed + elseif PTypeStructure.(iistr).simoptions.gridinterplayer==1 + II=repelem((1:1:N_a*(N_j-1))',1,N_probs); + PTypeStructure.(iistr).exceptlastj=[]; % not needed + PTypeStructure.(iistr).exceptfirstj=[]; % not needed + PTypeStructure.(iistr).justfirstj=[]; % not needed end - transpathoptions.(iistr).z_gridvals_J_T=permute(transpathoptions.(iistr).z_gridvals_J_T,[3,1,2,4]); % from [N_z,l_z,N_j,T] to [N_j,N_z,l_z,T] - transpathoptions.(iistr).pi_z_J_T=permute(transpathoptions.(iistr).pi_z_J_T,[3,1,2,4]); % We want it to be (j,z,z',t) - transpathoptions.(iistr).pi_z_J_T_alt=permute(transpathoptions.(iistr).pi_z_J_T,[1,3,2,4]); % We want it to be (j,z',z,t) [note, this permute is off the previous one] - end - end - - % z_gridvals_J is [N_z,l_z,N_j] if transpathoptions.fastOLG=0 - % is [N_j,N_z,l_z] if transpathoptions.fastOLG=1 - % pi_z_J is [N_z,N_z,N_j] if transpathoptions.fastOLG=0 (j,z,z') - % pi_z_J is [N_j,N_z,N_z] if transpathoptions.fastOLG=1 (j,z',z) - % pi_z_J and z_gridvals_J are both gpuArrays - % Now store them - PTypeStructure.(iistr).pi_z_J=gpuArray(pi_z_J); - PTypeStructure.(iistr).z_gridvals_J=gpuArray(z_gridvals_J); - end - %% If used, check if pi_e and e_grid can be procomputed - % Note: cannot handle that whether not not they can be precomputed differs across ptypes - if N_e>0 - % Check if e_grid and/or pi_e depend on prices. If not then create pi_e_J and e_grid_J for the entire transition before we start - - if isfield(PTypeStructure.(iistr).vfoptions,'pi_e') - transpathoptions.epathprecomputed=1; - transpathoptions.epathtrivial=1; % e_grid_J and pi_e_J are not varying over the path - if size(pi_e,2)==1 % does not depend on age - pi_e_J=PTypeStructure.(iistr).vfoptions.pi_e.*ones(1,N_j); - e_gridvals_J=CreateGridVals(PTypeStructure.(iistr).n_e,PTypeStructure.(iistr).vfoptions.e_grid,1); - else % depends on age - pi_e_J=PTypeStructure.(iistr).vfoptions.pi_e; - e_gridvals_J=PTypeStructure.(iistr).vfoptions.e_grid; - end - elseif isfield(PTypeStructure.(iistr).vfoptions,'EiidShockFn') - transpathoptions.epathprecomputed=0; - - % Note: If EiidShockFn depends on the path, it must be done via a parameter - % that depends on the path (i.e., via ParamPath or PricePath) - PTypeStructure.(iistr).vfoptions.EiidShockFnParamNames=getAnonymousFnInputNames(PTypeStructure.(iistr).vfoptions.EiidShockFn); - overlap=0; - for pp=1:length(PTypeStructure.(iistr).vfoptions.EiidShockFnParamNames) - if strcmp(PTypeStructure.(iistr).vfoptions.EiidShockFnParamNames{pp},PricePathNames) - overlap=1; + else % no z, yes e + if PTypeStructure.(iistr).simoptions.gridinterplayer==0 + II1=1:1:N_a*(N_j-1)*N_e; + PTypeStructure.(iistr).II2=ones(N_a*(N_j-1)*N_e,1); + PTypeStructure.(iistr).exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + PTypeStructure.(iistr).exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + PTypeStructure.(iistr).justfirstj=repmat((1:1:N_a)',N_e,1)+N_a*N_j*repelem((0:1:N_e-1)',N_a,1); + elseif PTypeStructure.(iistr).simoptions.gridinterplayer==1 + II=repelem((1:1:N_a*(N_j-1)*N_e)',1,N_probs); + PTypeStructure.(iistr).exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + PTypeStructure.(iistr).exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_e,1)+repelem(N_a*N_j*(0:1:N_e-1)',N_a*(N_j-1),1); + PTypeStructure.(iistr).justfirstj=repmat((1:1:N_a)',N_e,1)+N_a*N_j*repelem((0:1:N_e-1)',N_a,1); end end - if overlap==0 - transpathoptions.epathprecomputed=1; - % If ExogShockFn does not depend on any of the prices (in PricePath), then - % we can simply create it now rather than within each 'subfn' or 'p_grid' - - % Check if it depends on the ParamPath - transpathoptions.epathtrivial=1; - for pp=1:length(PTypeStructure.(iistr).vfoptions.EiidShockFnParamNames) - if strcmp(PTypeStructure.(iistr).vfoptions.EiidShockFnParamNames{pp},ParamPathNames) - transpathoptions.epathtrivial=0; - end + else % N_z>0 + if N_e==0 % z, no e + if PTypeStructure.(iistr).simoptions.gridinterplayer==0 + II1=1:1:N_a*(N_j-1)*N_z; + PTypeStructure.(iistr).II2=ones(N_a*(N_j-1)*N_z,1); + PTypeStructure.(iistr).exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + PTypeStructure.(iistr).exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + PTypeStructure.(iistr).justfirstj=repmat((1:1:N_a)',N_z,1)+N_a*N_j*repelem((0:1:N_z-1)',N_a,1); + elseif PTypeStructure.(iistr).simoptions.gridinterplayer==1 + II=repelem((1:1:N_a*(N_j-1)*N_z)',1,N_probs); + PTypeStructure.(iistr).exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + PTypeStructure.(iistr).exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z,1)+repelem(N_a*N_j*(0:1:N_z-1)',N_a*(N_j-1),1); + PTypeStructure.(iistr).justfirstj=repmat((1:1:N_a)',N_z,1)+N_a*N_j*repelem((0:1:N_z-1)',N_a,1); end - if transpathoptions.epathtrivial==1 - pi_e_J=zeros(N_e,N_j,'gpuArray'); - e_gridvals_J=zeros(sum(PTypeStructure.(iistr).vfoptions.n_e),l_e,N_j,'gpuArray'); - for jj=1:N_j - EiidShockFnParamsVec=CreateVectorFromParams(PTypeStructure.(iistr).Parameters, PTypeStructure.(iistr).vfoptions.EiidShockFnParamNames,jj); - EiidShockFnParamsCell=cell(length(EiidShockFnParamsVec),1); - for pp=1:length(EiidShockFnParamsVec) - EiidShockFnParamsCell(pp,1)={EiidShockFnParamsVec(pp)}; - end - [e_grid,pi_e]=PTypeStructure.(iistr).vfoptions.EiidShockFn(EiidShockFnParamsCell{:}); - pi_e_J(:,jj)=gpuArray(pi_e); - e_gridvals_J(:,:,jj)=CreateGridVals(n_e,gpuArray(e_grid),1); - end - elseif transpathoptions.epathtrivial==0 - % e_grid_J and/or pi_e_J varies along the transition path (but only depending on ParamPath, not PricePath) - transpathoptions.(iistr).pi_e_J_T=zeros(N_e,N_j,T,'gpuArray'); - transpathoptions.(iistr).e_gridvals_J_T=zeros(sum(PTypeStructure.(iistr).vfoptions.n_e),l_e,N_j,T,'gpuArray'); - pi_e_J=zeros(N_e,N_j,'gpuArray'); - e_gridvals_J=zeros(sum(PTypeStructure.(iistr).vfoptions.n_e),N_j,'gpuArray'); - for tt=1:T - for pp=1:length(ParamPathNames) - PTypeStructure.(iistr).Parameters.(ParamPathNames{pp})=ParamPathStruct.(ParamPathNames{pp}); - end - % Note, we know the PricePath is irrelevant for the current purpose - for jj=1:N_j - EiidShockFnParamsVec=CreateVectorFromParams(PTypeStructure.(iistr).Parameters, vPTypeStructure.(iistr).foptions.EiidShockFnParamNames,jj); - EiidShockFnParamsCell=cell(length(EiidShockFnParamsVec),1); - for pp=1:length(ExogShockFnParamsVec) - EiidShockFnParamsCell(pp,1)={EiidShockFnParamsVec(pp)}; - end - [e_grid,pi_e]=PTypeStructure.(iistr).vfoptions.ExogShockFn(EiidShockFnParamsCell{:}); - pi_e_J(:,jj)=gpuArray(pi_e); - e_gridvals_J(:,:,jj)=CreateGridVals(n_e,gpuArray(e_grid),1); - end - transpathoptions.(iistr).pi_e_J_T(:,:,tt)=pi_e_J; - transpathoptions.(iistr).e_gridvals_J_T(:,:,:,tt)=e_gridvals_J; - end + else % z and e + if PTypeStructure.(iistr).simoptions.gridinterplayer==0 + II1=1:1:N_a*(N_j-1)*N_z*N_e; + PTypeStructure.(iistr).II2=ones(N_a*(N_j-1)*N_z*N_e,1); + PTypeStructure.(iistr).exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + PTypeStructure.(iistr).exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + PTypeStructure.(iistr).justfirstj=repmat((1:1:N_a)',N_z*N_e,1)+N_a*N_j*repelem((0:1:N_z*N_e-1)',N_a,1); + elseif PTypeStructure.(iistr).simoptions.gridinterplayer==1 + II=repelem((1:1:N_a*(N_j-1)*N_z*N_e)',1,N_probs); + PTypeStructure.(iistr).exceptlastj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(0:1:N_j-2)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + PTypeStructure.(iistr).exceptfirstj=repmat((1:1:N_a)',(N_j-1)*N_z*N_e,1)+repmat(repelem(N_a*(1:1:N_j-1)',N_a,1),N_z*N_e,1)+repelem(N_a*N_j*(0:1:N_z*N_e-1)',N_a*(N_j-1),1); + PTypeStructure.(iistr).justfirstj=repmat((1:1:N_a)',N_z*N_e,1)+N_a*N_j*repelem((0:1:N_z*N_e-1)',N_a,1); end end end - % Now store them - PTypeStructure.(iistr).pi_e_J=pi_e_J; - PTypeStructure.(iistr).e_gridvals_J=e_gridvals_J; - - - if transpathoptions.fastOLG==1 % Reshape grid and transtion matrix for use with fastOLG - e_gridvals_J=permute(e_gridvals_J,[3,4,1,2]); % Give it the size required for CreateReturnFnMatrix_Case1_Disc_Par2_fastOLGe: (j,1,N_e,l_e) - pi_e_J=reshape(kron(pi_e_J,ones(N_a,1,'gpuArray'))',[N_a*N_j,1,N_e]); % Give it the size required for fastOLG value function - % transpathoptions.(iistr).pi_e_J_alt=permute(pi_e_J,[1,3,2]); % But is (j,z,z') for agent dist with fastOLG [note, this permute is off the previous one] - if transpathoptions.epathtrivial==0 - temp=transpathoptions.e_grid_J_T; - transpathoptions=rmfield(transpathoptions,'e_grid_J_T'); - transpathoptions.e_gridvals_J_T=zeros(N_e,l_e,N_j,T,'gpuArray'); - for tt=1:T - for jj=1:N_j - e_gridvals_J(:,:,jj,tt)=CreateGridvals(n_e,temp(:,jj,tt),1); - end - end - transpathoptions.e_gridvals_J_T=permute(transpathoptions.e_gridvals_J_T,[3,5,1,2,4]); % from (e,j,t) to (j,e,t) [second dimension is singular, this is how I want it for fastOLG value fn where first dim is j, then second is z (which is not relevant to e)] - transpathoptions.pi_e_J_T=repelem(permute(transpathoptions.pi_e_J_T,[3,1,2,4]),N_a,1,1,1); % We want it to be (a-j,1,e,t) - transpathoptions.pi_e_J_sim_T=zeros(N_a*(N_j-1)*N_z,N_e,T,'gpuArray'); - for tt=1:T - temp=reshape(transpathoptions.pi_e_J_T(:,:,:,tt),[N_a*N_j,N_e]); % transpathoptions.fastOLG means pi_e_J is [N_a*N_j,1,N_e] - transpathoptions.pi_e_J_sim_T(:,:,tt)=kron(ones(N_z,1,'gpuArray'),gpuArray(temp(N_a+1:end,:))); - end - end + % To keep inputs simpler + if PTypeStructure.(iistr).simoptions.gridinterplayer==0 + PTypeStructure.(iistr).II1orII=II1; + elseif PTypeStructure.(iistr).simoptions.gridinterplayer==1 + PTypeStructure.(iistr).II1orII=II; + PTypeStructure.(iistr).II2=[]; end - vfoptions.e_grid_J=gpuArray(e_gridvals_J); - vfoptions.pi_e_J=gpuArray(pi_e_J); - simoptions.e_grid_J=gpuArray(e_gridvals_J); - simoptions.pi_e_J=gpuArray(pi_e_J); - - % e_gridvals_J is [N_e,l_e,N_j] if transpathoptions.fastOLG=0 - % is [N_j,1,N_e,l_e] if transpathoptions.fastOLG=1 - % pi_e_J is [N_e,N_j] if transpathoptions.fastOLG=0 (e,j) - % pi_e_J is [N_a*N_j,1,N_e] if transpathoptions.fastOLG=1 (a-j,1,e) - % pi_e_J and e_gridvals_J are both gpuArrays - end - - %% We can precompute some things that the fastOLG needs for the agent dist - if N_z>0 && N_e==0 - pi_z_J_sim=gather(reshape(transpathoptions.(iistr).pi_z_J_alt(1:end-1,:,:),[(N_j-1)*N_z,N_z])); - - % Precompute some things needed for fastOLG agent dist iteration - PTypeStructure.(iistr).exceptlastj=kron(ones(1,(N_j-1)*N_z),1:1:N_a)+kron(kron(ones(1,N_z),N_a*(0:1:N_j-2)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_z-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist - PTypeStructure.(iistr).exceptfirstj=kron(ones(1,(N_j-1)*N_z),1:1:N_a)+kron(kron(ones(1,N_z),N_a*(1:1:N_j-1)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_z-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist - PTypeStructure.(iistr).justfirstj=kron(ones(1,N_z),1:1:N_a)+N_a+kron(N_a*N_j*(0:1:N_z-1),ones(1,N_a)); - II1=repmat(1:1:(N_j-1)*N_z,1,N_z); - II2=repmat(1:1:(N_j-1),1,N_z*N_z)+repelem((N_j-1)*(0:1:N_z-1),1,N_z*(N_j-1)); - pi_z_J_sim=sparse(II1,II2,pi_z_J_sim,(N_j-1)*N_z,(N_j-1)*N_z); - - PTypeStructure.(iistr).pi_z_J_sim=pi_z_J_sim; - elseif N_z>0 && N_e>0 - pi_z_J_sim=gather(reshape(transpathoptions.(iistr).pi_z_J_alt(1:end-1,:,:),[(N_j-1)*N_z,N_z])); - - % Precompute some things needed for fastOLG agent dist iteration - PTypeStructure.(iistr).exceptlastj=kron(ones(1,(N_j-1)*N_z*N_e),1:1:N_a)+kron(kron(ones(1,N_z*N_e),N_a*(0:1:N_j-2)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_z*N_e-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist - PTypeStructure.(iistr).exceptfirstj=kron(ones(1,(N_j-1)*N_z*N_e),1:1:N_a)+kron(kron(ones(1,N_z*N_e),N_a*(1:1:N_j-1)),ones(1,N_a))+kron(N_a*N_j*(0:1:N_z*N_e-1),ones(1,N_a*(N_j-1))); % Note: there is one use of N_j which is because we want to index AgentDist - PTypeStructure.(iistr).justfirstj=kron(ones(1,N_z*N_e),1:1:N_a)+N_a++kron(N_a*N_j*(0:1:N_z*N_e-1),ones(1,N_a)); - % note that following are not affected by e - II1=repmat(1:1:(N_j-1)*N_z,1,N_z); - II2=repmat(1:1:(N_j-1),1,N_z*N_z)+repelem((N_j-1)*(0:1:N_z-1),1,N_z*(N_j-1)); - pi_z_J_sim=sparse(II1,II2,pi_z_J_sim,(N_j-1)*N_z,(N_j-1)*N_z); - % and we now need additional pi_e_J_sim - pi_e_J_alt=reshape(pi_e_J,[N_a*N_j,N_e]); % transpathoptions.fastOLG means pi_e_J is [N_a*N_j,1,N_e] - pi_e_J_sim=repmat(pi_e_J_alt(N_a+1:end,:),N_z,1); % (a,j,z)-by-e (but only for jj=2:end) - - PTypeStructure.(iistr).pi_z_J_sim=pi_z_J_sim; - PTypeStructure.(iistr).pi_e_J_sim=pi_e_J_sim; + else + end diff --git a/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType_shooting.m b/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType_shooting.m index 2c32d93c..46b31937 100644 --- a/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType_shooting.m +++ b/TransitionPaths/FHorz/PType/TransitionPath_Case1_FHorz_PType_shooting.m @@ -161,12 +161,8 @@ z_gridvals_J=PTypeStructure.(iistr).z_gridvals_J; pi_z_J=PTypeStructure.(iistr).pi_z_J; pi_z_J_sim=PTypeStructure.(iistr).pi_z_J_sim; - exceptlastj=PTypeStructure.(iistr).exceptlastj; - exceptfirstj=PTypeStructure.(iistr).exceptfirstj; - justfirstj=PTypeStructure.(iistr).justfirstj; else z_gridvals_J=[]; pi_z_J=[]; pi_z_J_sim=[]; - exceptlastj=[]; exceptfirstj=[]; justfirstj=[]; end if N_e>0 e_gridvals_J=PTypeStructure.(iistr).e_gridvals_J; @@ -175,6 +171,17 @@ else e_gridvals_J=[]; pi_e_J=[]; pi_e_J_sim=[]; end + ze_gridvals_J_fastOLG=PTypeStructure.(iistr).ze_gridvals_J_fastOLG; + if transpathoptions.fastOLG==1 + exceptlastj=PTypeStructure.(iistr).exceptlastj; + exceptfirstj=PTypeStructure.(iistr).exceptfirstj; + justfirstj=PTypeStructure.(iistr).justfirstj; + II1orII=PTypeStructure.(iistr).II1orII; + II2=PTypeStructure.(iistr).II2; + else + exceptlastj=[]; exceptfirstj=[]; justfirstj=[]; + II1orII=[]; II2=[]; + end ReturnFn=PTypeStructure.(iistr).ReturnFn; Parameters=PTypeStructure.(iistr).Parameters; DiscountFactorParamNames=PTypeStructure.(iistr).DiscountFactorParamNames; @@ -199,9 +206,9 @@ % PricePathSizeVec_ii, ParamPathSizeVec_ii % For current ptype, do the backward iteration of V and Policy, then forward iterate agent dist and get the AggVarsPath - AggVarsPath=TransitionPath_FHorz_PType_singlepath(PricePathOld_ii, ParamPath_ii, PricePathNames,ParamPathNames,T,V_final.(iistr),AgentDist_init.(iistr),jequalOneDist_T.(iistr),AgeWeights_T.(iistr),l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluate, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec_ii, ParamPathSizeVec_ii, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions); + AggVarsPath=TransitionPath_FHorz_PType_singlepath(PricePathOld_ii, ParamPath_ii, PricePathNames,ParamPathNames,T,V_final.(iistr),AgentDist_init.(iistr),jequalOneDist_T.(iistr),AgeWeights_T.(iistr),l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ze_gridvals_J_fastOLG,ReturnFn, FnsToEvaluate, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec_ii, ParamPathSizeVec_ii, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, II1orII, II2, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions); % AggVarsPath=zeros(length(FnsToEvaluate),T-1); - + AggVarsFullPath(PTypeStructure.(iistr).WhichFnsForCurrentPType,:,ii)=AggVarsPath; end % done loop over ii @@ -274,17 +281,10 @@ end end - if transpathoptions.GEnewprice==1 % The GeneralEqmEqns are not really general eqm eqns, but instead have been given in the form of GEprice updating formulae - PricePathNew(tt,:)=real(GeneralEqmConditions_Case1_v3(GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters)); - % Note there is no GEnewprice==2, it uses a completely different code - elseif transpathoptions.GEnewprice==3 % Version of shooting algorithm where the new value is the current value +- fraction*(GECondn) - p_i=real(GeneralEqmConditions_Case1_v3(GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters)); - p_i=p_i(transpathoptions.GEnewprice3.permute); % Rearrange GeneralEqmEqns into the order of the relevant prices - I_makescutoff=(abs(p_i)>transpathoptions.updateaccuracycutoff); - p_i=I_makescutoff.*p_i; - PricePathNew(tt,:)=(PricePathOld(tt,:).*transpathoptions.GEnewprice3.keepold)+transpathoptions.GEnewprice3.add.*transpathoptions.GEnewprice3.factor.*p_i-(1-transpathoptions.GEnewprice3.add).*transpathoptions.GEnewprice3.factor.*p_i; - GECondnPath(tt,:)=p_i; - end + %% General Eqm Eqns + % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) + [PricePathNew_tt,~]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),transpathoptions); + PricePathNew(tt,:)=PricePathNew_tt; end % Done loop over tt, evaluating the GE conditions else % Some GE conditions depend on PType @@ -471,13 +471,13 @@ end + %% Now we just check for convergence, update prices, and give some feedback on progress % See how far apart the price paths are PricePathDist=max(abs(reshape(PricePathNew(1:T-1,:)-PricePathOld(1:T-1,:),[numel(PricePathOld(1:T-1,:)),1]))); % Notice that the distance is always calculated ignoring the time t=T periods, as these needn't ever converges if transpathoptions.verbose==1 - pathcounter % Would be nice to have a way to get the iteration count without having the whole printout of path values (I think that would be useful?) pathnametitles [PricePathOld,PricePathNew] @@ -515,7 +515,7 @@ end end end - if transpathoptions.graphGEconditions==1 + if transpathoptions.graphGEcondns==1 % Do a graph of the General eqm conditions figure(3); for gg=1:length(GEeqnNames) @@ -561,9 +561,9 @@ if transpathoptions.verbose==1 fprintf('Number of iterations on transition path: %i \n',pathcounter) fprintf('Current distance between old and new price path (in L-Infinity norm): %8.6f \n', PricePathDist) - fprintf('Current distance to convergence: %.2f (convergence when reaches 1) \n',TransPathConvergence) %So when this gets to 1 we have convergence (uncomment when you want to see how the convergence isgoing) + fprintf('Ratio of current distance to the convergence tolerance: %.2f (convergence when reaches 1) \n',TransPathConvergence) end - + if transpathoptions.historyofpricepath==1 % Store the whole history of the price path and save it every ten iterations PricePathHistory{pathcounter,1}=PricePathDist; diff --git a/TransitionPaths/FHorz/PType/TransitionPath_FHorz_PType_singlepath.m b/TransitionPaths/FHorz/PType/TransitionPath_FHorz_PType_singlepath.m index 91b77f99..f25355cc 100644 --- a/TransitionPaths/FHorz/PType/TransitionPath_FHorz_PType_singlepath.m +++ b/TransitionPaths/FHorz/PType/TransitionPath_FHorz_PType_singlepath.m @@ -1,4 +1,4 @@ -function AggVarsPath=TransitionPath_FHorz_PType_singlepath(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions) +function AggVarsPath=TransitionPath_FHorz_PType_singlepath(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ze_gridvals_J_fastOLG,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, II1orII, II2, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions) % When doing shooting alogrithm on TPath FHorz PType, this is for a given ptype, and does the steps of back-iterate to get policy, then forward to get agent dist and agg vars. % The only output is the agg vars path. @@ -9,27 +9,27 @@ if N_e==0 AggVarsPath=TransitionPath_FHorz_PType_singlepath_noz_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, vfoptions, simoptions); else - AggVarsPath=TransitionPath_FHorz_PType_singlepath_noz_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, vfoptions, simoptions); + AggVarsPath=TransitionPath_FHorz_PType_singlepath_noz_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,e_gridvals_J,pi_e_J,pi_e_J_sim,ze_gridvals_J_fastOLG,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, vfoptions, simoptions); end else if N_e==0 - AggVarsPath=TransitionPath_FHorz_PType_singlepath_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, vfoptions, simoptions); + AggVarsPath=TransitionPath_FHorz_PType_singlepath_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,ze_gridvals_J_fastOLG,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, vfoptions, simoptions); else - AggVarsPath=TransitionPath_FHorz_PType_singlepath_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, vfoptions, simoptions); + AggVarsPath=TransitionPath_FHorz_PType_singlepath_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ze_gridvals_J_fastOLG,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, vfoptions, simoptions); end end elseif transpathoptions.fastOLG==1 if N_z==0 if N_e==0 - AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_noz_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions); + AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_noz_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, II1orII, II2, transpathoptions, vfoptions, simoptions); else - AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_noz_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions); + AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_noz_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,e_gridvals_J,pi_e_J,pi_e_J_sim,ze_gridvals_J_fastOLG,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, II1orII, II2, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions); end else if N_e==0 - AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions); + AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,ze_gridvals_J_fastOLG,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, II1orII, II2, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions); else - AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions); + AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ze_gridvals_J_fastOLG,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, II1orII, II2, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions); end end end diff --git a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_e_raw.m b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_e_raw.m index efadbe2f..b3b454ca 100644 --- a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_e_raw.m +++ b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_e_raw.m @@ -1,8 +1,8 @@ -function AggVarsPath=TransitionPath_FHorz_PType_singlepath_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,daprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, vfoptions, simoptions) +function AggVarsPath=TransitionPath_FHorz_PType_singlepath_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ze_gridvals_J_fastOLG,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, vfoptions, simoptions) % When doing shooting alogrithm on TPath FHorz PType, this is for a given ptype, and does the steps of back-iterate to get policy, then forward to get agent dist and agg vars. % The only output is the agg vars path. -AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(length(FnsToEvaluateCell),T-1,'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect if N_d==0 l_d=0; @@ -193,12 +193,12 @@ %% AggVars AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights, PolicyValuesPath(:,:,:,1:l_d,tt), PolicyValuesPath(:,:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_ze,N_a,N_ze,a_gridvals,ze_gridvals_J_fastOLG,1); - for ii=1:length(AggVarNames) - Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; + for ff=1:length(AggVarNames) + Parameters.(AggVarNames{ff})=AggVars.(AggVarNames{ff}).Mean; end % Keep AggVars in the AggVarsPath - for ii=1:length(AggVarNames) - AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; + for ff=1:length(AggVarNames) + AggVarsPath(ff,tt)=AggVars.(AggVarNames{ff}).Mean; end AgentDist=AgentDistnext; diff --git a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_e_raw.m b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_e_raw.m index 7f663d2d..0f197e6c 100644 --- a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_e_raw.m +++ b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_e_raw.m @@ -1,15 +1,17 @@ -function AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,daprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions) +function AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,e_gridvals_J,pi_e_J,pi_e_J_sim,ze_gridvals_J_fastOLG,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, II1orII, II2, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions) % When doing shooting alogrithm on TPath FHorz PType, this is for a given ptype, and does the steps of back-iterate to get policy, then forward to get agent dist and agg vars. % The only output is the agg vars path. -AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(length(FnsToEvaluateCell),T-1,'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect if N_d==0 l_d=0; else l_d=length(n_d); end +l_a=length(n_a); l_aprime=length(n_a); +l_z=length(n_z); %% % fastOLG so everything is (a,j,z,e) @@ -157,12 +159,12 @@ %% AggVars AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights, PolicyValuesPath(:,:,:,1:l_d,tt), PolicyValuesPath(:,:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_ze,N_a,N_ze,a_gridvals,ze_gridvals_J_fastOLG,1); - for ii=1:length(AggVarNames) - Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; + for ff=1:length(AggVarNames) + Parameters.(AggVarNames{ff})=AggVars.(AggVarNames{ff}).Mean; end % Keep AggVars in the AggVarsPath - for ii=1:length(AggVarNames) - AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; + for ff=1:length(AggVarNames) + AggVarsPath(ff,tt)=AggVars.(AggVarNames{ff}).Mean; end AgentDist=AgentDistnext; diff --git a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_noz_e_raw.m b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_noz_e_raw.m index aeed811a..02b2bb1f 100644 --- a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_noz_e_raw.m +++ b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_noz_e_raw.m @@ -1,14 +1,15 @@ -function AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_noz_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_e,n_e,N_j,d_grid,a_grid,daprime_gridvals,a_gridvals,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions) +function AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_noz_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,e_gridvals_J,pi_e_J,pi_e_J_sim,e_gridvals_J_fastOLG,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, II1orII, II2, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions) % When doing shooting alogrithm on TPath FHorz PType, this is for a given ptype, and does the steps of back-iterate to get policy, then forward to get agent dist and agg vars. % The only output is the agg vars path. -AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(length(FnsToEvaluateCell),T-1,'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect if N_d==0 l_d=0; else l_d=length(n_d); end +l_a=length(n_a); l_aprime=length(n_a); %% @@ -149,12 +150,12 @@ %% AggVars AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights, PolicyValuesPath(:,:,:,1:l_d,tt), PolicyValuesPath(:,:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_e,N_a,N_e,a_gridvals,e_gridvals_J_fastOLG,1); - for ii=1:length(AggVarNames) - Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; + for ff=1:length(AggVarNames) + Parameters.(AggVarNames{ff})=AggVars.(AggVarNames{ff}).Mean; end % Keep AggVars in the AggVarsPath - for ii=1:length(AggVarNames) - AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; + for ff=1:length(AggVarNames) + AggVarsPath(ff,tt)=AggVars.(AggVarNames{ff}).Mean; end AgentDist=AgentDistnext; diff --git a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_noz_raw.m b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_noz_raw.m index c3b4b555..e3f3c721 100644 --- a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_noz_raw.m +++ b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_noz_raw.m @@ -1,14 +1,15 @@ -function AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_noz_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_j,d_grid,a_grid,daprime_gridvals,a_gridvals,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions) +function AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_noz_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, II1orII, II2, transpathoptions, vfoptions, simoptions) % When doing shooting alogrithm on TPath FHorz PType, this is for a given ptype, and does the steps of back-iterate to get policy, then forward to get agent dist and agg vars. % The only output is the agg vars path. -AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(length(FnsToEvaluateCell),T-1,'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect if N_d==0 l_d=0; else l_d=length(n_d); end +l_a=length(n_a); l_aprime=length(n_a); %% @@ -136,12 +137,12 @@ %% AggVars AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz(AgentDist.*AgeWeights,PolicyValuesPath(:,:,1:l_d,tt), PolicyValuesPath(:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,N_a,a_gridvals,1); - for ii=1:length(AggVarNames) - Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; + for ff=1:length(AggVarNames) + Parameters.(AggVarNames{ff})=AggVars.(AggVarNames{ff}).Mean; end % Keep AggVars in the AggVarsPath - for ii=1:length(AggVarNames) - AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; + for ff=1:length(AggVarNames) + AggVarsPath(ff,tt)=AggVars.(AggVarNames{ff}).Mean; end AgentDist=AgentDistnext; diff --git a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_raw.m b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_raw.m index 41c6bca6..47d6162d 100644 --- a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_raw.m +++ b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_fastOLG_raw.m @@ -1,15 +1,17 @@ -function AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions) +function AggVarsPath=TransitionPath_FHorz_PType_singlepath_fastOLG_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,z_gridvals_J_fastOLG,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, II1orII, II2, exceptlastj,exceptfirstj,justfirstj, transpathoptions, vfoptions, simoptions) % When doing shooting alogrithm on TPath FHorz PType, this is for a given ptype, and does the steps of back-iterate to get policy, then forward to get agent dist and agg vars. % The only output is the agg vars path. -AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(length(FnsToEvaluateCell),T-1,'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect if N_d==0 l_d=0; else l_d=length(n_d); end +l_a=length(n_a); l_aprime=length(n_a); +l_z=length(n_z); %% % fastOLG so everything is (a,j,z) @@ -148,12 +150,12 @@ %% AggVars AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights, PolicyValuesPath(:,:,:,1:l_d,tt), PolicyValuesPath(:,:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_z,N_a,N_z,a_gridvals,z_gridvals_J_fastOLG,1); - for ii=1:length(AggVarNames) - Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; + for ff=1:length(AggVarNames) + Parameters.(AggVarNames{ff})=AggVars.(AggVarNames{ff}).Mean; end % Keep AggVars in the AggVarsPath - for ii=1:length(AggVarNames) - AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; + for ff=1:length(AggVarNames) + AggVarsPath(ff,tt)=AggVars.(AggVarNames{ff}).Mean; end AgentDist=AgentDistnext; diff --git a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_noz_e_raw.m b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_noz_e_raw.m index c926bef7..6be48332 100644 --- a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_noz_e_raw.m +++ b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_noz_e_raw.m @@ -1,8 +1,8 @@ -function AggVarsPath=TransitionPath_FHorz_PType_singlepath_noz_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_e,n_e,N_j,d_grid,a_grid,daprime_gridvals,a_gridvals,e_gridvals_J,pi_e_J,pi_e_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, vfoptions, simoptions) +function AggVarsPath=TransitionPath_FHorz_PType_singlepath_noz_e_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_e,n_e,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,e_gridvals_J,pi_e_J,pi_e_J_sim,e_gridvals_J_fastOLG,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, vfoptions, simoptions) % When doing shooting alogrithm on TPath FHorz PType, this is for a given ptype, and does the steps of back-iterate to get policy, then forward to get agent dist and agg vars. % The only output is the agg vars path. -AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(length(FnsToEvaluateCell),T-1,'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect if N_d==0 l_d=0; @@ -176,12 +176,12 @@ %% AggVars AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights, PolicyValuesPath(:,:,:,1:l_d,tt), PolicyValuesPath(:,:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_e,N_a,N_e,a_gridvals,e_gridvals_J_fastOLG,1); - for ii=1:length(AggVarNames) - Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; + for ff=1:length(AggVarNames) + Parameters.(AggVarNames{ff})=AggVars.(AggVarNames{ff}).Mean; end % Keep AggVars in the AggVarsPath - for ii=1:length(AggVarNames) - AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; + for ff=1:length(AggVarNames) + AggVarsPath(ff,tt)=AggVars.(AggVarNames{ff}).Mean; end AgentDist=AgentDistnext; diff --git a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_noz_raw.m b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_noz_raw.m index 55ab5685..60264744 100644 --- a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_noz_raw.m +++ b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_noz_raw.m @@ -1,8 +1,8 @@ -function AggVarsPath=TransitionPath_FHorz_PType_singlepath_noz_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_j,d_grid,a_grid,daprime_gridvals,a_gridvals,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, vfoptions, simoptions) +function AggVarsPath=TransitionPath_FHorz_PType_singlepath_noz_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, vfoptions, simoptions) % When doing shooting alogrithm on TPath FHorz PType, this is for a given ptype, and does the steps of back-iterate to get policy, then forward to get agent dist and agg vars. % The only output is the agg vars path. -AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(length(FnsToEvaluateCell),T-1,'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect if N_d==0 l_d=0; @@ -159,12 +159,12 @@ %% AggVars AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG_noz(AgentDist.*AgeWeights,PolicyValuesPath(:,:,1:l_d,tt), PolicyValuesPath(:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,N_a,a_gridvals,1); - for ii=1:length(AggVarNames) - Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; + for ff=1:length(AggVarNames) + Parameters.(AggVarNames{ff})=AggVars.(AggVarNames{ff}).Mean; end % Keep AggVars in the AggVarsPath - for ii=1:length(AggVarNames) - AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; + for ff=1:length(AggVarNames) + AggVarsPath(ff,tt)=AggVars.(AggVarNames{ff}).Mean; end AgentDist=AgentDistnext; diff --git a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_raw.m b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_raw.m index 31ae29ae..d8cc9222 100644 --- a/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_raw.m +++ b/TransitionPaths/FHorz/PType/singlepath/TransitionPath_FHorz_PType_singlepath_raw.m @@ -1,8 +1,8 @@ -function AggVarsPath=TransitionPath_FHorz_PType_singlepath_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_j,d_grid,a_grid,daprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, vfoptions, simoptions) +function AggVarsPath=TransitionPath_FHorz_PType_singlepath_raw(PricePathOld, ParamPath, PricePathNames,ParamPathNames,T,V_final,AgentDist_initial,jequalOneDist_T,AgeWeights_T,l_d,N_d,n_d,N_a,n_a,N_z,n_z,N_j,d_grid,a_grid,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals_J, pi_z_J,pi_z_J_sim,z_gridvals_J_fastOLG,ReturnFn, FnsToEvaluateCell, Parameters, DiscountFactorParamNames, ReturnFnParamNames, FnsToEvaluateParamNames, AggVarNames, PricePathSizeVec, ParamPathSizeVec, use_tminus1price, use_tminus1params, use_tplus1price, use_tminus1AggVars, tminus1priceNames, tminus1paramNames, tplus1priceNames, tminus1AggVarsNames, transpathoptions, vfoptions, simoptions) % When doing shooting alogrithm on TPath FHorz PType, this is for a given ptype, and does the steps of back-iterate to get policy, then forward to get agent dist and agg vars. % The only output is the agg vars path. -AggVarsPath=zeros(T-1,length(FnsToEvaluateCell),'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect +AggVarsPath=zeros(length(FnsToEvaluateCell),T-1,'gpuArray'); % Note: does not include the final AggVars, might be good to add them later as a way to make if obvious to user it things are incorrect if N_d==0 l_d=0; @@ -186,14 +186,14 @@ %% AggVars AggVars=EvalFnOnAgentDist_AggVars_FHorz_fastOLG(AgentDist.*AgeWeights, PolicyValuesPath(:,:,:,1:l_d,tt), PolicyValuesPath(:,:,:,l_d+1:end,tt), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,N_j,l_d,l_a,l_a,l_z,N_a,N_z,a_gridvals,z_gridvals_J_fastOLG,1); - for ii=1:length(AggVarNames) - Parameters.(AggVarNames{ii})=AggVars.(AggVarNames{ii}).Mean; + for ff=1:length(AggVarNames) + Parameters.(AggVarNames{ff})=AggVars.(AggVarNames{ff}).Mean; end % Keep AggVars in the AggVarsPath - for ii=1:length(AggVarNames) - AggVarsPath(tt,ii)=AggVars.(AggVarNames{ii}).Mean; + for ff=1:length(AggVarNames) + AggVarsPath(ff,tt)=AggVars.(AggVarNames{ff}).Mean; end - + AgentDist=AgentDistnext; end From 70f3590a62cf07c2eb9b45afdc5f1b242eb61e4d Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Thu, 22 Jan 2026 16:10:52 +1300 Subject: [PATCH 28/67] fix FHorz TPath with PType --- .../EvalFnOnTransPath_AggVars_Case1_FHorz_PType.m | 2 +- .../TransPathFHorz/AgentDistOnTransPath_Case1_FHorz_PType.m | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnTransPath_AggVars_Case1_FHorz_PType.m b/EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnTransPath_AggVars_Case1_FHorz_PType.m index 5a86b06a..73201f17 100644 --- a/EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnTransPath_AggVars_Case1_FHorz_PType.m +++ b/EvaluateFnOnAgentDist/TransPathFHorz/EvalFnOnTransPath_AggVars_Case1_FHorz_PType.m @@ -35,7 +35,7 @@ % First set up transpathoptions if exist('transpathoptions','var') - transpathoptions_temp=PType_Options(simoptions,Names_i,ii); + transpathoptions_temp=PType_Options(transpathoptions,Names_i,ii); if ~isfield(transpathoptions_temp,'verbose') transpathoptions_temp.verbose=0; end diff --git a/StationaryDist/TransPathFHorz/AgentDistOnTransPath_Case1_FHorz_PType.m b/StationaryDist/TransPathFHorz/AgentDistOnTransPath_Case1_FHorz_PType.m index a0c56828..d1851e16 100644 --- a/StationaryDist/TransPathFHorz/AgentDistOnTransPath_Case1_FHorz_PType.m +++ b/StationaryDist/TransPathFHorz/AgentDistOnTransPath_Case1_FHorz_PType.m @@ -26,7 +26,7 @@ % First set up transpathoptions if exist('transpathoptions','var') - transpathoptions_temp=PType_Options(simoptions,Names_i,ii); + transpathoptions_temp=PType_Options(transpathoptions,Names_i,ii); if ~isfield(transpathoptions_temp,'verbose') transpathoptions_temp.verbose=0; end @@ -37,7 +37,7 @@ transpathoptions_temp.verbose=0; transpathoptions_temp.verboseparams=0; end - + % First set up simoptions if exist('simoptions','var') simoptions_temp=PType_Options(simoptions,Names_i,ii); From d8d8de54442628769b7913831f5317044ff70dc0 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Fri, 23 Jan 2026 12:26:39 +1300 Subject: [PATCH 29/67] minor --- EvaluateFnOnAgentDist/EvalFnOnAgentDist_AllStats_Case1.m | 2 +- EvaluateFnOnAgentDist/allstats/StatsFromWeightedGrid.m | 4 ++-- Optimization/setupGEnewprice3_shooting.m | 4 +++- 3 files changed, 6 insertions(+), 4 deletions(-) diff --git a/EvaluateFnOnAgentDist/EvalFnOnAgentDist_AllStats_Case1.m b/EvaluateFnOnAgentDist/EvalFnOnAgentDist_AllStats_Case1.m index 5919fc80..5e0bb5a3 100644 --- a/EvaluateFnOnAgentDist/EvalFnOnAgentDist_AllStats_Case1.m +++ b/EvaluateFnOnAgentDist/EvalFnOnAgentDist_AllStats_Case1.m @@ -149,7 +149,7 @@ Values=reshape(Values,[N_a*N_z,1]); AllStats.(FnsToEvalNames{ff})=StatsFromWeightedGrid(Values,StationaryDistVec,simoptions.npoints,simoptions.nquantiles,simoptions.tolerance,0,simoptions.whichstats); - + %% If there are any conditional restrictions then deal with these % Evaluate AllStats, but conditional on the restriction being one. if useCondlRest==1 diff --git a/EvaluateFnOnAgentDist/allstats/StatsFromWeightedGrid.m b/EvaluateFnOnAgentDist/allstats/StatsFromWeightedGrid.m index 9c2aaf07..1efd1ad7 100644 --- a/EvaluateFnOnAgentDist/allstats/StatsFromWeightedGrid.m +++ b/EvaluateFnOnAgentDist/allstats/StatsFromWeightedGrid.m @@ -132,7 +132,7 @@ % WeightedSortedValues contains NaNs CumSumSortedWeightedValues=cumsum(WeightedSortedValues); end - + if whichstats(4)>=1 % Lorenz curve if npoints>0 @@ -165,7 +165,7 @@ % Even thought the weights themselves are non-zero, you can still get that two consecutive elements of CumSumSortedWeights are the same (happened when the weight was 1e-26) [CumSumSortedWeights2,u1index,~]=unique(CumSumSortedWeights); % Sometimes this will become a single value, so need to check for this again - if length(CumSumSortedWeights2)==1 + if isscalar(CumSumSortedWeights2) LorenzCurve=1/npoints:1/npoints:1; else temp=interp1(CumSumSortedWeights2,CumSumSortedWeightedValues(u1index),llvec(1:end-1)); diff --git a/Optimization/setupGEnewprice3_shooting.m b/Optimization/setupGEnewprice3_shooting.m index 3d8eea0e..33d09d63 100644 --- a/Optimization/setupGEnewprice3_shooting.m +++ b/Optimization/setupGEnewprice3_shooting.m @@ -13,10 +13,12 @@ fminalgo5=1; % options.GEnewprice=3; options.GEnewprice3=options.fminalgo5; - options.oldpathweight=0; % Not actually used for anything elseif options.GEnewprice~=3 return % Not being used end +if ~isfield(options,'oldpathweight') + options.oldpathweight=0; % Not actually used for anything +end options.weightscheme=0; From aa69f4049558b91d8fcb0535f74ef045bc54f676 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Mon, 26 Jan 2026 10:40:07 +1300 Subject: [PATCH 30/67] minor --- .../AgentDist_InfHorz_TPath_SingleStep.m | 3 +++ .../Subcodes/createTPathFeedbackPlots.m | 19 +++++++++++++------ .../DC1/ValueFnIter_FHorz_DC1_GI_e_raw.m | 18 +++++++++--------- 3 files changed, 25 insertions(+), 15 deletions(-) diff --git a/TransitionPaths/InfHorz/subcodes/AgentDistSingleStep/AgentDist_InfHorz_TPath_SingleStep.m b/TransitionPaths/InfHorz/subcodes/AgentDistSingleStep/AgentDist_InfHorz_TPath_SingleStep.m index a3a4e2b0..39f26779 100644 --- a/TransitionPaths/InfHorz/subcodes/AgentDistSingleStep/AgentDist_InfHorz_TPath_SingleStep.m +++ b/TransitionPaths/InfHorz/subcodes/AgentDistSingleStep/AgentDist_InfHorz_TPath_SingleStep.m @@ -2,6 +2,9 @@ % II1 and IIones are inputs just so they can be precomputed and then reused each period of transition % II1=gpuArray(1:1:N_a*N_z); % IIones=ones(N_a*N_z,1,'gpuArray'); +% AgentDist is [N_a*N_z,1] +% Policy_aprimez is +% pi_z_sparse is [N_z,N_zprime] % AgentDist is already sparse and on cpu diff --git a/TransitionPaths/Subcodes/createTPathFeedbackPlots.m b/TransitionPaths/Subcodes/createTPathFeedbackPlots.m index c233e14e..2a5fa4a4 100644 --- a/TransitionPaths/Subcodes/createTPathFeedbackPlots.m +++ b/TransitionPaths/Subcodes/createTPathFeedbackPlots.m @@ -13,7 +13,7 @@ function createTPathFeedbackPlots(PricePathNames,AggVarNames,GEeqnNames,PricePat ncolumns=2; end nrows=ceil(length(PricePathNames)/ncolumns); - fig1=figure(1); + figure(1) for pp=1:length(PricePathNames) subplot(nrows,ncolumns,pp); plot(PricePathOld(:,pp)) title(PricePathNames{pp}) @@ -30,10 +30,17 @@ function createTPathFeedbackPlots(PricePathNames,AggVarNames,GEeqnNames,PricePat ncolumns=2; end nrows=ceil(length(AggVarNames)/ncolumns); - fig2=figure(2); - for pp=1:length(AggVarNames) - subplot(nrows,ncolumns,pp); plot(AggVarsPath(:,pp)) - title(AggVarNames{pp}) + figure(2) + if isstruct(AggVarsPath) + for pp=1:length(AggVarNames) + subplot(nrows,ncolumns,pp); plot(AggVarsPath.(AggVarNames{pp}).Mean) + title(AggVarNames{pp}) + end + else + for pp=1:length(AggVarNames) + subplot(nrows,ncolumns,pp); plot(AggVarsPath(:,pp)) + title(AggVarNames{pp}) + end end sgtitle('Current Agg Vars Path'); end @@ -48,7 +55,7 @@ function createTPathFeedbackPlots(PricePathNames,AggVarNames,GEeqnNames,PricePat ncolumns=2; end nrows=ceil(length(GEeqnNames)/ncolumns); - fig3=figure(3); + figure(3) for pp=1:length(GEeqnNames) subplot(nrows,ncolumns,pp); plot(GEcondnPath(:,pp)) title(GEeqnNames{pp}) diff --git a/ValueFnIter/FHorz/DivideConquer/GridInterpLayer/DC1/ValueFnIter_FHorz_DC1_GI_e_raw.m b/ValueFnIter/FHorz/DivideConquer/GridInterpLayer/DC1/ValueFnIter_FHorz_DC1_GI_e_raw.m index 1f93906a..70dd73a6 100644 --- a/ValueFnIter/FHorz/DivideConquer/GridInterpLayer/DC1/ValueFnIter_FHorz_DC1_GI_e_raw.m +++ b/ValueFnIter/FHorz/DivideConquer/GridInterpLayer/DC1/ValueFnIter_FHorz_DC1_GI_e_raw.m @@ -74,9 +74,9 @@ % loweredge is n_d-by-1-by-1-by-n_z-by-n_e aprimeindexes=loweredge+(0:1:maxgap(ii)); % aprime possibilities are n_d-by-maxgap(ii)+1-by-1-by-n_z-by-n_e - ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_DC1_Par2e(ReturnFn, n_d, n_z, n_e, d_gridvals, a_grid(aprimeindexes), a_grid(level1ii(ii)+1:level1ii(ii+1)-1), z_gridvals_J(:,:,N_j), e_gridvals_J(:,:,N_j), ReturnFnParamsVec,3); + ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_DC1_Par2e(ReturnFn, n_d, n_z, n_e, d_gridvals, a_grid(aprimeindexes), a_grid(level1ii(ii)+1:level1ii(ii+1)-1), z_gridvals_J(:,:,N_j), e_gridvals_J(:,:,N_j), ReturnFnParamsVec,6); [~,maxindex]=max(ReturnMatrix_ii,[],2); - midpoints_jj(:,1,curraindex,:,:)=shiftdim(maxindex+(loweredge-1),1); + midpoints_jj(:,1,curraindex,:,:)=maxindex+(loweredge-1); else loweredge=maxindex1(:,1,ii,:,:); midpoints_jj(:,1,curraindex,:,:)=repelem(loweredge,1,1,length(curraindex),1); @@ -118,9 +118,9 @@ % loweredge is n_d-by-1-by-1-by-n_z aprimeindexes=loweredge+(0:1:maxgap(ii)); % aprime possibilities are n_d-by-maxgap(ii)+1-by-1-by-n_z - ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_DC1_Par2e(ReturnFn, n_d, n_z, special_n_e, d_gridvals, a_grid(aprimeindexes), a_grid(level1ii(ii)+1:level1ii(ii+1)-1), z_gridvals_J(:,:,N_j), e_val, ReturnFnParamsVec,3); + ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_DC1_Par2e(ReturnFn, n_d, n_z, special_n_e, d_gridvals, a_grid(aprimeindexes), a_grid(level1ii(ii)+1:level1ii(ii+1)-1), z_gridvals_J(:,:,N_j), e_val, ReturnFnParamsVec,6); [~,maxindex]=max(ReturnMatrix_ii,[],2); - midpoints_jj(:,1,curraindex,:)=shiftdim(maxindex+(loweredge-1),1); + midpoints_jj(:,1,curraindex,:)=maxindex+(loweredge-1); else loweredge=maxindex1(:,1,ii,:); midpoints_jj(:,1,curraindex,:)=repelem(loweredge,1,1,length(curraindex),1); @@ -164,9 +164,9 @@ % loweredge is n_d-by-1-by-1 aprimeindexes=loweredge+(0:1:maxgap(ii)); % aprime possibilities are n_d-by-maxgap(ii)+1-by-1 - ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_DC1_Par2e(ReturnFn, n_d, special_n_z, special_n_e, d_gridvals, a_grid(aprimeindexes), a_grid(level1ii(ii)+1:level1ii(ii+1)-1), z_val, e_val, ReturnFnParamsVec,3); + ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_DC1_Par2e(ReturnFn, n_d, special_n_z, special_n_e, d_gridvals, a_grid(aprimeindexes), a_grid(level1ii(ii)+1:level1ii(ii+1)-1), z_val, e_val, ReturnFnParamsVec,6); [~,maxindex]=max(ReturnMatrix_ii,[],2); - midpoints_jj(:,1,curraindex)=shiftdim(maxindex+(loweredge-1),1); + midpoints_jj(:,1,curraindex)=maxindex+(loweredge-1); else loweredge=maxindex1(:,1,ii); midpoints_jj(:,1,curraindex)=repelem(loweredge,1,1,length(curraindex),1); @@ -226,7 +226,7 @@ % loweredge is n_d-by-1-by-1-by-n_z-by-n_e aprimeindexes=loweredge+(0:1:maxgap(ii)); % aprime possibilities are n_d-by-maxgap(ii)+1-by-1-by-n_z-by-n_e - ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_DC1_Par2e(ReturnFn, n_d, n_z, n_e, d_gridvals, a_grid(aprimeindexes), a_grid(level1ii(ii)+1:level1ii(ii+1)-1), z_gridvals_J(:,:,N_j), e_gridvals_J(:,:,N_j), ReturnFnParamsVec,3); + ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_DC1_Par2e(ReturnFn, n_d, n_z, n_e, d_gridvals, a_grid(aprimeindexes), a_grid(level1ii(ii)+1:level1ii(ii+1)-1), z_gridvals_J(:,:,N_j), e_gridvals_J(:,:,N_j), ReturnFnParamsVec,6); aprimez=aprimeindexes+N_a*zBind; entireRHS_ii=ReturnMatrix_ii+DiscountFactorParamsVec*reshape(EV(aprimez(:)),[N_d,(maxgap(ii)+1),1,N_z,N_e]); % autoexpand level1iidiff(ii) in 3rd-dim [~,maxindex]=max(entireRHS_ii,[],2); @@ -277,7 +277,7 @@ % loweredge is n_d-by-1-by-1-by-n_z aprimeindexes=loweredge+(0:1:maxgap(ii)); % aprime possibilities are n_d-by-maxgap(ii)+1-by-1-by-n_z - ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_DC1_Par2e(ReturnFn, n_d, n_z, special_n_e, d_gridvals, a_grid(aprimeindexes), a_grid(level1ii(ii)+1:level1ii(ii+1)-1), z_gridvals_J(:,:,N_j), e_val, ReturnFnParamsVec,3); + ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_DC1_Par2e(ReturnFn, n_d, n_z, special_n_e, d_gridvals, a_grid(aprimeindexes), a_grid(level1ii(ii)+1:level1ii(ii+1)-1), z_gridvals_J(:,:,N_j), e_val, ReturnFnParamsVec,6); aprimez=aprimeindexes+N_a*zBind; entireRHS_ii=ReturnMatrix_ii+DiscountFactorParamsVec*reshape(EV(aprimez(:)),[N_d,(maxgap(ii)+1),1,N_z]); % autoexpand level1iidiff(ii) in 3rd-dim [~,maxindex]=max(entireRHS_ii,[],2); @@ -333,7 +333,7 @@ % loweredge is n_d-by-1-by-1 aprimeindexes=loweredge+(0:1:maxgap(ii)); % aprime possibilities are n_d-by-maxgap(ii)+1-by-1 - ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_DC1_Par2e(ReturnFn, n_d, special_n_z, special_n_e, d_gridvals, a_grid(aprimeindexes), a_grid(level1ii(ii)+1:level1ii(ii+1)-1), z_val, e_val, ReturnFnParamsVec,3); + ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_DC1_Par2e(ReturnFn, n_d, special_n_z, special_n_e, d_gridvals, a_grid(aprimeindexes), a_grid(level1ii(ii)+1:level1ii(ii+1)-1), z_val, e_val, ReturnFnParamsVec,6); entireRHS_ii=ReturnMatrix_ii+DiscountFactorParamsVec*reshape(EV_z(aprimeindexes(:)),[N_d,(maxgap(ii)+1),1]); % autoexpand level1iidiff(ii) in 3rd-dim [~,maxindex]=max(entireRHS_ii,[],2); midpoints_jj(:,1,curraindex)=maxindex+(loweredge-1); From 806a10a657833a1a9ea220e9702b3b22d60414c3 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Mon, 26 Jan 2026 11:23:22 +1300 Subject: [PATCH 31/67] default never uses Howards greedy --- ValueFnIter/InfHorz/ValueFnIter_Case1.m | 29 +++++-------------------- 1 file changed, 6 insertions(+), 23 deletions(-) diff --git a/ValueFnIter/InfHorz/ValueFnIter_Case1.m b/ValueFnIter/InfHorz/ValueFnIter_Case1.m index 89730b0f..ce2dfd5f 100644 --- a/ValueFnIter/InfHorz/ValueFnIter_Case1.m +++ b/ValueFnIter/InfHorz/ValueFnIter_Case1.m @@ -21,16 +21,9 @@ vfoptions.divideandconquer=0; vfoptions.gridinterplayer=0; % grid interpolation layer vfoptions.lowmemory=0; - % Howards improvement [note: for vfoptions.gridinterplayer=0] - if isscalar(n_a) % one endogenous state - if N_a<400 && N_z<20 % iterated (aka modified-Policy Fn Iteration) or greedy (aka Policy Fn Iteration) - vfoptions.howardsgreedy=1; % small one endogenous state models, use Howards greedy, everything else uses Howards iterations - else - vfoptions.howardsgreedy=0; - end - else - vfoptions.howardsgreedy=0; - end + % Howards improvement + vfoptions.howardsgreedy=0; % =0 iterated (aka modified-Policy Fn Iteration) or =1 greedy (aka Policy Fn Iteration) + % Note: for small models, Howards greedy is faster, but cannot handle that V takes -Inf. % When doing Howards iterations, the following are some suboptions vfoptions.howards=150; % based on some tests, 80 to 150 was fastest, but 150 was best on average vfoptions.maxhowards=500; % Turn howards off after this many times (just so it cannot cause convergence to fail if thing are going wrong) @@ -90,19 +83,9 @@ end % Howards improvement if ~isfield(vfoptions,'howardsgreedy') - if vfoptions.gridinterplayer==0 - if isscalar(n_a) % one endogenous state - if N_a<400 && N_z<20 % iterated (aka modified-Policy Fn Iteration) or greedy (aka Policy Fn Iteration) - vfoptions.howardsgreedy=1; % small one endogenous state models, use Howards greedy, everything else uses Howards iterations - else - vfoptions.howardsgreedy=0; - end - else - vfoptions.howardsgreedy=0; - end - elseif vfoptions.gridinterplayer==1 - vfoptions.howardsgreedy=0; - end + vfoptions.howardsgreedy=0; % =0 iterated (aka modified-Policy Fn Iteration) or =1 greedy (aka Policy Fn Iteration) + % Note: for small models, Howards greedy is faster, but cannot handle that V takes -Inf. + % Note: Howards greedy =1 can only be used without grid interpolation layer (gridinterplayer=0) end % When doing Howards iterations, the following are some suboptions if ~isfield(vfoptions,'howards') From d85a981594830d724088c146cc52fb6fd5ccdb4c Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Mon, 26 Jan 2026 12:51:51 +1300 Subject: [PATCH 32/67] minor --- .../PType/StationaryDist_Case1_FHorz_PType.m | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/StationaryDist/FHorz/PType/StationaryDist_Case1_FHorz_PType.m b/StationaryDist/FHorz/PType/StationaryDist_Case1_FHorz_PType.m index 0badffa2..ae732a0d 100644 --- a/StationaryDist/FHorz/PType/StationaryDist_Case1_FHorz_PType.m +++ b/StationaryDist/FHorz/PType/StationaryDist_Case1_FHorz_PType.m @@ -144,19 +144,23 @@ end else if isfinite(N_j_temp) - sprintf(['ERROR: You must input jequaloneDist for permanent type ', Names_i{ii}, ' \n']) - dbstack + error(['You must input a jequaloneDist for permanent type ', Names_i{ii}, ' \n']) end end else % Note: when jequaloneDist is not a structure all ptypes must have the same grids - if idiminj1dist==0 + if idiminj1dist==0 % ptype is not a dimension jequaloneDist_temp=jequaloneDist; else % idminj1dist==1 - if prod(n_z_temp)==0 - jequaloneDist_temp=jequaloneDist(:,ii)/sum(jequaloneDist(:,ii)); % includes renormalizing so mass of one conditional on ptype - else + % ptype is a dimension, so need to get the jequaloneDist for ii and also normalize mass conditional on ptype to be one + if ndims(jequaloneDist)==5 % has all three of semiz,z,e [other two are a and i] + jequaloneDist_temp=jequaloneDist(:,:,:,:,ii)/sum(sum(jequaloneDist(:,:,:,:,ii))); % includes renormalizing so mass of one conditional on ptype + elseif ndims(jequaloneDist)==4 % has two of semiz,z,e + jequaloneDist_temp=jequaloneDist(:,:,:,ii)/sum(sum(jequaloneDist(:,:,:,ii))); % includes renormalizing so mass of one conditional on ptype + elseif ndims(jequaloneDist)==3 % has one of semiz,z,e jequaloneDist_temp=jequaloneDist(:,:,ii)/sum(sum(jequaloneDist(:,:,ii))); % includes renormalizing so mass of one conditional on ptype + elseif ndims(jequaloneDist)==2 % has none of semiz,z,e + jequaloneDist_temp=jequaloneDist(:,ii)/sum(jequaloneDist(:,ii)); % includes renormalizing so mass of one conditional on ptype end end if abs(sum(jequaloneDist_temp(:))-1)>10^(-12) @@ -170,8 +174,7 @@ AgeWeightParamNames_temp=AgeWeightsParamNames.(Names_i{ii}); else if isfinite(N_j_temp) - sprintf(['ERROR: You must input AgeWeightParamNames for permanent type ', Names_i{ii}, ' \n']) - dbstack + error(['You must input AgeWeightParamNames for permanent type ', Names_i{ii}, ' \n']) end end end From 5999850be3fad941845d1fcd2702f9f96a555aec Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Tue, 27 Jan 2026 13:19:23 +1300 Subject: [PATCH 33/67] mostly around maxiter, and howards-greedy, giving warnings --- .../discretizeAR1_FarmerToda.m | 2 +- ...lFnOnAgentDist_AggVars_FHorz_Case1_PType.m | 2 +- .../InfHorz/CPU/ValueFnIter_Par0_raw.m | 8 ++- .../InfHorz/CPU/ValueFnIter_Par1_raw.m | 8 ++- .../InfHorz/CPU/ValueFnIter_nod_Par0_raw.m | 9 ++- .../InfHorz/CPU/ValueFnIter_nod_Par1_raw.m | 9 ++- .../GI2B/ValueFnIter_Refine_postGI2B_raw.m | 4 ++ .../GI2B/ValueFnIter_Refine_preGI2B_raw.m | 4 ++ .../GI2B/ValueFnIter_postGI2B_nod_raw.m | 3 + .../GI2B/ValueFnIter_preGI2B_nod_raw.m | 3 + ...lueFnIter_Refine_postGI_HowardGreedy_raw.m | 11 +++- ...ValueFnIter_Refine_postGI_HowardMix2_raw.m | 7 +++ .../ValueFnIter_Refine_postGI_HowardMix_raw.m | 8 +++ .../ValueFnIter_Refine_postGI_raw.m | 60 +++++++++---------- ...alueFnIter_Refine_preGI_HowardGreedy_raw.m | 8 ++- .../ValueFnIter_Refine_preGI_HowardMix_raw.m | 8 +++ .../ValueFnIter_Refine_preGI_raw.m | 4 ++ .../ValueFnIter_postGI_HowardGreedy_nod_raw.m | 7 +++ .../ValueFnIter_postGI_HowardMix2_nod_raw.m | 7 +++ .../ValueFnIter_postGI_HowardMix_nod_raw.m | 8 +++ .../ValueFnIter_postGI_nod_raw.m | 3 + .../ValueFnIter_preGI_HowardGreedy_nod_raw.m | 9 +++ .../ValueFnIter_preGI_HowardMix_nod_raw.m | 9 +++ .../ValueFnIter_preGI_nod_raw.m | 5 ++ .../LowMemory/ValueFnIter_LowMem_nod_raw.m | 7 ++- .../LowMemory/ValueFnIter_LowMem_raw.m | 9 ++- .../ValueFnIter_LowMem_sparse_nod_raw.m | 8 ++- ValueFnIter/InfHorz/ValueFnIter_Case1.m | 26 ++++---- .../ValueFnIter_nod_HowardGreedy_raw.m | 9 +++ ValueFnIter/InfHorz/ValueFnIter_nod_raw.m | 3 + ValueFnIter/InfHorz/ValueFnIter_raw.m | 8 ++- .../InfHorz/ValueFnIter_sparse_nod_raw.m | 3 + 32 files changed, 211 insertions(+), 68 deletions(-) diff --git a/DiscretizationMethods/discretizeAR1_FarmerToda/discretizeAR1_FarmerToda.m b/DiscretizationMethods/discretizeAR1_FarmerToda/discretizeAR1_FarmerToda.m index 365eaa5a..b8a96a3f 100644 --- a/DiscretizationMethods/discretizeAR1_FarmerToda/discretizeAR1_FarmerToda.m +++ b/DiscretizationMethods/discretizeAR1_FarmerToda/discretizeAR1_FarmerToda.m @@ -33,7 +33,7 @@ %%%%%%%%%%%%%%% % Original paper: % Farmer & Toda (2017) - Discretizing Nonlinear, Non-Gaussian Markov Processes with Exact Conditional Moments -% They how that this method outperforms both Tauchen and Rouwenhorst for almost all discretization of Gaussian AR(1). +% They show that this method outperforms both Tauchen and Rouwenhorst for almost all discretization of Gaussian AR(1). if rho>=0.99 fprintf('COMMENT: When discretizing gaussian AR(1) process with autocorrelation (rho) greater than 0.99 (which you currently have), the Rouwenhorst method tends to outperform Farmer-Toda method. \n') diff --git a/EvaluateFnOnAgentDist/FHorz/PType/EvalFnOnAgentDist_AggVars_FHorz_Case1_PType.m b/EvaluateFnOnAgentDist/FHorz/PType/EvalFnOnAgentDist_AggVars_FHorz_Case1_PType.m index fe18ece4..664029a4 100644 --- a/EvaluateFnOnAgentDist/FHorz/PType/EvalFnOnAgentDist_AggVars_FHorz_Case1_PType.m +++ b/EvaluateFnOnAgentDist/FHorz/PType/EvalFnOnAgentDist_AggVars_FHorz_Case1_PType.m @@ -12,7 +12,7 @@ % AgeWeightParamNames is either same for all permanent types, or must be passed as a structure. % % The stationary distribution be a structure and will contain both the -% weights/distribution across the permenant types, as well as a pdf for the +% weights/distribution across the permanent types, as well as a pdf for the % stationary distribution of each specific permanent type. % % How exactly to handle these differences between permanent (fixed) types diff --git a/ValueFnIter/InfHorz/CPU/ValueFnIter_Par0_raw.m b/ValueFnIter/InfHorz/CPU/ValueFnIter_Par0_raw.m index ec0c9a0f..2a3273f1 100644 --- a/ValueFnIter/InfHorz/CPU/ValueFnIter_Par0_raw.m +++ b/ValueFnIter/InfHorz/CPU/ValueFnIter_Par0_raw.m @@ -1,4 +1,4 @@ -function [VKron, Policy]=ValueFnIter_Par0_raw(VKron, N_d,N_a,N_z,pi_z, beta, ReturnMatrix,Howards,Howards2,Tolerance) %Verbose, +function [VKron, Policy]=ValueFnIter_Par0_raw(VKron, N_d,N_a,N_z,pi_z, beta, ReturnMatrix,Howards,Howards2,Tolerance,maxiter) PolicyIndexes1=zeros(N_a,N_z); PolicyIndexes2=zeros(N_a,N_z); @@ -6,7 +6,7 @@ tempcounter=1; currdist=Inf; -while currdist>Tolerance +while currdist>Tolerance && tempcounter<=maxiter VKronold=VKron; @@ -60,5 +60,9 @@ Policy(1,:,:)=permute(PolicyIndexes1,[3,1,2]); Policy(2,:,:)=permute(PolicyIndexes2,[3,1,2]); +if tempcounter>=maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end + end diff --git a/ValueFnIter/InfHorz/CPU/ValueFnIter_Par1_raw.m b/ValueFnIter/InfHorz/CPU/ValueFnIter_Par1_raw.m index 32698d18..d5fc6d92 100644 --- a/ValueFnIter/InfHorz/CPU/ValueFnIter_Par1_raw.m +++ b/ValueFnIter/InfHorz/CPU/ValueFnIter_Par1_raw.m @@ -1,4 +1,4 @@ -function [VKron, Policy]=ValueFnIter_Par1_raw(VKron, N_d,N_a,N_z, pi_z, beta, ReturnMatrix, Howards, Howards2, Tolerance) %,Verbose +function [VKron, Policy]=ValueFnIter_Par1_raw(VKron, N_d,N_a,N_z, pi_z, beta, ReturnMatrix, Howards, Howards2, Tolerance, maxiter) tempcounter=1; currdist=Inf; @@ -8,7 +8,7 @@ pi_z_howards=repelem(pi_z,N_a,1); -while currdist>Tolerance +while currdist>Tolerance && tempcounter<=maxiter VKronold=VKron; @@ -55,4 +55,8 @@ Policy(1,:,:)=shiftdim(rem(PolicyIndexes-1,N_d)+1,-1); Policy(2,:,:)=shiftdim(ceil(PolicyIndexes/N_d),-1); +if tempcounter>=maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end + end diff --git a/ValueFnIter/InfHorz/CPU/ValueFnIter_nod_Par0_raw.m b/ValueFnIter/InfHorz/CPU/ValueFnIter_nod_Par0_raw.m index 7ea7a066..91fa71c9 100644 --- a/ValueFnIter/InfHorz/CPU/ValueFnIter_nod_Par0_raw.m +++ b/ValueFnIter/InfHorz/CPU/ValueFnIter_nod_Par0_raw.m @@ -1,4 +1,4 @@ -function [VKron, Policy]=ValueFnIter_nod_Par0_raw(VKron, N_a, N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix, Howards,Howards2,Tolerance) % Verbose +function [VKron, Policy]=ValueFnIter_nod_Par0_raw(VKron, N_a, N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix, Howards,Howards2,Tolerance,maxiter) % Verbose %Does pretty much exactly the same as ValueFnIter_Case1, only without any decision variable (n_d=0) @@ -14,7 +14,7 @@ %% tempcounter=1; currdist=Inf; -while currdist>Tolerance +while currdist>Tolerance && tempcounter<=maxiter VKronold=VKron; @@ -56,4 +56,9 @@ Policy=reshape(PolicyIndexes,[1,N_a,N_z]); + +if tempcounter>=maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end + end diff --git a/ValueFnIter/InfHorz/CPU/ValueFnIter_nod_Par1_raw.m b/ValueFnIter/InfHorz/CPU/ValueFnIter_nod_Par1_raw.m index 34ac8f5a..6da943eb 100644 --- a/ValueFnIter/InfHorz/CPU/ValueFnIter_nod_Par1_raw.m +++ b/ValueFnIter/InfHorz/CPU/ValueFnIter_nod_Par1_raw.m @@ -1,4 +1,4 @@ -function [VKron, Policy]=ValueFnIter_nod_Par1_raw(VKron, N_a, N_z, pi_z, beta, ReturnMatrix, Howards,Howards2, Tolerance) %Verbose +function [VKron, Policy]=ValueFnIter_nod_Par1_raw(VKron, N_a, N_z, pi_z, beta, ReturnMatrix, Howards,Howards2, Tolerance, maxiter) Policy=zeros(N_a,N_z); @@ -9,7 +9,7 @@ tempcounter=1; currdist=Inf; -while currdist>Tolerance +while currdist>Tolerance && tempcounter<=maxiter VKronold=VKron; @@ -52,4 +52,9 @@ Policy=reshape(Policy,[1,N_a,N_z]); + +if tempcounter>=maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end + end diff --git a/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_Refine_postGI2B_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_Refine_postGI2B_raw.m index 30790722..1cd3937f 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_Refine_postGI2B_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_Refine_postGI2B_raw.m @@ -355,4 +355,8 @@ temppolicyindex=fineindex(:)+N_aprime*(0:1:N_a*N_z-1)'; Policy(1,:,:)=reshape(dstar(temppolicyindex),[N_a,N_z]); % note: dstar is defined on the fine grid +if tempcounter>=vfoptions.maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end + end diff --git a/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_Refine_preGI2B_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_Refine_preGI2B_raw.m index 39914663..5eac6acc 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_Refine_preGI2B_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_Refine_preGI2B_raw.m @@ -169,5 +169,9 @@ temppolicyindex=fineindex(:)+N_aprime*(0:1:N_a*N_z-1)'; Policy(1,:,:)=reshape(dstar(temppolicyindex),[N_a,N_z]); % note: dstar is defined on the fine grid +if tempcounter>=vfoptions.maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end + end diff --git a/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_postGI2B_nod_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_postGI2B_nod_raw.m index be62eb0c..174db0ed 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_postGI2B_nod_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_postGI2B_nod_raw.m @@ -274,5 +274,8 @@ Policy(2,:,:)=fineindexvec2; Policy(3,:,:)=reshape(L2,[1,N_a,N_z]); +if tempcounter>=vfoptions.maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end end diff --git a/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_preGI2B_nod_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_preGI2B_nod_raw.m index 77b8bc6e..5977f57a 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_preGI2B_nod_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_preGI2B_nod_raw.m @@ -131,5 +131,8 @@ Policy(2,:,:)=fineindexvec2; Policy(3,:,:)=L2; +if tempcounter>=vfoptions.maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end end diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardGreedy_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardGreedy_raw.m index e1b58db7..46c33f61 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardGreedy_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardGreedy_raw.m @@ -127,8 +127,8 @@ EV(isnan(EV))=0; % multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) EV=squeeze(sum(EV,4)); % sum over z', leaving a singular second dimension % EV is now [N_aprimediff,N_a,N_z] - % Interpolate EV over aprime_grid + % Interpolate EV over aprime_grid EVinterp=interp1(EVinterpindex1,EV,EVinterpindex2); entireRHS=ReturnMatrixfine+DiscountFactorParamsVec*EVinterp; % aprime by a by z @@ -177,4 +177,13 @@ Policy(3,:,:)=reshape(L2,[1,N_a,N_z]); +%% Howards greedy cannot solve models where V contains values of -Inf. Can kind of test for this by looking for -Inf in Ftemp +if any(~isfinite(Ftemp)) + warning('Howards-greedy cannot be used for models where V contains values of -Inf. This model looks like it may be one where V takes a value of -Inf at some points in the state-space. Consider checking solution against that with vfoptions.howardsgreedy=0') +end +if tempcounter>=vfoptions.maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end + + end diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardMix2_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardMix2_raw.m index 0006a29c..3d1081fd 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardMix2_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardMix2_raw.m @@ -174,5 +174,12 @@ Policy(2,:,:)=reshape(L1,[1,N_a,N_z]); Policy(3,:,:)=reshape(L2,[1,N_a,N_z]); +%% Howards greedy cannot solve models where V contains values of -Inf. Can kind of test for this by looking for -Inf in Ftemp +if any(~isfinite(Ftemp)) + warning('Howards-greedy cannot be used for models where V contains values of -Inf. This model looks like it may be one where V takes a value of -Inf at some points in the state-space. Consider checking solution against that with vfoptions.howardsgreedy=0') +end +if tempcounter>=vfoptions.maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end end diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardMix_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardMix_raw.m index 0b177f63..55c600e6 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardMix_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardMix_raw.m @@ -69,6 +69,11 @@ end Policy_a=reshape(Policy_a,[1,N_a,N_z]); % Howards can mess with the size +%% Howards greedy cannot solve models where V contains values of -Inf. Can kind of test for this by looking for -Inf in Ftemp +if any(~isfinite(Ftemp)) + warning('Howards-greedy cannot be used for models where V contains values of -Inf. This model looks like it may be one where V takes a value of -Inf at some points in the state-space. Consider checking solution against that with vfoptions.howardsgreedy=0') +end + %% Now that we have solved on the rough grid, we resolve on the fine grid % Based on solving a bunch of value fns with and without grid % interpolation, the 'lower grid index' with grid interpolation is always @@ -171,5 +176,8 @@ Policy(2,:,:)=reshape(L1,[1,N_a,N_z]); Policy(3,:,:)=reshape(L2,[1,N_a,N_z]); +if tempcounter>=vfoptions.maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end end diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_raw.m index bddcc730..c2fa8e9c 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_raw.m @@ -1,11 +1,8 @@ function [VKron,Policy]=ValueFnIter_Refine_postGI_raw(VKron,n_d,n_a,n_z,d_gridvals,a_grid,z_gridvals,pi_z,ReturnFn,DiscountFactorParamsVec,ReturnFnParams,vfoptions) -% Optimized version: Replaces interp1 with pre-computed interpolation matrix -% OPTIMIZATION: Line 177 bottleneck fixed with matrix multiplication approach N_d=prod(n_d); N_a=prod(n_a); N_z=prod(n_z); -N_aNz = N_a*N_z; n_da=[n_d,n_a]; da_gridvals=[repmat(d_gridvals,N_a,1),repelem(a_grid,N_d,1)]; @@ -74,7 +71,7 @@ end Policy_a=reshape(Policy_a,[1,N_a,N_z]); -%% Now that we have solved on the rough grid, we resolve on the fine grid +%% Now that we have solved on the rough grid, we re-solve on the fine grid n_aprimediff=1+2*vfoptions.maxaprimediff; N_aprimediff=prod(n_aprimediff); aprimeshifter=min(max(Policy_a,1+vfoptions.maxaprimediff),N_a-vfoptions.maxaprimediff); @@ -107,27 +104,25 @@ end end +%% Now switch to considering the fine/interpolated aprime_grid EVinterpindex2=gpuArray.linspace(1,N_aprimediff,N_aprimediff+(N_aprimediff-1)*vfoptions.ngridinterp)'; -% OPTIMIZATION: Pre-compute interpolation matrix (all on GPU) +% Pre-compute interpolation matrix idx_low = floor(EVinterpindex2); idx_low = max(1, min(idx_low, N_aprimediff-1)); idx_high = idx_low + 1; weight_high = EVinterpindex2 - idx_low; weight_low = 1 - weight_high; - i_indices = [gpuArray.colon(1,N_aprime)'; gpuArray.colon(1,N_aprime)']; j_indices = [idx_low; idx_high]; weights = [weight_low; weight_high]; -interpMatrix_sparse = sparse(i_indices, j_indices, weights, N_aprime, N_aprimediff); -%interpMatrix = full(interpMatrix_sparse); % Keep on GPU, convert to dense for fast multiplication -interpMatrix = interpMatrix_sparse; +interpMatrix = full(sparse(i_indices, j_indices, weights, N_aprime, N_aprimediff)); addindexforazfine=gpuArray(N_aprime*(0:1:N_a-1)'+N_aprime*N_a*(0:1:N_z-1)); pi_z_alt2=shiftdim(pi_z,-2); -%% Now switch to considering the fine/interpolated aprime_grid +% Perform value fn iteration currdist=1; while currdist>vfoptions.tolerance && tempcounter<=vfoptions.maxiter VKronold=VKron; @@ -137,8 +132,8 @@ EV(isnan(EV))=0; EV=squeeze(sum(EV,4)); - % OPTIMIZED: Matrix multiplication instead of interp1 - EVinterp = reshape(interpMatrix * reshape(EV, N_aprimediff, N_aNz), N_aprime, N_a, N_z); + % Interpolation of EV is performed as a matrix multiplication + EVinterp=reshape(interpMatrix*reshape(EV, [N_aprimediff, N_a*N_z]), [N_aprime,N_a,N_z]); entireRHS=ReturnMatrixfine+DiscountFactorParamsVec*EVinterp; @@ -149,19 +144,17 @@ VKrondist(isnan(VKrondist))=0; currdist=max(abs(VKrondist)); + % Howards improvement iteration if isfinite(currdist) && currdist/vfoptions.tolerance>10 && tempcountervfoptions.tolerance && tempcounter<=vfoptions.maxiter VKronold=VKron; @@ -241,8 +233,8 @@ EV(isnan(EV))=0; EV=squeeze(sum(EV,4)); - % OPTIMIZED: Matrix multiplication - EVinterp = reshape(interpMatrix * reshape(EV, N_aprimediff, N_aNz), N_aprime, N_a, N_z); + % Interpolation of EV is performed as a matrix multiplication + EVinterp = reshape(interpMatrix *reshape(EV, [N_aprimediff,N_a*N_z]), [N_aprime,N_a,N_z]); entireRHS=ReturnMatrixfine+DiscountFactorParamsVec*EVinterp; @@ -252,20 +244,18 @@ VKrondist=VKron(:)-VKronold(:); VKrondist(isnan(VKrondist))=0; currdist=max(abs(VKrondist)); - + + % Howards improvement iteration if isfinite(currdist) && currdist/vfoptions.tolerance>10 && tempcounter=vfoptions.maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end + end \ No newline at end of file diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_preGI_HowardGreedy_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_preGI_HowardGreedy_raw.m index 9e3c60c7..593bd733 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_preGI_HowardGreedy_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_preGI_HowardGreedy_raw.m @@ -162,6 +162,12 @@ temppolicyindex=Policy_a'+N_aprime*(0:1:N_a*N_z-1); Policy(1,:,:)=reshape(dstar(temppolicyindex),[N_a,N_z]); % note: dstar is defined on the fine grid - +%% Howards greedy cannot solve models where V contains values of -Inf. Can kind of test for this by looking for -Inf in Ftemp +if any(~isfinite(Ftemp)) + warning('Howards-greedy cannot be used for models where V contains values of -Inf. This model looks like it may be one where V takes a value of -Inf at some points in the state-space. Consider checking solution against that with vfoptions.howardsgreedy=0') +end +if tempcounter>=vfoptions.maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end end diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_preGI_HowardMix_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_preGI_HowardMix_raw.m index 12b15fd3..4fa7055d 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_preGI_HowardMix_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_preGI_HowardMix_raw.m @@ -106,6 +106,11 @@ end +%% Howards greedy cannot solve models where V contains values of -Inf. Can kind of test for this by looking for -Inf in Ftemp +if any(~isfinite(Ftemp)) + warning('Howards-greedy cannot be used for models where V contains values of -Inf. This model looks like it may be one where V takes a value of -Inf at some points in the state-space. Consider checking solution against that with vfoptions.howardsgreedy=0') +end + %% Now switch to considering the fine/interpolated aprime_grid currdist=1; % force going into the next while loop at least one iteration while currdist>vfoptions.tolerance && tempcounter<=vfoptions.maxiter @@ -163,5 +168,8 @@ Policy(1,:,:)=reshape(dstar(temppolicyindex),[N_a,N_z]); % note: dstar is defined on the fine grid +if tempcounter>=vfoptions.maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end end diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_preGI_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_preGI_raw.m index 4bc7ab34..aa0138b8 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_preGI_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_preGI_raw.m @@ -156,5 +156,9 @@ Policy(1,:,:)=reshape(dstar(temppolicyindex),[N_a,N_z]); % note: dstar is defined on the fine grid +if tempcounter>=vfoptions.maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end + end diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_HowardGreedy_nod_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_HowardGreedy_nod_raw.m index 52539e60..b5a3401c 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_HowardGreedy_nod_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_HowardGreedy_nod_raw.m @@ -158,5 +158,12 @@ Policy(1,:,:)=reshape(L1,[1,N_a,N_z]); Policy(2,:,:)=reshape(L2,[1,N_a,N_z]); +%% Howards greedy cannot solve models where V contains values of -Inf. Can kind of test for this by looking for -Inf in Ftemp +if any(~isfinite(Ftemp)) + warning('Howards-greedy cannot be used for models where V contains values of -Inf. This model looks like it may be one where V takes a value of -Inf at some points in the state-space. Consider checking solution against that with vfoptions.howardsgreedy=0') +end +if tempcounter>=vfoptions.maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end end diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_HowardMix2_nod_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_HowardMix2_nod_raw.m index 4fcfdaf5..bfeedd6c 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_HowardMix2_nod_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_HowardMix2_nod_raw.m @@ -156,5 +156,12 @@ Policy(1,:,:)=reshape(L1,[1,N_a,N_z]); Policy(2,:,:)=reshape(L2,[1,N_a,N_z]); +%% Howards greedy cannot solve models where V contains values of -Inf. Can kind of test for this by looking for -Inf in Ftemp +if any(~isfinite(Ftemp)) + warning('Howards-greedy cannot be used for models where V contains values of -Inf. This model looks like it may be one where V takes a value of -Inf at some points in the state-space. Consider checking solution against that with vfoptions.howardsgreedy=0') +end +if tempcounter>=vfoptions.maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end end diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_HowardMix_nod_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_HowardMix_nod_raw.m index 1476aae4..f1d5666f 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_HowardMix_nod_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_HowardMix_nod_raw.m @@ -58,6 +58,11 @@ end Policy=reshape(Policy,[1,N_a,N_z]); % Howards can mess with the size +%% Howards greedy cannot solve models where V contains values of -Inf. Can kind of test for this by looking for -Inf in Ftemp +if any(~isfinite(Ftemp)) + warning('Howards-greedy cannot be used for models where V contains values of -Inf. This model looks like it may be one where V takes a value of -Inf at some points in the state-space. Consider checking solution against that with vfoptions.howardsgreedy=0') +end + %% Now that we have solved on the rough grid, we resolve on the fine grid % Based on solving a bunch of value fns with and without grid % interpolation, the 'lower grid index' with grid interpolation is always @@ -153,5 +158,8 @@ Policy(1,:,:)=reshape(L1,[1,N_a,N_z]); Policy(2,:,:)=reshape(L2,[1,N_a,N_z]); +if tempcounter>=vfoptions.maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end end diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_nod_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_nod_raw.m index 9658a746..69151249 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_nod_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_nod_raw.m @@ -244,5 +244,8 @@ Policy(1,:,:)=reshape(L1,[1,N_a,N_z]); Policy(2,:,:)=reshape(L2,[1,N_a,N_z]); +if tempcounter>=vfoptions.maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end end diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_preGI_HowardGreedy_nod_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_preGI_HowardGreedy_nod_raw.m index a819ce73..c09fc681 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_preGI_HowardGreedy_nod_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_preGI_HowardGreedy_nod_raw.m @@ -119,4 +119,13 @@ Policy(1,:,:)=reshape(L1,[1,N_a,N_z]); Policy(2,:,:)=reshape(L2,[1,N_a,N_z]); +%% Howards greedy cannot solve models where V contains values of -Inf. Can kind of test for this by looking for -Inf in Ftemp +if any(~isfinite(Ftemp)) + warning('Howards-greedy cannot be used for models where V contains values of -Inf. This model looks like it may be one where V takes a value of -Inf at some points in the state-space. Consider checking solution against that with vfoptions.howardsgreedy=0') +end +if tempcounter>=vfoptions.maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end + + end diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_preGI_HowardMix_nod_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_preGI_HowardMix_nod_raw.m index dedd798e..a7d00228 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_preGI_HowardMix_nod_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_preGI_HowardMix_nod_raw.m @@ -72,6 +72,11 @@ end +%% Howards greedy cannot solve models where V contains values of -Inf. Can kind of test for this by looking for -Inf in Ftemp +if any(~isfinite(Ftemp)) + warning('Howards-greedy cannot be used for models where V contains values of -Inf. This model looks like it may be one where V takes a value of -Inf at some points in the state-space. Consider checking solution against that with vfoptions.howardsgreedy=0') +end + %% Now switch to considering the fine/interpolated aprime_grid, use Howards iteration currdist=1; % force going into the next while loop at least one iteration while currdist>vfoptions.tolerance && tempcounter<=vfoptions.maxiter @@ -124,4 +129,8 @@ Policy(1,:,:)=reshape(L1,[1,N_a,N_z]); Policy(2,:,:)=reshape(L2,[1,N_a,N_z]); +if tempcounter>=vfoptions.maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end + end diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_preGI_nod_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_preGI_nod_raw.m index cccac340..ba91e817 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_preGI_nod_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_preGI_nod_raw.m @@ -115,4 +115,9 @@ Policy(1,:,:)=reshape(L1,[1,N_a,N_z]); Policy(2,:,:)=reshape(L2,[1,N_a,N_z]); +if tempcounter>=vfoptions.maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end + + end diff --git a/ValueFnIter/InfHorz/LowMemory/ValueFnIter_LowMem_nod_raw.m b/ValueFnIter/InfHorz/LowMemory/ValueFnIter_LowMem_nod_raw.m index b97bfa7b..30d40006 100644 --- a/ValueFnIter/InfHorz/LowMemory/ValueFnIter_LowMem_nod_raw.m +++ b/ValueFnIter/InfHorz/LowMemory/ValueFnIter_LowMem_nod_raw.m @@ -1,4 +1,4 @@ -function [VKron, Policy]=ValueFnIter_LowMem_nod_raw(VKron, n_a, n_z, a_grid, z_gridvals, pi_z, beta, ReturnFn, ReturnFnParams, Howards,Howards2,Tolerance) % Verbose, ReturnFnParamNames, +function [VKron, Policy]=ValueFnIter_LowMem_nod_raw(VKron, n_a, n_z, a_grid, z_gridvals, pi_z, beta, ReturnFn, ReturnFnParams, Howards,Howards2,Tolerance, maxiter) l_z=length(n_z); @@ -16,7 +16,7 @@ %% tempcounter=1; currdist=Inf; -while currdist>Tolerance +while currdist>Tolerance && tempcounter<=maxiter VKronold=VKron; for z_c=1:N_z @@ -58,6 +58,9 @@ Policy=reshape(Policy,[1,N_a,N_z]); +if tempcounter>=maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end end diff --git a/ValueFnIter/InfHorz/LowMemory/ValueFnIter_LowMem_raw.m b/ValueFnIter/InfHorz/LowMemory/ValueFnIter_LowMem_raw.m index 031006b2..667f0f36 100644 --- a/ValueFnIter/InfHorz/LowMemory/ValueFnIter_LowMem_raw.m +++ b/ValueFnIter/InfHorz/LowMemory/ValueFnIter_LowMem_raw.m @@ -1,4 +1,4 @@ -function [VKron, Policy]=ValueFnIter_LowMem_raw(VKron, n_d,n_a,n_z, d_gridvals,a_grid,z_gridvals, pi_z, beta, ReturnFn, ReturnFnParams, Howards,Howards2,Tolerance) %Verbose, +function [VKron, Policy]=ValueFnIter_LowMem_raw(VKron, n_d,n_a,n_z, d_gridvals,a_grid,z_gridvals, pi_z, beta, ReturnFn, ReturnFnParams, Howards,Howards2,Tolerance, maxiter) N_d=prod(n_d); N_a=prod(n_a); @@ -15,10 +15,9 @@ %% tempcounter=1; currdist=Inf; -while currdist>Tolerance +while currdist>Tolerance && tempcounter<=maxiter VKronold=VKron; - for z_c=1:N_z zvals=z_gridvals(z_c,:); @@ -64,4 +63,8 @@ Policy(1,:,:)=shiftdim(rem(PolicyIndexes-1,N_d)+1,-1); Policy(2,:,:)=shiftdim(ceil(PolicyIndexes/N_d),-1); +if tempcounter>=maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end + end diff --git a/ValueFnIter/InfHorz/LowMemory/ValueFnIter_LowMem_sparse_nod_raw.m b/ValueFnIter/InfHorz/LowMemory/ValueFnIter_LowMem_sparse_nod_raw.m index b8da4fd1..25349c6f 100644 --- a/ValueFnIter/InfHorz/LowMemory/ValueFnIter_LowMem_sparse_nod_raw.m +++ b/ValueFnIter/InfHorz/LowMemory/ValueFnIter_LowMem_sparse_nod_raw.m @@ -42,12 +42,11 @@ tempmaxindex=maxindex+(0:1:N_a-1)*N_a; Ftemp(:,z_c)=ReturnMatrix_z(tempmaxindex); - end %end z + end VKrondist=VKron(:)-VKronold(:); VKrondist(isnan(VKrondist))=0; currdist=max(abs(VKrondist)); - %disp(currdist) % Use Howards Policy Fn Iteration Improvement % (except for first few and last few iterations, as it is not a good idea there) @@ -72,6 +71,9 @@ Policy=reshape(Policy,[1,N_a,N_z]); +if tempcounter>=maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end -end %end function ValueFnIter_LowMem_nod_raw_sparse +end \ No newline at end of file diff --git a/ValueFnIter/InfHorz/ValueFnIter_Case1.m b/ValueFnIter/InfHorz/ValueFnIter_Case1.m index ce2dfd5f..d6810ca7 100644 --- a/ValueFnIter/InfHorz/ValueFnIter_Case1.m +++ b/ValueFnIter/InfHorz/ValueFnIter_Case1.m @@ -15,7 +15,7 @@ vfoptions.verbose=0; vfoptions.tolerance=10^(-9); % Convergence tolerance (for ||V_n - V_{n-1}|| ) vfoptions.parallel=1+(gpuDeviceCount>0); % GPU where available, otherwise parallel CPU. - vfoptions.maxiter=Inf; % Can be used to stop the VFI after a finite number of iterations + vfoptions.maxiter=10^4; % Can be used to stop the VFI after a finite number of iterations % Options relating to how the model is solved (which algorithm) vfoptions.solnmethod='purediscretization_refinement'; % if no d variable, will be set to 'purediscretization' below vfoptions.divideandconquer=0; @@ -60,7 +60,7 @@ vfoptions.parallel=1+(gpuDeviceCount>0); % GPU where available, otherwise parallel CPU. end if ~isfield(vfoptions,'maxiter') - vfoptions.maxiter=Inf; + vfoptions.maxiter=10^4; end if ~isfield(vfoptions,'solnmethod') vfoptions.solnmethod='purediscretization_refinement'; % if no d variable, will be set to 'purediscretization' below @@ -516,28 +516,28 @@ if N_d==0 if vfoptions.parallel==0 % On CPU - [VKron,Policy]=ValueFnIter_nod_Par0_raw(V0, N_a, N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance); + [VKron,Policy]=ValueFnIter_nod_Par0_raw(V0, N_a, N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); elseif vfoptions.parallel==1 % On Parallel CPU - [VKron,Policy]=ValueFnIter_nod_Par1_raw(V0, N_a, N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance); + [VKron,Policy]=ValueFnIter_nod_Par1_raw(V0, N_a, N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); elseif vfoptions.parallel==2 % On GPU if vfoptions.howardsgreedy==1 - [VKron,Policy]=ValueFnIter_nod_HowardGreedy_raw(V0, N_a, N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); % a_grid, z_grid, + [VKron,Policy]=ValueFnIter_nod_HowardGreedy_raw(V0, N_a, N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); elseif vfoptions.howardsgreedy==0 if vfoptions.howardssparse==0 - [VKron,Policy]=ValueFnIter_nod_raw(V0, N_a, N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); % a_grid, z_grid + [VKron,Policy]=ValueFnIter_nod_raw(V0, N_a, N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); elseif vfoptions.howardssparse==1 - [VKron,Policy]=ValueFnIter_sparse_nod_raw(V0, N_a, N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); % a_grid, z_grid + [VKron,Policy]=ValueFnIter_sparse_nod_raw(V0, N_a, N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); end end end else if vfoptions.parallel==0 % On CPU - [VKron, Policy]=ValueFnIter_Par0_raw(V0, N_d,N_a,N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix,vfoptions.howards, vfoptions.maxhowards,vfoptions.tolerance); + [VKron, Policy]=ValueFnIter_Par0_raw(V0, N_d,N_a,N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix,vfoptions.howards, vfoptions.maxhowards,vfoptions.tolerance, vfoptions.maxiter); elseif vfoptions.parallel==1 % On Parallel CPU - [VKron, Policy]=ValueFnIter_Par1_raw(V0, N_d,N_a,N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix,vfoptions.howards, vfoptions.maxhowards,vfoptions.tolerance); + [VKron, Policy]=ValueFnIter_Par1_raw(V0, N_d,N_a,N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix,vfoptions.howards, vfoptions.maxhowards,vfoptions.tolerance, vfoptions.maxiter); elseif vfoptions.parallel==2 % On GPU % Can't be bothered implementing HowardGreedy here, as for good runtimes you should anyway be doing Refine so wouldn't get here - [VKron, Policy]=ValueFnIter_raw(V0, n_d,n_a,n_z, pi_z, DiscountFactorParamsVec, ReturnMatrix,vfoptions.howards, vfoptions.maxhowards,vfoptions.tolerance); + [VKron, Policy]=ValueFnIter_raw(V0, n_d,n_a,n_z, pi_z, DiscountFactorParamsVec, ReturnMatrix,vfoptions.howards, vfoptions.maxhowards,vfoptions.tolerance, vfoptions.maxiter); end end @@ -550,12 +550,12 @@ if vfoptions.parallel==2 % On GPU if N_d==0 if vfoptions.howardssparse==0 - [VKron,Policy]=ValueFnIter_LowMem_nod_raw(V0, n_a, n_z, a_grid, z_gridvals, pi_z, DiscountFactorParamsVec, ReturnFn, ReturnFnParamsVec, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance); + [VKron,Policy]=ValueFnIter_LowMem_nod_raw(V0, n_a, n_z, a_grid, z_gridvals, pi_z, DiscountFactorParamsVec, ReturnFn, ReturnFnParamsVec, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); elseif vfoptions.howardssparse==1 - [VKron,Policy]=ValueFnIter_LowMem_sparse_nod_raw(V0, n_a, n_z, a_grid, z_gridvals, pi_z, DiscountFactorParamsVec, ReturnFn, ReturnFnParamsVec, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance); + [VKron,Policy]=ValueFnIter_LowMem_sparse_nod_raw(V0, n_a, n_z, a_grid, z_gridvals, pi_z, DiscountFactorParamsVec, ReturnFn, ReturnFnParamsVec, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); end else - [VKron, Policy]=ValueFnIter_LowMem_raw(V0, n_d,n_a,n_z, d_gridvals, a_grid, z_gridvals, pi_z, DiscountFactorParamsVec, ReturnFn, ReturnFnParamsVec,vfoptions.howards, vfoptions.maxhowards,vfoptions.tolerance); + [VKron, Policy]=ValueFnIter_LowMem_raw(V0, n_d,n_a,n_z, d_gridvals, a_grid, z_gridvals, pi_z, DiscountFactorParamsVec, ReturnFn, ReturnFnParamsVec,vfoptions.howards, vfoptions.maxhowards,vfoptions.tolerance, vfoptions.maxiter); end else error('can only use lowmemory on gpu') diff --git a/ValueFnIter/InfHorz/ValueFnIter_nod_HowardGreedy_raw.m b/ValueFnIter/InfHorz/ValueFnIter_nod_HowardGreedy_raw.m index 445a957c..b1fb35bd 100644 --- a/ValueFnIter/InfHorz/ValueFnIter_nod_HowardGreedy_raw.m +++ b/ValueFnIter/InfHorz/ValueFnIter_nod_HowardGreedy_raw.m @@ -51,5 +51,14 @@ Policy=reshape(Policy,[1,N_a,N_z]); +%% Howards greedy cannot solve models where V contains values of -Inf. Can kind of test for this by looking for -Inf in Ftemp +if any(~isfinite(Ftemp)) + warning('Howards-greedy cannot be used for models where V contains values of -Inf. This model looks like it may be one where V takes a value of -Inf at some points in the state-space. Consider checking solution against that with vfoptions.howardsgreedy=0') +end + +if tempcounter>=maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end + end diff --git a/ValueFnIter/InfHorz/ValueFnIter_nod_raw.m b/ValueFnIter/InfHorz/ValueFnIter_nod_raw.m index 7f7c1164..4eecf9ca 100644 --- a/ValueFnIter/InfHorz/ValueFnIter_nod_raw.m +++ b/ValueFnIter/InfHorz/ValueFnIter_nod_raw.m @@ -48,6 +48,9 @@ Policy=reshape(Policy,[1,N_a,N_z]); +if tempcounter>=maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end end diff --git a/ValueFnIter/InfHorz/ValueFnIter_raw.m b/ValueFnIter/InfHorz/ValueFnIter_raw.m index ad42b0d5..b4619b46 100644 --- a/ValueFnIter/InfHorz/ValueFnIter_raw.m +++ b/ValueFnIter/InfHorz/ValueFnIter_raw.m @@ -1,4 +1,4 @@ -function [VKron, Policy]=ValueFnIter_raw(VKron, n_d,n_a,n_z, pi_z, beta, ReturnMatrix, Howards,Howards2, Tolerance) %Verbose, +function [VKron, Policy]=ValueFnIter_raw(VKron, n_d,n_a,n_z, pi_z, beta, ReturnMatrix, Howards,Howards2, Tolerance, maxiter) N_d=prod(n_d); N_a=prod(n_a); @@ -15,7 +15,7 @@ %% tempcounter=1; currdist=Inf; -while currdist>Tolerance +while currdist>Tolerance && tempcounter<=maxiter VKronold=VKron; % Calc the condl expectation term (except beta), which depends on z but not on control variables @@ -61,4 +61,8 @@ Policy(1,:,:)=shiftdim(rem(PolicyIndexes-1,N_d)+1,-1); Policy(2,:,:)=shiftdim(ceil(PolicyIndexes/N_d),-1); +if tempcounter>=maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end + end diff --git a/ValueFnIter/InfHorz/ValueFnIter_sparse_nod_raw.m b/ValueFnIter/InfHorz/ValueFnIter_sparse_nod_raw.m index 63ad0c54..733719b7 100644 --- a/ValueFnIter/InfHorz/ValueFnIter_sparse_nod_raw.m +++ b/ValueFnIter/InfHorz/ValueFnIter_sparse_nod_raw.m @@ -59,5 +59,8 @@ Policy=reshape(Policy,[1,N_a,N_z]); +if tempcounter>=maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') +end end From 10204b9a056c859ead5281db13d5c28396f622db Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Tue, 27 Jan 2026 14:05:57 +1300 Subject: [PATCH 34/67] clean --- ValueFnIter/InfHorz/ValueFnIter_Case1.m | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ValueFnIter/InfHorz/ValueFnIter_Case1.m b/ValueFnIter/InfHorz/ValueFnIter_Case1.m index d6810ca7..2e828a16 100644 --- a/ValueFnIter/InfHorz/ValueFnIter_Case1.m +++ b/ValueFnIter/InfHorz/ValueFnIter_Case1.m @@ -27,7 +27,7 @@ % When doing Howards iterations, the following are some suboptions vfoptions.howards=150; % based on some tests, 80 to 150 was fastest, but 150 was best on average vfoptions.maxhowards=500; % Turn howards off after this many times (just so it cannot cause convergence to fail if thing are going wrong) - if N_a>1200 && N_z>100 && vfoptions.gridinterplayer==0 + if N_a>1200 && N_z>100 vfoptions.howardssparse=1; % Do Howards iteration using a sparse matrix (rather than indexing). Sparse is only faster for bigger models. else vfoptions.howardssparse=0; @@ -95,7 +95,7 @@ vfoptions.maxhowards=500; % Turn howards off after this many times (just so it cannot cause convergence to fail if thing are going wrong) end if ~isfield(vfoptions,'howardssparse') - if N_a>1200 && N_z>100 && vfoptions.gridinterplayer==0 + if N_a>1200 && N_z>100 vfoptions.howardssparse=1; % Do Howards iteration using a sparse matrix (rather than indexing). Sparse is only faster for bigger models. else vfoptions.howardssparse=0; From 284c36d7be9a1a5cc1d5b5dc50792b9756beff2d Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Tue, 27 Jan 2026 15:04:09 +1300 Subject: [PATCH 35/67] adapt sparse howards code to look like toolkit --- .../CreateReturnFnMatrix_Case1_Disc_Par2.m | 8 +- ...teReturnFnMatrix_Case1_Disc_DC1_nod_Par2.m | 8 +- .../ValueFnIter_postGI_sparse_nod_raw.m | 64 ++-------------- .../ValueFnIter_postGI_sparse_raw.m | 74 +++---------------- 4 files changed, 26 insertions(+), 128 deletions(-) diff --git a/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_Par2.m b/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_Par2.m index c2d6535e..207f1b0e 100644 --- a/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_Par2.m +++ b/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_Par2.m @@ -1,4 +1,4 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_Disc_Par2(ReturnFn, n_d, n_a, n_z, d_grid, a_grid, z_gridvals, ReturnFnParams,Refine) % Refine is an optional input +function Fmatrix=CreateReturnFnMatrix_Case1_Disc_Par2(ReturnFn, n_d, n_a, n_z, d_grid, a_grid, z_gridvals, ReturnFnParamsVec,Refine) % Refine is an optional input % would be good to make this version assume d (and d_gridvals) and use % alternative version when no d variable but problem is that so many codes % depend on this one would take ages to modify them all (all value fn @@ -15,9 +15,9 @@ Refine=0; end -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii,1)={ReturnFnParams(ii)}; +ParamCell=cell(length(ReturnFnParamsVec),1); +for ii=1:length(ReturnFnParamsVec) + ParamCell(ii,1)={ReturnFnParamsVec(ii)}; end N_d=prod(n_d); diff --git a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_nod_Par2.m b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_nod_Par2.m index 0b919282..a8f45d98 100644 --- a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_nod_Par2.m +++ b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_nod_Par2.m @@ -1,9 +1,9 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC1_nod_Par2(ReturnFn, n_z, aprime_grid, a_grid, z_gridvals, ReturnFnParams,Level) +function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC1_nod_Par2(ReturnFn, n_z, aprime_grid, a_grid, z_gridvals, ReturnFnParamsVec,Level) %If there is no d variable, just input n_d=0 and d_grid=0 -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii)={ReturnFnParams(ii)}; +ParamCell=cell(length(ReturnFnParamsVec),1); +for ii=1:length(ReturnFnParamsVec) + ParamCell(ii)={ReturnFnParamsVec(ii)}; end N_a=length(a_grid); % Because l_a=1 diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_sparse_nod_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_sparse_nod_raw.m index 96c05781..168efea4 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_sparse_nod_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_sparse_nod_raw.m @@ -22,24 +22,13 @@ N_a=prod(n_a); N_z=prod(n_z); -ParamCell=cell(length(ReturnFnParamsVec),1); -for ii=1:length(ReturnFnParamsVec) - if ~isequal(size(ReturnFnParamsVec(ii)), [1,1]) - error('Using GPU for the return fn does not allow for any of ReturnFnParams to be anything but a scalar') - end - ParamCell(ii,1)={ReturnFnParamsVec(ii)}; -end - %% Create return function matrix on coarse grid -aprime_gridvals = reshape(a_grid,[n_a,1,1]); % (a',1,1) -a_gridvals = reshape(a_grid,[1,n_a,1]); % (1,a,1) +a_gridvals = a_grid; % only one endogenous state, else wouldn't end up here -% ReturnMatrix(a',a,z) with a' on coarse grid -%ReturnMatrix = arrayfun(ReturnFn, aprime_gridvals, a_gridvals, z_gridvals3, ParamCell{:}); -ReturnMatrix = CreateReturnFnMatrix_GI_nod(ReturnFn,aprime_gridvals,a_gridvals,z_gridvals,ParamCell,n_z); +special_n_z=ones(1,length(n_z),'gpuArray'); -%NA = gpuArray.colon(1,N_a)'; -%NAZ = gpuArray.colon(1,N_a*N_z)'; +% ReturnMatrix(a',a,z) with a' on coarse grid +ReturnMatrix = CreateReturnFnMatrix_Case1_Disc_DC1_nod_Par2(ReturnFn, n_z, a_gridvals, a_gridvals, z_gridvals, ReturnFnParamsVec,1); [a_ind,z_ind] = ndgrid((1:N_a)',(1:N_z)'); a_ind = a_ind(:); % a varies first, size: [N_a*N_z,1] @@ -49,8 +38,6 @@ Policy = zeros(2,N_a,N_z,'gpuArray'); -Tolerance = vfoptions.tolerance; -maxiter = vfoptions.maxiter; howards = vfoptions.howards; verbose = vfoptions.verbose; n2short = vfoptions.ngridinterp; % number of (evenly spaced) points to put between each grid point (not counting the two points themselves) @@ -64,7 +51,7 @@ % computed at every iteration in the VFI loop. tempcounter=1; currdist=Inf; -while currdist>Tolerance && tempcounter<=maxiter +while currdist>vfoptions.tolerance && tempcounter<=vfoptions.maxiter % Calc the condl expectation term (except beta), which depends on z but not on control variables EV = VKronold*pi_z_transpose; % (a',z) @@ -87,7 +74,7 @@ aprimeindexes=(midpoint+(midpoint-1)*n2short)+(-n2short-1:1:1+n2short)'; % aprime points either side of midpoint aprime_fine_small = aprime_fine(aprimeindexes); % ReturnMatrix_fine(a',a) has size: [3+2*n2short,n_a] - ReturnMatrix_fine = CreateReturnFnMatrix_GI_nod_lowmem(ReturnFn,aprime_fine_small,a_gridvals,z_vals,ParamCell,n_z); + ReturnMatrix_fine = CreateReturnFnMatrix_Case1_Disc_DC1_nod_Par2(ReturnFn, special_n_z, aprime_fine_small, a_gridvals, z_vals, ReturnFnParamsVec,1); EV_z_interp = interp1(a_grid,EV_z,aprime_fine_small,'linear','extrap'); % entireRHS_fine has size [3+2*n2short,n_a] entireRHS_fine = ReturnMatrix_fine+DiscountFactorParamsVec*EV_z_interp; @@ -157,45 +144,10 @@ Policy(1,:,:)=Policy(1,:,:)-adjust; % lower grid point Policy(2,:,:)=adjust.*Policy(2,:,:)+(1-adjust).*(Policy(2,:,:)-n2short-1); % from 1 (lower grid point) to 1+n2short+1 (upper grid point) -end %end function - -%-------------------------------------------------------------------------% - -function Fmatrix = CreateReturnFnMatrix_GI_nod(ReturnFn,aprime_grid,a_grid,z_gridvals,ParamCell,n_z) -% Assumption: z_gridvals has size [1,length(n_z)] - -%ReturnMatrix_fine = arrayfun(ReturnFn,aprime_grid,a_grid,z_grid,ParamCell{:}); - -l_z = length(n_z); -if l_z>3 - error('ERROR: not allow for more than 3 of z variable (you have length(n_z)>3)') -end - -if l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime_grid, a_grid, shiftdim(z_gridvals(:,1),-2), ParamCell{:}); -elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime_grid, a_grid, shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), ParamCell{:}); -elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime_grid, a_grid, shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(z_gridvals(:,3),-2), ParamCell{:}); +if tempcounter>=vfoptions.maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') end -end % end subfunction - -function Fmatrix = CreateReturnFnMatrix_GI_nod_lowmem(ReturnFn,aprime_grid,a_grid,z_gridvals,ParamCell,n_z) -% Assumption: z_gridvals has size [1,length(n_z)] -l_z = length(n_z); -if l_z>3 - error('ERROR: not allow for more than 3 of z variable (you have length(n_z)>3)') end - -if l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime_grid, a_grid, z_gridvals(1), ParamCell{:}); -elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime_grid, a_grid, z_gridvals(1), z_gridvals(2), ParamCell{:}); -elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime_grid, a_grid, z_gridvals(1), z_gridvals(2), z_gridvals(3), ParamCell{:}); -end - -end % end subfunction \ No newline at end of file diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_sparse_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_sparse_raw.m index 249d1362..3c6238f9 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_sparse_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_postGI_sparse_raw.m @@ -24,36 +24,21 @@ N_a=prod(n_a); N_z=prod(n_z); -ParamCell=cell(length(ReturnFnParamsVec),1); -for ii=1:length(ReturnFnParamsVec) - if ~isequal(size(ReturnFnParamsVec(ii)), [1,1]) - error('Using GPU for the return fn does not allow for any of ReturnFnParams to be anything but a scalar') - end - ParamCell(ii,1)={ReturnFnParamsVec(ii)}; -end - %% Create return function matrix on coarse grid -%d_gridvals = d_gridvals; % (d,1,1,1) -aprime_gridvals = reshape(a_grid,[1,n_a,1,1]); % (1,a',1) -a_gridvals = reshape(a_grid,[1,1,n_a]); % (1,a,1) +a_gridvals = a_grid; % only one endogenous state, else wouldn't end up here % ReturnMatrix(d,a',a,z) with a' on coarse grid -ReturnMatrixraw = CreateReturnFnMatrix_GI(ReturnFn,d_gridvals,aprime_gridvals,a_gridvals,z_gridvals,ParamCell,n_z); +ReturnMatrixraw = CreateReturnFnMatrix_Case1_Disc_DC1_Par2(ReturnFn, n_d, n_z, d_gridvals, a_gridvals, a_gridvals, z_gridvals, ReturnFnParamsVec,1); ReturnMatrix = max(ReturnMatrixraw,[],1); ReturnMatrix = reshape(ReturnMatrix,[N_a,N_a,N_z]); -%NA = gpuArray.colon(1,N_a)'; -%NAZ = gpuArray.colon(1,N_a*N_z)'; - [a_ind,z_ind] = ndgrid((1:N_a)',(1:N_z)'); a_ind = a_ind(:); % a varies first, size: [N_a*N_z,1] z_ind = z_ind(:); % z varies second, size: [N_a*N_z,1] pi_z_transpose = pi_z.'; -Tolerance = vfoptions.tolerance; -maxiter = vfoptions.maxiter; howards = vfoptions.howards; verbose = vfoptions.verbose; @@ -62,6 +47,7 @@ n2long = vfoptions.ngridinterp*2+3; % total number of aprime points we end up looking at in second layer aprime_grid=interp1(1:1:N_a,a_grid,linspace(1,N_a,N_a+(N_a-1)*n2short)); +special_n_z=ones(1,length(n_z),'gpuArray'); VKron = zeros(N_a,N_z,'gpuArray'); Policy = zeros(3,N_a,N_z,'gpuArray'); % first dim indexes the optimal choice for aprime and aprime2 (in GI layer) @@ -69,18 +55,17 @@ tempcounter=1; currdist=Inf; -while currdist>Tolerance && tempcounter<=maxiter +while currdist>vfoptions.tolerance && tempcounter<=vfoptions.maxiter %% Given VKronold, obtain VKron - - + % Calc the condl expectation term (except beta), which depends on z but not on control variables EV = VKronold*pi_z_transpose; % (a',z) for z_c=1:N_z z_val = z_gridvals(z_c,:); % scalars z1,z2,etc. EV_z = EV(:,z_c); % (a',1) - + ReturnMatrix_z=ReturnMatrix(:,:,z_c); % (a',a) a' on coarse grid entireRHS_z=ReturnMatrix_z+DiscountFactorParamsVec*EV_z; %(a',a) @@ -96,9 +81,9 @@ % aprime possibilities are n_d-by-n2long-by-n_a aprime_ii = aprime_grid(aprimeindexes); % ReturnMatrix_ii_z is (N_d,n2long,n_a) - ReturnMatrix_ii_z = CreateReturnFnMatrix_GI_lowmem(ReturnFn,d_gridvals,aprime_ii,a_gridvals,z_val,ParamCell,n_z); + ReturnMatrix_ii_z = CreateReturnFnMatrix_Case1_Disc_DC1_Par2(ReturnFn, n_d, special_n_z, d_gridvals, aprime_ii, a_gridvals, z_val, ReturnFnParamsVec,1); % EV_z_interp is (n2long,n_a) - EV_z_interp = interp1(a_grid,EV_z,aprime_ii,'linear','extrap'); + EV_z_interp = interp1(a_grid,EV_z,aprime_ii,'linear'); % entireRHS_ii_z is (N_d,n2long,n_a) entireRHS_ii_z = ReturnMatrix_ii_z + DiscountFactorParamsVec*reshape(EV_z_interp,[1,n2long,n_a]); @@ -169,47 +154,8 @@ %Policy=Policy(1,:,:)+N_d*(Policy(2,:,:)-1)+N_d*N_a*(Policy(3,:,:)-1); - - -end %end function - -%-------------------------------------------------------------------------% - -function Fmatrix = CreateReturnFnMatrix_GI(ReturnFn,d_gridvals,aprime_grid,a_grid,z_gridvals,ParamCell,n_z) -% Assumption: z_gridvals has size [1,length(n_z)] - - -%ReturnMatrix_fine = arrayfun(ReturnFn,aprime_grid,a_grid,z_grid,ParamCell{:}); - -l_z = length(n_z); -if l_z>3 - error('ERROR: not allow for more than 3 of z variable (you have length(n_z)>3)') -end - -if l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals,aprime_grid, a_grid, shiftdim(z_gridvals(:,1),-3), ParamCell{:}); -elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals,aprime_grid, a_grid, shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), ParamCell{:}); -elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals,aprime_grid, a_grid, shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), ParamCell{:}); +if tempcounter>=vfoptions.maxiter + warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') end -end % end subfunction - -function Fmatrix = CreateReturnFnMatrix_GI_lowmem(ReturnFn,d_gridvals,aprime_grid,a_grid,z_gridvals,ParamCell,n_z) -% Assumption: z_gridvals has size [1,length(n_z)] - -l_z = length(n_z); -if l_z>3 - error('ERROR: not allow for more than 3 of z variable (you have length(n_z)>3)') end - -if l_z==1 - Fmatrix=arrayfun(ReturnFn,d_gridvals,shiftdim(aprime_grid,-1),a_grid, z_gridvals(1), ParamCell{:}); -elseif l_z==2 - Fmatrix=arrayfun(ReturnFn,d_gridvals,shiftdim(aprime_grid,-1),a_grid, z_gridvals(1), z_gridvals(2), ParamCell{:}); -elseif l_z==3 - Fmatrix=arrayfun(ReturnFn,d_gridvals,shiftdim(aprime_grid,-1),a_grid, z_gridvals(1), z_gridvals(2), z_gridvals(3), ParamCell{:}); -end - -end % end subfunction \ No newline at end of file From e352425d337c3d0ee4431cedf53482fe1e7d16db Mon Sep 17 00:00:00 2001 From: Michael Tiemann Date: Wed, 28 Jan 2026 09:11:32 +1300 Subject: [PATCH 36/67] Eliminate `for` loop Use `num2cell` idiom for cleaner code. OLGModel6 tests the Case1 cases, and LifeCycleModel31 tests the Case2 cases. --- ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_Par2.m | 5 +---- ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_Par2e.m | 5 +---- ReturnFnMatrix/CreateReturnFnMatrix_Case2_Disc_Par2.m | 9 +++------ ReturnFnMatrix/CreateReturnFnMatrix_Case2_Disc_Par2e.m | 9 +++------ 4 files changed, 8 insertions(+), 20 deletions(-) diff --git a/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_Par2.m b/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_Par2.m index 207f1b0e..09a56ddc 100644 --- a/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_Par2.m +++ b/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_Par2.m @@ -15,10 +15,7 @@ Refine=0; end -ParamCell=cell(length(ReturnFnParamsVec),1); -for ii=1:length(ReturnFnParamsVec) - ParamCell(ii,1)={ReturnFnParamsVec(ii)}; -end +ParamCell=num2cell(ReturnFnParamsVec)'; N_d=prod(n_d); N_a=prod(n_a); diff --git a/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_Par2e.m b/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_Par2e.m index 1b83d45a..a97dbd21 100644 --- a/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_Par2e.m +++ b/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_Par2e.m @@ -12,10 +12,7 @@ Refine=0; end -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii,1)={ReturnFnParams(ii)}; -end +ParamCell=num2cell(ReturnFnParams)'; N_d=prod(n_d); N_a=prod(n_a); diff --git a/ReturnFnMatrix/CreateReturnFnMatrix_Case2_Disc_Par2.m b/ReturnFnMatrix/CreateReturnFnMatrix_Case2_Disc_Par2.m index 3e3e4f69..96e3f7c6 100644 --- a/ReturnFnMatrix/CreateReturnFnMatrix_Case2_Disc_Par2.m +++ b/ReturnFnMatrix/CreateReturnFnMatrix_Case2_Disc_Par2.m @@ -1,13 +1,10 @@ function Fmatrix=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn,n_d, n_a, n_z, d_gridvals, a_gridvals, z_gridvals, ReturnFnParams) %If there is no d variable, just input n_d=0 and d_grid=0 -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - if size(ReturnFnParams(ii))~=[1,1] - error('Using GPU for the return fn does not allow for any of ReturnFnParams to be anything but a scalar') - end - ParamCell(ii,1)={ReturnFnParams(ii)}; +if ~all(arrayfun(@(x) isscalar(x),ReturnFnParams)) + error('Using GPU for the return fn does not allow for any of ReturnFnParams to be anything but a scalar') end +ParamCell=num2cell(ReturnFnParams)'; N_d=prod(n_d); N_a=prod(n_a); diff --git a/ReturnFnMatrix/CreateReturnFnMatrix_Case2_Disc_Par2e.m b/ReturnFnMatrix/CreateReturnFnMatrix_Case2_Disc_Par2e.m index 9ad7782c..278fead6 100644 --- a/ReturnFnMatrix/CreateReturnFnMatrix_Case2_Disc_Par2e.m +++ b/ReturnFnMatrix/CreateReturnFnMatrix_Case2_Disc_Par2e.m @@ -1,13 +1,10 @@ function Fmatrix=CreateReturnFnMatrix_Case2_Disc_Par2e(ReturnFn,n_d, n_a, n_z, n_e, d_gridvals, a_gridvals, z_gridvals, e_gridvals, ReturnFnParams) %If there is no d variable, just input n_d=0 and d_grid=0 -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - if ~all(size(ReturnFnParams(ii))==[1,1]) - error('Using GPU for the return fn does not allow for any of ReturnFnParams to be anything but a scalar') - end - ParamCell(ii,1)={ReturnFnParams(ii)}; +if ~all(arrayfun(@(x) isscalar(x),ReturnFnParams)) + error('Using GPU for the return fn does not allow for any of ReturnFnParams to be anything but a scalar') end +ParamCell=num2cell(ReturnFnParams)'; N_d=prod(n_d); N_a=prod(n_a); From 8d1ed083fafc50784ee965a23fa7cf6bf4df9c09 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Wed, 28 Jan 2026 09:19:03 +1300 Subject: [PATCH 37/67] clean --- ...tationaryDist_FHorz_Iteration_SemiExo_nProbs_raw.m | 11 ++--------- 1 file changed, 2 insertions(+), 9 deletions(-) diff --git a/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_raw.m b/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_raw.m index 0fd3927e..61ef5838 100644 --- a/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_raw.m +++ b/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_raw.m @@ -8,23 +8,16 @@ % put a&semiz&z together into the 1st dim, semiz'&nprobs into the 2nd dim. % Policy_aprime is currently [N_a,N_semiz*N_z,N_probs,N_j] -% Policy_aprimesemizz=repelem(reshape(Policy_aprime,[N_a*N_semiz*N_z,N_probs,N_j]),1,N_semiz)+repmat(N_a*gpuArray(0:1:N_semiz-1),1,N_probs)+repelem(N_a*N_semiz*gpuArray(0:1:N_z-1)',N_a*N_semiz,1); % Note: add semiz' index following the semiz' dimension, add z' index following the z dimension for Tan improvement -% Policy_aprimesemizz=gather(Policy_aprimesemizz); % [N_a*N_semiz*N_z,N_semiz*N_probs,N_j] -% % Previous two lines gave out of memory order, so the following line just does gather() earlier. Policy_aprimesemizz=repelem(reshape(gather(Policy_aprime),[N_a*N_semiz*N_z,N_probs,N_j]),1,N_semiz)+repmat(N_a*(0:1:N_semiz-1),1,N_probs)+repelem(N_a*N_semiz*(0:1:N_z-1)',N_a*N_semiz,1); % Note: add semiz' index following the semiz' dimension, add z' index following the z dimension for Tan improvement Policy_dsemiexo=reshape(Policy_dsemiexo,[N_a*N_semiz*N_z,1,N_j]); + % precompute -semizindex=repmat(repelem(gpuArray(1:1:N_semiz)',N_a,1),N_z,1)+N_semiz*gpuArray(0:1:N_semiz-1)+(N_semiz*N_semiz)*(Policy_dsemiexo-1); % index for semiz, plus that for semiz' (in the semiz' dim) and dsemiexo; their indexes in pi_semiz_J -% % Previous line gave out of memory order, so the following line just does gather() earlier. -% semizindex=repmat(repelem((1:1:N_semiz)',N_a,1),N_z,1)+N_semiz*(0:1:N_semiz-1)+gather((N_semiz*N_semiz)*(Policy_dsemiexo-1)); % index for semiz, plus that for semiz' (in the semiz' dim) and dsemiexo; their indexes in pi_semiz_J +semizindex=repmat(repelem((1:1:N_semiz)',N_a,1),N_z,1)+N_semiz*(0:1:N_semiz-1)+gather((N_semiz*N_semiz)*(Policy_dsemiexo-1)); % index for semiz, plus that for semiz' (in the semiz' dim) and dsemiexo; their indexes in pi_semiz_J % semizindex is [N_a*N_semiz*N_z,N_semiz,N_j] PolicyProbs=reshape(PolicyProbs,[N_a*N_semiz*N_z,N_probs,N_j]); -% PolicyProbs=repelem(PolicyProbs,1,N_semiz).*repmat(pi_semiz_J(semizindex),1,N_probs); -% PolicyProbs=gather(PolicyProbs); -% % Previous two lines gave out of memory order, so the following line just does gather() earlier. % pi_semiz_J=gather(pi_semiz_J); PolicyProbs=repelem(gather(PolicyProbs),1,N_semiz).*repmat(pi_semiz_J(semizindex),1,N_probs); From 743e2508b2b6e2f27840493ad3b27fa9345abbd8 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Wed, 28 Jan 2026 10:19:52 +1300 Subject: [PATCH 38/67] lots of cleaning --- .../CreateReturnFnMatrix_Case1_Disc.m | 17 +- .../CreateReturnFnMatrix_Case1_Disc_Par2.m | 208 +-- .../CreateReturnFnMatrix_Case1_Disc_Par2e.m | 1012 ++++++------- ...CreateReturnFnMatrix_Case1_Disc_nod_Par2.m | 51 +- .../CreateReturnFnMatrix_Case1_Disc_noz.m | 13 +- ...CreateReturnFnMatrix_Case1_Disc_noz_Par2.m | 53 +- .../CreateReturnFnMatrix_Case2_Disc_Par2.m | 288 ++-- .../CreateReturnFnMatrix_Case2_Disc_Par2e.m | 835 ++++++----- ...CreateReturnFnMatrix_Case2_Disc_noz_Par2.m | 52 +- ...CreateReturnFnMatrix_Case1_Disc_DC1_Par2.m | 40 +- ...reateReturnFnMatrix_Case1_Disc_DC1_Par2e.m | 136 +- ...teReturnFnMatrix_Case1_Disc_DC1_nod_Par2.m | 16 +- ...eReturnFnMatrix_Case1_Disc_DC1_nod_Par2e.m | 44 +- ...eReturnFnMatrix_Case1_Disc_DC1_nodz_Par2.m | 9 +- ...teReturnFnMatrix_Case1_Disc_DC1_noz_Par2.m | 16 +- ...reateReturnFnMatrix_Case1_Disc_DC2B_Par2.m | 44 +- ...eateReturnFnMatrix_Case1_Disc_DC2B_Par2e.m | 142 +- ...eReturnFnMatrix_Case1_Disc_DC2B_nod_Par2.m | 18 +- ...ReturnFnMatrix_Case1_Disc_DC2B_nod_Par2e.m | 44 +- ...ReturnFnMatrix_Case1_Disc_DC2B_nodz_Par2.m | 10 +- ...eReturnFnMatrix_Case1_Disc_DC2B_noz_Par2.m | 18 +- ...CreateReturnFnMatrix_Case1_Disc_DC2_Par2.m | 52 +- ...teReturnFnMatrix_Case1_Disc_DC2_nod_Par2.m | 25 +- ...eReturnFnMatrix_Case1_ExpAsset_Disc_Par2.m | 276 ++-- ...urnFnMatrix_Case1_ExpAsset_Disc_Par2_noz.m | 51 +- ...ReturnFnMatrix_Case1_ExpAsset_Disc_Par2e.m | 1300 ++++++++--------- ...ReturnFnMatrix_Case1_Disc_Par2_refineld1.m | 80 +- ...ReturnFnMatrix_Case1_Disc_Par2_refineld2.m | 80 +- ...ReturnFnMatrix_Case1_Disc_Par2_refineld3.m | 80 +- ...ReturnFnMatrix_Case1_Disc_Par2_refineld4.m | 81 +- ...eturnFnMatrix_Case1_ResidAsset_Disc_Par2.m | 453 +++--- ...turnFnMatrix_Case1_Disc_fastOLG_DC1_Par2.m | 40 +- ...urnFnMatrix_Case1_Disc_fastOLG_DC1_Par2e.m | 138 +- ...FnMatrix_Case1_Disc_fastOLG_DC1_nod_Par2.m | 22 +- ...nMatrix_Case1_Disc_fastOLG_DC1_nod_Par2e.m | 72 +- ...trix_Case1_Disc_fastOLG_DC1_nod_noz_Par2.m | 6 +- ...FnMatrix_Case1_Disc_fastOLG_DC1_noz_Par2.m | 14 +- 37 files changed, 2769 insertions(+), 3067 deletions(-) diff --git a/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc.m b/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc.m index 1401eb86..0dee07e2 100644 --- a/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc.m +++ b/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc.m @@ -5,10 +5,7 @@ Refine=0; end -ParamCell=cell(length(ReturnFnParamsVec),1); -for ii=1:length(ReturnFnParamsVec) - ParamCell(ii,1)={ReturnFnParamsVec(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_d=prod(n_d); N_a=prod(n_a); @@ -37,7 +34,7 @@ Fmatrix=zeros(N_a,N_a); for i2=1:N_a % a today for i1=1:N_a % a' tomorrow - Fmatrix(i1,i2)=ReturnFn(a_grid(i1),a_grid(i2),ParamCell{:}); + Fmatrix(i1,i2)=ReturnFn(a_grid(i1),a_grid(i2),ReturnFnParamsCell{:}); end end else @@ -45,7 +42,7 @@ for i3=1:N_a % a today for i2=1:N_a % a' tomorrow for i1=1:N_d % d choice - Fmatrix(i1+(i2-1)*N_d,i3)=ReturnFn(d_grid(i1),a_grid(i2),a_grid(i3),ParamCell{:}); + Fmatrix(i1+(i2-1)*N_d,i3)=ReturnFn(d_grid(i1),a_grid(i2),a_grid(i3),ReturnFnParamsCell{:}); end end end @@ -58,7 +55,7 @@ Fmatrix_z=zeros(N_a,N_a); for i2=1:N_a % a today for i1=1:N_a % a' tomorrow - Fmatrix_z(i1,i2)=ReturnFn(a_grid(i1),a_grid(i2),z_gridvals(i3),ParamCell{:}); + Fmatrix_z(i1,i2)=ReturnFn(a_grid(i1),a_grid(i2),z_gridvals(i3),ReturnFnParamsCell{:}); end end Fmatrix(:,:,i3)=Fmatrix_z; @@ -70,7 +67,7 @@ for i3=1:N_a % a today for i2=1:N_a % a' tomorrow for i1=1:N_d % d choice - Fmatrix_z(i1+(i2-1)*N_d,i3)=ReturnFn(d_grid(i1),a_grid(i2),a_grid(i3),z_gridvals(i4),ParamCell{:}); + Fmatrix_z(i1+(i2-1)*N_d,i3)=ReturnFn(d_grid(i1),a_grid(i2),a_grid(i3),z_gridvals(i4),ReturnFnParamsCell{:}); end end end @@ -86,7 +83,7 @@ Fmatrix_z=zeros(N_a,N_a); for i2=1:N_a % a today for i1=1:N_a % a' tomorrow - Fmatrix_z(i1,i2)=ReturnFn(a_grid(i1),a_grid(i2),z1,z2,ParamCell{:}); + Fmatrix_z(i1,i2)=ReturnFn(a_grid(i1),a_grid(i2),z1,z2,ReturnFnParamsCell{:}); end end Fmatrix(:,:,i3)=Fmatrix_z; @@ -100,7 +97,7 @@ for i3=1:N_a % a today for i2=1:N_a % a' tomorrow for i1=1:N_d % d choice - Fmatrix_z(i1+(i2-1)*N_d,i3)=ReturnFn(d_grid(i1),a_grid(i2),a_grid(i3),z1,z2,ParamCell{:}); + Fmatrix_z(i1+(i2-1)*N_d,i3)=ReturnFn(d_grid(i1),a_grid(i2),a_grid(i3),z1,z2,ReturnFnParamsCell{:}); end end end diff --git a/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_Par2.m b/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_Par2.m index 09a56ddc..3ee979d7 100644 --- a/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_Par2.m +++ b/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_Par2.m @@ -15,7 +15,7 @@ Refine=0; end -ParamCell=num2cell(ReturnFnParamsVec)'; +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_d=prod(n_d); N_a=prod(n_a); @@ -28,13 +28,13 @@ l_a=length(n_a); l_z=length(n_z); if l_d>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') + error('Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') end if l_a>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of a variable (you have length(n_a)>4)') + error('Using GPU for the return fn does not allow for more than four of a variable (you have length(n_a)>4)') end if l_z>5 - error('ERROR: Using GPU for the return fn does not allow for more than five of z variable (you have length(n_z)>5)') + error('Using GPU for the return fn does not allow for more than five of z variable (you have length(n_z)>5)') end if l_a>=1 @@ -71,206 +71,206 @@ end if l_d==0 && l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, a1primevals, a1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1primevals, a1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, a1primevals, a1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1primevals, a1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, a1primevals, a1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1primevals, a1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, a1primevals, a1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1primevals, a1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, a1primevals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1primevals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals, a1vals,a2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals, a1vals,a2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==1 && l_z==1 % d_gridvals(:,1)(1,1,1,1)=d_grid(1); % Requires special treatment - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals, a1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals, a1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals, a1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals, a1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals, a1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals, a1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals, a1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals, a1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals, a1vals,a2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals, a1vals,a2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals, a1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals, a1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals, a1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals, a1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals, a1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals, a1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals, a1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals, a1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals, a1vals,a2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals, a1vals,a2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals, a1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals, a1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals, a1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals, a1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals, a1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals, a1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals, a1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals, a1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals, a1vals,a2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals, a1vals,a2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals, a1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals, a1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals, a1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals, a1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals, a1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals, a1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals, a1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals, a1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals, a1vals,a2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals, a1vals,a2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals,a3primevals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1primevals,a2primevals,a3primevals,a4primevals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); end if l_d==0 diff --git a/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_Par2e.m b/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_Par2e.m index a97dbd21..d762770d 100644 --- a/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_Par2e.m +++ b/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_Par2e.m @@ -1,4 +1,4 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_Disc_Par2e(ReturnFn, n_d, n_a, n_z, n_e, d_grid, a_grid, z_gridvals, e_gridvals, ReturnFnParams, Refine) +function Fmatrix=CreateReturnFnMatrix_Case1_Disc_Par2e(ReturnFn, n_d, n_a, n_z, n_e, d_grid, a_grid, z_gridvals, e_gridvals, ReturnFnParamsVec, Refine) % If there is no d variable, just input n_d=0 % Same as CreateReturnFnMatrix_Case1_Disc_Par2, except with e variable @@ -12,7 +12,7 @@ Refine=0; end -ParamCell=num2cell(ReturnFnParams)'; +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_d=prod(n_d); N_a=prod(n_a); @@ -27,16 +27,16 @@ l_z=length(n_z); l_e=length(n_e); if l_d>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') + error('Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') end if l_a>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of a variable (you have length(n_a)>4)') + error('Using GPU for the return fn does not allow for more than four of a variable (you have length(n_a)>4)') end if l_z>5 - error('ERROR: Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') + error('Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') end if l_e>5 - error('ERROR: Using GPU for the return fn does not allow for more than four of e variable (you have length(n_e)>4)') + error('Using GPU for the return fn does not allow for more than four of e variable (you have length(n_e)>4)') end if l_a>=1 @@ -93,1061 +93,1061 @@ if l_e==1 if l_d==0 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==1 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); end end elseif l_e==2 if l_d==0 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ReturnFnParamsCell{:}); end elseif l_d==1 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals, ReturnFnParamsCell{:}); end end elseif l_e==3 if l_d==0 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); end elseif l_d==1 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals, ReturnFnParamsCell{:}); end end elseif l_e==4 if l_d==0 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); end elseif l_d==1 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals, ReturnFnParamsCell{:}); end end elseif l_e==5 if l_d==0 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==1 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals, ReturnFnParamsCell{:}); end end end diff --git a/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_nod_Par2.m b/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_nod_Par2.m index 5a5c35cf..b3e431c5 100644 --- a/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_nod_Par2.m +++ b/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_nod_Par2.m @@ -1,9 +1,6 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_Disc_nod_Par2(ReturnFn, n_a, n_z, a_grid, z_gridvals, ReturnFnParams) % Refine is not relevant without d +function Fmatrix=CreateReturnFnMatrix_Case1_Disc_nod_Par2(ReturnFn, n_a, n_z, a_grid, z_gridvals, ReturnFnParamsVec) % Refine is not relevant without d -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii,1)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_a=prod(n_a); N_z=prod(n_z); @@ -11,10 +8,10 @@ l_a=length(n_a); l_z=length(n_z); if l_a>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of a variable (you have length(n_a)>4)') + error('Using GPU for the return fn does not allow for more than four of a variable (you have length(n_a)>4)') end if l_z>5 - error('ERROR: Using GPU for the return fn does not allow for more than five of z variable (you have length(n_z)>5)') + error('Using GPU for the return fn does not allow for more than five of z variable (you have length(n_z)>5)') end if l_a>=1 @@ -51,45 +48,45 @@ end if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); end Fmatrix=reshape(Fmatrix,[N_a,N_a,N_z]); diff --git a/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_noz.m b/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_noz.m index 61d4ce69..8bf58dd6 100644 --- a/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_noz.m +++ b/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_noz.m @@ -5,10 +5,7 @@ Refine=0; end -ParamCell=cell(length(ReturnFnParamsVec),1); -for ii=1:length(ReturnFnParamsVec) - ParamCell(ii,1)={ReturnFnParamsVec(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_d=prod(n_d); N_a=prod(n_a); @@ -26,7 +23,7 @@ for i1=1:N_a for i2=1:N_a tempcell=num2cell([a_gridvals(i1,:),a_gridvals(i2,:)]); - Fmatrix(i1,i2)=ReturnFn(tempcell{:},ParamCell{:}); + Fmatrix(i1,i2)=ReturnFn(tempcell{:},ReturnFnParamsCell{:}); end end @@ -38,7 +35,7 @@ i1i2=i1+(i2-1)*N_d; for i3=1:N_a tempcell=num2cell([d_gridvals(i1,:),a_gridvals(i2,:),a_gridvals(i3,:)]); - Fmatrix(i1i2,i3)=ReturnFn(tempcell{:},ParamCell{:}); + Fmatrix(i1i2,i3)=ReturnFn(tempcell{:},ReturnFnParamsCell{:}); end end end @@ -53,7 +50,7 @@ a_vals=a_gridvals(i2,:); for i1=1:N_a tempcell=num2cell([a_gridvals(i1,:),a_vals]); - Fmatrix_a(i1)=ReturnFn(tempcell{:},ParamCell{:}); + Fmatrix_a(i1)=ReturnFn(tempcell{:},ReturnFnParamsCell{:}); end Fmatrix(:,i2)=Fmatrix_a; end @@ -65,7 +62,7 @@ for i1=1:N_d for i2=1:N_a tempcell=num2cell([d_gridvals(i1,:),a_gridvals(i2,:),a_vals]); - Fmatrix_a(i1+(i2-1)*N_d)=ReturnFn(tempcell{:},ParamCell{:}); + Fmatrix_a(i1+(i2-1)*N_d)=ReturnFn(tempcell{:},ReturnFnParamsCell{:}); end end Fmatrix(:,i3)=Fmatrix_a; diff --git a/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_noz_Par2.m b/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_noz_Par2.m index 18e8255f..c3a03174 100644 --- a/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_noz_Par2.m +++ b/ReturnFnMatrix/CreateReturnFnMatrix_Case1_Disc_noz_Par2.m @@ -1,5 +1,5 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(ReturnFn, n_d, n_a, d_grid, a_grid, ReturnFnParams,Refine) % Refine is an optional input -%If there is no d variable, just input n_d=0 and d_grid=0 +function Fmatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(ReturnFn, n_d, n_a, d_grid, a_grid, ReturnFnParamsVec,Refine) % Refine is an optional input +% If there is no d variable, just input n_d=0 and d_grid=0 if size(d_grid,2)==1 % stacked-column % IN FUTURE, CHANGE INPUT TO BE d_gridvals d_gridvals=CreateGridvals(n_d,d_grid,1); @@ -7,10 +7,7 @@ d_gridvals=d_grid; end -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_d=prod(n_d); N_a=prod(n_a); @@ -21,10 +18,10 @@ end l_a=length(n_a); if l_d>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') + error('Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') end if l_a>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of a variable (you have length(n_a)>4)') + error('Using GPU for the return fn does not allow for more than four of a variable (you have length(n_a)>4)') end if l_a>=1 @@ -45,46 +42,46 @@ end if l_d==0 && l_a==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==1 % d_gridvals(:,1)(1,1,1)=d_grid(1); % Requires special treatment - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals, a1vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals, a1vals,a2vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals, a1vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals, a1vals,a2vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals, a1vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals, a1vals,a2vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals, a1vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals, a1vals,a2vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, ReturnFnParamsCell{:}); end if l_d==0 diff --git a/ReturnFnMatrix/CreateReturnFnMatrix_Case2_Disc_Par2.m b/ReturnFnMatrix/CreateReturnFnMatrix_Case2_Disc_Par2.m index 96e3f7c6..31431165 100644 --- a/ReturnFnMatrix/CreateReturnFnMatrix_Case2_Disc_Par2.m +++ b/ReturnFnMatrix/CreateReturnFnMatrix_Case2_Disc_Par2.m @@ -1,10 +1,6 @@ -function Fmatrix=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn,n_d, n_a, n_z, d_gridvals, a_gridvals, z_gridvals, ReturnFnParams) -%If there is no d variable, just input n_d=0 and d_grid=0 +function Fmatrix=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn,n_d, n_a, n_z, d_gridvals, a_gridvals, z_gridvals, ReturnFnParamsVec) -if ~all(arrayfun(@(x) isscalar(x),ReturnFnParams)) - error('Using GPU for the return fn does not allow for any of ReturnFnParams to be anything but a scalar') -end -ParamCell=num2cell(ReturnFnParams)'; +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_d=prod(n_d); N_a=prod(n_a); @@ -14,32 +10,16 @@ l_a=length(n_a); l_z=length(n_z); if l_d>4 - error('=Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4): (in CreateReturnFnMatrix_Case2_Disc_Par2)') + error('Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') end if l_a>4 - error('Using GPU for the return fn does not allow for more than four of a variable (you have length(n_a)>4): (in CreateReturnFnMatrix_Case2_Disc_Par2)') + error('Using GPU for the return fn does not allow for more than four of a variable (you have length(n_a)>4)') end if l_z>8 - error('Using GPU for the return fn does not allow for more than four of z variable (plus four of semiz): (in CreateReturnFnMatrix_Case2_Disc_Par2)') -end - -if nargin(ReturnFn)~=l_d+l_a+l_z+length(ReturnFnParams) - error('Number of inputs to ReturnFn does not fit with size of ReturnFnParams') + error('Using GPU for the return fn does not allow for more than four of z variable (plus four of semiz)') end -if l_d>=1 - d1vals=d_gridvals(:,1); - if l_d>=2 - d2vals=d_gridvals(:,2); - if l_d>=3 - d3vals=d_gridvals(:,3); - if l_d>=4 - d4vals=d_gridvals(:,4); - end - end - end -end if l_a>=1 a1vals=shiftdim(a_gridvals(:,1),-1); if l_a>=2 @@ -79,268 +59,268 @@ if l_d==1 if l_a==1 && l_z==1 - % d1vals(1,1,1)=d_grid(1); % Requires special treatment - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,ParamCell{:}); + % d_gridvals(:,1)(1,1,1)=d_grid(1); % Requires special treatment + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals,z3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals,z3vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals,z3vals,z4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals,z3vals,z4vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==6 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==7 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==8 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals,z3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals,z3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==6 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==7 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==8 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==6 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==7 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==8 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==6 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==7 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==8 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ReturnFnParamsCell{:}); end elseif l_d==2 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals,z3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals,z3vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals,z3vals,z4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals,z3vals,z4vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==6 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==7 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==8 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals,z3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals,z3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==6 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==7 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==8 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==6 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==7 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==8 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==6 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==7 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==8 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ReturnFnParamsCell{:}); end elseif l_d==3 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals,z3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals,z3vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals,z3vals,z4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals,z3vals,z4vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==6 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==7 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==8 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals,z3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals,z3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==6 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==7 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==8 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==6 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==7 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==8 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==6 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==7 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==8 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ReturnFnParamsCell{:}); end elseif l_d==4 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals,z3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals,z3vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals,z3vals,z4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals,z3vals,z4vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==6 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==7 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==8 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals,z3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals,z3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==6 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==7 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==8 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==6 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==7 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==8 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==6 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==7 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==8 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals,ReturnFnParamsCell{:}); end end diff --git a/ReturnFnMatrix/CreateReturnFnMatrix_Case2_Disc_Par2e.m b/ReturnFnMatrix/CreateReturnFnMatrix_Case2_Disc_Par2e.m index 278fead6..574a20e0 100644 --- a/ReturnFnMatrix/CreateReturnFnMatrix_Case2_Disc_Par2e.m +++ b/ReturnFnMatrix/CreateReturnFnMatrix_Case2_Disc_Par2e.m @@ -1,10 +1,6 @@ -function Fmatrix=CreateReturnFnMatrix_Case2_Disc_Par2e(ReturnFn,n_d, n_a, n_z, n_e, d_gridvals, a_gridvals, z_gridvals, e_gridvals, ReturnFnParams) -%If there is no d variable, just input n_d=0 and d_grid=0 +function Fmatrix=CreateReturnFnMatrix_Case2_Disc_Par2e(ReturnFn,n_d, n_a, n_z, n_e, d_gridvals, a_gridvals, z_gridvals, e_gridvals, ReturnFnParamsVec) -if ~all(arrayfun(@(x) isscalar(x),ReturnFnParams)) - error('Using GPU for the return fn does not allow for any of ReturnFnParams to be anything but a scalar') -end -ParamCell=num2cell(ReturnFnParams)'; +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_d=prod(n_d); N_a=prod(n_a); @@ -31,23 +27,6 @@ error('Using GPU for the return fn does not allow for more than four of e variable (you have length(n_e)>4)') end -if nargin(ReturnFn)~=l_d+l_a+l_z+l_e+length(ReturnFnParams) - error('Number of inputs to ReturnFn does not fit with size of ReturnFnParams') -end - - -if l_d>=1 - d1vals=d_gridvals(:,1); - if l_d>=2 - d2vals=d_gridvals(:,2); - if l_d>=3 - d3vals=d_gridvals(:,3); - if l_d>=4 - d4vals=d_gridvals(:,4); - end - end - end -end if l_a>=1 a1vals=shiftdim(a_gridvals(:,1),-1); if l_a>=2 @@ -96,856 +75,856 @@ if l_e==1 if l_d==1 if l_a==1 && l_z==1 - % d1vals(1,1,1)=d_grid(1); % Requires special treatment - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals, e1vals,ParamCell{:}); + % d_gridvals(:,1)(1,1,1)=d_grid(1); % Requires special treatment + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals,z3vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals,z3vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ReturnFnParamsCell{:}); end elseif l_d==2 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals,z3vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals,z3vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ReturnFnParamsCell{:}); end elseif l_d==3 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals,z3vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals,z3vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ReturnFnParamsCell{:}); end elseif l_d==4 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals,z3vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals,z3vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,ReturnFnParamsCell{:}); end end elseif l_e==2 if l_d==1 if l_a==1 && l_z==1 - d1vals(1,1,1)=d_grid(1); % Requires special treatment - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals, e1vals,e2vals,ParamCell{:}); + d_gridvals(:,1)(1,1,1)=d_grid(1); % Requires special treatment + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ReturnFnParamsCell{:}); end elseif l_d==2 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ReturnFnParamsCell{:}); end elseif l_d==3 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ReturnFnParamsCell{:}); end elseif l_d==4 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,ReturnFnParamsCell{:}); end end elseif l_e==3 if l_d==1 if l_a==1 && l_z==1 - d1vals(1,1,1)=d_grid(1); % Requires special treatment - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals, e1vals,e2vals,e3vals,ParamCell{:}); + d_gridvals(:,1)(1,1,1)=d_grid(1); % Requires special treatment + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); end elseif l_d==2 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); end elseif l_d==3 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); end elseif l_d==4 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,ReturnFnParamsCell{:}); end end elseif l_e==4 if l_d==1 if l_a==1 && l_z==1 - d1vals(1,1,1)=d_grid(1); % Requires special treatment - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + d_gridvals(:,1)(1,1,1)=d_grid(1); % Requires special treatment + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); end elseif l_d==2 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); end elseif l_d==3 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); end elseif l_d==4 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,ReturnFnParamsCell{:}); end end elseif l_e==5 if l_d==1 if l_a==1 && l_z==1 - d1vals(1,1,1)=d_grid(1); % Requires special treatment - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + d_gridvals(:,1)(1,1,1)=d_grid(1); % Requires special treatment + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); end elseif l_d==2 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); end elseif l_d==3 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); end elseif l_d==4 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); elseif l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals,e2vals,e3vals,e4vals,e5vals,ReturnFnParamsCell{:}); end end end diff --git a/ReturnFnMatrix/CreateReturnFnMatrix_Case2_Disc_noz_Par2.m b/ReturnFnMatrix/CreateReturnFnMatrix_Case2_Disc_noz_Par2.m index a3288cb1..e83e640f 100644 --- a/ReturnFnMatrix/CreateReturnFnMatrix_Case2_Disc_noz_Par2.m +++ b/ReturnFnMatrix/CreateReturnFnMatrix_Case2_Disc_noz_Par2.m @@ -1,13 +1,6 @@ -function Fmatrix=CreateReturnFnMatrix_Case2_Disc_noz_Par2(ReturnFn,n_d, n_a, d_gridvals, a_gridvals, ReturnFnParams) -%If there is no d variable, just input n_d=0 and d_grid=0 +function Fmatrix=CreateReturnFnMatrix_Case2_Disc_noz_Par2(ReturnFn,n_d, n_a, d_gridvals, a_gridvals, ReturnFnParamsVec) -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - if size(ReturnFnParams(ii))~=[1,1] - disp('ERROR: Using GPU for the return fn does not allow for any of ReturnFnParams to be anything but a scalar') - end - ParamCell(ii,1)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_d=prod(n_d); N_a=prod(n_a); @@ -15,17 +8,12 @@ l_d=length(n_d); l_a=length(n_a); if l_d>4 - disp('ERROR: Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4): (in CreateReturnFnMatrix_Case2_Disc_Par2)') + error('Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') end if l_a>4 - disp('ERROR: Using GPU for the return fn does not allow for more than four of a variable (you have length(n_a)>4): (in CreateReturnFnMatrix_Case2_Disc_Par2)') + error('Using GPU for the return fn does not allow for more than four of a variable (you have length(n_a)>4)') end -if nargin(ReturnFn)~=l_d+l_a+length(ReturnFnParams) - disp('ERROR: Number of inputs to ReturnFn does not fit with size of ReturnFnParams') -end - - if l_d>=1 d1vals=d_gridvals(:,1); if l_d>=2 @@ -55,37 +43,37 @@ if l_d==1 && l_a==1 d1vals(1,1,1)=d_gridvals(1); % Requires special treatment - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, a1vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, a1vals,a2vals,a3vals,a4vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1vals,a2vals,a3vals,a4vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1vals,a2vals,a3vals,a4vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1vals,a2vals,a3vals,a4vals, ReturnFnParamsCell{:}); end Fmatrix=reshape(Fmatrix,[N_d,N_a]); diff --git a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_Par2.m b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_Par2.m index b9f16800..ef0c4a69 100644 --- a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_Par2.m +++ b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_Par2.m @@ -1,10 +1,6 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC1_Par2(ReturnFn, n_d, n_z, d_gridvals, aprime_grid, a_grid, z_gridvals, ReturnFnParams, Level) -%If there is no d variable, just input n_d=0 and d_grid=0 +function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC1_Par2(ReturnFn, n_d, n_z, d_gridvals, aprime_grid, a_grid, z_gridvals, ReturnFnParamsVec, Level) -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_d=prod(n_d); N_a=length(a_grid); % Because l_a=1 @@ -42,43 +38,43 @@ if l_z==1 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), ReturnFnParamsCell{:}); end elseif l_z==2 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), ReturnFnParamsCell{:}); end elseif l_z==3 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), ReturnFnParamsCell{:}); end elseif l_z==4 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), ReturnFnParamsCell{:}); end end diff --git a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_Par2e.m b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_Par2e.m index b90c36a0..57a43957 100644 --- a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_Par2e.m +++ b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_Par2e.m @@ -1,10 +1,6 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC1_Par2e(ReturnFn, n_d, n_z, n_e, d_gridvals, aprime_grid, a_grid, z_gridvals, e_gridvals, ReturnFnParams, Level) -%If there is no d variable, just input n_d=0 and d_grid=0 +function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC1_Par2e(ReturnFn, n_d, n_z, n_e, d_gridvals, aprime_grid, a_grid, z_gridvals, e_gridvals, ReturnFnParamsVec, Level) -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_d=prod(n_d); N_a=length(a_grid); % Because l_a=1 @@ -50,169 +46,169 @@ if l_e==1 if l_z==1 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), ReturnFnParamsCell{:}); end elseif l_z==2 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), ReturnFnParamsCell{:}); end elseif l_z==3 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), ReturnFnParamsCell{:}); end elseif l_z==4 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), ReturnFnParamsCell{:}); end end elseif l_e==2 if l_z==1 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ReturnFnParamsCell{:}); end elseif l_z==2 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ReturnFnParamsCell{:}); end elseif l_z==3 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ReturnFnParamsCell{:}); end elseif l_z==4 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), ReturnFnParamsCell{:}); end end elseif l_e==3 if l_z==1 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ReturnFnParamsCell{:}); end elseif l_z==2 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ReturnFnParamsCell{:}); end elseif l_z==3 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ReturnFnParamsCell{:}); end elseif l_z==4 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), ReturnFnParamsCell{:}); end end elseif l_e==4 if l_z==1 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ReturnFnParamsCell{:}); end elseif l_z==2 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ReturnFnParamsCell{:}); end elseif l_z==3 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ReturnFnParamsCell{:}); end elseif l_z==4 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), shiftdim(e_gridvals(:,1),-4), shiftdim(e_gridvals(:,2),-4), shiftdim(e_gridvals(:,3),-4), shiftdim(e_gridvals(:,4),-4), ReturnFnParamsCell{:}); end end end diff --git a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_nod_Par2.m b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_nod_Par2.m index a8f45d98..68185353 100644 --- a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_nod_Par2.m +++ b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_nod_Par2.m @@ -1,10 +1,6 @@ function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC1_nod_Par2(ReturnFn, n_z, aprime_grid, a_grid, z_gridvals, ReturnFnParamsVec,Level) -%If there is no d variable, just input n_d=0 and d_grid=0 -ParamCell=cell(length(ReturnFnParamsVec),1); -for ii=1:length(ReturnFnParamsVec) - ParamCell(ii)={ReturnFnParamsVec(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_a=length(a_grid); % Because l_a=1 N_z=prod(n_z); @@ -12,19 +8,19 @@ % l_a=1; % (or else won't get here) l_z=length(n_z); % won't get here if l_z=0 if l_z>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') + error('Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') end N_aprime=size(aprime_grid,1); % Because l_a=1 if l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), ReturnFnParamsCell{:}); elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), ReturnFnParamsCell{:}); elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(z_gridvals(:,3),-2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(z_gridvals(:,3),-2), ReturnFnParamsCell{:}); elseif l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(z_gridvals(:,3),-2), shiftdim(z_gridvals(:,4),-2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(z_gridvals(:,3),-2), shiftdim(z_gridvals(:,4),-2), ReturnFnParamsCell{:}); end Fmatrix=reshape(Fmatrix,[N_aprime,N_a,N_z]); diff --git a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_nod_Par2e.m b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_nod_Par2e.m index 7ac23444..0454c90d 100644 --- a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_nod_Par2e.m +++ b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_nod_Par2e.m @@ -1,10 +1,6 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC1_nod_Par2e(ReturnFn, n_z, n_e, aprime_grid, a_grid, z_gridvals, e_gridvals, ReturnFnParams,Level) -%If there is no d variable, just input n_d=0 and d_grid=0 +function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC1_nod_Par2e(ReturnFn, n_z, n_e, aprime_grid, a_grid, z_gridvals, e_gridvals, ReturnFnParamsVec,Level) -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_a=length(a_grid); % Because l_a=1 N_z=prod(n_z); @@ -14,10 +10,10 @@ l_z=length(n_z); % won't get here if l_z=0 l_e=length(n_e); % won't get here if l_e=0 if l_z>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') + error('Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') end if l_e>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of e variable (you have length(n_e)>4)') + error('Using GPU for the return fn does not allow for more than four of e variable (you have length(n_e)>4)') end if Level==1 @@ -30,43 +26,43 @@ if l_e==1 if l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(e_gridvals(:,1),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(e_gridvals(:,1),-3), ReturnFnParamsCell{:}); elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(e_gridvals(:,1),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(e_gridvals(:,1),-3), ReturnFnParamsCell{:}); elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(z_gridvals(:,3),-2), shiftdim(e_gridvals(:,1),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(z_gridvals(:,3),-2), shiftdim(e_gridvals(:,1),-3), ReturnFnParamsCell{:}); elseif l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(z_gridvals(:,3),-2), shiftdim(z_gridvals(:,4),-2), shiftdim(e_gridvals(:,1),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(z_gridvals(:,3),-2), shiftdim(z_gridvals(:,4),-2), shiftdim(e_gridvals(:,1),-3), ReturnFnParamsCell{:}); end elseif l_e==2 if l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), ReturnFnParamsCell{:}); elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), ReturnFnParamsCell{:}); elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(z_gridvals(:,3),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(z_gridvals(:,3),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), ReturnFnParamsCell{:}); elseif l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(z_gridvals(:,3),-2), shiftdim(z_gridvals(:,4),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(z_gridvals(:,3),-2), shiftdim(z_gridvals(:,4),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), ReturnFnParamsCell{:}); end elseif l_e==3 if l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), shiftdim(e_gridvals(:,3),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), shiftdim(e_gridvals(:,3),-3), ReturnFnParamsCell{:}); elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), shiftdim(e_gridvals(:,3),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), shiftdim(e_gridvals(:,3),-3), ReturnFnParamsCell{:}); elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(z_gridvals(:,3),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), shiftdim(e_gridvals(:,3),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(z_gridvals(:,3),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), shiftdim(e_gridvals(:,3),-3), ReturnFnParamsCell{:}); elseif l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(z_gridvals(:,3),-2), shiftdim(z_gridvals(:,4),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), shiftdim(e_gridvals(:,3),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(z_gridvals(:,3),-2), shiftdim(z_gridvals(:,4),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), shiftdim(e_gridvals(:,3),-3), ReturnFnParamsCell{:}); end elseif l_e==4 if l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), shiftdim(e_gridvals(:,3),-3), shiftdim(e_gridvals(:,4),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), shiftdim(e_gridvals(:,3),-3), shiftdim(e_gridvals(:,4),-3), ReturnFnParamsCell{:}); elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), shiftdim(e_gridvals(:,3),-3), shiftdim(e_gridvals(:,4),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), shiftdim(e_gridvals(:,3),-3), shiftdim(e_gridvals(:,4),-3), ReturnFnParamsCell{:}); elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(z_gridvals(:,3),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), shiftdim(e_gridvals(:,3),-3), shiftdim(e_gridvals(:,4),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(z_gridvals(:,3),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), shiftdim(e_gridvals(:,3),-3), shiftdim(e_gridvals(:,4),-3), ReturnFnParamsCell{:}); elseif l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(z_gridvals(:,3),-2), shiftdim(z_gridvals(:,4),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), shiftdim(e_gridvals(:,3),-3), shiftdim(e_gridvals(:,4),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), shiftdim(z_gridvals(:,1),-2), shiftdim(z_gridvals(:,2),-2), shiftdim(z_gridvals(:,3),-2), shiftdim(z_gridvals(:,4),-2), shiftdim(e_gridvals(:,1),-3), shiftdim(e_gridvals(:,2),-3), shiftdim(e_gridvals(:,3),-3), shiftdim(e_gridvals(:,4),-3), ReturnFnParamsCell{:}); end end diff --git a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_nodz_Par2.m b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_nodz_Par2.m index e3088e25..12e6d15f 100644 --- a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_nodz_Par2.m +++ b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_nodz_Par2.m @@ -1,10 +1,7 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC1_nodz_Par2(ReturnFn, aprime_grid, a_grid, ReturnFnParams) +function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC1_nodz_Par2(ReturnFn, aprime_grid, a_grid, ReturnFnParamsVec) % For divide and conquer, with l_a=1 and no d var and no z var -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; % l_d=0; % l_a=1; % (or else won't get here) @@ -12,7 +9,7 @@ % N_a=prod(n_a); % l_d=0, l_a=1 -Fmatrix=arrayfun(ReturnFn, aprime_grid, a_grid', ParamCell{:}); +Fmatrix=arrayfun(ReturnFn, aprime_grid, a_grid', ReturnFnParamsCell{:}); % size(Fmatrix)=[n_aprime,1] end diff --git a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_noz_Par2.m b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_noz_Par2.m index 8aca35fa..4509cbc7 100644 --- a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_noz_Par2.m +++ b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC1_noz_Par2.m @@ -1,10 +1,6 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC1_noz_Par2(ReturnFn, n_d, d_gridvals, aprime_grid, a_grid, ReturnFnParams,Level) -%If there is no d variable, just input n_d=0 and d_grid=0 +function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC1_noz_Par2(ReturnFn, n_d, d_gridvals, aprime_grid, a_grid, ReturnFnParamsVec,Level) -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_d=prod(n_d); N_a=length(a_grid); % Because l_a=1 @@ -28,13 +24,13 @@ end if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), ReturnFnParamsCell{:}); end diff --git a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_Par2.m b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_Par2.m index 7f8efde0..565ed646 100644 --- a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_Par2.m +++ b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_Par2.m @@ -1,10 +1,6 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC2B_Par2(ReturnFn, n_d, n_z, d_gridvals, a1prime_grid, a2prime_grid, a1_grid, a2_grid, z_gridvals, ReturnFnParams, Level) -%If there is no d variable, just input n_d=0 and d_grid=0 +function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC2B_Par2(ReturnFn, n_d, n_z, d_gridvals, a1prime_grid, a2prime_grid, a1_grid, a2_grid, z_gridvals, ReturnFnParamsVec, Level) -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_d=prod(n_d); N_a1=length(a1_grid); @@ -14,10 +10,10 @@ l_d=length(n_d); % won't get here if l_d=0 l_z=length(n_z); % won't get here if l_z=0 if l_d>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') + error('Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') end if l_z>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') + error('Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') end if Level==1 @@ -35,43 +31,43 @@ if l_z==1 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), ReturnFnParamsCell{:}); end elseif l_z==2 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), ReturnFnParamsCell{:}); end elseif l_z==3 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), ReturnFnParamsCell{:}); end elseif l_z==4 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), ReturnFnParamsCell{:}); end end diff --git a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_Par2e.m b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_Par2e.m index caebd36a..3ea30617 100644 --- a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_Par2e.m +++ b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_Par2e.m @@ -1,10 +1,6 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC2B_Par2e(ReturnFn, n_d, n_z, n_e, d_gridvals, a1prime_grid, a2prime_grid, a1_grid, a2_grid, z_gridvals, e_gridvals, ReturnFnParams, Level) -%If there is no d variable, just input n_d=0 and d_grid=0 +function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC2B_Par2e(ReturnFn, n_d, n_z, n_e, d_gridvals, a1prime_grid, a2prime_grid, a1_grid, a2_grid, z_gridvals, e_gridvals, ReturnFnParamsVec, Level) -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_d=prod(n_d); N_a1=length(a1_grid); @@ -16,13 +12,13 @@ l_z=length(n_z); % won't get here if l_z=0 l_e=length(n_e); % won't get here if l_e=0 if l_d>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') + error('Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') end if l_z>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') + error('Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') end if l_e>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of e variable (you have length(n_e)>4)') + error('Using GPU for the return fn does not allow for more than four of e variable (you have length(n_e)>4)') end if Level==1 @@ -36,169 +32,169 @@ if l_e==1 if l_z==1 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), ReturnFnParamsCell{:}); end elseif l_z==2 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), ReturnFnParamsCell{:}); end elseif l_z==3 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), ReturnFnParamsCell{:}); end elseif l_z==4 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), ReturnFnParamsCell{:}); end end elseif l_e==2 if l_z==1 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ReturnFnParamsCell{:}); end elseif l_z==2 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ReturnFnParamsCell{:}); end elseif l_z==3 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ReturnFnParamsCell{:}); end elseif l_z==4 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), ReturnFnParamsCell{:}); end end elseif l_e==3 if l_z==1 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ReturnFnParamsCell{:}); end elseif l_z==2 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ReturnFnParamsCell{:}); end elseif l_z==3 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ReturnFnParamsCell{:}); end elseif l_z==4 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), ReturnFnParamsCell{:}); end end elseif l_e==4 if l_z==1 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ReturnFnParamsCell{:}); end elseif l_z==2 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ReturnFnParamsCell{:}); end elseif l_z==3 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ReturnFnParamsCell{:}); end elseif l_z==4 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), shiftdim(z_gridvals(:,1),-5), shiftdim(z_gridvals(:,2),-5), shiftdim(z_gridvals(:,3),-5), shiftdim(z_gridvals(:,4),-5), shiftdim(e_gridvals(:,1),-6), shiftdim(e_gridvals(:,2),-6), shiftdim(e_gridvals(:,3),-6), shiftdim(e_gridvals(:,4),-6), ReturnFnParamsCell{:}); end end end diff --git a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_nod_Par2.m b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_nod_Par2.m index 41930f9d..d71523a7 100644 --- a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_nod_Par2.m +++ b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_nod_Par2.m @@ -1,10 +1,6 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC2B_nod_Par2(ReturnFn, n_z, a1prime_grid, a2prime_grid, a1_grid, a2_grid, z_gridvals, ReturnFnParams, Level) -%If there is no d variable, just input n_d=0 and d_grid=0 +function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC2B_nod_Par2(ReturnFn, n_z, a1prime_grid, a2prime_grid, a1_grid, a2_grid, z_gridvals, ReturnFnParamsVec, Level) -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_a1=length(a1_grid); N_a2=length(a2_grid); @@ -12,7 +8,7 @@ l_z=length(n_z); % won't get here if l_z=0 if l_z>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') + error('Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') end if Level==1 @@ -23,13 +19,13 @@ N_a2prime=N_a2; if l_z==1 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), ReturnFnParamsCell{:}); elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), ReturnFnParamsCell{:}); elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), ReturnFnParamsCell{:}); elseif l_z==4 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(z_gridvals(:,4),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(z_gridvals(:,4),-4), ReturnFnParamsCell{:}); end if Level==1 diff --git a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_nod_Par2e.m b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_nod_Par2e.m index 8894e9dc..2b084078 100644 --- a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_nod_Par2e.m +++ b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_nod_Par2e.m @@ -1,10 +1,6 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC2B_nod_Par2e(ReturnFn, n_z, n_e, a1prime_grid, a2prime_grid, a1_grid, a2_grid, z_gridvals, e_gridvals, ReturnFnParams, Level) -%If there is no d variable, just input n_d=0 and d_grid=0 +function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC2B_nod_Par2e(ReturnFn, n_z, n_e, a1prime_grid, a2prime_grid, a1_grid, a2_grid, z_gridvals, e_gridvals, ReturnFnParamsVec, Level) -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_a1=length(a1_grid); N_a2=length(a2_grid); @@ -14,10 +10,10 @@ l_z=length(n_z); % won't get here if l_z=0 l_e=length(n_e); % won't get here if l_e=0 if l_z>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') + error('Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') end if l_e>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of e variable (you have length(n_e)>4)') + error('Using GPU for the return fn does not allow for more than four of e variable (you have length(n_e)>4)') end if Level==1 @@ -29,43 +25,43 @@ if l_e==1 if l_z==1 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(e_gridvals(:,1),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(e_gridvals(:,1),-5), ReturnFnParamsCell{:}); elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(e_gridvals(:,1),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(e_gridvals(:,1),-5), ReturnFnParamsCell{:}); elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(e_gridvals(:,1),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(e_gridvals(:,1),-5), ReturnFnParamsCell{:}); elseif l_z==4 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(z_gridvals(:,4),-4), shiftdim(e_gridvals(:,1),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(z_gridvals(:,4),-4), shiftdim(e_gridvals(:,1),-5), ReturnFnParamsCell{:}); end elseif l_e==2 if l_z==1 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), ReturnFnParamsCell{:}); elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), ReturnFnParamsCell{:}); elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), ReturnFnParamsCell{:}); elseif l_z==4 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(z_gridvals(:,4),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(z_gridvals(:,4),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), ReturnFnParamsCell{:}); end elseif l_e==3 if l_z==1 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), shiftdim(e_gridvals(:,3),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), shiftdim(e_gridvals(:,3),-5), ReturnFnParamsCell{:}); elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), shiftdim(e_gridvals(:,3),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), shiftdim(e_gridvals(:,3),-5), ReturnFnParamsCell{:}); elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), shiftdim(e_gridvals(:,3),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), shiftdim(e_gridvals(:,3),-5), ReturnFnParamsCell{:}); elseif l_z==4 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(z_gridvals(:,4),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), shiftdim(e_gridvals(:,3),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(z_gridvals(:,4),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), shiftdim(e_gridvals(:,3),-5), ReturnFnParamsCell{:}); end elseif l_e==4 if l_z==1 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), shiftdim(e_gridvals(:,3),-5), shiftdim(e_gridvals(:,4),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), shiftdim(e_gridvals(:,3),-5), shiftdim(e_gridvals(:,4),-5), ReturnFnParamsCell{:}); elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), shiftdim(e_gridvals(:,3),-5), shiftdim(e_gridvals(:,4),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), shiftdim(e_gridvals(:,3),-5), shiftdim(e_gridvals(:,4),-5), ReturnFnParamsCell{:}); elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), shiftdim(e_gridvals(:,3),-5), shiftdim(e_gridvals(:,4),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), shiftdim(e_gridvals(:,3),-5), shiftdim(e_gridvals(:,4),-5), ReturnFnParamsCell{:}); elseif l_z==4 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(z_gridvals(:,4),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), shiftdim(e_gridvals(:,3),-5), shiftdim(e_gridvals(:,4),-5), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(z_gridvals(:,4),-4), shiftdim(e_gridvals(:,1),-5), shiftdim(e_gridvals(:,2),-5), shiftdim(e_gridvals(:,3),-5), shiftdim(e_gridvals(:,4),-5), ReturnFnParamsCell{:}); end end diff --git a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_nodz_Par2.m b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_nodz_Par2.m index b40e2994..c0c3255e 100644 --- a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_nodz_Par2.m +++ b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_nodz_Par2.m @@ -1,10 +1,6 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC2B_nodz_Par2(ReturnFn, a1prime_grid, a2prime_grid, a1_grid, a2_grid, ReturnFnParams, Level) -%If there is no d variable, just input n_d=0 and d_grid=0 +function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC2B_nodz_Par2(ReturnFn, a1prime_grid, a2prime_grid, a1_grid, a2_grid, ReturnFnParamsVec, Level) -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_a1=length(a1_grid); N_a2=length(a2_grid); @@ -12,7 +8,7 @@ N_a1prime=size(a1prime_grid,1); % Because l_a=1 N_a2prime=N_a2; -Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), ParamCell{:}); +Fmatrix=arrayfun(ReturnFn, a1prime_grid, shiftdim(a2prime_grid,-1), shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), ReturnFnParamsCell{:}); if Level==1 Fmatrix=reshape(Fmatrix,[N_a1prime,N_a2prime,N_a1,N_a2]); diff --git a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_noz_Par2.m b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_noz_Par2.m index 0df35ecc..c926aeaf 100644 --- a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_noz_Par2.m +++ b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2B_noz_Par2.m @@ -1,10 +1,6 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC2B_noz_Par2(ReturnFn, n_d, d_gridvals, a1prime_grid, a2prime_grid, a1_grid, a2_grid, ReturnFnParams, Level) -%If there is no d variable, just input n_d=0 and d_grid=0 +function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC2B_noz_Par2(ReturnFn, n_d, d_gridvals, a1prime_grid, a2prime_grid, a1_grid, a2_grid, ReturnFnParamsVec, Level) -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_d=prod(n_d); N_a1=length(a1_grid); @@ -12,7 +8,7 @@ l_d=length(n_d); % won't get here if l_d=0 if l_d>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') + error('Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') end if Level==1 @@ -24,13 +20,13 @@ N_a2prime=N_a2; if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, shiftdim(a2prime_grid,-2), shiftdim(a1_grid,-3), shiftdim(a2_grid,-4), ReturnFnParamsCell{:}); end if Level==1 || Level==3 diff --git a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2_Par2.m b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2_Par2.m index 9fe4c20c..7392e56a 100644 --- a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2_Par2.m +++ b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2_Par2.m @@ -1,10 +1,6 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC2_Par2(ReturnFn, n_d, n_z, d_gridvals, a1prime_grid, a2prime_grid, a1_grid, a2_grid, z_gridvals, ReturnFnParams, Level) -%If there is no d variable, just input n_d=0 and d_grid=0 +function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC2_Par2(ReturnFn, n_d, n_z, d_gridvals, a1prime_grid, a2prime_grid, a1_grid, a2_grid, z_gridvals, ReturnFnParamsVec, Level) -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_d=prod(n_d); N_a1=length(a1_grid); @@ -14,10 +10,10 @@ l_d=length(n_d); % won't get here if l_d=0 l_z=length(n_z); % won't get here if l_z=0 if l_d>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') + error('Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') end if l_z>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') + error('Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') end if Level==1 N_a1prime=length(a1prime_grid); @@ -29,54 +25,46 @@ N_a1a2prime=max(size(a1prime_grid,2),size(a2prime_grid,2)); % max(), they will either both be same size, or one is singular end -% disp('Rfn') -% size(d_gridvals(:,1)) -% size(a1prime_grid) -% size(a2prime_grid) -% size(shiftdim(a1_grid,-2)) -% size(shiftdim(a2_grid,-3)) -% size(shiftdim(z_gridvals(:,1),-4)) - if l_z==1 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), ReturnFnParamsCell{:}); end elseif l_z==2 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), ReturnFnParamsCell{:}); end elseif l_z==3 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), ReturnFnParamsCell{:}); end elseif l_z==4 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(z_gridvals(:,4),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(z_gridvals(:,4),-4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(z_gridvals(:,4),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(z_gridvals(:,4),-4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(z_gridvals(:,4),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(z_gridvals(:,4),-4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(z_gridvals(:,4),-4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime_grid, a2prime_grid, shiftdim(a1_grid,-2), shiftdim(a2_grid,-3), shiftdim(z_gridvals(:,1),-4), shiftdim(z_gridvals(:,2),-4), shiftdim(z_gridvals(:,3),-4), shiftdim(z_gridvals(:,4),-4), ReturnFnParamsCell{:}); end end diff --git a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2_nod_Par2.m b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2_nod_Par2.m index ee5ea616..a8bed28a 100644 --- a/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2_nod_Par2.m +++ b/ReturnFnMatrix/DivideConquer/CreateReturnFnMatrix_Case1_Disc_DC2_nod_Par2.m @@ -1,10 +1,7 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC2_nod_Par2(ReturnFn, n_z, a1prime_grid, a2prime_grid, a1_grid, a2_grid, z_gridvals, ReturnFnParams, Level) +function Fmatrix=CreateReturnFnMatrix_Case1_Disc_DC2_nod_Par2(ReturnFn, n_z, a1prime_grid, a2prime_grid, a1_grid, a2_grid, z_gridvals, ReturnFnParamsVec, Level) % 2D divide-and-conquer -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_a1=length(a1_grid); N_a2=length(a2_grid); @@ -12,7 +9,7 @@ l_z=length(n_z); % won't get here if l_z=0 if l_z>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') + error('Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') end if Level==1 @@ -25,23 +22,15 @@ N_a1a2prime=size(a1prime_grid,1); end -% disp('Rfn') -% size(a1prime_grid) -% size(a2prime_grid) -% size(shiftdim(a1_grid,-1)) -% size(shiftdim(a2_grid,-2)) -% size(shiftdim(z_gridvals(:,1),-3)) - - if l_z==1 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, a2prime_grid, shiftdim(a1_grid,-1), shiftdim(a2_grid,-2), shiftdim(z_gridvals(:,1),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, a2prime_grid, shiftdim(a1_grid,-1), shiftdim(a2_grid,-2), shiftdim(z_gridvals(:,1),-3), ReturnFnParamsCell{:}); elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, a2prime_grid, shiftdim(a1_grid,-1), shiftdim(a2_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, a2prime_grid, shiftdim(a1_grid,-1), shiftdim(a2_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), ReturnFnParamsCell{:}); elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, a2prime_grid, shiftdim(a1_grid,-1), shiftdim(a2_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, a2prime_grid, shiftdim(a1_grid,-1), shiftdim(a2_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), ReturnFnParamsCell{:}); elseif l_z==4 - Fmatrix=arrayfun(ReturnFn, a1prime_grid, a2prime_grid, shiftdim(a1_grid,-1), shiftdim(a2_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, a1prime_grid, a2prime_grid, shiftdim(a1_grid,-1), shiftdim(a2_grid,-2), shiftdim(z_gridvals(:,1),-3), shiftdim(z_gridvals(:,2),-3), shiftdim(z_gridvals(:,3),-3), shiftdim(z_gridvals(:,4),-3), ReturnFnParamsCell{:}); end Fmatrix=reshape(Fmatrix,[N_a1a2prime,N_a1,N_a2,N_z]); diff --git a/ReturnFnMatrix/ExperienceAsset/CreateReturnFnMatrix_Case1_ExpAsset_Disc_Par2.m b/ReturnFnMatrix/ExperienceAsset/CreateReturnFnMatrix_Case1_ExpAsset_Disc_Par2.m index 89adcb59..0f54266f 100644 --- a/ReturnFnMatrix/ExperienceAsset/CreateReturnFnMatrix_Case1_ExpAsset_Disc_Par2.m +++ b/ReturnFnMatrix/ExperienceAsset/CreateReturnFnMatrix_Case1_ExpAsset_Disc_Par2.m @@ -1,14 +1,10 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_ExpAsset_Disc_Par2(ReturnFn, n_d1, n_d2, n_a1prime, n_a1,n_a2, n_z, d_gridvals, a1prime_gridvals, a1_gridvals, a2_gridvals, z_gridvals, ReturnFnParams,Level,Refine) % Refine is an optional input +function Fmatrix=CreateReturnFnMatrix_Case1_ExpAsset_Disc_Par2(ReturnFn, n_d1, n_d2, n_a1prime, n_a1,n_a2, n_z, d_gridvals, a1prime_gridvals, a1_gridvals, a2_gridvals, z_gridvals, ReturnFnParamsVec,Level,Refine) % Refine is an optional input % Note: d_gridvals is both d1 and d2 (unless n_d1=1 so there is no d1, in which case is just d2) % Level and Refine are about different shapes of inputs/output % Set Level=0, unless using Divide-and-Conquer % When Level=1 or 2, Refine is ignored - -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii,1)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; if n_d1(1)==0 n_d=n_d2; @@ -38,18 +34,6 @@ error('Using GPU for the return fn does not allow for more than eight of semiz and z variables') end -if l_d>=1 - d1vals=d_gridvals(:,1); - if l_d>=2 - d2vals=d_gridvals(:,2); - if l_d>=3 - d3vals=d_gridvals(:,3); - if l_d>=4 - d4vals=d_gridvals(:,4); - end - end - end -end if Level==0 || Level==1 if l_a1>=1 a1prime1vals=shiftdim(a1prime_gridvals(:,1),-1); @@ -113,337 +97,337 @@ if l_z==1 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, ReturnFnParamsCell{:}); end end elseif l_z==2 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, ReturnFnParamsCell{:}); end end elseif l_z==3 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); end end elseif l_z==4 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); end end elseif l_z==5 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); end end elseif l_z==6 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, ReturnFnParamsCell{:}); end end elseif l_z==7 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, ReturnFnParamsCell{:}); end end elseif l_z==8 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, ReturnFnParamsCell{:}); end end end diff --git a/ReturnFnMatrix/ExperienceAsset/CreateReturnFnMatrix_Case1_ExpAsset_Disc_Par2_noz.m b/ReturnFnMatrix/ExperienceAsset/CreateReturnFnMatrix_Case1_ExpAsset_Disc_Par2_noz.m index c68d9797..1f236192 100644 --- a/ReturnFnMatrix/ExperienceAsset/CreateReturnFnMatrix_Case1_ExpAsset_Disc_Par2_noz.m +++ b/ReturnFnMatrix/ExperienceAsset/CreateReturnFnMatrix_Case1_ExpAsset_Disc_Par2_noz.m @@ -1,14 +1,11 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_ExpAsset_Disc_Par2_noz(ReturnFn, n_d1, n_d2, n_a1prime, n_a1,n_a2, d_gridvals, a1prime_gridvals, a1_gridvals, a2_gridvals, ReturnFnParams,Level,Refine) % Refine is an optional input +function Fmatrix=CreateReturnFnMatrix_Case1_ExpAsset_Disc_Par2_noz(ReturnFn, n_d1, n_d2, n_a1prime, n_a1,n_a2, d_gridvals, a1prime_gridvals, a1_gridvals, a2_gridvals, ReturnFnParamsVec,Level,Refine) % Refine is an optional input % Note: d_gridvals is both d1 and d2 (unless n_d1=1 so there is no d1, in which case is just d2) % Level and Refine are about different shapes of inputs/output % Set Level=0, unless using Divide-and-Conquer % When Level=1 or 2, Refine is ignored -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii,1)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; if n_d1(1)==0 n_d=n_d2; @@ -34,18 +31,6 @@ end -if l_d>=1 - d1vals=d_gridvals(:,1); - if l_d>=2 - d2vals=d_gridvals(:,2); - if l_d>=3 - d3vals=d_gridvals(:,3); - if l_d>=4 - d4vals=d_gridvals(:,4); - end - end - end -end if Level==0 || Level==1 if l_a1>=1 a1prime1vals=shiftdim(a1prime_gridvals(:,1),-1); @@ -85,43 +70,43 @@ if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, ReturnFnParamsCell{:}); end end diff --git a/ReturnFnMatrix/ExperienceAsset/CreateReturnFnMatrix_Case1_ExpAsset_Disc_Par2e.m b/ReturnFnMatrix/ExperienceAsset/CreateReturnFnMatrix_Case1_ExpAsset_Disc_Par2e.m index ada6a17c..e4fdae42 100644 --- a/ReturnFnMatrix/ExperienceAsset/CreateReturnFnMatrix_Case1_ExpAsset_Disc_Par2e.m +++ b/ReturnFnMatrix/ExperienceAsset/CreateReturnFnMatrix_Case1_ExpAsset_Disc_Par2e.m @@ -1,14 +1,10 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_ExpAsset_Disc_Par2e(ReturnFn, n_d1, n_d2, n_a1prime, n_a1,n_a2, n_z,n_e, d_gridvals, a1prime_gridvals, a1_gridvals, a2_gridvals, z_gridvals, e_gridvals, ReturnFnParams,Level,Refine) % Refine is an optional input +function Fmatrix=CreateReturnFnMatrix_Case1_ExpAsset_Disc_Par2e(ReturnFn, n_d1, n_d2, n_a1prime, n_a1,n_a2, n_z,n_e, d_gridvals, a1prime_gridvals, a1_gridvals, a2_gridvals, z_gridvals, e_gridvals, ReturnFnParamsVec,Level,Refine) % Refine is an optional input % Note: d_gridvals is both d1 and d2 (unless n_d1=1 so there is no d1, in which case is just d2) % Level and Refine are about different shapes of inputs/output % Set Level=0, unless using Divide-and-Conquer % When Level=1 or 2, Refine is ignored - -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii,1)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; if n_d1(1)==0 n_d=n_d2; @@ -44,18 +40,6 @@ end -if l_d>=1 - d1vals=d_gridvals(:,1); - if l_d>=2 - d2vals=d_gridvals(:,2); - if l_d>=3 - d3vals=d_gridvals(:,3); - if l_d>=4 - d4vals=d_gridvals(:,4); - end - end - end -end if Level==0 || Level==1 if l_a1>=1 a1prime1vals=shiftdim(a1prime_gridvals(:,1),-1); @@ -134,337 +118,337 @@ if l_z==1 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, ReturnFnParamsCell{:}); end end elseif l_z==2 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, ReturnFnParamsCell{:}); end end elseif l_z==3 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, ReturnFnParamsCell{:}); end end elseif l_z==4 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, ReturnFnParamsCell{:}); end end elseif l_z==5 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, ReturnFnParamsCell{:}); end end elseif l_z==6 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, ReturnFnParamsCell{:}); end end elseif l_z==7 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, ReturnFnParamsCell{:}); end end elseif l_z==8 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, ReturnFnParamsCell{:}); end end end @@ -472,337 +456,337 @@ if l_z==1 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, ReturnFnParamsCell{:}); end end elseif l_z==2 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, ReturnFnParamsCell{:}); end end elseif l_z==3 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, ReturnFnParamsCell{:}); end end elseif l_z==4 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, ReturnFnParamsCell{:}); end end elseif l_z==5 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, ReturnFnParamsCell{:}); end end elseif l_z==6 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, ReturnFnParamsCell{:}); end end elseif l_z==7 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, ReturnFnParamsCell{:}); end end elseif l_z==8 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, ReturnFnParamsCell{:}); end end end @@ -810,337 +794,337 @@ if l_z==1 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end end elseif l_z==2 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end end elseif l_z==3 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end end elseif l_z==4 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end end elseif l_z==5 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end end elseif l_z==6 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end end elseif l_z==7 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end end elseif l_z==8 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, ReturnFnParamsCell{:}); end end end @@ -1148,337 +1132,337 @@ if l_z==1 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end end elseif l_z==2 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end end elseif l_z==3 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end end elseif l_z==4 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end end elseif l_z==5 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end end elseif l_z==6 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end end elseif l_z==7 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end end elseif l_z==8 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals, ReturnFnParamsCell{:}); end end end @@ -1486,337 +1470,337 @@ if l_z==1 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end end elseif l_z==2 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end end elseif l_z==3 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end end elseif l_z==4 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end end elseif l_z==5 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end end elseif l_z==6 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end end elseif l_z==7 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end end elseif l_z==8 if l_d==1 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==2 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==3 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end elseif l_d==4 if l_a1==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals, a1vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals, a1vals,a2vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals, a1vals,a2vals,a3vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); elseif l_a1==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), a1prime1vals,a1prime2vals,a1prime3vals,a1prime4vals, a1vals,a2vals,a3vals,a4vals, expassetvals, z1vals,z2vals,z3vals,z4vals,z5vals,z6vals,z7vals,z8vals, e1vals, e2vals, e3vals, e4vals,e5vals, ReturnFnParamsCell{:}); end end end diff --git a/ReturnFnMatrix/RefineBurst/CreateReturnFnMatrix_Case1_Disc_Par2_refineld1.m b/ReturnFnMatrix/RefineBurst/CreateReturnFnMatrix_Case1_Disc_Par2_refineld1.m index 6050dabf..c03a7580 100644 --- a/ReturnFnMatrix/RefineBurst/CreateReturnFnMatrix_Case1_Disc_Par2_refineld1.m +++ b/ReturnFnMatrix/RefineBurst/CreateReturnFnMatrix_Case1_Disc_Par2_refineld1.m @@ -1,12 +1,9 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_Disc_Par2_refineld1(ReturnFn, d1_grid_layer, n_d, n_a, n_z, a_grid, z_grid, ReturnFnParams) % Refine is an optional input +function Fmatrix=CreateReturnFnMatrix_Case1_Disc_Par2_refineld1(ReturnFn, d1_grid_layer, n_d, n_a, n_z, a_grid, z_gridvals, ReturnFnParamsVec) % Refine is an optional input % Note: this command is only called when l_d=1 l_d=1; % Hardcodes: Refine=1 -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii,1)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_d=prod(n_d); N_a=prod(n_a); @@ -15,10 +12,10 @@ l_a=length(n_a); l_z=length(n_z); if l_a>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of a variable (you have length(n_a)>4): (in CreateReturnFnMatrix_Case1_Disc_Par2)') + error('Using GPU for the return fn does not allow for more than four of a variable (you have length(n_a)>4)') end if l_z>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4): (in CreateReturnFnMatrix_Case1_Disc_Par2)') + error('Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') end if l_a>=1 @@ -37,35 +34,14 @@ end end end -if all(size(z_grid)==[sum(n_z),1]) % kroneker product z_grid - if l_z>=1 - z1vals=shiftdim(z_grid(1:n_z(1)),-l_d-l_a-l_a); - if l_z>=2 - z2vals=shiftdim(z_grid(n_z(1)+1:n_z(1)+n_z(2)),-l_d-l_a-l_a-1); - if l_z>=3 - z3vals=shiftdim(z_grid(sum(n_z(1:2))+1:sum(n_z(1:3))),-l_d-l_a-l_a-2); - if l_z>=4 - z4vals=shiftdim(z_grid(sum(n_z(1:3))+1:sum(n_z(1:4))),-l_d-l_a-l_a-3); - if l_z>=5 - z5vals=shiftdim(z_grid(sum(n_z(1:4))+1:sum(n_z(1:5))),-l_d-l_a-l_a-4); - end - end - end - end - end -elseif all(size(z_grid)==[prod(n_z),l_z]) % joint z_grid - if l_z>=1 - z1vals=shiftdim(z_grid(:,1),-l_d-l_a-l_a); - if l_z>=2 - z2vals=shiftdim(z_grid(:,2),-l_d-l_a-l_a); - if l_z>=3 - z3vals=shiftdim(z_grid(:,3),-l_d-l_a-l_a); - if l_z>=4 - z4vals=shiftdim(z_grid(:,4),-l_d-l_a-l_a); - if l_z>=5 - z5vals=shiftdim(z_grid(:,5),-l_d-l_a-l_a); - end - end +if l_z>=1 + z1vals=shiftdim(z_gridvals(:,1),-l_d-l_a-l_a); + if l_z>=2 + z2vals=shiftdim(z_gridvals(:,2),-l_d-l_a-l_a); + if l_z>=3 + z3vals=shiftdim(z_gridvals(:,3),-l_d-l_a-l_a); + if l_z>=4 + z4vals=shiftdim(z_gridvals(:,4),-l_d-l_a-l_a); end end end @@ -73,37 +49,37 @@ % l_d==1 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals, a1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals, a1vals, z1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals, a1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals, a1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals, a1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals, a1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); end Fmatrix=reshape(Fmatrix,[N_d,N_a,N_a,N_z]); % This is the difference when using Refine diff --git a/ReturnFnMatrix/RefineBurst/CreateReturnFnMatrix_Case1_Disc_Par2_refineld2.m b/ReturnFnMatrix/RefineBurst/CreateReturnFnMatrix_Case1_Disc_Par2_refineld2.m index b0e10d87..8558270a 100644 --- a/ReturnFnMatrix/RefineBurst/CreateReturnFnMatrix_Case1_Disc_Par2_refineld2.m +++ b/ReturnFnMatrix/RefineBurst/CreateReturnFnMatrix_Case1_Disc_Par2_refineld2.m @@ -1,12 +1,9 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_Disc_Par2_refineld2(ReturnFn, d1_grid_layer, d2_grid_layer, n_d, n_a, n_z, a_grid, z_grid, ReturnFnParams) % Refine is an optional input +function Fmatrix=CreateReturnFnMatrix_Case1_Disc_Par2_refineld2(ReturnFn, d1_grid_layer, d2_grid_layer, n_d, n_a, n_z, a_grid, z_gridvals, ReturnFnParamsVec) % Refine is an optional input % Note: this command is only called when l_d=2 l_d=2; % Hardcodes: Refine=1 -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii,1)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_d=prod(n_d); N_a=prod(n_a); @@ -15,10 +12,10 @@ l_a=length(n_a); l_z=length(n_z); if l_a>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of a variable (you have length(n_a)>4): (in CreateReturnFnMatrix_Case1_Disc_Par2)') + error('Using GPU for the return fn does not allow for more than four of a variable (you have length(n_a)>4)') end if l_z>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4): (in CreateReturnFnMatrix_Case1_Disc_Par2)') + error('Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') end @@ -38,35 +35,14 @@ end end end -if all(size(z_grid)==[sum(n_z),1]) % kroneker product z_grid - if l_z>=1 - z1vals=shiftdim(z_grid(1:n_z(1)),-l_d-l_a-l_a); - if l_z>=2 - z2vals=shiftdim(z_grid(n_z(1)+1:n_z(1)+n_z(2)),-l_d-l_a-l_a-1); - if l_z>=3 - z3vals=shiftdim(z_grid(sum(n_z(1:2))+1:sum(n_z(1:3))),-l_d-l_a-l_a-2); - if l_z>=4 - z4vals=shiftdim(z_grid(sum(n_z(1:3))+1:sum(n_z(1:4))),-l_d-l_a-l_a-3); - if l_z>=5 - z5vals=shiftdim(z_grid(sum(n_z(1:4))+1:sum(n_z(1:5))),-l_d-l_a-l_a-4); - end - end - end - end - end -elseif all(size(z_grid)==[prod(n_z),l_z]) % joint z_grid - if l_z>=1 - z1vals=shiftdim(z_grid(:,1),-l_d-l_a-l_a); - if l_z>=2 - z2vals=shiftdim(z_grid(:,2),-l_d-l_a-l_a); - if l_z>=3 - z3vals=shiftdim(z_grid(:,3),-l_d-l_a-l_a); - if l_z>=4 - z4vals=shiftdim(z_grid(:,4),-l_d-l_a-l_a); - if l_z>=5 - z5vals=shiftdim(z_grid(:,5),-l_d-l_a-l_a); - end - end +if l_z>=1 + z1vals=shiftdim(z_gridvals(:,1),-l_d-l_a-l_a); + if l_z>=2 + z2vals=shiftdim(z_gridvals(:,2),-l_d-l_a-l_a); + if l_z>=3 + z3vals=shiftdim(z_gridvals(:,3),-l_d-l_a-l_a); + if l_z>=4 + z4vals=shiftdim(z_gridvals(:,4),-l_d-l_a-l_a); end end end @@ -74,37 +50,37 @@ % l_d==2 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals, a1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals, a1vals, z1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals, a1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals, a1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals, a1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals, a1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); end Fmatrix=reshape(Fmatrix,[N_d,N_a,N_a,N_z]); % This is the difference when using Refine diff --git a/ReturnFnMatrix/RefineBurst/CreateReturnFnMatrix_Case1_Disc_Par2_refineld3.m b/ReturnFnMatrix/RefineBurst/CreateReturnFnMatrix_Case1_Disc_Par2_refineld3.m index 3e5102a1..e93ef424 100644 --- a/ReturnFnMatrix/RefineBurst/CreateReturnFnMatrix_Case1_Disc_Par2_refineld3.m +++ b/ReturnFnMatrix/RefineBurst/CreateReturnFnMatrix_Case1_Disc_Par2_refineld3.m @@ -1,12 +1,9 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_Disc_Par2_refineld3(ReturnFn, d1_grid_layer, d2_grid_layer, d3_grid_layer, n_d, n_a, n_z, a_grid, z_grid, ReturnFnParams) % Refine is an optional input +function Fmatrix=CreateReturnFnMatrix_Case1_Disc_Par2_refineld3(ReturnFn, d1_grid_layer, d2_grid_layer, d3_grid_layer, n_d, n_a, n_z, a_grid, z_gridvals, ReturnFnParamsVec) % Refine is an optional input % Note: this command is only called when l_d=3 l_d=3; % Hardcodes: Refine=1 -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii,1)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_d=prod(n_d); N_a=prod(n_a); @@ -15,10 +12,10 @@ l_a=length(n_a); l_z=length(n_z); if l_a>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of a variable (you have length(n_a)>4): (in CreateReturnFnMatrix_Case1_Disc_Par2)') + error('Using GPU for the return fn does not allow for more than four of a variable (you have length(n_a)>4)') end if l_z>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4): (in CreateReturnFnMatrix_Case1_Disc_Par2)') + error('Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') end if l_a>=1 @@ -37,35 +34,14 @@ end end end -if all(size(z_grid)==[sum(n_z),1]) % kroneker product z_grid - if l_z>=1 - z1vals=shiftdim(z_grid(1:n_z(1)),-l_d-l_a-l_a); - if l_z>=2 - z2vals=shiftdim(z_grid(n_z(1)+1:n_z(1)+n_z(2)),-l_d-l_a-l_a-1); - if l_z>=3 - z3vals=shiftdim(z_grid(sum(n_z(1:2))+1:sum(n_z(1:3))),-l_d-l_a-l_a-2); - if l_z>=4 - z4vals=shiftdim(z_grid(sum(n_z(1:3))+1:sum(n_z(1:4))),-l_d-l_a-l_a-3); - if l_z>=5 - z5vals=shiftdim(z_grid(sum(n_z(1:4))+1:sum(n_z(1:5))),-l_d-l_a-l_a-4); - end - end - end - end - end -elseif all(size(z_grid)==[prod(n_z),l_z]) % joint z_grid - if l_z>=1 - z1vals=shiftdim(z_grid(:,1),-l_d-l_a-l_a); - if l_z>=2 - z2vals=shiftdim(z_grid(:,2),-l_d-l_a-l_a); - if l_z>=3 - z3vals=shiftdim(z_grid(:,3),-l_d-l_a-l_a); - if l_z>=4 - z4vals=shiftdim(z_grid(:,4),-l_d-l_a-l_a); - if l_z>=5 - z5vals=shiftdim(z_grid(:,5),-l_d-l_a-l_a); - end - end +if l_z>=1 + z1vals=shiftdim(z_gridvals(:,1),-l_d-l_a-l_a); + if l_z>=2 + z2vals=shiftdim(z_gridvals(:,2),-l_d-l_a-l_a); + if l_z>=3 + z3vals=shiftdim(z_gridvals(:,3),-l_d-l_a-l_a); + if l_z>=4 + z4vals=shiftdim(z_gridvals(:,4),-l_d-l_a-l_a); end end end @@ -73,37 +49,37 @@ % l_d==3 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals, a1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals, a1vals, z1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals, a1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals, a1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals, a1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals, a1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); end Fmatrix=reshape(Fmatrix,[N_d,N_a,N_a,N_z]); % This is the difference when using Refine diff --git a/ReturnFnMatrix/RefineBurst/CreateReturnFnMatrix_Case1_Disc_Par2_refineld4.m b/ReturnFnMatrix/RefineBurst/CreateReturnFnMatrix_Case1_Disc_Par2_refineld4.m index a2c6e63d..95c49588 100644 --- a/ReturnFnMatrix/RefineBurst/CreateReturnFnMatrix_Case1_Disc_Par2_refineld4.m +++ b/ReturnFnMatrix/RefineBurst/CreateReturnFnMatrix_Case1_Disc_Par2_refineld4.m @@ -1,12 +1,9 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_Disc_Par2_refineld4(ReturnFn, d1_grid_layer, d2_grid_layer, d3_grid_layer, d4_grid_layer, n_d, n_a, n_z, a_grid, z_grid, ReturnFnParams) % Refine is an optional input +function Fmatrix=CreateReturnFnMatrix_Case1_Disc_Par2_refineld4(ReturnFn, d1_grid_layer, d2_grid_layer, d3_grid_layer, d4_grid_layer, n_d, n_a, n_z, a_grid, z_gridvals, ReturnFnParamsVec) % Note: this command is only called when l_d=4 l_d=4; % Hardcodes: Refine=1 -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii,1)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_d=prod(n_d); N_a=prod(n_a); @@ -15,10 +12,10 @@ l_a=length(n_a); l_z=length(n_z); if l_a>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of a variable (you have length(n_a)>4): (in CreateReturnFnMatrix_Case1_Disc_Par2)') + error('Using GPU for the return fn does not allow for more than four of a variable (you have length(n_a)>4)') end if l_z>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4): (in CreateReturnFnMatrix_Case1_Disc_Par2)') + error('Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') end if l_a>=1 @@ -37,35 +34,15 @@ end end end -if all(size(z_grid)==[sum(n_z),1]) % kroneker product z_grid - if l_z>=1 - z1vals=shiftdim(z_grid(1:n_z(1)),-l_d-l_a-l_a); - if l_z>=2 - z2vals=shiftdim(z_grid(n_z(1)+1:n_z(1)+n_z(2)),-l_d-l_a-l_a-1); - if l_z>=3 - z3vals=shiftdim(z_grid(sum(n_z(1:2))+1:sum(n_z(1:3))),-l_d-l_a-l_a-2); - if l_z>=4 - z4vals=shiftdim(z_grid(sum(n_z(1:3))+1:sum(n_z(1:4))),-l_d-l_a-l_a-3); - if l_z>=5 - z5vals=shiftdim(z_grid(sum(n_z(1:4))+1:sum(n_z(1:5))),-l_d-l_a-l_a-4); - end - end - end - end - end -elseif all(size(z_grid)==[prod(n_z),l_z]) % joint z_grid - if l_z>=1 - z1vals=shiftdim(z_grid(:,1),-l_d-l_a-l_a); - if l_z>=2 - z2vals=shiftdim(z_grid(:,2),-l_d-l_a-l_a); - if l_z>=3 - z3vals=shiftdim(z_grid(:,3),-l_d-l_a-l_a); - if l_z>=4 - z4vals=shiftdim(z_grid(:,4),-l_d-l_a-l_a); - if l_z>=5 - z5vals=shiftdim(z_grid(:,5),-l_d-l_a-l_a); - end - end + +if l_z>=1 + z1vals=shiftdim(z_gridvals(:,1),-l_d-l_a-l_a); + if l_z>=2 + z2vals=shiftdim(z_gridvals(:,2),-l_d-l_a-l_a); + if l_z>=3 + z3vals=shiftdim(z_gridvals(:,3),-l_d-l_a-l_a); + if l_z>=4 + z4vals=shiftdim(z_gridvals(:,4),-l_d-l_a-l_a); end end end @@ -73,37 +50,37 @@ % l_d==4 if l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals, a1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals, a1vals, z1vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals, a1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals, a1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals, a1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals, a1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals, a1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals, a1vals,a2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1_grid_layer,d2_grid_layer,d3_grid_layer,d4_grid_layer, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); end Fmatrix=reshape(Fmatrix,[N_d,N_a,N_a,N_z]); % This is the difference when using Refine diff --git a/ReturnFnMatrix/ResidualAsset/CreateReturnFnMatrix_Case1_ResidAsset_Disc_Par2.m b/ReturnFnMatrix/ResidualAsset/CreateReturnFnMatrix_Case1_ResidAsset_Disc_Par2.m index bb224a1f..7db912ae 100644 --- a/ReturnFnMatrix/ResidualAsset/CreateReturnFnMatrix_Case1_ResidAsset_Disc_Par2.m +++ b/ReturnFnMatrix/ResidualAsset/CreateReturnFnMatrix_Case1_ResidAsset_Disc_Par2.m @@ -1,14 +1,11 @@ -function Fmatrix=CreateReturnFnMatrix_Case1_ResidAsset_Disc_Par2(ReturnFn, n_d, n_a, n_r, n_z, d_grid, a_grid, r_grid, z_grid, ReturnFnParams,Refine) % Refine is an optional input +function Fmatrix=CreateReturnFnMatrix_Case1_ResidAsset_Disc_Par2(ReturnFn, n_d, n_a, n_r, n_z, d_grid, a_grid, r_grid, z_gridvals, ReturnFnParamsVec,Refine) % Refine is an optional input % If there is no d variable, just input n_d=0 and d_grid=0 if ~exist('Refine','var') Refine=0; end -ParamCell=cell(length(ReturnFnParams),1); -for ii=1:length(ReturnFnParams) - ParamCell(ii,1)={ReturnFnParams(ii)}; -end +ReturnFnParamsCell=num2cell(ReturnFnParamsVec)'; N_d=prod(n_d); N_a=prod(n_a); @@ -23,16 +20,16 @@ l_r=length(n_r); l_z=length(n_z); if l_d>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') + error('Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') end if l_a>3 - error('ERROR: Using GPU for the return fn does not allow for more than four of a variable (you have length(n_a)>4)') + error('Using GPU for the return fn does not allow for more than four of a variable (you have length(n_a)>4)') end if l_r>2 - error('ERROR: Using GPU for the return fn does not allow for more than two of r variable (you have length(n_r)>2)') + error('Using GPU for the return fn does not allow for more than two of r variable (you have length(n_r)>2)') end if l_z>5 - error('ERROR: Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>5)') + error('Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>5)') end @@ -72,34 +69,16 @@ r2vals=shiftdim(r_grid(n_r(1)+1:sum(n_r(1:2))),-l_a-l_a-l_d-1); end end -if all(size(z_grid)==[sum(n_z),1]) % kroneker product z_grid - if l_z>=1 - z1vals=shiftdim(z_grid(1:n_z(1)),-l_d-l_a-l_a-l_r); - if l_z>=2 - z2vals=shiftdim(z_grid(n_z(1)+1:n_z(1)+n_z(2)),-l_d-l_a-l_a-l_r-1); - if l_z>=3 - z3vals=shiftdim(z_grid(sum(n_z(1:2))+1:sum(n_z(1:3))),-l_d-l_a-l_a-l_r-2); - if l_z>=4 - z4vals=shiftdim(z_grid(sum(n_z(1:3))+1:sum(n_z(1:4))),-l_d-l_a-l_a-l_r-3); - if l_z>=5 - z5vals=shiftdim(z_grid(sum(n_z(1:4))+1:sum(n_z(1:5))),-l_d-l_a-l_a-l_r-4); - end - end - end - end - end -elseif all(size(z_grid)==[prod(n_z),l_z]) % joint z_grid - if l_z>=1 - z1vals=shiftdim(z_grid(:,1),-l_d-l_a-l_a-l_r); - if l_z>=2 - z2vals=shiftdim(z_grid(:,2),-l_d-l_a-l_a-l_r); - if l_z>=3 - z3vals=shiftdim(z_grid(:,3),-l_d-l_a-l_a-l_r); - if l_z>=4 - z4vals=shiftdim(z_grid(:,4),-l_d-l_a-l_a-l_r); - if l_z>=5 - z5vals=shiftdim(z_grid(:,5),-l_d-l_a-l_a-l_r); - end +if l_z>=1 + z1vals=shiftdim(z_gridvals(:,1),-l_d-l_a-l_a-l_r); + if l_z>=2 + z2vals=shiftdim(z_gridvals(:,2),-l_d-l_a-l_a-l_r); + if l_z>=3 + z3vals=shiftdim(z_gridvals(:,3),-l_d-l_a-l_a-l_r); + if l_z>=4 + z4vals=shiftdim(z_gridvals(:,4),-l_d-l_a-l_a-l_r); + if l_z>=5 + z5vals=shiftdim(z_gridvals(:,5),-l_d-l_a-l_a-l_r); end end end @@ -109,409 +88,409 @@ % Note: if l_r=0 you should never end up here anyway if l_r==1 if l_d==0 && l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, r1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, r1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, r1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, r1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==1 && l_z==1 d1vals(1,1,1,1)=d_grid(1); % Requires special treatment - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals, a1vals, r1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals, a1vals, r1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals, a1vals, r1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals, a1vals, r1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals, a1vals, r1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals, a1vals, r1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals, a1vals, r1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals, a1vals, r1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals, a1vals, r1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals, a1vals, r1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals, a1vals, r1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals, a1vals, r1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals, a1vals, r1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals, a1vals, r1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals, a1vals, r1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals, a1vals, r1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals, a1vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); end elseif l_r==2 if l_d==0 && l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, r1vals, r2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, r1vals, r2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==0 && l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==1 && l_z==1 d1vals(1,1,1,1)=d_grid(1); % Requires special treatment - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals, a1vals, r1vals, r2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals, a1vals, r1vals, r2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==1 && l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals, a1vals, r1vals, r2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals, a1vals, r1vals, r2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==2 && l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals, a1vals, r1vals, r2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals, a1vals, r1vals, r2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==3 && l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==1 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals, a1vals, r1vals, r2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals, a1vals, r1vals, r2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==1 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==1 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==1 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==1 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals, a1vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==2 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==2 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==2 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==2 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==2 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals, a1vals,a2vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==3 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==3 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==3 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==3 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==3 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals, a1vals,a2vals,a3vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==4 && l_z==1 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==4 && l_z==2 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==4 && l_z==3 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==4 && l_z==4 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals, ReturnFnParamsCell{:}); elseif l_d==4 && l_a==4 && l_z==5 - Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d1vals,d2vals,d3vals,d4vals, aprime1vals,aprime2vals,aprime3vals,aprime4vals, a1vals,a2vals,a3vals,a4vals, r1vals, r2vals, z1vals,z2vals,z3vals,z4vals,z5vals, ReturnFnParamsCell{:}); end end diff --git a/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_Par2.m b/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_Par2.m index e4634f7d..f19f8d52 100644 --- a/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_Par2.m +++ b/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_Par2.m @@ -3,17 +3,17 @@ l_d=length(n_d); % won't get here if l_d=0 l_a=1; % (or else won't get here) if l_d>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') + error('Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') end l_z=length(n_z); % won't get here if l_z=0 if l_z>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') + error('Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') end nReturnFnParams=size(ReturnFnParamsAgeMatrix,2); -ParamCell=cell(nReturnFnParams,1); +ReturnFnParamsCell=cell(nReturnFnParams,1); for ii=1:nReturnFnParams - ParamCell(ii,1)={shiftdim(ReturnFnParamsAgeMatrix(:,ii),-l_d-l_a-l_a)}; + ReturnFnParamsCell(ii,1)={shiftdim(ReturnFnParamsAgeMatrix(:,ii),-l_d-l_a-l_a)}; end N_d=prod(n_d); @@ -27,43 +27,43 @@ if l_z==1 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), ReturnFnParamsCell{:}); end elseif l_z==2 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), ReturnFnParamsCell{:}); end elseif l_z==3 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), ReturnFnParamsCell{:}); end elseif l_z==4 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), ReturnFnParamsCell{:}); end end diff --git a/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_Par2e.m b/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_Par2e.m index fd62e6dd..4d55d836 100644 --- a/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_Par2e.m +++ b/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_Par2e.m @@ -3,22 +3,22 @@ l_d=length(n_d); % won't get here if l_d=0 l_a=1; % (or else won't get here) if l_d>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') + error('Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') end l_z=length(n_z); % won't get here if l_z=0 if l_z>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') + error('Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') end l_e=length(n_e); % won't get here if l_e=0 if l_e>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of e variable (you have length(n_e)>4)') + error('Using GPU for the return fn does not allow for more than four of e variable (you have length(n_e)>4)') end nReturnFnParams=size(ReturnFnParamsAgeMatrix,2); -ParamCell=cell(nReturnFnParams,1); +ReturnFnParamsCell=cell(nReturnFnParams,1); for ii=1:nReturnFnParams - ParamCell(ii,1)={shiftdim(ReturnFnParamsAgeMatrix(:,ii),-l_d-l_a-l_a)}; + ReturnFnParamsCell(ii,1)={shiftdim(ReturnFnParamsAgeMatrix(:,ii),-l_d-l_a-l_a)}; end N_d=prod(n_d); @@ -34,169 +34,169 @@ if l_e==1 if l_z==1 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), ReturnFnParamsCell{:}); end elseif l_z==2 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), ReturnFnParamsCell{:}); end elseif l_z==3 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), ReturnFnParamsCell{:}); end elseif l_z==4 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), ReturnFnParamsCell{:}); end end elseif l_e==2 if l_z==1 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ReturnFnParamsCell{:}); end elseif l_z==2 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ReturnFnParamsCell{:}); end elseif l_z==3 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ReturnFnParamsCell{:}); end elseif l_z==4 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), ReturnFnParamsCell{:}); end end elseif l_e==3 if l_z==1 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ReturnFnParamsCell{:}); end elseif l_z==2 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ReturnFnParamsCell{:}); end elseif l_z==3 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ReturnFnParamsCell{:}); end elseif l_z==4 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), ReturnFnParamsCell{:}); end end elseif l_e==4 if l_z==1 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ReturnFnParamsCell{:}); end elseif l_z==2 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ReturnFnParamsCell{:}); end elseif l_z==3 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ReturnFnParamsCell{:}); end elseif l_z==4 if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), shiftdim(aprime_grid,-1), shiftdim(a_grid,-2), z_gridvals_J(1,1,1,:,:,1), z_gridvals_J(1,1,1,:,:,2), z_gridvals_J(1,1,1,:,:,3), z_gridvals_J(1,1,1,:,:,4), e_gridvals_J(1,1,1,:,1,:,1), e_gridvals_J(1,1,1,:,1,:,2), e_gridvals_J(1,1,1,:,1,:,3), e_gridvals_J(1,1,1,:,1,:,4), ReturnFnParamsCell{:}); end end end diff --git a/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_nod_Par2.m b/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_nod_Par2.m index b893968e..e6a9e010 100644 --- a/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_nod_Par2.m +++ b/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_nod_Par2.m @@ -3,13 +3,13 @@ l_a=1; % (or else won't get here) l_z=length(n_z); % won't get here if l_z=0 if l_z>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') + error('Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') end nReturnFnParams=size(ReturnFnParamsAgeMatrix,2); -ParamCell=cell(nReturnFnParams,1); +ReturnFnParamsCell=cell(nReturnFnParams,1); for ii=1:nReturnFnParams - ParamCell(ii,1)={shiftdim(ReturnFnParamsAgeMatrix(:,ii),-l_a-l_a)}; + ReturnFnParamsCell(ii,1)={shiftdim(ReturnFnParamsAgeMatrix(:,ii),-l_a-l_a)}; end N_a=length(a_grid); % Because l_a=1 @@ -22,23 +22,23 @@ if Level==1 if l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), ReturnFnParamsCell{:}); elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), ReturnFnParamsCell{:}); elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), ReturnFnParamsCell{:}); elseif l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), z_gridvals_J(1,1,:,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), z_gridvals_J(1,1,:,:,4), ReturnFnParamsCell{:}); end elseif Level==2 if l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), ReturnFnParamsCell{:}); elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), ReturnFnParamsCell{:}); elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), ReturnFnParamsCell{:}); elseif l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), z_gridvals_J(1,1,:,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), z_gridvals_J(1,1,:,:,4), ReturnFnParamsCell{:}); end end diff --git a/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_nod_Par2e.m b/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_nod_Par2e.m index 464fe5be..5176b341 100644 --- a/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_nod_Par2e.m +++ b/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_nod_Par2e.m @@ -3,18 +3,18 @@ l_a=1; % (or else won't get here) l_z=length(n_z); % won't get here if l_z=0 if l_z>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') + error('Using GPU for the return fn does not allow for more than four of z variable (you have length(n_z)>4)') end l_e=length(n_e); % won't get here if l_e=0 if l_e>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of e variable (you have length(n_e)>4)') + error('Using GPU for the return fn does not allow for more than four of e variable (you have length(n_e)>4)') end nReturnFnParams=size(ReturnFnParamsAgeMatrix,2); -ParamCell=cell(nReturnFnParams,1); +ReturnFnParamsCell=cell(nReturnFnParams,1); for ii=1:nReturnFnParams - ParamCell(ii,1)={shiftdim(ReturnFnParamsAgeMatrix(:,ii),-l_a-l_a)}; + ReturnFnParamsCell(ii,1)={shiftdim(ReturnFnParamsAgeMatrix(:,ii),-l_a-l_a)}; end N_a=length(a_grid); % Because l_a=1 @@ -29,85 +29,85 @@ if Level==1 if l_e==1 if l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), e_gridvals_J(1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), e_gridvals_J(1,1,:,1,:,1), ReturnFnParamsCell{:}); elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), e_gridvals_J(1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), e_gridvals_J(1,1,:,1,:,1), ReturnFnParamsCell{:}); elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), e_gridvals_J(1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), e_gridvals_J(1,1,:,1,:,1), ReturnFnParamsCell{:}); elseif l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), z_gridvals_J(1,1,:,:,4), e_gridvals_J(1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), z_gridvals_J(1,1,:,:,4), e_gridvals_J(1,1,:,1,:,1), ReturnFnParamsCell{:}); end elseif l_e==2 if l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), ReturnFnParamsCell{:}); elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), ReturnFnParamsCell{:}); elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), ReturnFnParamsCell{:}); elseif l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), z_gridvals_J(1,1,:,:,4), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), z_gridvals_J(1,1,:,:,4), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), ReturnFnParamsCell{:}); end elseif l_e==3 if l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), ReturnFnParamsCell{:}); elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), ReturnFnParamsCell{:}); elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), ReturnFnParamsCell{:}); elseif l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), z_gridvals_J(1,1,:,:,4), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), z_gridvals_J(1,1,:,:,4), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), ReturnFnParamsCell{:}); end elseif l_e==4 if l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), e_gridvals_J(1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), e_gridvals_J(1,1,:,1,:,4), ReturnFnParamsCell{:}); elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), e_gridvals_J(1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), e_gridvals_J(1,1,:,1,:,4), ReturnFnParamsCell{:}); elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), e_gridvals_J(1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), e_gridvals_J(1,1,:,1,:,4), ReturnFnParamsCell{:}); elseif l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), z_gridvals_J(1,1,:,:,4), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), e_gridvals_J(1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), z_gridvals_J(1,1,:,:,4), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), e_gridvals_J(1,1,:,1,:,4), ReturnFnParamsCell{:}); end end elseif Level==2 if l_e==1 if l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), e_gridvals_J(1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), e_gridvals_J(1,1,:,1,:,1), ReturnFnParamsCell{:}); elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), e_gridvals_J(1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), e_gridvals_J(1,1,:,1,:,1), ReturnFnParamsCell{:}); elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), e_gridvals_J(1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), e_gridvals_J(1,1,:,1,:,1), ReturnFnParamsCell{:}); elseif l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), z_gridvals_J(1,1,:,:,4), e_gridvals_J(1,1,:,1,:,1), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), z_gridvals_J(1,1,:,:,4), e_gridvals_J(1,1,:,1,:,1), ReturnFnParamsCell{:}); end elseif l_e==2 if l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), ReturnFnParamsCell{:}); elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), ReturnFnParamsCell{:}); elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), ReturnFnParamsCell{:}); elseif l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), z_gridvals_J(1,1,:,:,4), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), z_gridvals_J(1,1,:,:,4), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), ReturnFnParamsCell{:}); end elseif l_e==3 if l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), ReturnFnParamsCell{:}); elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), ReturnFnParamsCell{:}); elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), ReturnFnParamsCell{:}); elseif l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), z_gridvals_J(1,1,:,:,4), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), z_gridvals_J(1,1,:,:,4), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), ReturnFnParamsCell{:}); end elseif l_e==4 if l_z==1 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), e_gridvals_J(1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), e_gridvals_J(1,1,:,1,:,4), ReturnFnParamsCell{:}); elseif l_z==2 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), e_gridvals_J(1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), e_gridvals_J(1,1,:,1,:,4), ReturnFnParamsCell{:}); elseif l_z==3 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), e_gridvals_J(1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), e_gridvals_J(1,1,:,1,:,4), ReturnFnParamsCell{:}); elseif l_z==4 - Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), z_gridvals_J(1,1,:,:,4), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), e_gridvals_J(1,1,:,1,:,4), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), z_gridvals_J(1,1,:,:,1), z_gridvals_J(1,1,:,:,2), z_gridvals_J(1,1,:,:,3), z_gridvals_J(1,1,:,:,4), e_gridvals_J(1,1,:,1,:,1), e_gridvals_J(1,1,:,1,:,2), e_gridvals_J(1,1,:,1,:,3), e_gridvals_J(1,1,:,1,:,4), ReturnFnParamsCell{:}); end end end diff --git a/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_nod_noz_Par2.m b/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_nod_noz_Par2.m index d4f2b137..c5622630 100644 --- a/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_nod_noz_Par2.m +++ b/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_nod_noz_Par2.m @@ -3,9 +3,9 @@ l_a=1; % (or else won't get here) nReturnFnParams=size(ReturnFnParamsAgeMatrix,2); -ParamCell=cell(nReturnFnParams,1); +ReturnFnParamsCell=cell(nReturnFnParams,1); for ii=1:nReturnFnParams - ParamCell(ii,1)={shiftdim(ReturnFnParamsAgeMatrix(:,ii),-l_a-l_a)}; + ReturnFnParamsCell(ii,1)={shiftdim(ReturnFnParamsAgeMatrix(:,ii),-l_a-l_a)}; end N_a=length(a_grid); % Because l_a=1 @@ -17,7 +17,7 @@ N_aprime=size(aprime_grid,2); % Because l_a=1 end -Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), ParamCell{:}); +Fmatrix=arrayfun(ReturnFn, aprime_grid, shiftdim(a_grid,-1), ReturnFnParamsCell{:}); Fmatrix=reshape(Fmatrix,[N_aprime,N_a,N_j]); diff --git a/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_noz_Par2.m b/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_noz_Par2.m index 5135a4b3..90d9ff4d 100644 --- a/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_noz_Par2.m +++ b/ReturnFnMatrix/fastOLG/CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_noz_Par2.m @@ -3,13 +3,13 @@ l_d=length(n_d); % won't get here if l_d=0 l_a=1; % (or else won't get here) if l_d>4 - error('ERROR: Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') + error('Using GPU for the return fn does not allow for more than four of d variable (you have length(n_d)>4)') end nReturnFnParams=size(ReturnFnParamsAgeMatrix,2); -ParamCell=cell(nReturnFnParams,1); +ReturnFnParamsCell=cell(nReturnFnParams,1); for ii=1:nReturnFnParams - ParamCell(ii,1)={shiftdim(ReturnFnParamsAgeMatrix(:,ii),-l_d-l_a-l_a)}; + ReturnFnParamsCell(ii,1)={shiftdim(ReturnFnParamsAgeMatrix(:,ii),-l_d-l_a-l_a)}; end N_d=prod(n_d); @@ -22,13 +22,13 @@ if l_d==1 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1), aprime_grid, shiftdim(a_grid,-2), ReturnFnParamsCell{:}); elseif l_d==2 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2), aprime_grid, shiftdim(a_grid,-2), ReturnFnParamsCell{:}); elseif l_d==3 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3), aprime_grid, shiftdim(a_grid,-2), ReturnFnParamsCell{:}); elseif l_d==4 - Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), ParamCell{:}); + Fmatrix=arrayfun(ReturnFn, d_gridvals(:,1),d_gridvals(:,2),d_gridvals(:,3),d_gridvals(:,4), aprime_grid, shiftdim(a_grid,-2), ReturnFnParamsCell{:}); end if Level==1 || Level==3 % For level 1 From 243bad9228f7e82b2ca5e52f897c85ce4c5c794f Mon Sep 17 00:00:00 2001 From: Michael Tiemann Date: Wed, 28 Jan 2026 23:10:00 +1300 Subject: [PATCH 39/67] CPU/GPU balancing The slow step in these files is computing the sparse matrix for the Gamma transpose. Strangely (and I measure it), the more of the inputs that start on the CPU rather than the GPU (e.g., `II2`, `PolicyProbs`, and `Policy_aprimesemizz` and the like), the faster MATLAB can construct the sparse matrix. Based on this observation, uses of `gpuArray` that would only need to be `gather`ed immediately anyway, and which were themselves not in any computational loops, were also removed. It was verified that StationaryDist_jj remains sparse within its loops, and that its contents become full when assigned to StationaryDist(:,jj+1). Which enabled additional simplifications. Finally, it should be noted that all these optimizations greatly relieve pressure on GPU memory, while actually improving specific sparse matrix creation performance by as much as 10x (based on tic/toc and timeit measurements). --- .../FHorz/StationaryDist_FHorz_Case1.m | 2 +- ...ist_FHorz_Iteration_SemiExo_nProbs_e_raw.m | 25 +++++++++---------- ...FHorz_Iteration_SemiExo_nProbs_noz_e_raw.m | 23 +++++++++-------- ...t_FHorz_Iteration_SemiExo_nProbs_noz_raw.m | 23 +++++++++-------- ...yDist_FHorz_Iteration_SemiExo_nProbs_raw.m | 17 ++++++------- 5 files changed, 45 insertions(+), 45 deletions(-) diff --git a/StationaryDist/FHorz/StationaryDist_FHorz_Case1.m b/StationaryDist/FHorz/StationaryDist_FHorz_Case1.m index d299343d..cb990ca8 100644 --- a/StationaryDist/FHorz/StationaryDist_FHorz_Case1.m +++ b/StationaryDist/FHorz/StationaryDist_FHorz_Case1.m @@ -88,7 +88,7 @@ %% Semi-exogenous shock gridvals and pi if isfield(simoptions,'n_semiz') % Internally, only ever use age-dependent joint-grids (makes all the code much easier to write) - simoptions=SemiExogShockSetup_FHorz(n_d,N_j,simoptions.d_grid,Parameters,simoptions,1); + simoptions=SemiExogShockSetup_FHorz(n_d,N_j,simoptions.d_grid,Parameters,simoptions,simoptions.parallel); % output: simoptions.semiz_gridvals_J, simoptions.pi_semiz_J % size(semiz_gridvals_J)=[prod(n_z),length(n_z),N_j] % size(pi_semiz_J)=[prod(n_semiz),prod(n_semiz),prod(n_dsemiz),N_j] diff --git a/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_e_raw.m b/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_e_raw.m index a448046f..a4ad8cd9 100644 --- a/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_e_raw.m +++ b/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_e_raw.m @@ -8,46 +8,45 @@ % put a&semiz&z together into the 1st dim, semiz'&nprobs into the 2nd dim. % Policy_aprime is currently [N_a,N_semiz*N_z*N_e,N_probs,N_j] -Policy_aprimesemizz=repelem(reshape(Policy_aprime,[N_a*N_semiz*N_z*N_e,N_probs,N_j]),1,N_semiz)+repmat(N_a*gpuArray(0:1:N_semiz-1),1,N_probs)+repmat(repelem(N_a*N_semiz*(0:1:N_z-1)',N_a*N_semiz,1),N_e,1); % Note: add semiz' index following the semiz' dimension, add z' index following the z dimension for Tan improvement -Policy_aprimesemizz=gather(Policy_aprimesemizz); % [N_a*N_semiz*N_z*N_e,N_semiz*N_probs,N_j] +Policy_aprimesemizz=repelem(reshape(gather(Policy_aprime),[N_a*N_semiz*N_z*N_e,N_probs,N_j]),1,N_semiz)+repmat(N_a*(0:1:N_semiz-1),1,N_probs)+repmat(repelem(N_a*N_semiz*(0:1:N_z-1)',N_a*N_semiz,1),N_e,1); % Note: add semiz' index following the semiz' dimension, add z' index following the z dimension for Tan improvement Policy_dsemiexo=reshape(Policy_dsemiexo,[N_a*N_semiz*N_z*N_e,1,N_j]); -% precompute -semizindex=repmat(repelem(gpuArray(1:1:N_semiz)',N_a,1),N_z*N_e,1)+N_semiz*gpuArray(0:1:N_semiz-1)+(N_semiz*N_semiz)*(Policy_dsemiexo-1); % index for semiz, plus that for semiz' (in the semiz' dim) and dsemiexo; their indexes in pi_semiz_J + +% precompute; Don't want `PolicyProbs` on GPU anyway, so leave these in CPU RAM +semizindex=repmat(repelem((1:1:N_semiz)',N_a,1),N_z*N_e,1)+N_semiz*(0:1:N_semiz-1)+gather((N_semiz*N_semiz)*(Policy_dsemiexo-1)); % index for semiz, plus that for semiz' (in the semiz' dim) and dsemiexo; their indexes in pi_semiz_J +pi_semiz_J=gather(pi_semiz_J); % semizindex is [N_a*N_semiz*N_z*N_e,N_semiz,N_j] PolicyProbs=reshape(PolicyProbs,[N_a*N_semiz*N_z*N_e,N_probs,N_j]); -PolicyProbs=repelem(PolicyProbs,1,N_semiz).*repmat(pi_semiz_J(semizindex),1,N_probs); -PolicyProbs=gather(PolicyProbs); +PolicyProbs=repelem(gather(PolicyProbs),1,N_semiz).*repmat(pi_semiz_J(semizindex),1,N_probs); +clear semizindex; N_bothz=N_semiz*N_z; %% Use Tan improvement -StationaryDist=zeros(N_a*N_semiz*N_z*N_e,N_j,'gpuArray'); +StationaryDist=zeros(N_a*N_semiz*N_z*N_e,N_j,'gpuArray'); % StationaryDist cannot be sparse StationaryDist(:,1)=jequaloneDistKron; -StationaryDist_jj=sparse(jequaloneDistKron); % sparse() creates a matrix of zeros +StationaryDist_jj=sparse(jequaloneDistKron); % use sparse matrix -% Precompute +% Precompute; II2 used only for sparse matrix creation...best done on CPU II2=repelem((1:1:N_a*N_semiz*N_z*N_e)',1,N_semiz*N_probs); % Index for this period (a,semiz), note the N_probs-copies for jj=1:(N_j-1) - % First, get Gamma Gammatranspose=sparse(Policy_aprimesemizz(:,:,jj),II2,PolicyProbs(:,:,jj),N_a*N_bothz,N_a*N_bothz*N_e); % Note: sparse() will accumulate at repeated indices [only relevant at grid end points] % First step of Tan improvement StationaryDist_jj=reshape(Gammatranspose*StationaryDist_jj,[N_a*N_semiz,N_z]); % Second step of Tan improvement - pi_z=sparse(pi_z_J(:,:,jj)); - StationaryDist_jj=reshape(StationaryDist_jj*pi_z,[N_a*N_bothz,1]); + StationaryDist_jj=reshape(StationaryDist_jj*pi_z_J(:,:,jj),[N_a*N_bothz,1]); % Now do e transitions pi_e=sparse(pi_e_J(:,jj)); StationaryDist_jj=kron(pi_e,StationaryDist_jj); - StationaryDist(:,jj+1)=gpuArray(full(StationaryDist_jj)); + StationaryDist(:,jj+1)=StationaryDist_jj; end % Reweight the different ages based on 'AgeWeightParamNames'. (it is assumed there is only one Age Weight Parameter (name)) diff --git a/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_noz_e_raw.m b/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_noz_e_raw.m index 7edf9db3..1461f32a 100644 --- a/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_noz_e_raw.m +++ b/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_noz_e_raw.m @@ -12,22 +12,24 @@ Policy_aprimesemiz=gather(Policy_aprimesemiz); % [N_a*N_semiz*N_e,N_semiz*N_probs,N_j] Policy_dsemiexo=reshape(Policy_dsemiexo,[N_a*N_semiz*N_e,1,N_j]); -% precompute -semizindex=repmat(repelem(gpuArray(1:1:N_semiz)',N_a,1),N_e,1)+N_semiz*gpuArray(0:1:N_semiz-1)+(N_semiz*N_semiz)*(Policy_dsemiexo-1); % index for semiz, plus that for semiz' (in the semiz' dim) and dsemiexo; their indexes in pi_semiz_J + +% precompute; Don't want `PolicyProbs` on GPU anyway, so leave these in CPU RAM +semizindex=repmat(repelem((1:1:N_semiz)',N_a,1),N_e,1)+N_semiz*(0:1:N_semiz-1)+gather((N_semiz*N_semiz)*(Policy_dsemiexo-1)); % index for semiz, plus that for semiz' (in the semiz' dim) and dsemiexo; their indexes in pi_semiz_J +pi_semiz_J=gather(pi_semiz_J); % semizindex is [N_a*N_semiz*N_e,N_semiz,N_j] PolicyProbs=reshape(PolicyProbs,[N_a*N_semiz*N_e,N_probs,N_j]); -PolicyProbs=repelem(PolicyProbs,1,N_semiz).*repmat(pi_semiz_J(semizindex),1,N_probs); -PolicyProbs=gather(PolicyProbs); +PolicyProbs=repelem(gather(PolicyProbs),1,N_semiz).*repmat(pi_semiz_J(semizindex),1,N_probs); +clear semizindex; %% Use Tan improvement -StationaryDist=zeros(N_a*N_semiz*N_e,N_j,'gpuArray'); +StationaryDist=zeros(N_a*N_semiz*N_e,N_j,'gpuArray'); % StationaryDist cannot be sparse StationaryDist(:,1)=jequaloneDistKron; -StationaryDist_jj=sparse(jequaloneDistKron); % sparse() creates a matrix of zeros +StationaryDist_jj=sparse(jequaloneDistKron); % use sparse matrix -% Precompute -II2=repelem(gpuArray(1:1:N_a*N_semiz*N_e)',1,N_semiz*N_probs); % Index for this period (a,semiz), note the N_probs-copies +% Precompute; II2 used only for sparse matrix creation...best done on CPU +II2=repelem((1:1:N_a*N_semiz*N_e)',1,N_semiz*N_probs); % Index for this period (a,semiz), note the N_probs-copies for jj=1:(N_j-1) @@ -37,10 +39,9 @@ StationaryDist_jj=Gammatranspose*StationaryDist_jj; % Put e back into dist - pi_e=sparse(gather(pi_e_J(:,jj))); - StationaryDist_jj=kron(pi_e,StationaryDist_jj); + StationaryDist_jj=kron(pi_e_J(:,jj),StationaryDist_jj); - StationaryDist(:,jj+1)=gpuArray(full(StationaryDist_jj)); + StationaryDist(:,jj+1)=StationaryDist_jj; end % Reweight the different ages based on 'AgeWeightParamNames'. (it is assumed there is only one Age Weight Parameter (name)) diff --git a/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_noz_raw.m b/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_noz_raw.m index 8e640caa..2b8391f4 100644 --- a/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_noz_raw.m +++ b/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_noz_raw.m @@ -8,26 +8,27 @@ % put a&semiz together into the 1st dim, semiz'&nprobs into the 2nd dim. % Policy_aprime is currently [N_a,N_semiz,N_probs,N_j] -Policy_aprimesemiz=repelem(reshape(Policy_aprime,[N_a*N_semiz,N_probs,N_j]),1,N_semiz)+repmat(N_a*gpuArray(0:1:N_semiz-1),1,N_probs); % Note: add semiz' index following the semiz' dimension -Policy_aprimesemiz=gather(Policy_aprimesemiz); % [N_a*N_semiz,N_semiz*N_probs,N_j] +Policy_aprimesemiz=repelem(reshape(gather(Policy_aprime),[N_a*N_semiz,N_probs,N_j]),1,N_semiz)+repmat(N_a*(0:1:N_semiz-1),1,N_probs); % Note: add semiz' index following the semiz' dimension Policy_dsemiexo=reshape(Policy_dsemiexo,[N_a*N_semiz,1,N_j]); -% precompute -semizindex=repelem(gpuArray(1:1:N_semiz)',N_a,1)+N_semiz*gpuArray(0:1:N_semiz-1)+(N_semiz*N_semiz)*(Policy_dsemiexo-1); % index for semiz, plus that for semiz' (in the semiz' dim) and dsemiexo; their indexes in pi_semiz_J + +% precompute; Don't want `PolicyProbs` on GPU anyway, so leave these in CPU RAM +semizindex=repelem((1:1:N_semiz)',N_a,1)+N_semiz*(0:1:N_semiz-1)+gather((N_semiz*N_semiz)*(Policy_dsemiexo-1)); % index for semiz, plus that for semiz' (in the semiz' dim) and dsemiexo; their indexes in pi_semiz_J +pi_semiz_J=gather(pi_semiz_J); % semizindex is [N_a*N_semiz,N_semiz,N_j] PolicyProbs=reshape(PolicyProbs,[N_a*N_semiz,N_probs,N_j]); -PolicyProbs=repelem(PolicyProbs,1,N_semiz).*repmat(pi_semiz_J(semizindex),1,N_probs); -PolicyProbs=gather(PolicyProbs); +PolicyProbs=repelem(gather(PolicyProbs),1,N_semiz).*repmat(pi_semiz_J(semizindex),1,N_probs); +clear semizindex; %% Use Tan improvement -StationaryDist=zeros(N_a*N_semiz,N_j,'gpuArray'); +StationaryDist=zeros(N_a*N_semiz,N_j,'gpuArray'); % StationaryDist cannot be sparse StationaryDist(:,1)=jequaloneDistKron; -StationaryDist_jj=sparse(jequaloneDistKron); % sparse() creates a matrix of zeros +StationaryDist_jj=sparse(jequaloneDistKron); % use sparse matrix -% Precompute -II2=repelem(gpuArray(1:1:N_a*N_semiz)',1,N_semiz*N_probs); % Index for this period (a,semiz), note the N_semiz*N_probs-copies +% Precompute; II2 used only for sparse matrix creation...best done on CPU +II2=repelem((1:1:N_a*N_semiz)',1,N_semiz*N_probs); % Index for this period (a,semiz), note the N_semiz*N_probs-copies for jj=1:(N_j-1) @@ -36,7 +37,7 @@ % No z, so just a single interation StationaryDist_jj=Gammatranspose*StationaryDist_jj; - StationaryDist(:,jj+1)=gpuArray(full(StationaryDist_jj)); + StationaryDist(:,jj+1)=StationaryDist_jj; end diff --git a/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_raw.m b/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_raw.m index 61ef5838..e69a9749 100644 --- a/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_raw.m +++ b/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_raw.m @@ -12,25 +12,25 @@ Policy_dsemiexo=reshape(Policy_dsemiexo,[N_a*N_semiz*N_z,1,N_j]); -% precompute +% precompute; Don't want `PolicyProbs` on GPU anyway, so leave these in CPU RAM semizindex=repmat(repelem((1:1:N_semiz)',N_a,1),N_z,1)+N_semiz*(0:1:N_semiz-1)+gather((N_semiz*N_semiz)*(Policy_dsemiexo-1)); % index for semiz, plus that for semiz' (in the semiz' dim) and dsemiexo; their indexes in pi_semiz_J +pi_semiz_J=gather(pi_semiz_J); % semizindex is [N_a*N_semiz*N_z,N_semiz,N_j] - PolicyProbs=reshape(PolicyProbs,[N_a*N_semiz*N_z,N_probs,N_j]); -% pi_semiz_J=gather(pi_semiz_J); PolicyProbs=repelem(gather(PolicyProbs),1,N_semiz).*repmat(pi_semiz_J(semizindex),1,N_probs); +clear semizindex; N_bothz=N_semiz*N_z; %% Use Tan improvement -StationaryDist=zeros(N_a*N_semiz*N_z,N_j,'gpuArray'); +StationaryDist=zeros(N_a*N_semiz*N_z,N_j,'gpuArray'); % StationaryDist cannot be sparse StationaryDist(:,1)=jequaloneDistKron; StationaryDist_jj=sparse(jequaloneDistKron); % use sparse matrix -% Precompute -II2=repelem(gpuArray(1:1:N_a*N_semiz*N_z)',1,N_semiz*N_probs); % Index for this period (a,semiz), note the N_probs-copies +% Precompute; II2 used only for sparse matrix creation...best done on CPU +II2=repelem((1:1:N_a*N_semiz*N_z)',1,N_semiz*N_probs); % Index for this period (a,semiz), note the N_probs-copies for jj=1:(N_j-1) @@ -40,10 +40,9 @@ StationaryDist_jj=reshape(Gammatranspose*StationaryDist_jj,[N_a*N_semiz,N_z]); % Second step of Tan improvement - pi_z=sparse(gather(pi_z_J(:,:,jj))); - StationaryDist_jj=reshape(StationaryDist_jj*pi_z,[N_a*N_bothz,1]); + StationaryDist_jj=reshape(StationaryDist_jj*pi_z_J(:,:,jj),[N_a*N_bothz,1]); - StationaryDist(:,jj+1)=gpuArray(full(StationaryDist_jj)); + StationaryDist(:,jj+1)=StationaryDist_jj; end From d9c767f721cdcf64c5b58936fa60b5fba96ae480 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Thu, 29 Jan 2026 15:05:08 +1300 Subject: [PATCH 40/67] separate out the CPU version --- .../OnCPU/UnKronPolicyIndexes_InfHorz_CPU.m | 4 +- .../InfHorz/CPU/ValueFnIter_InfHorz_CPU.m | 186 ++++++++++++++++++ ValueFnIter/InfHorz/ValueFnIter_Case1.m | 105 ++++------ 3 files changed, 223 insertions(+), 72 deletions(-) create mode 100644 ValueFnIter/InfHorz/CPU/ValueFnIter_InfHorz_CPU.m diff --git a/SubCodes/UnKronPolicyIndexes/OnCPU/UnKronPolicyIndexes_InfHorz_CPU.m b/SubCodes/UnKronPolicyIndexes/OnCPU/UnKronPolicyIndexes_InfHorz_CPU.m index ea3f770e..413b480d 100644 --- a/SubCodes/UnKronPolicyIndexes/OnCPU/UnKronPolicyIndexes_InfHorz_CPU.m +++ b/SubCodes/UnKronPolicyIndexes/OnCPU/UnKronPolicyIndexes_InfHorz_CPU.m @@ -7,6 +7,8 @@ N_a=prod(n_a); N_z=prod(n_z); +l_aprime=length(n_a); + % On CPU if n_d(1)==0 Policy=zeros(l_aprime,N_a,N_z); @@ -26,7 +28,7 @@ optdindexKron=PolicyKron(1,i,j); optaindexKron=PolicyKron(2,i,j); optD=ind2sub_homemade(n_d',optdindexKron); - optA=ind2sub_homemade(n_aprime',optaindexKron); + optA=ind2sub_homemade(n_a',optaindexKron); % n_aprime Policy(:,i,j)=[optD';optA']; end end diff --git a/ValueFnIter/InfHorz/CPU/ValueFnIter_InfHorz_CPU.m b/ValueFnIter/InfHorz/CPU/ValueFnIter_InfHorz_CPU.m new file mode 100644 index 00000000..ae7ded75 --- /dev/null +++ b/ValueFnIter/InfHorz/CPU/ValueFnIter_InfHorz_CPU.m @@ -0,0 +1,186 @@ +function varargout=ValueFnIter_InfHorz_CPU(n_d,n_a,n_z,d_grid,a_grid,z_grid, pi_z, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions) +% Solves infinite-horizon value function problems on the CPU +% Because this is the CPU code, you just get (d,a,z) and nothing that needs vfoptions to be set. +% varargoutput={V,Policy}; + +V=nan; % Matlab was complaining that V was not assigned + +N_d=prod(n_d); +N_a=prod(n_a); +N_z=prod(n_z); + +%% Check the sizes of some of the inputs +if strcmp(vfoptions.solnmethod,'purediscretization') || strcmp(vfoptions.solnmethod,'purediscretization_refinement') || strcmp(vfoptions.solnmethod,'localpolicysearch') + if N_d>0 && ~all(size(d_grid)==[sum(n_d), 1]) + error('d_grid is not the correct shape (should be of size sum(n_d)-by-1)') + elseif ~all(size(a_grid)==[sum(n_a), 1]) + error('a_grid is not the correct shape (should be of size sum(n_a)-by-1)') + + % Check z_grid inputs + elseif isfield(vfoptions,'ExogShockFn') + % okay + elseif N_z>0 + if ~all(size(z_grid)==[sum(n_z), 1]) + if all(size(z_grid)==[prod(n_z),length(n_z)]) + % Using joint grids + else + error('z_grid is not the correct shape (should be of size sum(n_z)-by-1)') + end + elseif ~all(size(pi_z)==[N_z, N_z]) + error('pi is not of size N_z-by-N_z') + end + elseif n_z(end)>1 % Ignores this final check if last dimension of n_z is singleton as will cause an error + if ndims(V0)>2 + if ~all(size(V0)==[n_a,n_z]) % Allow for input to be already transformed into Kronecker form + error('Starting choice for ValueFn is not of size [n_a,n_z]') + end + elseif ~all(size(V0)==[N_a,N_z]) % Allows for possiblity that V0 is already in kronecker form + error('Starting choice for ValueFn is not of size [n_a,n_z]') + end + end +end + +if N_z>0 + if min(min(pi_z))<0 + error('Problem with pi_z in ValueFnIter_Case1: min(min(pi_z))<0 \n') + elseif vfoptions.piz_strictonrowsaddingtoone==1 + if max(sum(pi_z,2))~=1 || min(sum(pi_z,2))~=1 + error('Problem with pi_z in ValueFnIter_Case1: rows do not sum to one \n') + end + elseif vfoptions.piz_strictonrowsaddingtoone==0 + if max(abs((sum(pi_z,2))-1)) > 10^(-13) + error('Problem with pi_z in ValueFnIter_Case1: rows do not sum to one \n') + end + end +end + + +%% Anything but the basics is only for GPU +if vfoptions.experienceasset==1 + error('Cannot use vfoptions.experienceasset=1 without a GPU') +end + + +%% V0 (initial guess) +if isfield(vfoptions,'V0') + V0=reshape(vfoptions.V0,[N_a,N_z]); + vfoptions.actualV0=1; +else + V0=zeros([N_a,N_z]); + vfoptions.actualV0=0; % DC2 has different way of creating inital guess so this will be ignored +end + + +%% Switch to z_gridvals +if vfoptions.alreadygridvals==0 + % only basics allowed with cpu (can have two z variables, but that is as complex as it gets) + z_gridvals=CreateGridvals(n_z,z_grid,1); +elseif vfoptions.alreadygridvals==1 + z_gridvals=z_grid; +end + +%% Implement new way of handling ReturnFn inputs +if isempty(ReturnFnParamNames) + ReturnFnParamNames=ReturnFnParamNamesFn(ReturnFn,n_d,n_a,n_z,0,vfoptions,Parameters); +end +% Basic setup: the first inputs of ReturnFn will be (d,aprime,a,z,..) and everything after this is a parameter, so we get the names of all these parameters. +% But this changes if you have e, semiz, or just multiple d, and if you use riskyasset, expasset, etc. +% So figure out which setup we have, and get the relevant ReturnFnParamNames + + +%% Entry and Exit +if vfoptions.endogenousexit==1 + % ExitPolicy is binary decision to exit (1 is exit, 0 is 'not exit'). + [V, Policy,ExitPolicy]=ValueFnIter_Case1_EndogExit(V0, n_d,n_a,n_z,d_grid,a_grid,z_grid, pi_z, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + varargout={V,Policy,ExitPolicy}; + return +elseif vfoptions.endogenousexit==2 % Mixture of endogenous and exogenous exit. + % ExitPolicy is binary decision to exit (1 is exit, 0 is 'not exit'). + % Policy is for those who remain. + % PolicyWhenExit is current period decisions of those who will exit at end of period. + [V, Policy, PolicyWhenExit, ExitPolicy]=ValueFnIter_Case1_EndogExit2(V0, n_d,n_a,n_z,d_grid,a_grid,z_grid, pi_z, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + varargout={V,Policy, PolicyWhenExit,ExitPolicy}; + return +end + +%% Create a vector containing all the return function parameters (in order) +ReturnFnParamsVec=CreateVectorFromParams(Parameters, ReturnFnParamNames); +DiscountFactorParamsVec=CreateVectorFromParams(Parameters, DiscountFactorParamNames); +DiscountFactorParamsVec=prod(DiscountFactorParamsVec); % Infinite horizon, so just do this once. + +%% +if length(n_d)>1 + d_gridvals=CreateGridvals(n_d,d_grid,1); +else + d_gridvals=d_grid; +end + +%% On CPU, pure-discretization is the only solution algorithm +if strcmp(vfoptions.solnmethod,'purediscretization') + + N_d=prod(n_d); + + if vfoptions.lowmemory==0 + + %% CreateReturnFnMatrix_Case1_Disc creates a matrix of dimension (d and aprime)-by-a-by-z. + % Since the return function is independent of time creating it once and + % then using it every iteration is good for speed, but it does use a lot of memory. + + if vfoptions.verbose==1 + disp('Creating return fn matrix') + end + + ReturnMatrix=CreateReturnFnMatrix_Case1_Disc(ReturnFn, n_d, n_a, n_z, d_gridvals, a_grid, z_gridvals, ReturnFnParamsVec); + + if vfoptions.verbose==1 + fprintf('Starting Value Function \n') + end + + if N_d==0 + if vfoptions.parallel==0 % On CPU + [VKron,Policy]=ValueFnIter_nod_Par0_raw(V0, N_a, N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); + elseif vfoptions.parallel==1 % On Parallel CPU + [VKron,Policy]=ValueFnIter_nod_Par1_raw(V0, N_a, N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); + end + else + if vfoptions.parallel==0 % On CPU + [VKron, Policy]=ValueFnIter_Par0_raw(V0, N_d,N_a,N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix,vfoptions.howards, vfoptions.maxhowards,vfoptions.tolerance, vfoptions.maxiter); + elseif vfoptions.parallel==1 % On Parallel CPU + [VKron, Policy]=ValueFnIter_Par1_raw(V0, N_d,N_a,N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix,vfoptions.howards, vfoptions.maxhowards,vfoptions.tolerance, vfoptions.maxiter); + end + end + + elseif vfoptions.lowmemory==1 + error('Can only use lowmemory on GPU') + end +end + +%% +if vfoptions.verbose==1 + disp('Transforming Value Fn and Optimal Policy matrices back out of Kronecker Form') + tic; +end + + +%% Cleaning up the output +if vfoptions.outputkron==0 + V=reshape(VKron,[n_a,n_z]); + Policy=UnKronPolicyIndexes_InfHorz_CPU(Policy, n_d, n_a, n_z); +else + Policy=reshape(Policy,[1,N_a,N_z]); + varargout={VKron,Policy}; + return +end + +% Sometimes numerical rounding errors (of the order of 10^(-16) can mean +% that Policy is not integer valued. The following corrects this by converting to int64 and then +% makes the output back into double as Matlab otherwise cannot use it in +% any arithmetical expressions. +if vfoptions.policy_forceintegertype==1 + Policy=uint64(Policy); + Policy=double(Policy); +end + +varargout={V,Policy}; + +end diff --git a/ValueFnIter/InfHorz/ValueFnIter_Case1.m b/ValueFnIter/InfHorz/ValueFnIter_Case1.m index 2e828a16..1838cea0 100644 --- a/ValueFnIter/InfHorz/ValueFnIter_Case1.m +++ b/ValueFnIter/InfHorz/ValueFnIter_Case1.m @@ -163,6 +163,12 @@ vfoptions end +%% If using CPU, then go off to dedicated function +if vfoptions.parallel<2 + [V,Policy]=ValueFnIter_InfHorz_CPU(n_d,n_a,n_z,d_grid,a_grid,z_grid, pi_z, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + varargout={V,Policy}; + return +end %% Check the sizes of some of the inputs if strcmp(vfoptions.solnmethod,'purediscretization') || strcmp(vfoptions.solnmethod,'purediscretization_refinement') || strcmp(vfoptions.solnmethod,'localpolicysearch') @@ -220,46 +226,25 @@ end end -%% Anything but the basics is only for GPU -if vfoptions.parallel~=2 - if vfoptions.experienceasset==1 - error('Cannot use vfoptions.experienceasset=1 without a GPU') - end -else - % If using GPU make sure all the relevant inputs are GPU arrays (not standard arrays) - pi_z=gpuArray(pi_z); - d_grid=gpuArray(d_grid); - a_grid=gpuArray(a_grid); - z_grid=gpuArray(z_grid); -end - +%% Make sure all the relevant inputs are GPU arrays (not standard arrays) +pi_z=gpuArray(pi_z); +d_grid=gpuArray(d_grid); +a_grid=gpuArray(a_grid); +z_grid=gpuArray(z_grid); %% V0 (initial guess) if isfield(vfoptions,'V0') - if vfoptions.parallel==2 - V0=reshape(gpuArray(vfoptions.V0),[N_a,N_z]); - else - V0=reshape(vfoptions.V0,[N_a,N_z]); - end + V0=reshape(gpuArray(vfoptions.V0),[N_a,N_z]); vfoptions.actualV0=1; else - if vfoptions.parallel==2 - V0=zeros([N_a,N_z], 'gpuArray'); - else - V0=zeros([N_a,N_z]); - end + V0=zeros([N_a,N_z], 'gpuArray'); vfoptions.actualV0=0; % DC2 has different way of creating inital guess so this will be ignored end %% Switch to z_gridvals if vfoptions.alreadygridvals==0 - if vfoptions.parallel<2 - % only basics allowed with cpu (can have two z variables, but that is as complex as it gets) - z_gridvals=CreateGridvals(n_z,z_grid,1); - else - [z_gridvals, pi_z, vfoptions]=ExogShockSetup(n_z,z_grid,pi_z,Parameters,vfoptions,3); - end + [z_gridvals, pi_z, vfoptions]=ExogShockSetup(n_z,z_grid,pi_z,Parameters,vfoptions,3); elseif vfoptions.alreadygridvals==1 z_gridvals=z_grid; end @@ -321,9 +306,7 @@ end end DiscountFactorParamsMatrix=DiscountFactorParamsMatrix.*ones(N_z,N_z,'gpuArray'); % Make it of size z-by-zprime, so that I can later just assume that it takes this shape - if vfoptions.parallel==2 - DiscountFactorParamsMatrix=gpuArray(DiscountFactorParamsMatrix); - end + DiscountFactorParamsMatrix=gpuArray(DiscountFactorParamsMatrix); % Set the 'fake discount factor to one. DiscountFactorParamsVec=1; % Set pi_z to include the state-dependent discount factors @@ -500,14 +483,10 @@ disp('Creating return fn matrix') end - if vfoptions.parallel==2 % GPU - if N_d==0 - ReturnMatrix=CreateReturnFnMatrix_Case1_Disc_nod_Par2(ReturnFn, n_a, n_z, a_grid, z_gridvals, ReturnFnParamsVec); - else - ReturnMatrix=CreateReturnFnMatrix_Case1_Disc_Par2(ReturnFn, n_d, n_a, n_z, d_gridvals, a_grid, z_gridvals, ReturnFnParamsVec,0); - end - elseif vfoptions.parallel<2 - ReturnMatrix=CreateReturnFnMatrix_Case1_Disc(ReturnFn, n_d, n_a, n_z, d_gridvals, a_grid, z_gridvals, ReturnFnParamsVec); + if N_d==0 + ReturnMatrix=CreateReturnFnMatrix_Case1_Disc_nod_Par2(ReturnFn, n_a, n_z, a_grid, z_gridvals, ReturnFnParamsVec); + else + ReturnMatrix=CreateReturnFnMatrix_Case1_Disc_Par2(ReturnFn, n_d, n_a, n_z, d_gridvals, a_grid, z_gridvals, ReturnFnParamsVec,0); end if vfoptions.verbose==1 @@ -515,30 +494,18 @@ end if N_d==0 - if vfoptions.parallel==0 % On CPU - [VKron,Policy]=ValueFnIter_nod_Par0_raw(V0, N_a, N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); - elseif vfoptions.parallel==1 % On Parallel CPU - [VKron,Policy]=ValueFnIter_nod_Par1_raw(V0, N_a, N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); - elseif vfoptions.parallel==2 % On GPU - if vfoptions.howardsgreedy==1 - [VKron,Policy]=ValueFnIter_nod_HowardGreedy_raw(V0, N_a, N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); - elseif vfoptions.howardsgreedy==0 - if vfoptions.howardssparse==0 - [VKron,Policy]=ValueFnIter_nod_raw(V0, N_a, N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); - elseif vfoptions.howardssparse==1 - [VKron,Policy]=ValueFnIter_sparse_nod_raw(V0, N_a, N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); - end + if vfoptions.howardsgreedy==1 + [VKron,Policy]=ValueFnIter_nod_HowardGreedy_raw(V0, N_a, N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); + elseif vfoptions.howardsgreedy==0 + if vfoptions.howardssparse==0 + [VKron,Policy]=ValueFnIter_nod_raw(V0, N_a, N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); + elseif vfoptions.howardssparse==1 + [VKron,Policy]=ValueFnIter_sparse_nod_raw(V0, N_a, N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); end end else - if vfoptions.parallel==0 % On CPU - [VKron, Policy]=ValueFnIter_Par0_raw(V0, N_d,N_a,N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix,vfoptions.howards, vfoptions.maxhowards,vfoptions.tolerance, vfoptions.maxiter); - elseif vfoptions.parallel==1 % On Parallel CPU - [VKron, Policy]=ValueFnIter_Par1_raw(V0, N_d,N_a,N_z, pi_z, DiscountFactorParamsVec, ReturnMatrix,vfoptions.howards, vfoptions.maxhowards,vfoptions.tolerance, vfoptions.maxiter); - elseif vfoptions.parallel==2 % On GPU - % Can't be bothered implementing HowardGreedy here, as for good runtimes you should anyway be doing Refine so wouldn't get here - [VKron, Policy]=ValueFnIter_raw(V0, n_d,n_a,n_z, pi_z, DiscountFactorParamsVec, ReturnMatrix,vfoptions.howards, vfoptions.maxhowards,vfoptions.tolerance, vfoptions.maxiter); - end + % Can't be bothered implementing HowardGreedy here, as for good runtimes you should anyway be doing Refine so wouldn't get here + [VKron, Policy]=ValueFnIter_raw(V0, n_d,n_a,n_z, pi_z, DiscountFactorParamsVec, ReturnMatrix,vfoptions.howards, vfoptions.maxhowards,vfoptions.tolerance, vfoptions.maxiter); end elseif vfoptions.lowmemory==1 @@ -547,18 +514,14 @@ disp('Starting Value Function') end - if vfoptions.parallel==2 % On GPU - if N_d==0 - if vfoptions.howardssparse==0 - [VKron,Policy]=ValueFnIter_LowMem_nod_raw(V0, n_a, n_z, a_grid, z_gridvals, pi_z, DiscountFactorParamsVec, ReturnFn, ReturnFnParamsVec, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); - elseif vfoptions.howardssparse==1 - [VKron,Policy]=ValueFnIter_LowMem_sparse_nod_raw(V0, n_a, n_z, a_grid, z_gridvals, pi_z, DiscountFactorParamsVec, ReturnFn, ReturnFnParamsVec, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); - end - else - [VKron, Policy]=ValueFnIter_LowMem_raw(V0, n_d,n_a,n_z, d_gridvals, a_grid, z_gridvals, pi_z, DiscountFactorParamsVec, ReturnFn, ReturnFnParamsVec,vfoptions.howards, vfoptions.maxhowards,vfoptions.tolerance, vfoptions.maxiter); + if N_d==0 + if vfoptions.howardssparse==0 + [VKron,Policy]=ValueFnIter_LowMem_nod_raw(V0, n_a, n_z, a_grid, z_gridvals, pi_z, DiscountFactorParamsVec, ReturnFn, ReturnFnParamsVec, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); + elseif vfoptions.howardssparse==1 + [VKron,Policy]=ValueFnIter_LowMem_sparse_nod_raw(V0, n_a, n_z, a_grid, z_gridvals, pi_z, DiscountFactorParamsVec, ReturnFn, ReturnFnParamsVec, vfoptions.howards, vfoptions.maxhowards, vfoptions.tolerance, vfoptions.maxiter); end else - error('can only use lowmemory on gpu') + [VKron, Policy]=ValueFnIter_LowMem_raw(V0, n_d,n_a,n_z, d_gridvals, a_grid, z_gridvals, pi_z, DiscountFactorParamsVec, ReturnFn, ReturnFnParamsVec,vfoptions.howards, vfoptions.maxhowards,vfoptions.tolerance, vfoptions.maxiter); end end end From 9294e5c600847707ba19d27ca930205747ae61c4 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Sat, 31 Jan 2026 13:26:29 +1300 Subject: [PATCH 41/67] fix --- .../AgentDist_InfHorz_TPath_SingleStep.m | 2 +- .../ValueFnIter_GridInterpLayer.m | 19 ++++++++++++++++++- 2 files changed, 19 insertions(+), 2 deletions(-) diff --git a/TransitionPaths/InfHorz/subcodes/AgentDistSingleStep/AgentDist_InfHorz_TPath_SingleStep.m b/TransitionPaths/InfHorz/subcodes/AgentDistSingleStep/AgentDist_InfHorz_TPath_SingleStep.m index 39f26779..17809915 100644 --- a/TransitionPaths/InfHorz/subcodes/AgentDistSingleStep/AgentDist_InfHorz_TPath_SingleStep.m +++ b/TransitionPaths/InfHorz/subcodes/AgentDistSingleStep/AgentDist_InfHorz_TPath_SingleStep.m @@ -11,7 +11,7 @@ Gammatranspose=sparse(gather(Policy_aprimez),II1,IIones,N_a*N_z,N_a*N_z); % Two steps of the Tan improvement -AgentDist=reshape(Gammatranspose*AgentDist,[N_a,N_z]); %No point checking distance every single iteration. Do 100, then check. +AgentDist=reshape(Gammatranspose*AgentDist,[N_a,N_z]); AgentDist=reshape(AgentDist*pi_z_sparse,[N_a*N_z,1]); end diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_GridInterpLayer.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_GridInterpLayer.m index b8abc787..81ea7e89 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_GridInterpLayer.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_GridInterpLayer.m @@ -185,8 +185,25 @@ end - %% Reshape +% Grid interp with 2 endo states leaves them separate, so first we have to +% put them together before we can pass it to UnKronPolicyIndexes [nowadays +% with divide-and-conquer and grid interpolation layer, this is common, so +% maybe I should modify UnKronPolicyIndexes to just permit this as an +% alternative case] +if ~isscalar(n_a) + if N_d==0 + Policy(1,:,:)=Policy(1,:,:)+n_a(1)*(Policy(2,:,:)-1); % aprime (both) + Policy(2,:,:)=Policy(3,:,:); % L2index + Policy=Policy(1:2,:,:); + else + % Policy(1,:,:)=Policy(1,:,:); % d + Policy(2,:,:)=Policy(2,:,:)+n_a(1)*(Policy(3,:,:)-1); % aprime (both) + Policy(3,:,:)=Policy(4,:,:); % L2index + Policy=Policy(1:3,:,:); + end +end + V=reshape(V,[n_a,n_z]); Policy=UnKronPolicyIndexes_Case1(Policy,n_d,n_a,n_z,vfoptions); From d9a445e908e28b881f6cbf1f424ddc6267407a11 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Mon, 2 Feb 2026 10:00:10 +1300 Subject: [PATCH 42/67] verboseaccuracy --- .../HeteroAgentStationaryEqm_Case1_FHorz.m | 57 ++++++++++------ ...teroAgentStationaryEqm_Case1_FHorz_subfn.m | 10 +-- ...HeteroAgentStationaryEqm_FHorz_CPU_subfn.m | 8 +-- ...teroAgentStationaryEqm_Case1_FHorz_PType.m | 65 +++++++++++-------- ...onaryEqm_Case1_FHorz_PType_GEptype_subfn.m | 14 ++-- ...entStationaryEqm_Case1_FHorz_PType_subfn.m | 10 +-- .../InfHorz/HeteroAgentStationaryEqm_Case1.m | 59 ++++++++++------- .../HeteroAgentStationaryEqm_Case1_subfn.m | 10 +-- .../HeteroAgentStationaryEqm_Case1_PType.m | 61 ++++++++++------- ...teroAgentStationaryEqm_Case1_PType_subfn.m | 10 +-- 10 files changed, 176 insertions(+), 128 deletions(-) diff --git a/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m b/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m index b1ebae79..ae8cbcf0 100644 --- a/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m +++ b/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m @@ -40,51 +40,50 @@ end if ~exist('heteroagentoptions','var') - heteroagentoptions.multiGEcriterion=1; - heteroagentoptions.multiGEweights=ones(1,length(fieldnames(GeneralEqmEqns))); + heteroagentoptions.fminalgo=1; % =1 use fminsearch. Main alternatives: =4 is shooting (you set update rules), =5 is CMA-ES (robust but slow), =8 is lsqnonlin() fast but requires Matlab Optimization Toolbox (and often not quite high accuracy of results) + heteroagentoptions.multiGEcriterion=1; % How to combine multiple GE condns (default is sum-of-squares) + heteroagentoptions.multiGEweights=ones(1,length(fieldnames(GeneralEqmEqns))); % Weights on GECondns, when being combined heteroagentoptions.toleranceGEprices=10^(-4); % Accuracy of general eqm prices heteroagentoptions.toleranceGEcondns=10^(-4); % Accuracy of general eqm eqns - heteroagentoptions.fminalgo=1; % use fminsearch - heteroagentoptions.verbose=0; - heteroagentoptions.maxiter=1000; % =0 just evaluate (rather than solves for) GE condns - heteroagentoptions.pricehistory=0; % =1, saves the history of the GEPrices during the convergence + heteroagentoptions.maxiter=1000; % maximum iterations of optimization routine % Constrain parameters heteroagentoptions.constrainpositive={}; % names of parameters to constrained to be positive (gets converted to binary-valued vector below) heteroagentoptions.constrain0to1={}; % names of parameters to constrained to be positive (gets converted to binary-valued vector below) heteroagentoptions.constrainAtoB={}; % names of parameters to constrained to be positive (gets converted to binary-valued vector below) - % heteroagentoptions.outputGEform=0; % For internal use only + % Verbose settings (feedback) + heteroagentoptions.verbose=0; % =1, give feedback + heteroagentoptions.verboseaccuracy1=4; % number of decimal places for GEPrices (among others) + heteroagentoptions.verboseaccuracy2=6; % number of decimal places for GECondns + heteroagentoptions.pricehistory=0; % =1, saves the history of the GEPrices during the convergence + % For internal use only + % heteroagentoptions.outputGEform=0; heteroagentoptions.outputGEstruct=1; % output GE conditions as a structure (=2 will output as a vector) heteroagentoptions.outputgather=1; % output GE conditions on CPU [some optimization routines only work on CPU, some can handle GPU] else + if ~isfield(heteroagentoptions,'fminalgo') + heteroagentoptions.fminalgo=1; % use fminsearch + end if ~isfield(heteroagentoptions,'multiGEcriterion') heteroagentoptions.multiGEcriterion=1; end if ~isfield(heteroagentoptions,'multiGEweights') heteroagentoptions.multiGEweights=ones(1,length(fieldnames(GeneralEqmEqns))); end - if N_p~=0 - if ~isfield(heteroagentoptions,'p_grid') - error('You have set n_p to a non-zero value, but not declared heteroagentoptions.p_grid') - end - end if ~isfield(heteroagentoptions,'toleranceGEprices') heteroagentoptions.toleranceGEprices=10^(-4); % Accuracy of general eqm prices end if ~isfield(heteroagentoptions,'toleranceGEcondns') heteroagentoptions.toleranceGEcondns=10^(-4); % Accuracy of general eqm prices end - if ~isfield(heteroagentoptions,'verbose') - heteroagentoptions.verbose=0; - end - if ~isfield(heteroagentoptions,'fminalgo') - heteroagentoptions.fminalgo=1; % use fminsearch - end if ~isfield(heteroagentoptions,'maxiter') heteroagentoptions.maxiter=1000; % use fminsearch end - if ~isfield(heteroagentoptions,'pricehistory') - heteroagentoptions.pricehistory=0; % =1, saves the history of the GEPrices during the convergence + if N_p~=0 + if ~isfield(heteroagentoptions,'p_grid') + error('You have set n_p to a non-zero value, but not declared heteroagentoptions.p_grid') + end end + % Constrain parameters if ~isfield(heteroagentoptions,'constrainpositive') heteroagentoptions.constrainpositive={}; % names of parameters to constrained to be positive (gets converted to binary-valued vector below) % Convert constrained positive p into x=log(p) which is unconstrained. @@ -104,7 +103,21 @@ error('You have used heteroagentoptions.constrainAtoB, but are missing heteroagentoptions.constrainAtoBlimits') end end - % heteroagentoptions.outputGEform=0; % For internal use only + % Verbose settings (feedback) + if ~isfield(heteroagentoptions,'verbose') + heteroagentoptions.verbose=0; + end + if ~isfield(heteroagentoptions,'verboseaccuracy1') + heteroagentoptions.verboseaccuracy1=4; % number of decimal places for GEPrices (among others) + end + if ~isfield(heteroagentoptions,'verboseaccuracy2') + heteroagentoptions.verboseaccuracy2=6; % number of decimal places for GECondns + end + if ~isfield(heteroagentoptions,'pricehistory') + heteroagentoptions.pricehistory=0; % =1, saves the history of the GEPrices during the convergence + end + % For internal use only + % heteroagentoptions.outputGEform=0; if ~isfield(heteroagentoptions,'outputGEstruct') heteroagentoptions.outputGEstruct=1; % output GE conditions as a structure (=2 will output as a vector) end @@ -137,6 +150,8 @@ error('length(heteroagentoptions.multiGEweights)~=length(fieldnames(GeneralEqmEqns)) (the length of the GE weights is not equal to the number of general eqm equations') end +heteroagentoptions.verboseaccuracy1=[' %s: %8.',num2str(heteroagentoptions.verboseaccuracy1),'f \n']; % set up a string +heteroagentoptions.verboseaccuracy2=[' %s: %8.',num2str(heteroagentoptions.verboseaccuracy2),'f \n']; % set up a string nGEprices=length(GEPriceParamNames); GEeqnNames=fieldnames(GeneralEqmEqns); diff --git a/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz_subfn.m b/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz_subfn.m index 2718e07f..1f7162c8 100644 --- a/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz_subfn.m +++ b/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz_subfn.m @@ -91,27 +91,27 @@ fprintf(' \n') fprintf('Current GE prices: \n') for pp=1:nGEprices - fprintf(' %s: %8.4f \n',GEPriceParamNames{pp},GEpricesvec(pp)) + fprintf(heteroagentoptions.verboseaccuracy1,GEPriceParamNames{pp},GEpricesvec(pp)) end fprintf('Current aggregate variables: \n') for aa=1:length(AggVarNames) - fprintf(' %s: %8.4f \n',AggVarNames{aa},AggVars(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix + fprintf(heteroagentoptions.verboseaccuracy1,AggVarNames{aa},AggVars(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix end if isfield(heteroagentoptions,'intermediateEqns') fprintf('Current intermediateEqn variables: \n') for aa=1:length(intEqnnames) - fprintf(' %s: %8.4f \n',intEqnnames{aa},intermediateEqnsVec(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix + fprintf(heteroagentoptions.verboseaccuracy1,intEqnnames{aa},intermediateEqnsVec(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix end end if heteroagentoptions.useCustomModelStats==1 fprintf('Current CustomModelStats variables: \n') for ii=1:length(customstatnames) - fprintf(' %s: %8.4f \n',customstatnames{ii},CustomStats.(customstatnames{ii})) + fprintf(heteroagentoptions.verboseaccuracy1,customstatnames{ii},CustomStats.(customstatnames{ii})) end end fprintf('Current GeneralEqmEqns: \n') for gg=1:length(GEeqnNames) - fprintf(' %s: %8.6f \n',GEeqnNames{gg},GeneralEqmConditionsVec(gg)) + fprintf(heteroagentoptions.verboseaccuracy2,GEeqnNames{gg},GeneralEqmConditionsVec(gg)) end end diff --git a/HeterogeneousAgent/FHorz/OnCPU/HeteroAgentStationaryEqm_FHorz_CPU_subfn.m b/HeterogeneousAgent/FHorz/OnCPU/HeteroAgentStationaryEqm_FHorz_CPU_subfn.m index ce117bd6..dacf1a6f 100644 --- a/HeterogeneousAgent/FHorz/OnCPU/HeteroAgentStationaryEqm_FHorz_CPU_subfn.m +++ b/HeterogeneousAgent/FHorz/OnCPU/HeteroAgentStationaryEqm_FHorz_CPU_subfn.m @@ -61,21 +61,21 @@ fprintf(' \n') fprintf('Current GE prices: \n') for pp=1:nGEprices - fprintf(' %s: %8.4f \n',GEPriceParamNames{pp},GEpricesvec(pp)) + fprintf(heteroagentoptions.verboseaccuracy1,GEPriceParamNames{pp},GEpricesvec(pp)) end fprintf('Current aggregate variables: \n') for aa=1:length(AggVarNames) - fprintf(' %s: %8.4f \n',AggVarNames{aa},AggVars(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix + fprintf(heteroagentoptions.verboseaccuracy1,AggVarNames{aa},AggVars(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix end if isfield(heteroagentoptions,'intermediateEqns') fprintf('Current intermediateEqn variables: \n') for aa=1:length(intEqnnames) - fprintf(' %s: %8.4f \n',intEqnnames{aa},intermediateEqnsVec(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix + fprintf(heteroagentoptions.verboseaccuracy1,intEqnnames{aa},intermediateEqnsVec(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix end end fprintf('Current GeneralEqmEqns: \n') for gg=1:length(GEeqnNames) - fprintf(' %s: %8.6f \n',GEeqnNames{gg},GeneralEqmConditionsVec(gg)) + fprintf(heteroagentoptions.verboseaccuracy2,GEeqnNames{gg},GeneralEqmConditionsVec(gg)) end end diff --git a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m index 51a4ceca..64b91a4f 100644 --- a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m +++ b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m @@ -66,56 +66,50 @@ end if exist('heteroagentoptions','var')==0 - heteroagentoptions.multiGEcriterion=1; - heteroagentoptions.multiGEweights=ones(1,length(fieldnames(GeneralEqmEqns))); + heteroagentoptions.fminalgo=1; % =1 use fminsearch. Main alternatives: =4 is shooting (you set update rules), =5 is CMA-ES (robust but slow), =8 is lsqnonlin() fast but requires Matlab Optimization Toolbox (and often not quite high accuracy of results) + heteroagentoptions.multiGEcriterion=1; % How to combine multiple GE condns (default is sum-of-squares) + heteroagentoptions.multiGEweights=ones(1,length(fieldnames(GeneralEqmEqns))); % Weights on GECondns, when being combined heteroagentoptions.toleranceGEprices=10^(-4); % Accuracy of general eqm prices heteroagentoptions.toleranceGEcondns=10^(-4); % Accuracy of general eqm eqns - heteroagentoptions.fminalgo=1; % use fminsearch - heteroagentoptions.verbose=0; - heteroagentoptions.parallel=1+(gpuDeviceCount>0); % GPU where available, otherwise parallel CPU. - heteroagentoptions.maxiter=200*length(GEPriceParamNames); % =0 just evaluate (rather than solves for) GE condns - heteroagentoptions.pricehistory=0; % =1, saves the history of the GEPrices during the convergence + heteroagentoptions.maxiter=1000; % maximum iterations of optimization routine heteroagentoptions.GEptype={}; % zeros(1,length(fieldnames(GeneralEqmEqns))); % 1 indicates that this general eqm condition is 'conditional on permanent type' [input should be a cell of names; it gets reformatted internally to be this form] % heteroagentoptions.GEusenames=0; % =1, can use '_name' for Params and AggVars in the general eqm eqns % Constrain parameters heteroagentoptions.constrainpositive={}; % names of parameters to constrained to be positive (gets converted to binary-valued vector below) heteroagentoptions.constrain0to1={}; % names of parameters to constrained to be positive (gets converted to binary-valued vector below) heteroagentoptions.constrainAtoB={}; % names of parameters to constrained to be positive (gets converted to binary-valued vector below) - % heteroagentoptions.outputGEform=0; % For internal use only + % Verbose settings (feedback) + heteroagentoptions.verbose=0; % =1, give feedback + heteroagentoptions.verboseaccuracy1=4; % number of decimal places for GEPrices (among others) + heteroagentoptions.verboseaccuracy2=6; % number of decimal places for GECondns + heteroagentoptions.pricehistory=0; % =1, saves the history of the GEPrices during the convergence + % For internal use only + % heteroagentoptions.outputGEform=0; heteroagentoptions.outputGEstruct=1; % output GE conditions as a structure (=2 will output as a vector) heteroagentoptions.outputgather=1; % output GE conditions on CPU [some optimization routines only work on CPU, some can handle GPU] else + if ~isfield(heteroagentoptions,'fminalgo') + heteroagentoptions.fminalgo=1; % use fminsearch + end if ~isfield(heteroagentoptions,'multiGEcriterion') heteroagentoptions.multiGEcriterion=1; end if ~isfield(heteroagentoptions,'multiGEweights') heteroagentoptions.multiGEweights=ones(1,length(fieldnames(GeneralEqmEqns))); end - if ~isfield(heteroagentoptions,'maxiter') - heteroagentoptions.maxiter=200*length(GEPriceParamNames); % =0 just evaluate (rather than solves for) GE condns - end - if N_p~=0 - if ~isfield(heteroagentoptions,'p_grid') - error('You have set n_p to a non-zero value, but not declared heteroagentoptions.p_grid') - end - end if ~isfield(heteroagentoptions,'toleranceGEprices') heteroagentoptions.toleranceGEprices=10^(-4); % Accuracy of general eqm prices end if ~isfield(heteroagentoptions,'toleranceGEcondns') heteroagentoptions.toleranceGEcondns=10^(-4); % Accuracy of general eqm prices end - if ~isfield(heteroagentoptions,'fminalgo') - heteroagentoptions.fminalgo=1; % use fminsearch - end - if ~isfield(heteroagentoptions,'verbose') - heteroagentoptions.verbose=0; - end - if ~isfield(heteroagentoptions,'parallel') - heteroagentoptions.parallel=1+(gpuDeviceCount>0); % GPU where available, otherwise parallel CPU. + if ~isfield(heteroagentoptions,'maxiter') + heteroagentoptions.maxiter=200*length(GEPriceParamNames); % =0 just evaluate (rather than solves for) GE condns end - if ~isfield(heteroagentoptions,'pricehistory') - heteroagentoptions.pricehistory=0; % =1, saves the history of the GEPrices during the convergence + if N_p~=0 + if ~isfield(heteroagentoptions,'p_grid') + error('You have set n_p to a non-zero value, but not declared heteroagentoptions.p_grid') + end end if ~isfield(heteroagentoptions,'GEptype') heteroagentoptions.GEptype={}; % zeros(1,length(fieldnames(GeneralEqmEqns))); % 1 indicates that this general eqm condition is 'conditional on permanent type' [input should be a cell of names; it gets reformatted internally to be this form] @@ -143,7 +137,21 @@ error('You have used heteroagentoptions.constrainAtoB, but are missing heteroagentoptions.constrainAtoBlimits') end end - % heteroagentoptions.outputGEform=0; % For internal use only + % Verbose settings (feedback) + if ~isfield(heteroagentoptions,'verbose') + heteroagentoptions.verbose=0; + end + if ~isfield(heteroagentoptions,'verboseaccuracy1') + heteroagentoptions.verboseaccuracy1=4; % number of decimal places for GEPrices (among others) + end + if ~isfield(heteroagentoptions,'verboseaccuracy2') + heteroagentoptions.verboseaccuracy2=6; % number of decimal places for GECondns + end + if ~isfield(heteroagentoptions,'pricehistory') + heteroagentoptions.pricehistory=0; % =1, saves the history of the GEPrices during the convergence + end + % For internal use only + % heteroagentoptions.outputGEform=0; if ~isfield(heteroagentoptions,'outputGEstruct') heteroagentoptions.outputGEstruct=1; % output GE conditions as a structure (=2 will output as a vector) end @@ -176,6 +184,9 @@ error('length(heteroagentoptions.multiGEweights)~=length(fieldnames(GeneralEqmEqns)) (the length of the GE weights is not equal to the number of general eqm equations') end +heteroagentoptions.verboseaccuracy1=[' %s: %8.',num2str(heteroagentoptions.verboseaccuracy1),'f \n']; % set up a string +heteroagentoptions.verboseaccuracy2=[' %s: %8.',num2str(heteroagentoptions.verboseaccuracy2),'f \n']; % set up a string + AggVarNames=fieldnames(FnsToEvaluate); nGEprices=length(GEPriceParamNames); diff --git a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_GEptype_subfn.m b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_GEptype_subfn.m index 694abebd..c56b14c7 100644 --- a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_GEptype_subfn.m +++ b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_GEptype_subfn.m @@ -173,16 +173,16 @@ fprintf(' \n') fprintf('Current GE prices: \n') for ii=1:nGEprices - fprintf(' %s: %8.4f \n',GEPriceParamNames{ii},GEpricesvec(ii)) + fprintf(heteroagentoptions.verboseaccuracy1,GEPriceParamNames{ii},GEpricesvec(ii)) end fprintf('Current aggregate variables: \n') for ii=1:length(AggVarNames) - fprintf(' %s: %8.4f \n',AggVarNames{ii},Parameters.(AggVarNames{ii})) % Note, this is done differently here because AggVars itself has been set as a matrix + fprintf(heteroagentoptions.verboseaccuracy1,AggVarNames{ii},Parameters.(AggVarNames{ii})) % Note, this is done differently here because AggVars itself has been set as a matrix end fprintf('Current GeneralEqmEqns: \n') GeneralEqmEqnsNames=fieldnames(GeneralEqmEqns); for ii=1:length(GeneralEqmEqnsNames) - fprintf(' %s: %8.4f \n',GeneralEqmEqnsNames{ii},GeneralEqmConditionsVec(ii)) + fprintf(heteroagentoptions.verboseaccuracy2,GeneralEqmEqnsNames{ii},GeneralEqmConditionsVec(ii)) end else numberstr=repmat(' %8.4f',1,PTypeStructure.N_i); @@ -193,12 +193,12 @@ if GEprice_ptype(pp)==1 fprintf([' %s:',numberstr,' \n'],GEPriceParamNames{pp},GEpricesvec(GEpriceindexes(pp,1):GEpriceindexes(pp,2))) else - fprintf([' %s: %8.4f \n'],GEPriceParamNames{pp},GEpricesvec(GEpriceindexes(pp,1):GEpriceindexes(pp,2))) + fprintf(heteroagentoptions.verboseaccuracy1,GEPriceParamNames{pp},GEpricesvec(GEpriceindexes(pp,1):GEpriceindexes(pp,2))) end end fprintf('Current aggregate variables: \n') for aa=1:length(AggVarNames) - fprintf(' %s: %8.4f \n',AggVarNames{aa},AggVars(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix + fprintf(heteroagentoptions.verboseaccuracy1,AggVarNames{aa},AggVars(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix end fprintf('Current aggregate variables, conditional on ptype: \n') for aa=1:length(AggVarNames) @@ -212,7 +212,7 @@ if heteroagentoptions.intermediateEqnsptype(gg)==1 fprintf([' %s:',numberstr,' \n'],intEqnnames{gg},intermediateEqnsVec(ggindex(gg,1):ggindex(gg,2))) else - fprintf(' %s: %8.4f \n',intEqnnames{gg},intermediateEqnsVec(ggindex(gg,1):ggindex(gg,2))) + fprintf(heteroagentoptions.verboseaccuracy1,intEqnnames{gg},intermediateEqnsVec(ggindex(gg,1):ggindex(gg,2))) end end end @@ -224,7 +224,7 @@ if heteroagentoptions.GEptype(gg)==1 fprintf([' %s:',numberstr,' \n'],GeneralEqmEqnsNames{gg},GeneralEqmConditionsVec(ggindex(gg,1):ggindex(gg,2))) else - fprintf(' %s: %8.6f \n',GeneralEqmEqnsNames{gg},GeneralEqmConditionsVec(ggindex(gg,1):ggindex(gg,2))) + fprintf(heteroagentoptions.verboseaccuracy2,GeneralEqmEqnsNames{gg},GeneralEqmConditionsVec(ggindex(gg,1):ggindex(gg,2))) end end end diff --git a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_subfn.m b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_subfn.m index 0545da68..f91a9c51 100644 --- a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_subfn.m +++ b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_subfn.m @@ -130,27 +130,27 @@ fprintf(' \n') fprintf('Current GE prices: \n') for pp=1:nGEprices - fprintf(' %s: %8.4f \n',GEPriceParamNames{pp},GEpricesvec(pp)) + fprintf(heteroagentoptions.verboseaccuracy1,GEPriceParamNames{pp},GEpricesvec(pp)) end fprintf('Current aggregate variables: \n') for aa=1:length(AggVarNames) - fprintf(' %s: %8.4f \n',AggVarNames{aa},AggVars(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix + fprintf(heteroagentoptions.verboseaccuracy1,AggVarNames{aa},AggVars(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix end if heteroagentoptions.useintermediateEqns==1 fprintf('Current intermediateEqn variables: \n') for aa=1:length(intEqnnames) - fprintf(' %s: %8.4f \n',intEqnnames{aa},intermediateEqnsVec(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix + fprintf(heteroagentoptions.verboseaccuracy1,intEqnnames{aa},intermediateEqnsVec(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix end end if heteroagentoptions.useCustomModelStats==1 fprintf('Current CustomModelStats variables: \n') for ii=1:length(customstatnames) - fprintf(' %s: %8.4f \n',customstatnames{ii},CustomStats.(customstatnames{ii})) + fprintf(heteroagentoptions.verboseaccuracy1,customstatnames{ii},CustomStats.(customstatnames{ii})) end end fprintf('Current GeneralEqmEqns: \n') for gg=1:length(GEeqnNames) - fprintf(' %s: %8.6f \n',GEeqnNames{gg},GeneralEqmConditionsVec(gg)) + fprintf(heteroagentoptions.verboseaccuracy2,GEeqnNames{gg},GeneralEqmConditionsVec(gg)) end end diff --git a/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1.m b/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1.m index fb90b94d..2dae0194 100644 --- a/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1.m +++ b/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1.m @@ -76,54 +76,48 @@ end if exist('heteroagentoptions','var')==0 - heteroagentoptions.multiGEcriterion=1; - heteroagentoptions.multiGEweights=ones(1,length(fieldnames(GeneralEqmEqns))); + heteroagentoptions.fminalgo=1; % =1 use fminsearch. Main alternatives: =4 is shooting (you set update rules), =5 is CMA-ES (robust but slow), =8 is lsqnonlin() fast but requires Matlab Optimization Toolbox (and often not quite high accuracy of results) + heteroagentoptions.multiGEcriterion=1; % How to combine multiple GE condns (default is sum-of-squares) + heteroagentoptions.multiGEweights=ones(1,length(fieldnames(GeneralEqmEqns))); % Weights on GECondns, when being combined heteroagentoptions.toleranceGEprices=10^(-4); % Accuracy of general eqm prices heteroagentoptions.toleranceGEcondns=10^(-4); % Accuracy of general eqm eqns - heteroagentoptions.fminalgo=1; % use fminsearch - heteroagentoptions.verbose=0; heteroagentoptions.maxiter=1000; % maximum iterations of optimization routine - heteroagentoptions.pricehistory=0; % =1, saves the history of the GEPrices during the convergence - heteroagentoptions.oldGE=1; % Constrain parameters heteroagentoptions.constrainpositive={}; % names of parameters to constrained to be positive (gets converted to binary-valued vector below) heteroagentoptions.constrain0to1={}; % names of parameters to constrained to be positive (gets converted to binary-valued vector below) heteroagentoptions.constrainAtoB={}; % names of parameters to constrained to be positive (gets converted to binary-valued vector below) - % heteroagentoptions.outputGEform=0; % For internal use only + % Verbose settings (feedback) + heteroagentoptions.verbose=0; % =1, give feedback + heteroagentoptions.verboseaccuracy1=4; % number of decimal places for GEPrices (among others) + heteroagentoptions.verboseaccuracy2=6; % number of decimal places for GECondns + heteroagentoptions.pricehistory=0; % =1, saves the history of the GEPrices during the convergence + % For internal use only + % heteroagentoptions.outputGEform=0; heteroagentoptions.outputGEstruct=1; % output GE conditions as a structure (=2 will output as a vector) heteroagentoptions.outputgather=1; % output GE conditions on CPU [some optimization routines only work on CPU, some can handle GPU] else + if ~isfield(heteroagentoptions,'fminalgo') + heteroagentoptions.fminalgo=1; % use fminsearch + end if ~isfield(heteroagentoptions,'multiGEcriterion') heteroagentoptions.multiGEcriterion=1; end if ~isfield(heteroagentoptions,'multiGEweights') heteroagentoptions.multiGEweights=ones(1,length(fieldnames(GeneralEqmEqns))); end - if N_p~=0 - if ~isfield(heteroagentoptions,'p_grid') - error('You have set n_p to a non-zero value, but not declared heteroagentoptions.p_grid') - end - end if ~isfield(heteroagentoptions,'toleranceGEprices') heteroagentoptions.toleranceGEprices=10^(-4); % Accuracy of general eqm prices end if ~isfield(heteroagentoptions,'toleranceGEcondns') heteroagentoptions.toleranceGEcondns=10^(-4); % Accuracy of general eqm eqns end - if ~isfield(heteroagentoptions,'fminalgo') - heteroagentoptions.fminalgo=1; % use fminsearch - end - if ~isfield(heteroagentoptions,'verbose') - heteroagentoptions.verbose=0; - end if ~isfield(heteroagentoptions,'maxiter') heteroagentoptions.maxiter=1000; % maximum iterations of optimization routine end - if ~isfield(heteroagentoptions,'pricehistory') - heteroagentoptions.pricehistory=0; % =1, saves the history of the GEPrices during the convergence - end - if ~isfield(heteroagentoptions,'oldGE') - heteroagentoptions.oldGE=1; + if N_p~=0 + if ~isfield(heteroagentoptions,'p_grid') + error('You have set n_p to a non-zero value, but not declared heteroagentoptions.p_grid') + end end % Constrain parameters if ~isfield(heteroagentoptions,'constrainpositive') @@ -145,7 +139,21 @@ error('You have used heteroagentoptions.constrainAtoB, but are missing heteroagentoptions.constrainAtoBlimits') end end - % heteroagentoptions.outputGEform=0; % For internal use only + % Verbose settings (feedback) + if ~isfield(heteroagentoptions,'verbose') + heteroagentoptions.verbose=0; % =1, give feedback + end + if ~isfield(heteroagentoptions,'verboseaccuracy1') + heteroagentoptions.verboseaccuracy1=4; % number of decimal places for GEPrices (among others) + end + if ~isfield(heteroagentoptions,'verboseaccuracy2') + heteroagentoptions.verboseaccuracy2=6; % number of decimal places for GECondns + end + if ~isfield(heteroagentoptions,'pricehistory') + heteroagentoptions.pricehistory=0; % =1, saves the history of the GEPrices during the convergence + end + % For internal use only + % heteroagentoptions.outputGEform=0; if ~isfield(heteroagentoptions,'outputGEstruct') heteroagentoptions.outputGEstruct=1; % output GE conditions as a structure (=2 will output as a vector) end @@ -178,6 +186,9 @@ error('length(heteroagentoptions.multiGEweights)~=length(fieldnames(GeneralEqmEqns)) (the length of the GE weights is not equal to the number of general eqm equations') end +heteroagentoptions.verboseaccuracy1=[' %s: %8.',num2str(heteroagentoptions.verboseaccuracy1),'f \n']; % set up a string +heteroagentoptions.verboseaccuracy2=[' %s: %8.',num2str(heteroagentoptions.verboseaccuracy2),'f \n']; % set up a string + nGEprices=length(GEPriceParamNames); GEeqnNames=fieldnames(GeneralEqmEqns); nGeneralEqmEqns=length(GEeqnNames); diff --git a/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1_subfn.m b/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1_subfn.m index 2c52a179..9b7d8352 100644 --- a/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1_subfn.m +++ b/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1_subfn.m @@ -99,29 +99,29 @@ fprintf(' \n') fprintf('Current GE prices: \n') for pp=1:nGEprices - fprintf(' %s: %8.4f \n',GEPriceParamNames{pp},GEpricesvec(pp)) + fprintf(heteroagentoptions.verboseaccuracy1,GEPriceParamNames{pp},GEpricesvec(pp)) end end if heteroagentoptions.verbose>=1 fprintf('Current aggregate variables: \n') for aa=1:length(AggVarNames) - fprintf(' %s: %8.4f \n',AggVarNames{aa},AggVars(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix + fprintf(heteroagentoptions.verboseaccuracy1,AggVarNames{aa},AggVars(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix end if heteroagentoptions.useintermediateEqns==1 fprintf('Current intermediateEqn variables: \n') for aa=1:length(intEqnnames) - fprintf(' %s: %8.4f \n',intEqnnames{aa},intermediateEqnsVec(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix + fprintf(heteroagentoptions.verboseaccuracy1,intEqnnames{aa},intermediateEqnsVec(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix end end if heteroagentoptions.useCustomModelStats==1 fprintf('Current CustomModelStats variables: \n') for ii=1:length(customstatnames) - fprintf(' %s: %8.4f \n',customstatnames{ii},CustomStats.(customstatnames{ii})) + fprintf(heteroagentoptions.verboseaccuracy1,customstatnames{ii},CustomStats.(customstatnames{ii})) end end fprintf('Current GeneralEqmEqns: \n') for gg=1:length(GEeqnNames) - fprintf(' %s: %8.6f \n',GEeqnNames{gg},GeneralEqmConditionsVec(gg)) + fprintf(heteroagentoptions.verboseaccuracy2,GEeqnNames{gg},GeneralEqmConditionsVec(gg)) end end diff --git a/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m b/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m index 002945c3..3a579438 100644 --- a/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m +++ b/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m @@ -58,55 +58,49 @@ end if exist('heteroagentoptions','var')==0 - heteroagentoptions.multiGEcriterion=1; - heteroagentoptions.multiGEweights=ones(1,length(fieldnames(GeneralEqmEqns))); + heteroagentoptions.fminalgo=1; % =1 use fminsearch. Main alternatives: =4 is shooting (you set update rules), =5 is CMA-ES (robust but slow), =8 is lsqnonlin() fast but requires Matlab Optimization Toolbox (and often not quite high accuracy of results) + heteroagentoptions.multiGEcriterion=1; % How to combine multiple GE condns (default is sum-of-squares) + heteroagentoptions.multiGEweights=ones(1,length(fieldnames(GeneralEqmEqns))); % Weights on GECondns, when being combined heteroagentoptions.toleranceGEprices=10^(-4); % Accuracy of general eqm prices heteroagentoptions.toleranceGEcondns=10^(-4); % Accuracy of general eqm eqns - heteroagentoptions.fminalgo=1; % use fminsearch - heteroagentoptions.verbose=0; - heteroagentoptions.parallel=1+(gpuDeviceCount>0); % GPU where available, otherwise parallel CPU. heteroagentoptions.maxiter=1000; % maximum iterations of optimization routine - heteroagentoptions.pricehistory=0; % =1, saves the history of the GEPrices during the convergence - heteroagentoptions.GEptype={}; % zeros(1,length(fieldnames(GeneralEqmEqns))); % 1 indicates that this general eqm condition is 'conditional on permanent type' [input should be a cell of names; it gets reformatted internally to be this form] + heteroagentoptions.GEptype={}; % zeros(1,length(fieldnames(GeneralEqmEqns))); % 1 indicates that this general eqm condition is 'conditional on permanent type' [input should be a cell of names; it gets reformatted internally to be matrix of 1s and 0s] % Constrain parameters heteroagentoptions.constrainpositive={}; % names of parameters to constrained to be positive (gets converted to binary-valued vector below) heteroagentoptions.constrain0to1={}; % names of parameters to constrained to be positive (gets converted to binary-valued vector below) heteroagentoptions.constrainAtoB={}; % names of parameters to constrained to be positive (gets converted to binary-valued vector below) - % heteroagentoptions.outputGEform=0; % For internal use only + % Verbose settings (feedback) + heteroagentoptions.verbose=0; % =1, give feedback + heteroagentoptions.verboseaccuracy1=4; % number of decimal places for GEPrices (among others) + heteroagentoptions.verboseaccuracy2=6; % number of decimal places for GECondns + heteroagentoptions.pricehistory=0; % =1, saves the history of the GEPrices during the convergence + % For internal use only + % heteroagentoptions.outputGEform=0; heteroagentoptions.outputGEstruct=1; % output GE conditions as a structure (=2 will output as a vector) heteroagentoptions.outputgather=1; % output GE conditions on CPU [some optimization routines only work on CPU, some can handle GPU] else + if isfield(heteroagentoptions,'fminalgo')==0 + heteroagentoptions.fminalgo=1; % use fminsearch + end if isfield(heteroagentoptions,'multiGEcriterion')==0 heteroagentoptions.multiGEcriterion=1; end if isfield(heteroagentoptions,'multiGEweights')==0 heteroagentoptions.multiGEweights=ones(1,length(fieldnames(GeneralEqmEqns))); end - if N_p~=0 - if isfield(heteroagentoptions,'p_grid')==0 - error('You have set n_p to a non-zero value, but not declared heteroagentoptions.p_grid') - end - end if isfield(heteroagentoptions,'toleranceGEprices')==0 heteroagentoptions.toleranceGEprices=10^(-4); % Accuracy of general eqm prices end if isfield(heteroagentoptions,'toleranceGEcondns')==0 heteroagentoptions.toleranceGEcondns=10^(-4); % Accuracy of general eqm prices end - if isfield(heteroagentoptions,'fminalgo')==0 - heteroagentoptions.fminalgo=1; % use fminsearch - end - if isfield(heteroagentoptions,'verbose')==0 - heteroagentoptions.verbose=0; - end - if isfield(heteroagentoptions,'parallel')==0 - heteroagentoptions.parallel=1+(gpuDeviceCount>0); % GPU where available, otherwise parallel CPU. - end if isfield(heteroagentoptions,'maxiter')==0 heteroagentoptions.maxiter=1000; % maximum iterations of optimization routine end - if ~isfield(heteroagentoptions,'pricehistory') - heteroagentoptions.pricehistory=0; % =1, saves the history of the GEPrices during the convergence + if N_p~=0 + if isfield(heteroagentoptions,'p_grid')==0 + error('You have set n_p to a non-zero value, but not declared heteroagentoptions.p_grid') + end end if ~isfield(heteroagentoptions,'GEptype') heteroagentoptions.GEptype={}; % zeros(1,length(fieldnames(GeneralEqmEqns))); % 1 indicates that this general eqm condition is 'conditional on permanent type' [input should be a cell of names; it gets reformatted internally to be this form] @@ -131,7 +125,21 @@ error('You have used heteroagentoptions.constrainAtoB, but are missing heteroagentoptions.constrainAtoBlimits') end end - % heteroagentoptions.outputGEform=0; % For internal use only + % Verbose settings (feedback) + if isfield(heteroagentoptions,'verbose')==0 + heteroagentoptions.verbose=0; + end + if ~isfield(heteroagentoptions,'verboseaccuracy1') + heteroagentoptions.verboseaccuracy1=4; % number of decimal places for GEPrices (among others) + end + if ~isfield(heteroagentoptions,'verboseaccuracy2') + heteroagentoptions.verboseaccuracy2=6; % number of decimal places for GECondns + end + if ~isfield(heteroagentoptions,'pricehistory') + heteroagentoptions.pricehistory=0; % =1, saves the history of the GEPrices during the convergence + end + % For internal use only + % heteroagentoptions.outputGEform=0; if ~isfield(heteroagentoptions,'outputGEstruct') heteroagentoptions.outputGEstruct=1; % output GE conditions as a structure (=2 will output as a vector) end @@ -164,6 +172,9 @@ error('length(heteroagentoptions.multiGEweights)~=length(fieldnames(GeneralEqmEqns)) (the length of the GE weights is not equal to the number of general eqm equations') end +heteroagentoptions.verboseaccuracy1=[' %s: %8.',num2str(heteroagentoptions.verboseaccuracy1),'f \n']; % set up a string +heteroagentoptions.verboseaccuracy2=[' %s: %8.',num2str(heteroagentoptions.verboseaccuracy2),'f \n']; % set up a string + AggVarNames=fieldnames(FnsToEvaluate); nGEprices=length(GEPriceParamNames); diff --git a/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType_subfn.m b/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType_subfn.m index 4df43a48..be6af570 100644 --- a/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType_subfn.m +++ b/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType_subfn.m @@ -137,27 +137,27 @@ fprintf(' \n') fprintf('Current GE prices: \n') for pp=1:nGEprices - fprintf(' %s: %8.4f \n',GEPriceParamNames{pp},GEpricesvec(pp)) + fprintf(heteroagentoptions.verboseaccuracy1,GEPriceParamNames{pp},GEpricesvec(pp)) end fprintf('Current aggregate variables: \n') for aa=1:length(AggVarNames) - fprintf(' %s: %8.4f \n',AggVarNames{aa},AggVars(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix + fprintf(heteroagentoptions.verboseaccuracy1,AggVarNames{aa},AggVars(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix end if heteroagentoptions.useintermediateEqns==1 fprintf('Current intermediateEqn variables: \n') for aa=1:length(intEqnnames) - fprintf(' %s: %8.4f \n',intEqnnames{aa},intermediateEqnsVec(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix + fprintf(heteroagentoptions.verboseaccuracy1,intEqnnames{aa},intermediateEqnsVec(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix end end if heteroagentoptions.useCustomModelStats==1 fprintf('Current CustomModelStats variables: \n') for ii=1:length(customstatnames) - fprintf(' %s: %8.4f \n',customstatnames{ii},CustomStats.(customstatnames{ii})) + fprintf(heteroagentoptions.verboseaccuracy1,customstatnames{ii},CustomStats.(customstatnames{ii})) end end fprintf('Current GeneralEqmEqns: \n') for gg=1:length(GEeqnNames) - fprintf(' %s: %8.6f \n',GEeqnNames{gg},GeneralEqmConditionsVec(gg)) + fprintf(heteroagentoptions.verboseaccuracy2,GEeqnNames{gg},GeneralEqmConditionsVec(gg)) end end From 177263d79c54b9fd2a14a2379d1f4cc0c6b10a82 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Mon, 2 Feb 2026 10:20:16 +1300 Subject: [PATCH 43/67] clean --- StationaryDist/FHorz/StationaryDist_FHorz_Case1.m | 2 +- .../StationaryDist_FHorz_Iteration_SemiExo_nProbs_e_raw.m | 4 ++-- .../StationaryDist_FHorz_Iteration_SemiExo_nProbs_noz_e_raw.m | 4 ++-- .../StationaryDist_FHorz_Iteration_SemiExo_nProbs_noz_raw.m | 2 +- .../StationaryDist_FHorz_Iteration_SemiExo_nProbs_raw.m | 3 +-- 5 files changed, 7 insertions(+), 8 deletions(-) diff --git a/StationaryDist/FHorz/StationaryDist_FHorz_Case1.m b/StationaryDist/FHorz/StationaryDist_FHorz_Case1.m index cb990ca8..d299343d 100644 --- a/StationaryDist/FHorz/StationaryDist_FHorz_Case1.m +++ b/StationaryDist/FHorz/StationaryDist_FHorz_Case1.m @@ -88,7 +88,7 @@ %% Semi-exogenous shock gridvals and pi if isfield(simoptions,'n_semiz') % Internally, only ever use age-dependent joint-grids (makes all the code much easier to write) - simoptions=SemiExogShockSetup_FHorz(n_d,N_j,simoptions.d_grid,Parameters,simoptions,simoptions.parallel); + simoptions=SemiExogShockSetup_FHorz(n_d,N_j,simoptions.d_grid,Parameters,simoptions,1); % output: simoptions.semiz_gridvals_J, simoptions.pi_semiz_J % size(semiz_gridvals_J)=[prod(n_z),length(n_z),N_j] % size(pi_semiz_J)=[prod(n_semiz),prod(n_semiz),prod(n_dsemiz),N_j] diff --git a/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_e_raw.m b/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_e_raw.m index a4ad8cd9..316dfdda 100644 --- a/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_e_raw.m +++ b/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_e_raw.m @@ -19,7 +19,7 @@ PolicyProbs=reshape(PolicyProbs,[N_a*N_semiz*N_z*N_e,N_probs,N_j]); PolicyProbs=repelem(gather(PolicyProbs),1,N_semiz).*repmat(pi_semiz_J(semizindex),1,N_probs); -clear semizindex; + N_bothz=N_semiz*N_z; @@ -46,7 +46,7 @@ pi_e=sparse(pi_e_J(:,jj)); StationaryDist_jj=kron(pi_e,StationaryDist_jj); - StationaryDist(:,jj+1)=StationaryDist_jj; + StationaryDist(:,jj+1)=gpuArray(full(StationaryDist_jj)); end % Reweight the different ages based on 'AgeWeightParamNames'. (it is assumed there is only one Age Weight Parameter (name)) diff --git a/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_noz_e_raw.m b/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_noz_e_raw.m index 1461f32a..2ff0e1bd 100644 --- a/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_noz_e_raw.m +++ b/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_noz_e_raw.m @@ -20,7 +20,7 @@ PolicyProbs=reshape(PolicyProbs,[N_a*N_semiz*N_e,N_probs,N_j]); PolicyProbs=repelem(gather(PolicyProbs),1,N_semiz).*repmat(pi_semiz_J(semizindex),1,N_probs); -clear semizindex; + %% Use Tan improvement @@ -41,7 +41,7 @@ % Put e back into dist StationaryDist_jj=kron(pi_e_J(:,jj),StationaryDist_jj); - StationaryDist(:,jj+1)=StationaryDist_jj; + StationaryDist(:,jj+1)=gpuArray(full(StationaryDist_jj)); end % Reweight the different ages based on 'AgeWeightParamNames'. (it is assumed there is only one Age Weight Parameter (name)) diff --git a/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_noz_raw.m b/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_noz_raw.m index 2b8391f4..06419521 100644 --- a/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_noz_raw.m +++ b/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_noz_raw.m @@ -37,7 +37,7 @@ % No z, so just a single interation StationaryDist_jj=Gammatranspose*StationaryDist_jj; - StationaryDist(:,jj+1)=StationaryDist_jj; + StationaryDist(:,jj+1)=gpuArray(full(StationaryDist_jj)); end diff --git a/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_raw.m b/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_raw.m index e69a9749..5ff94c11 100644 --- a/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_raw.m +++ b/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_raw.m @@ -19,7 +19,6 @@ PolicyProbs=reshape(PolicyProbs,[N_a*N_semiz*N_z,N_probs,N_j]); PolicyProbs=repelem(gather(PolicyProbs),1,N_semiz).*repmat(pi_semiz_J(semizindex),1,N_probs); -clear semizindex; N_bothz=N_semiz*N_z; @@ -42,7 +41,7 @@ % Second step of Tan improvement StationaryDist_jj=reshape(StationaryDist_jj*pi_z_J(:,:,jj),[N_a*N_bothz,1]); - StationaryDist(:,jj+1)=StationaryDist_jj; + StationaryDist(:,jj+1)=gpuArray(full(StationaryDist_jj)); end From c82f9d8bef5eea5e0e99b408aa80ed51c72f82f4 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Tue, 3 Feb 2026 10:47:31 +1300 Subject: [PATCH 44/67] verbose=2 --- ...teroAgentStationaryEqm_Case1_FHorz_subfn.m | 10 ++++ ...onaryEqm_Case1_FHorz_PType_GEptype_subfn.m | 47 +++++++++++++++---- ...entStationaryEqm_Case1_FHorz_PType_subfn.m | 12 ++++- ...teroAgentStationaryEqm_Case1_PType_subfn.m | 12 ++++- 4 files changed, 69 insertions(+), 12 deletions(-) diff --git a/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz_subfn.m b/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz_subfn.m index 1f7162c8..8d22ba97 100644 --- a/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz_subfn.m +++ b/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz_subfn.m @@ -3,6 +3,14 @@ heteroagentparamsvecindex=0:1:length(GEpricesvec); [GEpricesvec,penalty]=ParameterConstraints_TransformParamsToOriginal(GEpricesvec,heteroagentparamsvecindex,GEPriceParamNames,heteroagentoptions); +if heteroagentoptions.verbose==2 + fprintf(' \n') + fprintf('Current GE prices: \n') + for pp=1:nGEprices + fprintf(' %s: %8.4f \n',GEPriceParamNames{pp},GEpricesvec(pp)) + end +end + %% for ii=1:nGEprices Parameters.(GEPriceParamNames{ii})=GEpricesvec(ii); @@ -93,6 +101,8 @@ for pp=1:nGEprices fprintf(heteroagentoptions.verboseaccuracy1,GEPriceParamNames{pp},GEpricesvec(pp)) end +end +if heteroagentoptions.verbose>=1 fprintf('Current aggregate variables: \n') for aa=1:length(AggVarNames) fprintf(heteroagentoptions.verboseaccuracy1,AggVarNames{aa},AggVars(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix diff --git a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_GEptype_subfn.m b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_GEptype_subfn.m index c56b14c7..d2ffc13a 100644 --- a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_GEptype_subfn.m +++ b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_GEptype_subfn.m @@ -4,6 +4,28 @@ heteroagentparamsvecindex=[0; GEpriceindexes(:,2)]; [GEpricesvec,penalty]=ParameterConstraints_TransformParamsToOriginal(GEpricesvec,heteroagentparamsvecindex,GEPriceParamNames,heteroagentoptions); +if heteroagentoptions.verbose==2 + if all(heteroagentoptions.GEptype==0) + fprintf(' \n') + fprintf('Current GE prices: \n') + for ii=1:nGEprices + fprintf(heteroagentoptions.verboseaccuracy1,GEPriceParamNames{ii},GEpricesvec(ii)) + end + else + numberstr=repmat(' %8.4f',1,PTypeStructure.N_i); + % Adjust output for the fact there are multiple ptypes + fprintf(' \n') + fprintf('Current GE prices: \n') + for pp=1:nGEprices + if GEprice_ptype(pp)==1 + fprintf([' %s:',numberstr,' \n'],GEPriceParamNames{pp},GEpricesvec(GEpriceindexes(pp,1):GEpriceindexes(pp,2))) + else + fprintf(heteroagentoptions.verboseaccuracy1,GEPriceParamNames{pp},GEpricesvec(GEpriceindexes(pp,1):GEpriceindexes(pp,2))) + end + end + end +end + %% for pp=1:nGEprices % Not sure this is needed, have it just in case they are used when calling 'GeneralEqmConditionsFn', but I am pretty sure they never would be. Parameters.(GEPriceParamNames{pp})=GEpricesvec(GEpriceindexes(pp,1):GEpriceindexes(pp,2)); @@ -168,22 +190,13 @@ %% Give feedback on current iteration -if heteroagentoptions.verbose==1 +if heteroagentoptions.verbose==1 % When=2, we report these earlier if all(heteroagentoptions.GEptype==0) fprintf(' \n') fprintf('Current GE prices: \n') for ii=1:nGEprices fprintf(heteroagentoptions.verboseaccuracy1,GEPriceParamNames{ii},GEpricesvec(ii)) end - fprintf('Current aggregate variables: \n') - for ii=1:length(AggVarNames) - fprintf(heteroagentoptions.verboseaccuracy1,AggVarNames{ii},Parameters.(AggVarNames{ii})) % Note, this is done differently here because AggVars itself has been set as a matrix - end - fprintf('Current GeneralEqmEqns: \n') - GeneralEqmEqnsNames=fieldnames(GeneralEqmEqns); - for ii=1:length(GeneralEqmEqnsNames) - fprintf(heteroagentoptions.verboseaccuracy2,GeneralEqmEqnsNames{ii},GeneralEqmConditionsVec(ii)) - end else numberstr=repmat(' %8.4f',1,PTypeStructure.N_i); % Adjust output for the fact there are multiple ptypes @@ -196,6 +209,20 @@ fprintf(heteroagentoptions.verboseaccuracy1,GEPriceParamNames{pp},GEpricesvec(GEpriceindexes(pp,1):GEpriceindexes(pp,2))) end end + end +end +if heteroagentoptions.verbose>=1 + if all(heteroagentoptions.GEptype==0) + fprintf('Current aggregate variables: \n') + for ii=1:length(AggVarNames) + fprintf(heteroagentoptions.verboseaccuracy1,AggVarNames{ii},Parameters.(AggVarNames{ii})) % Note, this is done differently here because AggVars itself has been set as a matrix + end + fprintf('Current GeneralEqmEqns: \n') + GeneralEqmEqnsNames=fieldnames(GeneralEqmEqns); + for ii=1:length(GeneralEqmEqnsNames) + fprintf(heteroagentoptions.verboseaccuracy2,GeneralEqmEqnsNames{ii},GeneralEqmConditionsVec(ii)) + end + else fprintf('Current aggregate variables: \n') for aa=1:length(AggVarNames) fprintf(heteroagentoptions.verboseaccuracy1,AggVarNames{aa},AggVars(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix diff --git a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_subfn.m b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_subfn.m index f91a9c51..d268e3d1 100644 --- a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_subfn.m +++ b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_subfn.m @@ -3,6 +3,14 @@ heteroagentparamsvecindex=0:1:length(GEpricesvec); [GEpricesvec,penalty]=ParameterConstraints_TransformParamsToOriginal(GEpricesvec,heteroagentparamsvecindex,GEPriceParamNames,heteroagentoptions); +if heteroagentoptions.verbose==2 + fprintf(' \n') + fprintf('Current GE prices: \n') + for pp=1:nGEprices + fprintf(' %s: %8.4f \n',GEPriceParamNames{pp},GEpricesvec(pp)) + end +end + %% for pp=1:nGEprices Parameters.(GEPriceParamNames{pp})=GEpricesvec(pp); @@ -126,12 +134,14 @@ end %% Feedback on progress -if heteroagentoptions.verbose==1 +if heteroagentoptions.verbose==1 % When=2, we report these earlier fprintf(' \n') fprintf('Current GE prices: \n') for pp=1:nGEprices fprintf(heteroagentoptions.verboseaccuracy1,GEPriceParamNames{pp},GEpricesvec(pp)) end +end +if heteroagentoptions.verbose>=1 fprintf('Current aggregate variables: \n') for aa=1:length(AggVarNames) fprintf(heteroagentoptions.verboseaccuracy1,AggVarNames{aa},AggVars(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix diff --git a/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType_subfn.m b/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType_subfn.m index be6af570..71c7625f 100644 --- a/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType_subfn.m +++ b/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType_subfn.m @@ -3,6 +3,14 @@ heteroagentparamsvecindex=0:1:length(GEpricesvec); [GEpricesvec,penalty]=ParameterConstraints_TransformParamsToOriginal(GEpricesvec,heteroagentparamsvecindex,GEPriceParamNames,heteroagentoptions); +if heteroagentoptions.verbose==2 + fprintf(' \n') + fprintf('Current GE prices: \n') + for pp=1:nGEprices + fprintf(' %s: %8.4f \n',GEPriceParamNames{pp},GEpricesvec(pp)) + end +end + %% for pp=1:nGEprices Parameters.(GEPriceParamNames{pp})=GEpricesvec(pp); @@ -133,12 +141,14 @@ %% Feedback on progress -if heteroagentoptions.verbose==1 +if heteroagentoptions.verbose==1 % When=2, we report these earlier fprintf(' \n') fprintf('Current GE prices: \n') for pp=1:nGEprices fprintf(heteroagentoptions.verboseaccuracy1,GEPriceParamNames{pp},GEpricesvec(pp)) end +end +if heteroagentoptions.verbose>=1 fprintf('Current aggregate variables: \n') for aa=1:length(AggVarNames) fprintf(heteroagentoptions.verboseaccuracy1,AggVarNames{aa},AggVars(aa)) % Note, this is done differently here because AggVars itself has been set as a matrix From abb1a64df321be4918dc9f770bcbad1eb6dcb648 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Wed, 4 Feb 2026 08:00:30 +1300 Subject: [PATCH 45/67] minor --- SimulateTimeSeries/InfHorz/SimPanelValues_Case1.m | 6 +++++- .../OnCPU/UnKronPolicyIndexes_InfHorz_CPU.m | 4 ++-- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/SimulateTimeSeries/InfHorz/SimPanelValues_Case1.m b/SimulateTimeSeries/InfHorz/SimPanelValues_Case1.m index 77925f54..6cb094be 100644 --- a/SimulateTimeSeries/InfHorz/SimPanelValues_Case1.m +++ b/SimulateTimeSeries/InfHorz/SimPanelValues_Case1.m @@ -250,7 +250,11 @@ end a_gridvals=CreateGridvals(n_a,a_grid,1); % 1 at end indicates output as matrices. -z_gridvals=CreateGridvals(n_z,z_grid,1); % 1 at end indicates output as matrices. +if all(size(z_grid)==[prod(n_z),1]) + z_gridvals=CreateGridvals(n_z,z_grid,1); % 1 at end indicates output as matrices. +elseif all(size(z_grid)==[prod(n_z),length(n_z)]) + z_gridvals=z_grid; % already gridvals +end %% Now switch everything to gpu so can use arrayfun() to evaluates all the FnsToEvaluate daprimePolicy_gridvals=gpuArray(daprimePolicy_gridvals); diff --git a/SubCodes/UnKronPolicyIndexes/OnCPU/UnKronPolicyIndexes_InfHorz_CPU.m b/SubCodes/UnKronPolicyIndexes/OnCPU/UnKronPolicyIndexes_InfHorz_CPU.m index 413b480d..7c125fd8 100644 --- a/SubCodes/UnKronPolicyIndexes/OnCPU/UnKronPolicyIndexes_InfHorz_CPU.m +++ b/SubCodes/UnKronPolicyIndexes/OnCPU/UnKronPolicyIndexes_InfHorz_CPU.m @@ -14,8 +14,8 @@ Policy=zeros(l_aprime,N_a,N_z); for i=1:N_a for j=1:N_z - optaindexKron=PolicyKron(i,j); - optA=ind2sub_homemade(n_aprime',optaindexKron); + optaindexKron=PolicyKron(1,i,j); + optA=ind2sub_homemade(n_a',optaindexKron); % n_aprime Policy(:,i,j)=optA'; end end From ac9e32772cb2006ed1662e7b838b1b927696ce29 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Wed, 4 Feb 2026 20:26:52 +1300 Subject: [PATCH 46/67] minor --- .../EvalFnOnAgentDist_ValuesOnGrid_Case1.m | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/EvaluateFnOnAgentDist/EvalFnOnAgentDist_ValuesOnGrid_Case1.m b/EvaluateFnOnAgentDist/EvalFnOnAgentDist_ValuesOnGrid_Case1.m index 06c7a120..5ecdc94f 100644 --- a/EvaluateFnOnAgentDist/EvalFnOnAgentDist_ValuesOnGrid_Case1.m +++ b/EvaluateFnOnAgentDist/EvalFnOnAgentDist_ValuesOnGrid_Case1.m @@ -26,9 +26,13 @@ if simoptions.gridinterplayer==1 l_daprime=l_daprime-1; end -a_gridvals=CreateGridvals(n_a,a_grid,1); -[z_gridvals,~,simoptions]=ExogShockSetup(n_z,z_grid,[],Parameters,simoptions,1); - +if Parallel==2 + a_gridvals=CreateGridvals(n_a,a_grid,1); + [z_gridvals,~,simoptions]=ExogShockSetup(n_z,z_grid,[],Parameters,simoptions,1); +elseif Parallel==1 + a_gridvals=CreateGridvals(n_a,a_grid,2); + z_gridvals=CreateGridvals(n_z,z_grid,2); % CPU, so must just be simple stacked column for z +end %% Implement new way of handling FnsToEvaluate if isstruct(FnsToEvaluate) @@ -76,9 +80,12 @@ Values=reshape(Values,[N_a*N_z,1]); ValuesOnGrid.(AggVarNames{ff})=reshape(Values,[n_a,n_z]); end -else +elseif Parallel==1 + % CPU + simoptions.experienceasset=0; % needs to be set so can use CreateGridvals_Policy() + simoptions.experienceassetu=0; % needs to be set so can use CreateGridvals_Policy() [d_gridvals, aprime_gridvals]=CreateGridvals_Policy(Policy,n_d,n_a,n_a,n_z,d_grid,a_grid,simoptions,1, 2); - + if l_d>0 for ff=1:length(FnsToEvaluate) From 6dd9713383e3d7ded1afbf0d335d1202f21dba23 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Thu, 5 Feb 2026 13:06:39 +1300 Subject: [PATCH 47/67] minor --- .../TransPath/EvalFnOnTransPath_AggVars_Case1.m | 9 ++++++++- .../PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m | 2 +- .../InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m | 2 +- Optimization/setupGEnewprice3_shooting.m | 2 +- ValueFnIter/TransPath/ValueFnOnTransPath_Case1.m | 8 +++++++- 5 files changed, 18 insertions(+), 5 deletions(-) diff --git a/EvaluateFnOnAgentDist/TransPath/EvalFnOnTransPath_AggVars_Case1.m b/EvaluateFnOnAgentDist/TransPath/EvalFnOnTransPath_AggVars_Case1.m index dd75f998..5ed6b654 100644 --- a/EvaluateFnOnAgentDist/TransPath/EvalFnOnTransPath_AggVars_Case1.m +++ b/EvaluateFnOnAgentDist/TransPath/EvalFnOnTransPath_AggVars_Case1.m @@ -83,13 +83,20 @@ %% a_gridvals=CreateGridvals(n_a,a_grid,1); -z_gridvals=CreateGridvals(n_z,z_grid,1); PolicyPath=reshape(PolicyPath,[size(PolicyPath,1),N_a,N_z,T]); % Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats PolicyValuesPath=PolicyInd2Val_InfHorz_TPath(PolicyPath,n_d,n_a,n_z,T,d_grid,a_grid,simoptions,1); PolicyValuesPath=permute(reshape(PolicyValuesPath,[size(PolicyValuesPath,1),N_a,N_z,T]),[2,3,1,4]); %[N_a,N_z,l_d+l_a,T-1] +%% Switch to z_gridvals +l_z=length(n_z); +if all(size(z_grid)==[sum(n_z),1]) + z_gridvals=CreateGridvals(n_z,z_grid,1); % The 1 at end indicates want output in form of matrix. +elseif all(size(z_grid)==[prod(n_z),l_z]) + z_gridvals=z_grid; +end + %% AgentDistPath=reshape(AgentDistPath,[N_a,N_z,T]); diff --git a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m index 64b91a4f..252d2c34 100644 --- a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m +++ b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m @@ -790,7 +790,7 @@ elseif heteroagentoptions.fminalgo==5 % Update based on rules in heteroagentoptions.fminalgo5.howtoupdate % Set up the howtoupdate rules in the format needed - heteroagentoptions=setupGEnewprice3_shooting(heteroagentoptions,GeneralEqmEqns,GEPriceParamNames); + heteroagentoptions=setupGEnewprice3_shooting(heteroagentoptions,GeneralEqmEqns,GEPriceParamNames,N_i,GEpriceindexes'); % Get initial prices, p p=nan(1,length(GEPriceParamNames)); for ii=1:length(GEPriceParamNames) diff --git a/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m b/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m index 3a579438..9881174d 100644 --- a/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m +++ b/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m @@ -728,7 +728,7 @@ elseif heteroagentoptions.fminalgo==5 % Update based on rules in heteroagentoptions.fminalgo5.howtoupdate % Set up the howtoupdate rules in the format needed - heteroagentoptions=setupGEnewprice3_shooting(heteroagentoptions,GeneralEqmEqns,GEPriceParamNames); + heteroagentoptions=setupGEnewprice3_shooting(heteroagentoptions,GeneralEqmEqns,GEPriceParamNames,N_i,GEpriceindexes'); % Get initial prices, p p=nan(1,length(GEPriceParamNames)); for ii=1:length(GEPriceParamNames) diff --git a/Optimization/setupGEnewprice3_shooting.m b/Optimization/setupGEnewprice3_shooting.m index 33d09d63..772c3c22 100644 --- a/Optimization/setupGEnewprice3_shooting.m +++ b/Optimization/setupGEnewprice3_shooting.m @@ -77,7 +77,7 @@ end else - %% Model with permanent type: allow for options.GEptype + %% Model with permanent type and using options.GEptype nGeneralEqmEqns_acrossptypes=sum(options.GEptype==0)+N_i*sum(options.GEptype==1); % Before starting, make sure that GE that depend on ptype match up with PricePaths that depend on ptype diff --git a/ValueFnIter/TransPath/ValueFnOnTransPath_Case1.m b/ValueFnIter/TransPath/ValueFnOnTransPath_Case1.m index 5366a3b5..766a563c 100644 --- a/ValueFnIter/TransPath/ValueFnOnTransPath_Case1.m +++ b/ValueFnIter/TransPath/ValueFnOnTransPath_Case1.m @@ -161,7 +161,13 @@ VKronPath(:,:,T)=V_final; -z_gridvals=CreateGridvals(n_z,z_grid,1); +%% Switch to z_gridvals +l_z=length(n_z); +if all(size(z_grid)==[sum(n_z),1]) + z_gridvals=CreateGridvals(n_z,z_grid,1); % The 1 at end indicates want output in form of matrix. +elseif all(size(z_grid)==[prod(n_z),l_z]) + z_gridvals=z_grid; +end %% if N_d==0 From 00c538093bc545b50260a3838d7b80ef9ffbe1e6 Mon Sep 17 00:00:00 2001 From: Michael Tiemann Date: Wed, 11 Feb 2026 19:55:12 +1300 Subject: [PATCH 48/67] Support ExpAsset with length(n_a)==4 This is my best guess at extending the pattern to support 3 other assets and an experience asset. I have used this code to successfully run a modified OLG14 with an experience asset that produces results I expected. If this is correct, it should be adapted to the other ExpAsset cases. --- .../FHorz/ExpAsset/StationaryDist_FHorz_ExpAsset.m | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/StationaryDist/FHorz/ExpAsset/StationaryDist_FHorz_ExpAsset.m b/StationaryDist/FHorz/ExpAsset/StationaryDist_FHorz_ExpAsset.m index 31bd136d..6d78e70b 100644 --- a/StationaryDist/FHorz/ExpAsset/StationaryDist_FHorz_ExpAsset.m +++ b/StationaryDist/FHorz/ExpAsset/StationaryDist_FHorz_ExpAsset.m @@ -95,8 +95,11 @@ elseif l_a==3 % two other assets, then experience asset Policy_aprime(:,:,1,jj)=shiftdim(Policy(l_d+1,:,:,jj),1)+n_a(1)*(shiftdim(Policy(l_d+2,:,:,jj),1)-1)+n_a(1)*n_a(2)*(aprimeIndexes-1); Policy_aprime(:,:,2,jj)=Policy_aprime(:,:,1,jj)+n_a(1)*n_a(2); + elseif l_a==4 % three other assets, then experience asset + Policy_aprime(:,:,1,jj)=shiftdim(Policy(l_d+1,:,:,jj),1)+n_a(1)*(shiftdim(Policy(l_d+2,:,:,jj),1)-1)+n_a(1)*n_a(2)*(shiftdim(Policy(l_d+3,:,:,jj),1)-1)+n_a(1)*n_a(2)*n_a(3)*(aprimeIndexes-1); + Policy_aprime(:,:,2,jj)=Policy_aprime(:,:,1,jj)+n_a(1)*n_a(2)*n_a(3); else - error('Not yet implemented experience asset with length(n_a)>3') + error('Not yet implemented experience asset with length(n_a)>4') end PolicyProbs(:,:,1,jj)=aprimeProbs; From 07c6f459aaec4c4739d60dbeca635773bba27f4c Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Mon, 23 Feb 2026 13:41:29 +1300 Subject: [PATCH 49/67] fix --- ...alFnOnAgentDist_ValuesOnGrid_FHorz_Case1.m | 6 +- .../ValueFnIter_Refine_postGI_raw.m | 220 ++++++++++-------- 2 files changed, 131 insertions(+), 95 deletions(-) diff --git a/EvaluateFnOnAgentDist/FHorz/EvalFnOnAgentDist_ValuesOnGrid_FHorz_Case1.m b/EvaluateFnOnAgentDist/FHorz/EvalFnOnAgentDist_ValuesOnGrid_FHorz_Case1.m index df45b629..450b4873 100644 --- a/EvaluateFnOnAgentDist/FHorz/EvalFnOnAgentDist_ValuesOnGrid_FHorz_Case1.m +++ b/EvaluateFnOnAgentDist/FHorz/EvalFnOnAgentDist_ValuesOnGrid_FHorz_Case1.m @@ -32,7 +32,11 @@ %% Implement new way of handling FnsToEvaluate % Figure out l_daprime from Policy -l_daprime=size(Policy,1); +if simoptions.gridinterplayer==0 + l_daprime=size(Policy,1); +else + l_daprime=size(Policy,1)-1; +end % Note: l_z includes e and semiz (when appropriate) if isstruct(FnsToEvaluate) diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_raw.m index c2fa8e9c..dde04fba 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_raw.m @@ -1,22 +1,27 @@ function [VKron,Policy]=ValueFnIter_Refine_postGI_raw(VKron,n_d,n_a,n_z,d_gridvals,a_grid,z_gridvals,pi_z,ReturnFn,DiscountFactorParamsVec,ReturnFnParams,vfoptions) +% When using refinement, lowmemory is implemented in the first stage (return fn) but not the second (the actual iteration). +% Refine, so there is at least one d variable N_d=prod(n_d); N_a=prod(n_a); N_z=prod(n_z); n_da=[n_d,n_a]; -da_gridvals=[repmat(d_gridvals,N_a,1),repelem(a_grid,N_d,1)]; +da_gridvals=[repmat(d_gridvals,N_a,1),repelem(a_grid,N_d,1)]; % only one aprime -%% CreateReturnFnMatrix_Case1_Disc creates a matrix of dimension (d and aprime)-by-a-by-z. +%% Refinement: calculate ReturnMatrix and 'remove' the d dimension +% Since the return function is independent of time creating it once and then using it every iteration is good for +% speed, but it does use a lot of memory. Hence the lowmemory option is here. if vfoptions.lowmemory==0 ReturnMatrixraw=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn,n_da, n_a, n_z, da_gridvals, a_grid, z_gridvals, ReturnFnParams); ReturnMatrixraw=reshape(ReturnMatrixraw,[N_d,N_a,N_a,N_z]); + % For refinement, now we solve for d*(aprime,a,z) that maximizes the ReturnFn [ReturnMatrix,~]=max(ReturnMatrixraw,[],1); - ReturnMatrix=shiftdim(ReturnMatrix,1); + ReturnMatrix=shiftdim(ReturnMatrix,1); % 'refined' return matrix -elseif vfoptions.lowmemory==1 - ReturnMatrix=zeros(N_a,N_a,N_z,'gpuArray'); +elseif vfoptions.lowmemory==1 % loop over z + ReturnMatrix=zeros(N_a,N_a,N_z,'gpuArray'); % 'refined' return matrix dstar=zeros(N_a,N_a,N_z,'gpuArray'); l_z=length(n_z); special_n_z=ones(1,l_z); @@ -24,11 +29,12 @@ zvals=z_gridvals(z_c,:); ReturnMatrix_z=CreateReturnFnMatrix_Case2_Disc_Par2(ReturnFn,n_da, n_a, special_n_z, da_gridvals, a_grid, zvals, ReturnFnParams); ReturnMatrix_z=reshape(ReturnMatrix_z,[N_d,N_a,N_a]); - [ReturnMatrix_z,dstar_z]=max(ReturnMatrix_z,[],1); + [ReturnMatrix_z,dstar_z]=max(ReturnMatrix_z,[],1); % solve for dstar ReturnMatrix(:,:,z_c)=shiftdim(ReturnMatrix_z,1); dstar(:,:,z_c)=shiftdim(dstar_z,1); end end +% The rest, except putting d back into Policy at the end, is all just copy-paste from ValueFnIter_postGI_nod_raw() pi_z_alt=shiftdim(pi_z',-1); pi_z_howards=repelem(pi_z,N_a,1); @@ -41,56 +47,76 @@ while currdist>(vfoptions.multigridswitch*vfoptions.tolerance) && tempcounter<=vfoptions.maxiter VKronold=VKron; + % Calc the condl expectation term (except beta), which depends on z but not on control variables EV=VKronold.*pi_z_alt; - EV(isnan(EV))=0; - EV=sum(EV,2); + EV(isnan(EV))=0; % multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=sum(EV,2); % sum over z', leaving a singular second dimension entireRHS=ReturnMatrix+DiscountFactorParamsVec*EV; + % Calc the max and it's index [VKron,Policy_a]=max(entireRHS,[],1); - VKron=shiftdim(VKron,1); + VKron=shiftdim(VKron,1); % a by z VKrondist=VKron(:)-VKronold(:); VKrondist(isnan(VKrondist))=0; currdist=max(abs(VKrondist)); - if isfinite(currdist) && currdist/vfoptions.tolerance>10 && tempcounter10 && tempcountervfoptions.tolerance && tempcounter<=vfoptions.maxiter VKronold=VKron; - EVpre=reshape(VKron(aprimeindex,:),[N_aprimediff,N_a,N_z,N_z]); + % Switch VKron into being over vfoptions.maxaprimediff + EVpre=reshape(VKron(aprimeindex,:),[N_aprimediff,N_a,N_z,N_z]); % last dimension is zprime + % Calc the condl expectation term (except beta), which depends on z but not on control variables EV=EVpre.*pi_z_alt2; EV(isnan(EV))=0; EV=squeeze(sum(EV,4)); + % EV is now [N_aprimediff,N_a,N_z] - % Interpolation of EV is performed as a matrix multiplication - EVinterp=reshape(interpMatrix*reshape(EV, [N_aprimediff, N_a*N_z]), [N_aprime,N_a,N_z]); - - entireRHS=ReturnMatrixfine+DiscountFactorParamsVec*EVinterp; + % Interpolate EV over aprime_grid + EVinterp=interp1(EVinterpindex1,EV,EVinterpindex2); + + entireRHS=ReturnMatrixfine+DiscountFactorParamsVec*EVinterp; % aprime by a by z [VKron,Policy_a]=max(entireRHS,[],1); - VKron=shiftdim(VKron,1); + VKron=shiftdim(VKron,1); % a by z VKrondist=VKron(:)-VKronold(:); VKrondist(isnan(VKrondist))=0; currdist=max(abs(VKrondist)); - % Howards improvement iteration - if isfinite(currdist) && currdist/vfoptions.tolerance>10 && tempcounter10 && tempcounter0 vfoptions.postGIrepeat=vfoptions.postGIrepeat-1; - Policy_a=reshape(Policy_a,[1,N_a,N_z]); + % Current optimal aprime is Policy_a + % So create an aprime_grid that is just an interpolation within +-vfoptions.maxaprimediff + + % First, we switch Policy_a to be the nearest point on the rough grid + Policy_a=reshape(Policy_a,[1,N_a,N_z]); % Howards can mess with the size Policy_a=ceil((Policy_a-1)/(n2short+1))-vfoptions.maxaprimediff+aprimeshifter; + % ceil((Policy_a-1)/(n2short+1))-vfoptions.maxaprimediff ranges -vfoptions.maxaprimediff:1:vfoptions.maxaprimediff + % First, create an aprime_grid that is just the +-vfoptions.maxaprimediff + % Note: this code is for models with a single endogenous state n_aprimediff=1+2*vfoptions.maxaprimediff; N_aprimediff=prod(n_aprimediff); aprimeshifter=min(max(Policy_a,1+vfoptions.maxaprimediff),N_a-vfoptions.maxaprimediff); - aprimeindex=(-vfoptions.maxaprimediff:1:vfoptions.maxaprimediff)' +aprimeshifter; + aprimeindex=(-vfoptions.maxaprimediff:1:vfoptions.maxaprimediff)' +aprimeshifter; % size n_aprime-by-n_a aprime_grid=a_grid(aprimeindex); - - n2short=vfoptions.ngridinterp; + + % Second, interpolate this + n2short=vfoptions.ngridinterp; % number of (evenly spaced) points to put between each grid point (not counting the two points themselves) n_aprime=n_aprimediff+(n_aprimediff-1)*vfoptions.ngridinterp; N_aprime=prod(n_aprime); aprime_grid=interp1((1:1:N_aprimediff)',aprime_grid,linspace(1,N_aprimediff,N_aprimediff+(N_aprimediff-1)*vfoptions.ngridinterp)'); + % Note: aprime_grid is N_aprime-by-N_a-by-N_z if vfoptions.lowmemory==0 ReturnMatrixfine=CreateReturnFnMatrix_Case1_Disc_DC1_Par2(ReturnFn, n_d, n_z, d_gridvals, aprime_grid, a_grid, z_gridvals, ReturnFnParams,1); + % ReturnMatrixfineraw=reshape(ReturnMatrixfineraw,[N_d,N_aprime,N_a,N_z]); + % For refinement, now we solve for d*(aprime,a,z) that maximizes the ReturnFn [ReturnMatrixfine,dstar]=max(ReturnMatrixfine,[],1); ReturnMatrixfine=shiftdim(ReturnMatrixfine,1); - elseif vfoptions.lowmemory==1 - ReturnMatrixfine=zeros(N_aprime,N_a,N_z,'gpuArray'); + elseif vfoptions.lowmemory==1 % loop over z + % Refinement: calculate ReturnMatrix and 'remove' the d dimension + ReturnMatrixfine=zeros(N_aprime,N_a,N_z,'gpuArray'); % 'refined' return matrix dstar=zeros(N_aprime,N_a,N_z,'gpuArray'); l_z=length(n_z); special_n_z=ones(1,l_z); @@ -200,44 +234,39 @@ zvals=z_gridvals(z_c,:); ReturnMatrixfine_z=CreateReturnFnMatrix_Case1_Disc_DC1_Par2(ReturnFn, n_d, special_n_z, d_gridvals, aprime_grid(:,:,z_c), a_grid, zvals, ReturnFnParams,1); ReturnMatrixfine_z=reshape(ReturnMatrixfine_z,[N_d,N_aprime,N_a]); - [ReturnMatrixfine_z,dstar_z]=max(ReturnMatrixfine_z,[],1); + [ReturnMatrixfine_z,dstar_z]=max(ReturnMatrixfine_z,[],1); % solve for dstar ReturnMatrixfine(:,:,z_c)=shiftdim(ReturnMatrixfine_z,1); dstar(:,:,z_c)=shiftdim(dstar_z,1); end end - EVinterpindex2=gpuArray.linspace(1,N_aprimediff,N_aprimediff+(N_aprimediff-1)*vfoptions.ngridinterp)'; - - % Pre-compute interpolation matrix - idx_low = floor(EVinterpindex2); - idx_low = max(1, min(idx_low, N_aprimediff-1)); - idx_high = idx_low + 1; - weight_high = EVinterpindex2 - idx_low; - weight_low = 1 - weight_high; - i_indices = [gpuArray.colon(1,N_aprime)'; gpuArray.colon(1,N_aprime)']; - j_indices = [idx_low; idx_high]; - weights = [weight_low; weight_high]; - interpMatrix = full(sparse(i_indices, j_indices, weights, N_aprime, N_aprimediff)); + EVinterpindex1=gpuArray(1:1:N_aprimediff)'; + EVinterpindex2=gpuArray(linspace(1,N_aprimediff,N_aprimediff+(N_aprimediff-1)*vfoptions.ngridinterp))'; + % For Howards we need addindexforazfine=gpuArray(N_aprime*(0:1:N_a-1)'+N_aprime*N_a*(0:1:N_z-1)); pi_z_alt2=shiftdim(pi_z,-2); - % Perform value fn iteration - currdist=1; + %% Now switch to considering the fine/interpolated aprime_grid + currdist=1; % force going into the next while loop at least one iteration while currdist>vfoptions.tolerance && tempcounter<=vfoptions.maxiter VKronold=VKron; - EVpre=reshape(VKron(aprimeindex,:),[N_aprimediff,N_a,N_z,N_z]); + % Switch VKron into being over vfoptions.maxaprimediff + EVpre=reshape(VKron(aprimeindex,:),[N_aprimediff,N_a,N_z,N_z]); % last dimension is zprime + % Calc the condl expectation term (except beta), which depends on z but not on control variables EV=EVpre.*pi_z_alt2; - EV(isnan(EV))=0; - EV=squeeze(sum(EV,4)); - - % Interpolation of EV is performed as a matrix multiplication - EVinterp = reshape(interpMatrix *reshape(EV, [N_aprimediff,N_a*N_z]), [N_aprime,N_a,N_z]); + EV(isnan(EV))=0; % multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=squeeze(sum(EV,4)); % sum over z', leaving a singular second dimension + % EV is now [N_aprimediff,N_a,N_z] - entireRHS=ReturnMatrixfine+DiscountFactorParamsVec*EVinterp; + % Interpolate EV over aprime_grid + EVinterp=interp1(EVinterpindex1,EV,EVinterpindex2); + + entireRHS=ReturnMatrixfine+DiscountFactorParamsVec*EVinterp; % aprime by a by z + % Calc the max and it's index [VKron,Policy_a]=max(entireRHS,[],1); VKron=shiftdim(VKron,1); @@ -245,18 +274,18 @@ VKrondist(isnan(VKrondist))=0; currdist=max(abs(VKrondist)); - % Howards improvement iteration + % Use Howards Policy Fn Iteration Improvement (except for first few and last few iterations, as it is not a good idea there) if isfinite(currdist) && currdist/vfoptions.tolerance>10 && tempcounter Date: Mon, 23 Feb 2026 14:45:10 +1300 Subject: [PATCH 50/67] minor fix --- ...r_Case1_FHorz_GulPesendorfer_nod_noz_raw.m | 121 +++-------- ...nIter_Case1_FHorz_GulPesendorfer_nod_raw.m | 168 ++-------------- ...nIter_Case1_FHorz_GulPesendorfer_noz_raw.m | 138 ++++--------- ...lueFnIter_Case1_FHorz_GulPesendorfer_raw.m | 188 +++--------------- 4 files changed, 115 insertions(+), 500 deletions(-) diff --git a/ValueFnIter/FHorz/ExoticPrefs/GulPesendorfer/ValueFnIter_Case1_FHorz_GulPesendorfer_nod_noz_raw.m b/ValueFnIter/FHorz/ExoticPrefs/GulPesendorfer/ValueFnIter_Case1_FHorz_GulPesendorfer_nod_noz_raw.m index 361c2c20..67c9c705 100644 --- a/ValueFnIter/FHorz/ExoticPrefs/GulPesendorfer/ValueFnIter_Case1_FHorz_GulPesendorfer_nod_noz_raw.m +++ b/ValueFnIter/FHorz/ExoticPrefs/GulPesendorfer/ValueFnIter_Case1_FHorz_GulPesendorfer_nod_noz_raw.m @@ -7,11 +7,7 @@ %% a_grid=gpuArray(a_grid); - -if vfoptions.lowmemory==1 - special_n_a=ones(1,length(n_a)); - a_gridvals=CreateGridvals(n_a,a_grid,1); % The 1 at end indicates want output in form of matrix. -end +a_gridvals=CreateGridvals(n_a,a_grid,1); % The 1 at end indicates want output in form of matrix. %% j=N_j @@ -20,37 +16,16 @@ TemptationFnParamsVec=CreateVectorFromParams(Parameters, TemptationFnParamNames, N_j); if ~isfield(vfoptions,'V_Jplus1') - if vfoptions.lowmemory==0 - - ReturnMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(ReturnFn, 0, n_a, 0, a_grid, ReturnFnParamsVec,0); - - TemptationMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(TemptationFn, 0, n_a, 0, a_grid, TemptationFnParamsVec,0); - MostTempting=max(TemptationMatrix,[],1); - entireRHS=ReturnMatrix+TemptationMatrix-ones(N_a,1).*MostTempting; - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS,[],1); - V(:,N_j)=Vtemp; - Policy(:,N_j)=maxindex; - - elseif vfoptions.lowmemory==1 - - for a_c=1:N_a - a_val=a_gridvals(a_c,:); - ReturnMatrix_a=CreateReturnFnMatrix_Case1_Disc_noz_Par2(ReturnFn, 0, special_n_a, 0, a_val, ReturnFnParamsVec,0); - - TemptationMatrix_a=CreateReturnFnMatrix_Case1_Disc_noz_Par2(TemptationFn, 0, special_n_a, 0, a_val, TemptationFnParamsVec,0); - MostTempting_a=max(TemptationMatrix_a,[],1); - entireRHS_a=ReturnMatrix_a+TemptationMatrix_a-ones(N_a,1).*MostTempting_a; + ReturnMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(ReturnFn, 0, n_a, 0, a_grid, ReturnFnParamsVec,0); - % Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_a); - V(a_c,N_j)=Vtemp; - Policy(a_c,N_j)=maxindex; + TemptationMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(TemptationFn, 0, n_a, 0, a_grid, TemptationFnParamsVec,0); + MostTempting=max(TemptationMatrix,[],1); + entireRHS=ReturnMatrix+TemptationMatrix-ones(N_a,1).*MostTempting; - end - - end + %Calc the max and it's index + [Vtemp,maxindex]=max(entireRHS,[],1); + V(:,N_j)=Vtemp; + Policy(:,N_j)=maxindex; else % Using V_Jplus1 V_Jplus1=reshape(vfoptions.V_Jplus1,[N_a,1]); % First, switch V_Jplus1 into Kron form @@ -58,36 +33,17 @@ DiscountFactorParamsVec=CreateVectorFromParams(Parameters, DiscountFactorParamNames,N_j); DiscountFactorParamsVec=prod(DiscountFactorParamsVec); - if vfoptions.lowmemory==0 - %if vfoptions.returnmatrix==2 % GPU - ReturnMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(ReturnFn, 0, n_a, 0, a_grid, ReturnFnParamsVec,0); - - TemptationMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(TemptationFn, 0, n_a, 0, a_grid, TemptationFnParamsVec,0); - MostTempting=max(TemptationMatrix,[],1); - entireRHS=ReturnMatrix+TemptationMatrix-ones(N_a,1).*MostTempting+DiscountFactorParamsVec*V_Jplus1; %.*ones(1,N_a); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS,[],1); - - V(:,N_j)=shiftdim(Vtemp,1); - Policy(:,N_j)=shiftdim(maxindex,1); - - elseif vfoptions.lowmemory==1 - for a_c=1:N_a - a_val=a_gridvals(a_c,:); - ReturnMatrix_a=CreateReturnFnMatrix_Case1_Disc_noz_Par2(ReturnFn, 0, special_n_a, 0, a_val, ReturnFnParamsVec,0); - - TemptationMatrix_a=CreateReturnFnMatrix_Case1_Disc_noz_Par2(TemptationFn, 0, special_n_a, 0, a_val, TemptationFnParamsVec,0); - MostTempting_a=max(TemptationMatrix_a,[],1); - entireRHS_a=ReturnMatrix_a+TemptationMatrix_a-ones(N_a,1).*MostTempting_a+DiscountFactorParamsVec*V_Jplus1; - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_a); - V(a_c,N_j)=Vtemp; - Policy(a_c,N_j)=maxindex; - end + ReturnMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(ReturnFn, 0, n_a, 0, a_grid, ReturnFnParamsVec,0); - end + TemptationMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(TemptationFn, 0, n_a, 0, a_grid, TemptationFnParamsVec,0); + MostTempting=max(TemptationMatrix,[],1); + entireRHS=ReturnMatrix+TemptationMatrix-ones(N_a,1).*MostTempting+DiscountFactorParamsVec*V_Jplus1; %.*ones(1,N_a); + + %Calc the max and it's index + [Vtemp,maxindex]=max(entireRHS,[],1); + + V(:,N_j)=shiftdim(Vtemp,1); + Policy(:,N_j)=shiftdim(maxindex,1); end @@ -109,36 +65,17 @@ VKronNext_j=V(:,jj+1); - if vfoptions.lowmemory==0 - %if vfoptions.returnmatrix==2 % GPU - ReturnMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(ReturnFn, 0, n_a, 0, a_grid, ReturnFnParamsVec,0); - - TemptationMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(TemptationFn, 0, n_a, 0, a_grid, TemptationFnParamsVec,0); - MostTempting=max(TemptationMatrix,[],1); - entireRHS=ReturnMatrix+TemptationMatrix-ones(N_a,1).*MostTempting+DiscountFactorParamsVec*VKronNext_j; %.*ones(1,N_a); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS,[],1); - - V(:,jj)=shiftdim(Vtemp,1); - Policy(:,jj)=shiftdim(maxindex,1); - - elseif vfoptions.lowmemory==1 - for a_c=1:N_a - a_val=a_gridvals(a_c,:); - ReturnMatrix_a=CreateReturnFnMatrix_Case1_Disc_noz_Par2(ReturnFn, 0, special_n_a, 0, a_val, ReturnFnParamsVec,0); - - TemptationMatrix_a=CreateReturnFnMatrix_Case1_Disc_noz_Par2(TemptationFn, 0, special_n_a, 0, a_val, TemptationFnParamsVec,0); - MostTempting_a=max(TemptationMatrix_a,[],1); - entireRHS_a=ReturnMatrix_a+TemptationMatrix_a-ones(N_a,1).*MostTempting_a+DiscountFactorParamsVec*VKronNext_j; - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_a); - V(a_c,jj)=Vtemp; - Policy(a_c,jj)=maxindex; - end + ReturnMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(ReturnFn, 0, n_a, 0, a_grid, ReturnFnParamsVec,0); - end + TemptationMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(TemptationFn, 0, n_a, 0, a_grid, TemptationFnParamsVec,0); + MostTempting=max(TemptationMatrix,[],1); + entireRHS=ReturnMatrix+TemptationMatrix-ones(N_a,1).*MostTempting+DiscountFactorParamsVec*VKronNext_j; %.*ones(1,N_a); + + %Calc the max and it's index + [Vtemp,maxindex]=max(entireRHS,[],1); + + V(:,jj)=shiftdim(Vtemp,1); + Policy(:,jj)=shiftdim(maxindex,1); end diff --git a/ValueFnIter/FHorz/ExoticPrefs/GulPesendorfer/ValueFnIter_Case1_FHorz_GulPesendorfer_nod_raw.m b/ValueFnIter/FHorz/ExoticPrefs/GulPesendorfer/ValueFnIter_Case1_FHorz_GulPesendorfer_nod_raw.m index 60e429f5..c41a17cc 100644 --- a/ValueFnIter/FHorz/ExoticPrefs/GulPesendorfer/ValueFnIter_Case1_FHorz_GulPesendorfer_nod_raw.m +++ b/ValueFnIter/FHorz/ExoticPrefs/GulPesendorfer/ValueFnIter_Case1_FHorz_GulPesendorfer_nod_raw.m @@ -8,16 +8,12 @@ %% a_grid=gpuArray(a_grid); +a_gridvals=CreateGridvals(n_a,a_grid,1); % The 1 at end indicates want output in form of matrix. if vfoptions.lowmemory>0 l_z=length(n_z); special_n_z=ones(1,l_z); end -if vfoptions.lowmemory>1 - special_n_a=ones(1,length(n_a)); - a_gridvals=CreateGridvals(n_a,a_grid,1); % The 1 at end indicates want output in form of matrix. -end - %% j=N_j % Create a vector containing all the return function parameters (in order) @@ -53,26 +49,6 @@ V(:,z_c,N_j)=Vtemp; Policy(:,z_c,N_j)=maxindex; end - - elseif vfoptions.lowmemory==2 - - for z_c=1:N_z - z_val=z_gridvals_J(z_c,:,N_j); - for a_c=1:N_a - a_val=a_gridvals(a_c,:); - ReturnMatrix_az=CreateReturnFnMatrix_Case1_Disc_Par2(ReturnFn, 0, special_n_a, special_n_z, 0, a_val, z_val, ReturnFnParamsVec,0); - - TemptationMatrix_az=CreateReturnFnMatrix_Case1_Disc_Par2(TemptationFn, 0, special_n_a, special_n_z, 0, a_val, z_val, TemptationFnParamsVec,0); - MostTempting_az=max(TemptationMatrix_az,[],1); - entireRHS_az=ReturnMatrix_az+TemptationMatrix_az-ones(N_a,1).*MostTempting_az; - - % Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_az); - V(a_c,z_c,N_j)=Vtemp; - Policy(a_c,z_c,N_j)=maxindex; - end - end - end else % Using V_Jplus1 @@ -88,43 +64,18 @@ TemptationMatrix=CreateReturnFnMatrix_Case1_Disc_Par2(TemptationFn, 0, n_a, n_z, 0, a_grid, z_gridvals_J(:,:,N_j), TemptationFnParamsVec,0); MostTempting=max(TemptationMatrix,[],1); - if vfoptions.paroverz==1 - % (aprime,a,z) - - % Use sparse for a few lines until sum over zprime - EV=V_Jplus1.*shiftdim(pi_z_J(:,:,N_j)',-1); - EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV=sum(EV,2); % sum over z', leaving a singular second dimension - - entireRHS=ReturnMatrix+TemptationMatrix-ones(N_a,1).*MostTempting+DiscountFactorParamsVec*EV;%.*ones(1,N_a,1); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS,[],1); - - V(:,:,N_j)=shiftdim(Vtemp,1); - Policy(:,:,N_j)=shiftdim(maxindex,1); + % Use sparse for a few lines until sum over zprime + EV=V_Jplus1.*shiftdim(pi_z_J(:,:,N_j)',-1); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=sum(EV,2); % sum over z', leaving a singular second dimension - elseif vfoptions.paroverz==0 + entireRHS=ReturnMatrix+TemptationMatrix-ones(N_a,1).*MostTempting+DiscountFactorParamsVec*EV;%.*ones(1,N_a,1); - for z_c=1:N_z - ReturnMatrix_z=ReturnMatrix(:,:,z_c); - TemptationMatrix_z=ReturnMatrix(:,:,z_c); - MostTempting_z=MostTempting(1,:,z_c); - - %Calc the condl expectation term (except beta), which depends on z but - %not on control variables - EV_z=V_Jplus1.*(ones(N_a,1,'gpuArray')*pi_z_J(z_c,:,N_j)); - EV_z(isnan(EV_z))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV_z=sum(EV_z,2); + %Calc the max and it's index + [Vtemp,maxindex]=max(entireRHS,[],1); - entireRHS_z=ReturnMatrix_z+TemptationMatrix_z-ones(N_a,1).*MostTempting_z+DiscountFactorParamsVec*EV_z; %*ones(1,N_a,1); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_z,[],1); - V(:,z_c,N_j)=Vtemp; - Policy(:,z_c,N_j)=maxindex; - end - end + V(:,:,N_j)=shiftdim(Vtemp,1); + Policy(:,:,N_j)=shiftdim(maxindex,1); elseif vfoptions.lowmemory==1 for z_c=1:N_z @@ -147,31 +98,6 @@ V(:,z_c,N_j)=Vtemp; Policy(:,z_c,N_j)=maxindex; end - - elseif vfoptions.lowmemory==2 - for z_c=1:N_z - %Calc the condl expectation term (except beta), which depends on z but - %not on control variables - EV_z=V_Jplus1.*(ones(N_a,1,'gpuArray')*pi_z_J(z_c,:,N_j)); - EV_z(isnan(EV_z))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV_z=sum(EV_z,2); - - z_val=z_gridvals_J(z_c,:,N_j); - for a_c=1:N_a - a_val=a_gridvals(a_c,:); - ReturnMatrix_az=CreateReturnFnMatrix_Case1_Disc_Par2(ReturnFn, 0, special_n_a, special_n_z, 0, a_val, z_val, ReturnFnParamsVec,0); - - TemptationMatrix_az=CreateReturnFnMatrix_Case1_Disc_Par2(TemptationFn, 0, special_n_a, special_n_z, 0, a_val, z_val, TemptationFnParamsVec,0); - MostTempting_az=max(TemptationMatrix_az,[],1); - - entireRHS_az=ReturnMatrix_az+TemptationMatrix_az-ones(N_a,1).*MostTempting_az+DiscountFactorParamsVec*EV_z; - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_az); - V(a_c,z_c,N_j)=Vtemp; - Policy(a_c,z_c,N_j)=maxindex; - end - end - end end @@ -199,44 +125,19 @@ TemptationMatrix=CreateReturnFnMatrix_Case1_Disc_Par2(TemptationFn, 0, n_a, n_z, 0, a_grid, z_gridvals_J(:,:,jj), TemptationFnParamsVec,0); MostTempting=max(TemptationMatrix,[],1); - - if vfoptions.paroverz==1 - % (aprime,a,z) - % Use sparse for a few lines until sum over zprime - EV=VKronNext_j.*shiftdim(pi_z_J(:,:,jj)',-1); - EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV=sum(EV,2); % sum over z', leaving a singular second dimension - - entireRHS=ReturnMatrix+TemptationMatrix-ones(N_a,1).*MostTempting+DiscountFactorParamsVec*EV; %.*ones(1,N_a,1); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS,[],1); - - V(:,:,jj)=shiftdim(Vtemp,1); - Policy(:,:,jj)=shiftdim(maxindex,1); - - elseif vfoptions.paroverz==0 - - for z_c=1:N_z - ReturnMatrix_z=ReturnMatrix(:,:,z_c); - TemptationMatrix_z=ReturnMatrix(:,:,z_c); - MostTempting_z=MostTempting(1,:,z_c); - - %Calc the condl expectation term (except beta), which depends on z but - %not on control variables - EV_z=VKronNext_j.*(ones(N_a,1,'gpuArray')*pi_z_J(z_c,:,jj)); - EV_z(isnan(EV_z))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV_z=sum(EV_z,2); - - entireRHS_z=ReturnMatrix_z+TemptationMatrix_z-ones(N_a,1).*MostTempting_z+DiscountFactorParamsVec*EV_z; %*ones(1,N_a,1); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_z,[],1); - V(:,z_c,jj)=Vtemp; - Policy(:,z_c,jj)=maxindex; - end - end + % Use sparse for a few lines until sum over zprime + EV=VKronNext_j.*shiftdim(pi_z_J(:,:,jj)',-1); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=sum(EV,2); % sum over z', leaving a singular second dimension + + entireRHS=ReturnMatrix+TemptationMatrix-ones(N_a,1).*MostTempting+DiscountFactorParamsVec*EV; %.*ones(1,N_a,1); + + %Calc the max and it's index + [Vtemp,maxindex]=max(entireRHS,[],1); + + V(:,:,jj)=shiftdim(Vtemp,1); + Policy(:,:,jj)=shiftdim(maxindex,1); elseif vfoptions.lowmemory==1 for z_c=1:N_z @@ -259,31 +160,6 @@ V(:,z_c,jj)=Vtemp; Policy(:,z_c,jj)=maxindex; end - - elseif vfoptions.lowmemory==2 - for z_c=1:N_z - %Calc the condl expectation term (except beta), which depends on z but - %not on control variables - EV_z=VKronNext_j.*(ones(N_a,1,'gpuArray')*pi_z_J(z_c,:,jj)); - EV_z(isnan(EV_z))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV_z=sum(EV_z,2); - - z_val=z_gridvals_J(z_c,:,jj); - for a_c=1:N_a - a_val=a_gridvals(a_c,:); - ReturnMatrix_az=CreateReturnFnMatrix_Case1_Disc_Par2(ReturnFn, 0, special_n_a, special_n_z, 0, a_val, z_val, ReturnFnParamsVec,0); - - TemptationMatrix_az=CreateReturnFnMatrix_Case1_Disc_Par2(TemptationFn, 0, special_n_a, special_n_z, 0, a_val, z_val, TemptationFnParamsVec,0); - MostTempting_az=max(TemptationMatrix_az,[],1); - - entireRHS_az=ReturnMatrix_az+TemptationMatrix_az-ones(N_a,1).*MostTempting_az+DiscountFactorParamsVec*EV_z; - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_az); - V(a_c,z_c,jj)=Vtemp; - Policy(a_c,z_c,jj)=maxindex; - end - end - end end diff --git a/ValueFnIter/FHorz/ExoticPrefs/GulPesendorfer/ValueFnIter_Case1_FHorz_GulPesendorfer_noz_raw.m b/ValueFnIter/FHorz/ExoticPrefs/GulPesendorfer/ValueFnIter_Case1_FHorz_GulPesendorfer_noz_raw.m index 59ef2f62..778e6cd1 100644 --- a/ValueFnIter/FHorz/ExoticPrefs/GulPesendorfer/ValueFnIter_Case1_FHorz_GulPesendorfer_noz_raw.m +++ b/ValueFnIter/FHorz/ExoticPrefs/GulPesendorfer/ValueFnIter_Case1_FHorz_GulPesendorfer_noz_raw.m @@ -10,10 +10,7 @@ d_grid=gpuArray(d_grid); a_grid=gpuArray(a_grid); -if vfoptions.lowmemory>0 - special_n_a=ones(1,length(n_a)); - a_gridvals=CreateGridvals(n_a,a_grid,1); % The 1 at end indicates want output in form of matrix. -end +a_gridvals=CreateGridvals(n_a,a_grid,1); % The 1 at end indicates want output in form of matrix. %% j=N_j @@ -22,35 +19,16 @@ TemptationFnParamsVec=CreateVectorFromParams(Parameters, TemptationFnParamNames, N_j); if ~isfield(vfoptions,'V_Jplus1') - if vfoptions.lowmemory==0 - %if vfoptions.returnmatrix==2 % GPU - ReturnMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(ReturnFn, n_d, n_a, d_grid, a_grid, ReturnFnParamsVec,0); - - TemptationMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(TemptationFn, n_d, n_a, d_grid, a_grid, TemptationFnParamsVec,0); - MostTempting=max(TemptationMatrix,[],1); - entireRHS=ReturnMatrix+TemptationMatrix-ones(N_d*N_a,1).*MostTempting; - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS,[],1); - V(:,N_j)=Vtemp; - Policy(:,N_j)=maxindex; - - elseif vfoptions.lowmemory==1 - %if vfoptions.returnmatrix==2 % GPU - for a_c=1:N_a - a_val=a_gridvals(a_c,:); - ReturnMatrix_a=CreateReturnFnMatrix_Case1_Disc_noz_Par2(ReturnFn, n_d, special_n_a, d_grid, a_val, ReturnFnParamsVec,0); - - TemptationMatrix_a=CreateReturnFnMatrix_Case1_Disc_noz_Par2(TemptationFn, n_d, special_n_a, d_grid, a_val, TemptationFnParamsVec,0); - MostTempting_a=max(TemptationMatrix_a,[],1); - entireRHS_a=ReturnMatrix_a+TemptationMatrix_a-ones(N_d*N_a,1).*MostTempting_a; - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_a,[],1); - V(a_c,N_j)=Vtemp; - Policy(a_c,N_j)=maxindex; - end - end + ReturnMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(ReturnFn, n_d, n_a, d_grid, a_grid, ReturnFnParamsVec,0); + + TemptationMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(TemptationFn, n_d, n_a, d_grid, a_grid, TemptationFnParamsVec,0); + MostTempting=max(TemptationMatrix,[],1); + entireRHS=ReturnMatrix+TemptationMatrix-ones(N_d*N_a,1).*MostTempting; + + %Calc the max and it's index + [Vtemp,maxindex]=max(entireRHS,[],1); + V(:,N_j)=Vtemp; + Policy(:,N_j)=maxindex; else % Using V_Jplus1 V_Jplus1=reshape(vfoptions.V_Jplus1,[N_a,1]); % First, switch V_Jplus1 into Kron form @@ -58,40 +36,19 @@ DiscountFactorParamsVec=CreateVectorFromParams(Parameters, DiscountFactorParamNames,N_j); DiscountFactorParamsVec=prod(DiscountFactorParamsVec); - if vfoptions.lowmemory==0 - - %if vfoptions.returnmatrix==2 % GPU - ReturnMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(ReturnFn, n_d, n_a, d_grid, a_grid, ReturnFnParamsVec,0); - % (d,aprime,a) - - entireEV=kron(V_Jplus1,ones(N_d,1)); - - TemptationMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(TemptationFn, n_d, n_a, d_grid, a_grid, TemptationFnParamsVec,0); - MostTempting=max(TemptationMatrix,[],1); - entireRHS=ReturnMatrix+TemptationMatrix-ones(N_d*N_a,1).*MostTempting+DiscountFactorParamsVec*entireEV; %*ones(1,N_a,1); % aprime-by-a - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS,[],1); - V(:,N_j)=Vtemp; - Policy(:,N_j)=maxindex; - - elseif vfoptions.lowmemory==1 - - for a_c=1:N_a - a_val=a_gridvals(a_c,:); - ReturnMatrix_a=CreateReturnFnMatrix_Case1_Disc_noz_Par2(ReturnFn, n_d, special_n_a, d_grid, a_val, ReturnFnParamsVec,0); - - TemptationMatrix_a=CreateReturnFnMatrix_Case1_Disc_noz_Par2(TemptationFn, n_d, special_n_a, d_grid, a_val, TemptationFnParamsVec,0); - MostTempting_a=max(TemptationMatrix_a,[],1); - entireRHS_a=ReturnMatrix_a+TemptationMatrix_a-ones(N_d*N_a,1).*MostTempting_a+DiscountFactorParamsVec*V_Jplus1; % aprime-by-1 - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_a,[],1); - V(a_c,N_j)=Vtemp; - Policy(a_c,N_j)=maxindex; - end - - end + ReturnMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(ReturnFn, n_d, n_a, d_grid, a_grid, ReturnFnParamsVec,0); + % (d,aprime,a) + + entireEV=kron(V_Jplus1,ones(N_d,1)); + + TemptationMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(TemptationFn, n_d, n_a, d_grid, a_grid, TemptationFnParamsVec,0); + MostTempting=max(TemptationMatrix,[],1); + entireRHS=ReturnMatrix+TemptationMatrix-ones(N_d*N_a,1).*MostTempting+DiscountFactorParamsVec*entireEV; %*ones(1,N_a,1); % aprime-by-a + + %Calc the max and it's index + [Vtemp,maxindex]=max(entireRHS,[],1); + V(:,N_j)=Vtemp; + Policy(:,N_j)=maxindex; end %% Iterate backwards through j. @@ -111,40 +68,19 @@ VKronNext_j=V(:,jj+1); - if vfoptions.lowmemory==0 - - %if vfoptions.returnmatrix==2 % GPU - ReturnMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(ReturnFn, n_d, n_a, d_grid, a_grid, ReturnFnParamsVec,0); - % (d,aprime,a) - - entireEV=kron(VKronNext_j,ones(N_d,1)); - - TemptationMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(TemptationFn, n_d, n_a, d_grid, a_grid, TemptationFnParamsVec,0); - MostTempting=max(TemptationMatrix,[],1); - entireRHS=ReturnMatrix+TemptationMatrix-ones(N_d*N_a,1).*MostTempting+DiscountFactorParamsVec*entireEV; %*ones(1,N_a,1); % aprime-by-a - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS,[],1); - V(:,jj)=Vtemp; - Policy(:,jj)=maxindex; - - elseif vfoptions.lowmemory==1 - - for a_c=1:N_a - a_val=a_gridvals(a_c,:); - ReturnMatrix_a=CreateReturnFnMatrix_Case1_Disc_noz_Par2(ReturnFn, n_d, special_n_a, d_grid, a_val, ReturnFnParamsVec,0); - - TemptationMatrix_a=CreateReturnFnMatrix_Case1_Disc_noz_Par2(TemptationFn, n_d, special_n_a, d_grid, a_val, TemptationFnParamsVec,0); - MostTempting_a=max(TemptationMatrix_a,[],1); - entireRHS_a=ReturnMatrix_a+TemptationMatrix_a-ones(N_d*N_a,1).*MostTempting_a+DiscountFactorParamsVec*VKronNext_j; % aprime-by-1 - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_a,[],1); - V(a_c,jj)=Vtemp; - Policy(a_c,jj)=maxindex; - end - - end + ReturnMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(ReturnFn, n_d, n_a, d_grid, a_grid, ReturnFnParamsVec,0); + % (d,aprime,a) + + entireEV=kron(VKronNext_j,ones(N_d,1)); + + TemptationMatrix=CreateReturnFnMatrix_Case1_Disc_noz_Par2(TemptationFn, n_d, n_a, d_grid, a_grid, TemptationFnParamsVec,0); + MostTempting=max(TemptationMatrix,[],1); + entireRHS=ReturnMatrix+TemptationMatrix-ones(N_d*N_a,1).*MostTempting+DiscountFactorParamsVec*entireEV; %*ones(1,N_a,1); % aprime-by-a + + %Calc the max and it's index + [Vtemp,maxindex]=max(entireRHS,[],1); + V(:,jj)=Vtemp; + Policy(:,jj)=maxindex; end %% diff --git a/ValueFnIter/FHorz/ExoticPrefs/GulPesendorfer/ValueFnIter_Case1_FHorz_GulPesendorfer_raw.m b/ValueFnIter/FHorz/ExoticPrefs/GulPesendorfer/ValueFnIter_Case1_FHorz_GulPesendorfer_raw.m index a5910634..56cf0fda 100644 --- a/ValueFnIter/FHorz/ExoticPrefs/GulPesendorfer/ValueFnIter_Case1_FHorz_GulPesendorfer_raw.m +++ b/ValueFnIter/FHorz/ExoticPrefs/GulPesendorfer/ValueFnIter_Case1_FHorz_GulPesendorfer_raw.m @@ -12,14 +12,8 @@ a_grid=gpuArray(a_grid); if vfoptions.lowmemory>0 - l_z=length(n_z); special_n_z=ones(1,length(n_z)); end -if vfoptions.lowmemory>1 - special_n_a=ones(1,length(n_a)); - a_gridvals=CreateGridvals(n_a,a_grid,1); % The 1 at end indicates want output in form of matrix. -end - %% j=N_j @@ -58,28 +52,6 @@ V(:,z_c,N_j)=Vtemp; Policy(:,z_c,N_j)=maxindex; end - - elseif vfoptions.lowmemory==2 - - %if vfoptions.returnmatrix==2 % GPU - for z_c=1:N_z - z_val=z_gridvals_J(z_c,:,N_j); - for a_c=1:N_a - a_val=a_gridvals(a_c,:); - ReturnMatrix_az=CreateReturnFnMatrix_Case1_Disc_Par2(ReturnFn, n_d, special_n_a, special_n_z, d_grid, a_val, z_val, ReturnFnParamsVec); - - TemptationMatrix_az=CreateReturnFnMatrix_Case1_Disc_Par2(TemptationFn, n_d, special_n_a, special_n_z, d_grid, a_val, z_val, TemptationFnParamsVec); - MostTempting_az=max(TemptationMatrix_az,[],1); - entireRHS_az=ReturnMatrix_az+TemptationMatrix_az-ones(N_d*N_a,1).*MostTempting_az; - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_az); - V(a_c,z_c,N_j)=Vtemp; - Policy(a_c,z_c,N_j)=maxindex; - - end - end - end else % Using V_Jplus1 @@ -95,47 +67,21 @@ TemptationMatrix=CreateReturnFnMatrix_Case1_Disc_Par2(TemptationFn, n_d, n_a, n_z, d_grid, a_grid, z_gridvals_J(:,:,N_j), TemptationFnParamsVec); MostTempting=max(TemptationMatrix,[],1); - - if vfoptions.paroverz==1 - - EV=V_Jplus1.*shiftdim(pi_z_J(:,:,N_j)',-1); - EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV=sum(EV,2); % sum over z', leaving a singular second dimension - - entireEV=kron(EV,ones(N_d,1)); -% entireEV=repelem(EV,N_d,1,1); % I tried this instead but appears repelem() is slower than kron() - entireRHS=ReturnMatrix+TemptationMatrix-ones(N_d*N_a,1).*MostTempting+DiscountFactorParamsVec*entireEV; %*repmat(entireEV,1,N_a,1); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS,[],1); - - V(:,:,N_j)=shiftdim(Vtemp,1); - Policy(:,:,N_j)=shiftdim(maxindex,1); - - - elseif vfoptions.paroverz==0 - - for z_c=1:N_z - ReturnMatrix_z=ReturnMatrix(:,:,z_c); - TemptationMatrix_z=TemptationMatrix(:,:,z_c); - MostTempting_z=MostTempting(1,:,z_c); - - %Calc the condl expectation term (except beta), which depends on z but not on control variables - EV_z=V_Jplus1.*(ones(N_a,1,'gpuArray')*pi_z_J(z_c,:,N_j)); - EV_z(isnan(EV_z))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV_z=sum(EV_z,2); - - entireEV_z=kron(EV_z,ones(N_d,1)); - - entireRHS_z=ReturnMatrix_z+TemptationMatrix_z-ones(N_d*N_a,1).*MostTempting_z+DiscountFactorParamsVec*entireEV_z; %*ones(1,N_a,1); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_z,[],1); - V(:,z_c,N_j)=Vtemp; - Policy(:,z_c,N_j)=maxindex; - end - end + EV=V_Jplus1.*shiftdim(pi_z_J(:,:,N_j)',-1); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=sum(EV,2); % sum over z', leaving a singular second dimension + + entireEV=kron(EV,ones(N_d,1)); + % entireEV=repelem(EV,N_d,1,1); % I tried this instead but appears repelem() is slower than kron() + + entireRHS=ReturnMatrix+TemptationMatrix-ones(N_d*N_a,1).*MostTempting+DiscountFactorParamsVec*entireEV; %*repmat(entireEV,1,N_a,1); + + %Calc the max and it's index + [Vtemp,maxindex]=max(entireRHS,[],1); + + V(:,:,N_j)=shiftdim(Vtemp,1); + Policy(:,:,N_j)=shiftdim(maxindex,1); elseif vfoptions.lowmemory==1 for z_c=1:N_z @@ -159,33 +105,6 @@ V(:,z_c,N_j)=Vtemp; Policy(:,z_c,N_j)=maxindex; end - - elseif vfoptions.lowmemory==2 - for z_c=1:N_z - %Calc the condl expectation term (except beta), which depends on z but - %not on control variables - EV_z=V_Jplus1.*(ones(N_a,1,'gpuArray')*pi_z_J(z_c,:,N_j)); - EV_z(isnan(EV_z))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV_z=sum(EV_z,2); - - entireEV_z=kron(EV_z,ones(N_d,1)); - - z_val=z_gridvals_J(z_c,:,N_j); - for a_c=1:N_a - a_val=a_gridvals(a_c,:); - ReturnMatrix_az=CreateReturnFnMatrix_Case1_Disc_Par2(ReturnFn, n_d, special_n_a, special_n_z, d_grid, a_val, z_val, ReturnFnParamsVec); - - TemptationMatrix_az=CreateReturnFnMatrix_Case1_Disc_Par2(TemptationFn, n_d, special_n_a, special_n_z, d_grid, a_val, z_val, TemptationFnParamsVec); - MostTempting_az=max(TemptationMatrix_az,[],1); - entireRHS_az=ReturnMatrix_az+TemptationMatrix_az-ones(N_d*N_a,1).*MostTempting_az+DiscountFactorParamsVec*entireEV_z; - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_az); - V(a_c,z_c,N_j)=Vtemp; - Policy(a_c,z_c,N_j)=maxindex; - end - end - end end @@ -213,45 +132,19 @@ TemptationMatrix=CreateReturnFnMatrix_Case1_Disc_Par2(TemptationFn, n_d, n_a, n_z, d_grid, a_grid, z_gridvals_J(:,:,jj), TemptationFnParamsVec); MostTempting=max(TemptationMatrix,[],1); - if vfoptions.paroverz==1 - - EV=VKronNext_j.*shiftdim(pi_z_J(:,:,jj)',-1); - EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV=sum(EV,2); % sum over z', leaving a singular second dimension - - entireEV=repelem(EV,N_d,1,1); + EV=VKronNext_j.*shiftdim(pi_z_J(:,:,jj)',-1); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=sum(EV,2); % sum over z', leaving a singular second dimension - entireRHS=ReturnMatrix+TemptationMatrix-ones(N_d*N_a,1).*MostTempting+DiscountFactorParamsVec*entireEV; %*repmat(entireEV,1,N_a,1); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS,[],1); - - V(:,:,jj)=shiftdim(Vtemp,1); - Policy(:,:,jj)=shiftdim(maxindex,1); - - - elseif vfoptions.paroverz==0 - - for z_c=1:N_z - ReturnMatrix_z=ReturnMatrix(:,:,z_c); - TemptationMatrix_z=TemptationMatrix(:,:,z_c); - MostTempting_z=MostTempting(1,:,z_c); - - %Calc the condl expectation term (except beta), which depends on z but not on control variables - EV_z=VKronNext_j.*(ones(N_a,1,'gpuArray')*pi_z_J(z_c,:,jj)); - EV_z(isnan(EV_z))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV_z=sum(EV_z,2); - - entireEV_z=kron(EV_z,ones(N_d,1)); - - entireRHS_z=ReturnMatrix_z+TemptationMatrix_z-ones(N_d*N_a,1).*MostTempting_z+DiscountFactorParamsVec*entireEV_z; %*ones(1,N_a,1); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_z,[],1); - V(:,z_c,jj)=Vtemp; - Policy(:,z_c,jj)=maxindex; - end - end + entireEV=repelem(EV,N_d,1,1); + + entireRHS=ReturnMatrix+TemptationMatrix-ones(N_d*N_a,1).*MostTempting+DiscountFactorParamsVec*entireEV; %*repmat(entireEV,1,N_a,1); + + %Calc the max and it's index + [Vtemp,maxindex]=max(entireRHS,[],1); + + V(:,:,jj)=shiftdim(Vtemp,1); + Policy(:,:,jj)=shiftdim(maxindex,1); elseif vfoptions.lowmemory==1 for z_c=1:N_z @@ -274,34 +167,7 @@ [Vtemp,maxindex]=max(entireRHS_z,[],1); V(:,z_c,jj)=Vtemp; Policy(:,z_c,jj)=maxindex; - end - - elseif vfoptions.lowmemory==2 - for z_c=1:N_z - %Calc the condl expectation term (except beta), which depends on z but - %not on control variables - EV_z=VKronNext_j.*(ones(N_a,1,'gpuArray')*pi_z_J(z_c,:,jj)); - EV_z(isnan(EV_z))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV_z=sum(EV_z,2); - - entireEV_z=kron(EV_z,ones(N_d,1)); - - z_val=z_gridvals_J(z_c,:,jj); - for a_c=1:N_a - a_val=a_gridvals(a_c,:); - ReturnMatrix_az=CreateReturnFnMatrix_Case1_Disc_Par2(ReturnFn, n_d, special_n_a, special_n_z, d_grid, a_val, z_val, ReturnFnParamsVec); - - TemptationMatrix_az=CreateReturnFnMatrix_Case1_Disc_Par2(TemptationFn, n_d, special_n_a, special_n_z, d_grid, a_val, z_val, TemptationFnParamsVec); - MostTempting_az=max(TemptationMatrix_az,[],1); - entireRHS_az=ReturnMatrix_az+TemptationMatrix_az-ones(N_d*N_a,1).*MostTempting_az+DiscountFactorParamsVec*entireEV_z; - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_az); - V(a_c,z_c,jj)=Vtemp; - Policy(a_c,z_c,jj)=maxindex; - end - end - + end end end From 5584246711fed2de6d5a0891ac3ae3ee1984e386 Mon Sep 17 00:00:00 2001 From: Michael Tiemann Date: Thu, 26 Feb 2026 06:21:20 +1300 Subject: [PATCH 51/67] Support an addition case Support the noz case as well. --- .../FHorz/ExpAsset/StationaryDist_FHorz_ExpAsset_noz.m | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/StationaryDist/FHorz/ExpAsset/StationaryDist_FHorz_ExpAsset_noz.m b/StationaryDist/FHorz/ExpAsset/StationaryDist_FHorz_ExpAsset_noz.m index 0959fe46..4f00db08 100644 --- a/StationaryDist/FHorz/ExpAsset/StationaryDist_FHorz_ExpAsset_noz.m +++ b/StationaryDist/FHorz/ExpAsset/StationaryDist_FHorz_ExpAsset_noz.m @@ -51,8 +51,11 @@ elseif l_a==3 % experience asset and two other assets Policy_aprime(:,1,jj)=shiftdim(Policy(l_d+1,:,jj),1)+n_a(1)*(shiftdim(Policy(l_d+2,:,jj),1)-1)+prod(n_a(1:2))*(aprimeIndexes-1); Policy_aprime(:,2,jj)=Policy_aprime(:,1,jj)+prod(n_a(1:2)); + elseif l_a==4 % three other assets, then experience asset + Policy_aprime(:,1,jj)=shiftdim(Policy(l_d+1,:,jj),1)+n_a(1)*(shiftdim(Policy(l_d+2,:,jj),1)-1)+prod(n_a(1:2))*(shiftdim(Policy(l_d+3,:,jj),1)-1)+prod(n_a(1:3))*(aprimeIndexes-1); + Policy_aprime(:,2,jj)=Policy_aprime(:,1,jj)+prod(n_a(1:3)); else - error('Not yet implemented experience asset with length(n_a)>3') + error('Not yet implemented experience asset with length(n_a)>4') end PolicyProbs(:,1,jj)=aprimeProbs; PolicyProbs(:,2,jj)=1-aprimeProbs; From 0d44f610a512b0d076be43b34fbec152ead851fb Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Tue, 3 Mar 2026 13:11:45 +1300 Subject: [PATCH 52/67] small improvement --- ...Horz_TPath_SingleStep_fastOLG_DC1_GI_e_raw.m | 17 ++++++++--------- ..._TPath_SingleStep_fastOLG_DC1_GI_noz_e_raw.m | 11 +++++------ ...rz_TPath_SingleStep_fastOLG_DC1_GI_noz_raw.m | 6 +++--- ..._FHorz_TPath_SingleStep_fastOLG_DC1_GI_raw.m | 13 ++++++------- 4 files changed, 22 insertions(+), 25 deletions(-) diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_e_raw.m index b984053a..d8cae53f 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_e_raw.m @@ -75,8 +75,7 @@ DiscountedEV=DiscountFactorParamsVec.*EV; DiscountedEV=repelem(shiftdim(DiscountedEV,-1),N_d,1,1,1); % [d,aprime,1,j,z] -DiscountedEVinterp=DiscountFactorParamsVec.*EVinterp; -DiscountedEVinterp=repelem(shiftdim(DiscountedEVinterp,-1),N_d,1,1,1); % [d,aprime,1,j,z] +DiscountedEVinterp=DiscountFactorParamsVec.*EVinterp; % [n2aprime fine,1,j,z] if vfoptions.lowmemory==0 @@ -117,8 +116,8 @@ aprimeindexes=(midpoints_jj+(midpoints_jj-1)*n2short)+(-n2short-1:1:1+n2short); % aprime points either side of midpoint % aprime possibilities are n_d-by-n2long-by-n_a-by-N_j-by-n_z-by-n_e ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_Par2e(ReturnFn,n_d, n_z,n_e,N_j,d_gridvals,aprime_grid(aprimeindexes),a_grid, z_gridvals_J,e_gridvals_J, ReturnFnParamsAgeMatrix,2); - daprimejz=(1:1:N_d)'+N_d*(aprimeindexes-1)+N_d*n2aprime*jind+N_d*n2aprime*N_j*zind; - entireRHS_ii=ReturnMatrix_ii+reshape(DiscountedEVinterp(daprimejz(:)),[N_d*n2long,N_a,N_j,N_z,N_e]); + aprimejz=aprimeindexes+n2aprime*jind+n2aprime*N_j*zind; + entireRHS_ii=ReturnMatrix_ii+reshape(DiscountedEVinterp(aprimejz(:)),[N_d*n2long,N_a,N_j,N_z,N_e]); [V,maxindexL2]=max(entireRHS_ii,[],1); V=reshape(V,[N_a*N_j,N_z,N_e]); d_ind=rem(maxindexL2-1,N_d)+1; @@ -172,8 +171,8 @@ aprimeindexes=(midpoints_jj+(midpoints_jj-1)*n2short)+(-n2short-1:1:1+n2short); % aprime points either side of midpoint % aprime possibilities are n_d-by-n2long-by-n_a-by-N_j-by-n_z ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_Par2e(ReturnFn,n_d, n_z,special_n_e,N_j,d_gridvals,aprime_grid(aprimeindexes),a_grid, z_gridvals_J,e_vals, ReturnFnParamsAgeMatrix,2); - daprimejz=(1:1:N_d)'+N_d*(aprimeindexes-1)+N_d*n2aprime*jind+N_d*n2aprime*N_j*zind; - entireRHS_ii=ReturnMatrix_ii+reshape(DiscountedEVinterp(daprimejz(:)),[N_d*n2long,N_a,N_j,N_z]); + aprimejz=aprimeindexes+n2aprime*jind+n2aprime*N_j*zind; + entireRHS_ii=ReturnMatrix_ii+reshape(DiscountedEVinterp(aprimejz(:)),[N_d*n2long,N_a,N_j,N_z]); [Vtemp,maxindexL2]=max(entireRHS_ii,[],1); V(:,:,e_c)=reshape(Vtemp,[N_a*N_j,N_z]); d_ind=rem(maxindexL2-1,N_d)+1; @@ -192,7 +191,7 @@ for z_c=1:N_z z_vals=z_gridvals_J(1,1,1,:,z_c,:); % z_gridvals_J has shape (1,1,1,N_j,N_z,l_z) for fastOLG DiscountedEV_z=DiscountedEV(:,:,:,:,z_c); - DiscountedEVinterp_z=DiscountedEVinterp(:,:,:,:,z_c); + DiscountedEVinterp_z=DiscountedEVinterp(:,:,:,z_c); for e_c=1:N_e e_vals=e_gridvals_J(1,1,1,:,1,e_c,:); % e_gridvals_J has shape (1,1,1,N_j,1,N_z,l_z) for fastOLG with d @@ -234,8 +233,8 @@ aprimeindexes=(midpoints_jj+(midpoints_jj-1)*n2short)+(-n2short-1:1:1+n2short); % aprime points either side of midpoint % aprime possibilities are n_d-by-n2long-by-n_a-by-N_j ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_Par2e(ReturnFn,n_d, special_n_z,special_n_e,N_j,d_gridvals,aprime_grid(aprimeindexes),a_grid, z_vals,e_vals, ReturnFnParamsAgeMatrix,2); - daprimej=(1:1:N_d)'+N_d*(aprimeindexes-1)+N_d*n2aprime*jind; - entireRHS_ii=ReturnMatrix_ii+reshape(DiscountedEVinterp_z(daprimej(:)),[N_d*n2long,N_a,N_j]); + aprimej=aprimeindexes+n2aprime*jind; + entireRHS_ii=ReturnMatrix_ii+reshape(DiscountedEVinterp_z(aprimej(:)),[N_d*n2long,N_a,N_j]); [Vtemp,maxindexL2]=max(entireRHS_ii,[],1); V(:,z_c,e_c)=reshape(Vtemp,[N_a*N_j,1]); d_ind=rem(maxindexL2-1,N_d)+1; diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_e_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_e_raw.m index f45768e8..95444162 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_e_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_e_raw.m @@ -67,8 +67,7 @@ DiscountedEV=DiscountFactorParamsVec.*EV; DiscountedEV=repelem(shiftdim(DiscountedEV,-1),N_d,1,1); % [d,aprime,1,j] -DiscountedEVinterp=DiscountFactorParamsVec.*EVinterp; -DiscountedEVinterp=repelem(shiftdim(DiscountedEVinterp,-1),N_d,1,1); % [d,aprime,1,j] +DiscountedEVinterp=DiscountFactorParamsVec.*EVinterp; % [n2aprime fine,1,j,z] if vfoptions.lowmemory==0 @@ -109,8 +108,8 @@ aprimeindexes=(midpoints_jj+(midpoints_jj-1)*n2short)+(-n2short-1:1:1+n2short); % aprime points either side of midpoint % aprime possibilities are n_d-by-n2long-by-n_a-by-N_j-by-n_e ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_Par2(ReturnFn,n_d, n_e, N_j,d_gridvals,aprime_grid(aprimeindexes),a_grid, e_gridvals_J, ReturnFnParamsAgeMatrix,2); - daprimej=(1:1:N_d)'+N_d*(aprimeindexes-1)+N_d*n2aprime*jind; - entireRHS_ii=ReturnMatrix_ii+reshape(DiscountedEVinterp(daprimej(:)),[N_d*n2long,N_a,N_j,N_e]); + aprimej=aprimeindexes+n2aprime*jind; + entireRHS_ii=ReturnMatrix_ii+reshape(DiscountedEVinterp(aprimej(:)),[N_d*n2long,N_a,N_j,N_e]); [V,maxindexL2]=max(entireRHS_ii,[],1); V=reshape(V,[N_a*N_j,N_e]); d_ind=rem(maxindexL2-1,N_d)+1; @@ -164,8 +163,8 @@ aprimeindexes=(midpoints_jj+(midpoints_jj-1)*n2short)+(-n2short-1:1:1+n2short); % aprime points either side of midpoint % aprime possibilities are n_d-by-n2long-by-n_a-by-N_j ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_Par2(ReturnFn,n_d, special_n_e, N_j,d_gridvals,aprime_grid(aprimeindexes),a_grid, e_vals, ReturnFnParamsAgeMatrix,2); - daprimej=(1:1:N_d)'+N_d*(aprimeindexes-1)+N_d*n2aprime*jind; - entireRHS_ii=ReturnMatrix_ii+reshape(DiscountedEVinterp(daprimej(:)),[N_d*n2long,N_a,N_j]); + aprimej=aprimeindexes+n2aprime*jind; + entireRHS_ii=ReturnMatrix_ii+reshape(DiscountedEVinterp(aprimej(:)),[N_d*n2long,N_a,N_j]); [Vtemp,maxindexL2]=max(entireRHS_ii,[],1); V(:,e_c)=reshape(Vtemp,[N_a*N_j,1]); d_ind=rem(maxindexL2-1,N_d)+1; diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_raw.m index d6e35852..9965d6fd 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_noz_raw.m @@ -51,7 +51,7 @@ EVinterp=interp1(a_grid,EV,aprime_grid); DiscountedEV=repelem(shiftdim(DiscountFactorParamsVec.*EV,-1),N_d,1,1); % [N_d,N_a,1,N_j], singular first dimension for d -DiscountedEVinterp=repelem(DiscountFactorParamsVec.*EVinterp,N_d,1,1); % [N_d*n2aprime,1,N_j], singular first dimension for d +DiscountedEVinterp=DiscountFactorParamsVec.*EVinterp; % [n2aprime,1,N_j], singular first dimension for d % n-Monotonicity ReturnMatrix=CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_noz_Par2(ReturnFn, n_d, N_j, d_gridvals, a_grid, a_grid(level1ii), ReturnFnParamsAgeMatrix,1); @@ -90,8 +90,8 @@ aprimeindexes=(midpoints_jj+(midpoints_jj-1)*n2short)+(-n2short-1:1:1+n2short); % aprime points either side of midpoint % aprime possibilities are n_d-by-n2long-by-n_a-by-N_j ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_noz_Par2(ReturnFn,n_d,N_j,d_gridvals,aprime_grid(aprimeindexes),a_grid,ReturnFnParamsAgeMatrix,2); -daprimej=(1:1:N_d)'+N_d*(aprimeindexes-1)+N_d*n2aprime*jind; -entireRHS_ii=ReturnMatrix_ii+reshape(DiscountedEVinterp(daprimej(:)),[N_d*n2long,N_a,N_j]); +aprimej=aprimeindexes+n2aprime*jind; +entireRHS_ii=ReturnMatrix_ii+reshape(DiscountedEVinterp(aprimej(:)),[N_d*n2long,N_a,N_j]); [V,maxindexL2]=max(entireRHS_ii,[],1); V=squeeze(V); d_ind=rem(maxindexL2-1,N_d)+1; diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_raw.m index 22ca5a2b..0bea6414 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_raw.m @@ -70,8 +70,7 @@ DiscountedEV=DiscountFactorParamsVec.*EV; DiscountedEV=repelem(shiftdim(DiscountedEV,-1),N_d,1,1,1); % [d,aprime,1,j,z] -DiscountedEVinterp=DiscountFactorParamsVec.*EVinterp; -DiscountedEVinterp=repelem(shiftdim(DiscountedEVinterp,-1),N_d,1,1,1); % [d,aprime,1,j,z] +DiscountedEVinterp=DiscountFactorParamsVec.*EVinterp; % [n2aprime fine,1,j,z] if vfoptions.lowmemory==0 @@ -112,8 +111,8 @@ aprimeindexes=(midpoints_jj+(midpoints_jj-1)*n2short)+(-n2short-1:1:1+n2short); % aprime points either side of midpoint % aprime possibilities are n_d-by-n2long-by-n_a-by-N_j-by-n_z ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_Par2(ReturnFn,n_d, n_z, N_j,d_gridvals,aprime_grid(aprimeindexes),a_grid, z_gridvals_J, ReturnFnParamsAgeMatrix,2); - daprimejz=(1:1:N_d)'+N_d*(aprimeindexes-1)+N_d*n2aprime*jind+N_d*n2aprime*N_j*zind; - entireRHS_ii=ReturnMatrix_ii+reshape(DiscountedEVinterp(daprimejz(:)),[N_d*n2long,N_a,N_j,N_z]); + aprimejz=aprimeindexes+n2aprime*jind+n2aprime*N_j*zind; + entireRHS_ii=ReturnMatrix_ii+reshape(DiscountedEVinterp(aprimejz(:)),[N_d*n2long,N_a,N_j,N_z]); [V,maxindexL2]=max(entireRHS_ii,[],1); V=reshape(V,[N_a*N_j,N_z]); d_ind=rem(maxindexL2-1,N_d)+1; @@ -130,7 +129,7 @@ for z_c=1:N_z z_vals=z_gridvals_J(1,1,1,:,z_c,:); % z_gridvals_J has shape (1,1,1,N_j,N_z,l_z) for fastOLG DiscountedEV_z=DiscountedEV(:,:,:,:,z_c); - DiscountedEVinterp_z=DiscountedEVinterp(:,:,:,:,z_c); + DiscountedEVinterp_z=DiscountedEVinterp(:,:,:,z_c); % n-Monotonicity ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_Par2(ReturnFn, n_d, special_n_z, N_j, d_gridvals, a_grid, a_grid(level1ii), z_vals, ReturnFnParamsAgeMatrix,1); @@ -169,8 +168,8 @@ aprimeindexes=(midpoints_jj+(midpoints_jj-1)*n2short)+(-n2short-1:1:1+n2short); % aprime points either side of midpoint % aprime possibilities are n_d-by-n2long-by-n_a-by-N_j ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_Par2(ReturnFn,n_d, special_n_z, N_j,d_gridvals,aprime_grid(aprimeindexes),a_grid, z_vals, ReturnFnParamsAgeMatrix,2); - daprimej=(1:1:N_d)'+N_d*(aprimeindexes-1)+N_d*n2aprime*jind; - entireRHS_ii=ReturnMatrix_ii+reshape(DiscountedEVinterp_z(daprimej(:)),[N_d*n2long,N_a,N_j]); + aprimej=aprimeindexes+n2aprime*jind; + entireRHS_ii=ReturnMatrix_ii+reshape(DiscountedEVinterp_z(aprimej(:)),[N_d*n2long,N_a,N_j]); [Vtemp,maxindexL2]=max(entireRHS_ii,[],1); V(:,z_c)=reshape(Vtemp,[N_a*N_j,1]); d_ind=rem(maxindexL2-1,N_d)+1; From 0338916721f0994a27baef33c7d9a18ca6e97f3d Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Wed, 4 Mar 2026 10:40:48 +1300 Subject: [PATCH 53/67] minor fix and improve --- ...Horz_TPath_SingleStep_fastOLG_DC1_GI_raw.m | 19 ++++++++++--------- .../GI2B/ValueFnIter_Refine_postGI2B_raw.m | 2 ++ .../GI2B/ValueFnIter_postGI2B_nod_raw.m | 2 ++ ...lueFnIter_Refine_postGI_HowardGreedy_raw.m | 1 + ...ValueFnIter_Refine_postGI_HowardMix2_raw.m | 1 + .../ValueFnIter_Refine_postGI_HowardMix_raw.m | 1 + .../ValueFnIter_Refine_postGI_raw.m | 5 ++++- 7 files changed, 21 insertions(+), 10 deletions(-) diff --git a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_raw.m b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_raw.m index 0bea6414..4cc188a6 100644 --- a/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_raw.m +++ b/TransitionPaths/FHorz/subcodes/ValueFnSingleStep/fastOLG/DivideConquer/GridInterpLayer/ValueFnIter_FHorz_TPath_SingleStep_fastOLG_DC1_GI_raw.m @@ -68,7 +68,8 @@ EVinterp=interp1(a_grid,EV,aprime_grid); DiscountedEV=DiscountFactorParamsVec.*EV; -DiscountedEV=repelem(shiftdim(DiscountedEV,-1),N_d,1,1,1); % [d,aprime,1,j,z] +DiscountedEV=shiftdim(DiscountedEV,-1); % [1,aprime,1,j,z] +% DiscountedEV=repelem(shiftdim(DiscountedEV,-1),N_d,1,1,1); % [d,aprime,1,j,z] DiscountedEVinterp=DiscountFactorParamsVec.*EVinterp; % [n2aprime fine,1,j,z] @@ -77,8 +78,8 @@ % n-Monotonicity ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_Par2(ReturnFn, n_d, n_z, N_j, d_gridvals, a_grid, a_grid(level1ii), z_gridvals_J, ReturnFnParamsAgeMatrix,1); - entireRHS_ii=ReturnMatrix_ii+DiscountedEV; % (d,aprime,a and j,z), autofills a for expectation term - + entireRHS_ii=ReturnMatrix_ii+DiscountedEV; % (d,aprime,a and j,z), autofills d&a for expectation term + % First, we want aprime conditional on (d,1,a,j) [~,maxindex1]=max(entireRHS_ii,[],2); @@ -95,8 +96,8 @@ aprimeindexes=loweredge+(0:1:maxgap(ii)); % aprime possibilities are n_d-by-maxgap(ii)+1-by-1-by-N_j-by-n_z ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_Par2(ReturnFn, n_d, n_z, N_j, d_gridvals, a_grid(aprimeindexes), a_grid(level1ii(ii)+1:level1ii(ii+1)-1), z_gridvals_J, ReturnFnParamsAgeMatrix,3); - daprimejz=(1:1:N_d)'+N_d*(aprimeindexes-1)+N_d*N_a*jind+N_d*N_a*N_j*zind; - entireRHS_ii=ReturnMatrix_ii+reshape(DiscountedEV(daprimejz(:)),[N_d,(maxgap(ii)+1),1,N_j,N_z]); % note: 3rd dim autofills to level1iidiff(ii) + aprimejz=aprimeindexes+N_a*jind+N_a*N_j*zind; + entireRHS_ii=ReturnMatrix_ii+reshape(DiscountedEV(aprimejz(:)),[N_d,(maxgap(ii)+1),1,N_j,N_z]); % note: 3rd dim autofills to level1iidiff(ii) [~,maxindex]=max(entireRHS_ii,[],2); midpoints_jj(:,1,curraindex,:,:)=maxindex+(loweredge-1); else @@ -104,7 +105,7 @@ midpoints_jj(:,1,curraindex,:,:)=repelem(loweredge,1,1,length(curraindex),1); end end - + % Turn this into the 'midpoint' midpoints_jj=max(min(midpoints_jj,n_a-1),2); % avoid the top end (inner), and avoid the bottom end (outer) % midpoint is n_d-by-1-by-n_a-by-N_j-by-n_z @@ -134,7 +135,7 @@ % n-Monotonicity ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_Par2(ReturnFn, n_d, special_n_z, N_j, d_gridvals, a_grid, a_grid(level1ii), z_vals, ReturnFnParamsAgeMatrix,1); - entireRHS_ii=ReturnMatrix_ii+DiscountedEV_z; % (d,aprime,a and j,z), autofills j for expectation term + entireRHS_ii=ReturnMatrix_ii+DiscountedEV_z; % (d,aprime,a and j), autofills d&a for expectation term % First, we want aprime conditional on (d,1,a,j) [~,maxindex1]=max(entireRHS_ii,[],2); @@ -152,8 +153,8 @@ aprimeindexes=loweredge+(0:1:maxgap(ii)); % aprime possibilities are n_d-by-maxgap(ii)+1-by-1-by-N_j ReturnMatrix_ii=CreateReturnFnMatrix_Case1_Disc_fastOLG_DC1_Par2(ReturnFn, n_d, special_n_z, N_j, d_gridvals, a_grid(aprimeindexes), a_grid(level1ii(ii)+1:level1ii(ii+1)-1), z_vals, ReturnFnParamsAgeMatrix,3); - daprimej=(1:1:N_d)'+N_d*(aprimeindexes-1)+N_d*N_a*jind; - entireRHS_ii=ReturnMatrix_ii+reshape(DiscountedEV_z(daprimej(:)),[N_d,(maxgap(ii)+1),1,N_j]); % note: 3rd dim autofills to level1iidiff(ii) + aprimej=aprimeindexes+N_a*jind; + entireRHS_ii=ReturnMatrix_ii+reshape(DiscountedEV_z(aprimej(:)),[N_d,(maxgap(ii)+1),1,N_j]); % note: 3rd dim autofills to level1iidiff(ii) [~,maxindex]=max(entireRHS_ii,[],2); midpoints_jj(:,1,curraindex,:)=maxindex+(loweredge-1); else diff --git a/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_Refine_postGI2B_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_Refine_postGI2B_raw.m index 1cd3937f..a840d5f4 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_Refine_postGI2B_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_Refine_postGI2B_raw.m @@ -162,6 +162,7 @@ %% Now switch to considering the fine/interpolated aprime_grid currdist=1; % force going into the next while loop at least one iteration +tempcounter=1; % reset tempcounter while currdist>vfoptions.tolerance && tempcounter<=vfoptions.maxiter VKronold=VKron; @@ -286,6 +287,7 @@ %% Now switch to considering the fine/interpolated aprime_grid currdist=1; % force going into the next while loop at least one iteration + tempcounter=1; % reset tempcounter while currdist>vfoptions.tolerance && tempcounter<=vfoptions.maxiter VKronold=VKron; diff --git a/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_postGI2B_nod_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_postGI2B_nod_raw.m index 174db0ed..a66834f5 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_postGI2B_nod_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/GI2B/ValueFnIter_postGI2B_nod_raw.m @@ -111,6 +111,7 @@ %% Now switch to considering the fine/interpolated aprime_grid currdist=1; % force going into the next while loop at least one iteration +tempcounter=1; % reset tempcounter while currdist>vfoptions.tolerance && tempcounter<=vfoptions.maxiter VKronold=VKron; @@ -210,6 +211,7 @@ %% Now switch to considering the fine/interpolated aprime_grid currdist=1; % force going into the next while loop at least one iteration + tempcounter=1; % reset tempcounter while currdist>vfoptions.tolerance && tempcounter<=vfoptions.maxiter VKronold=VKron; diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardGreedy_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardGreedy_raw.m index 46c33f61..f7e7995b 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardGreedy_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardGreedy_raw.m @@ -117,6 +117,7 @@ %% Now switch to considering the fine/interpolated aprime_grid currdist=1; % force going into the next while loop at least one iteration +tempcounter=1; % reset tempcounter while currdist>vfoptions.tolerance && tempcounter<=vfoptions.maxiter VKronold=VKron; diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardMix2_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardMix2_raw.m index 3d1081fd..628f0c66 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardMix2_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardMix2_raw.m @@ -115,6 +115,7 @@ %% Now switch to considering the fine/interpolated aprime_grid currdist=1; % force going into the next while loop at least one iteration +tempcounter=1; % reset tempcounter while currdist>vfoptions.tolerance && tempcounter<=vfoptions.maxiter VKronold=VKron; diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardMix_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardMix_raw.m index 55c600e6..91628aee 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardMix_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_HowardMix_raw.m @@ -116,6 +116,7 @@ %% Now switch to considering the fine/interpolated aprime_grid currdist=1; % force going into the next while loop at least one iteration +tempcounter=1; % reset tempcounter while currdist>vfoptions.tolerance && tempcounter<=vfoptions.maxiter VKronold=VKron; diff --git a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_raw.m b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_raw.m index dde04fba..1b7ecec7 100644 --- a/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_raw.m +++ b/ValueFnIter/InfHorz/GridInterpLayer/ValueFnIter_Refine_postGI_raw.m @@ -141,6 +141,7 @@ % Perform value fn iteration currdist=1; % force going into the next while loop at least one iteration +tempcounter=1; % reset tempcounter while currdist>vfoptions.tolerance && tempcounter<=vfoptions.maxiter VKronold=VKron; @@ -187,6 +188,7 @@ tempcounter=tempcounter+1; end + %% Do another post-GI layer % Note: is just a copy-paste of the previous post-GI layer code % Only difference that before we start there are two lines of code to convert Policy_a back into being about the nearest rough grid index @@ -200,7 +202,7 @@ Policy_a=reshape(Policy_a,[1,N_a,N_z]); % Howards can mess with the size Policy_a=ceil((Policy_a-1)/(n2short+1))-vfoptions.maxaprimediff+aprimeshifter; % ceil((Policy_a-1)/(n2short+1))-vfoptions.maxaprimediff ranges -vfoptions.maxaprimediff:1:vfoptions.maxaprimediff - + % First, create an aprime_grid that is just the +-vfoptions.maxaprimediff % Note: this code is for models with a single endogenous state n_aprimediff=1+2*vfoptions.maxaprimediff; @@ -250,6 +252,7 @@ %% Now switch to considering the fine/interpolated aprime_grid currdist=1; % force going into the next while loop at least one iteration + tempcounter=1; % reset tempcounter while currdist>vfoptions.tolerance && tempcounter<=vfoptions.maxiter VKronold=VKron; From bed644cd6c6b97c09a5bfba8d0c042875c596280 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Mon, 9 Mar 2026 11:24:02 +1300 Subject: [PATCH 54/67] AggShocks plus some minor improvements --- Optimization/setupGEnewprice3_shooting.m | 7 + ...tchedExpectationsPath_CreateInitialGuess.m | 100 ++++ ...MatchedExpectationsPath_InfHorz_shooting.m | 544 ++++++++++++++++++ ...hedExpectationsPath_InfHorz_shooting_nod.m | 498 ++++++++++++++++ ...RecursiveGeneralEqmWithAggShocks_InfHorz.m | 400 +++++++++++++ .../Subcodes/updatePricePathNew_TPath_tt.m | 6 + 6 files changed, 1555 insertions(+) create mode 100644 RecursiveEqmAggShocks/MatchedExpectationsPath_CreateInitialGuess.m create mode 100644 RecursiveEqmAggShocks/MatchedExpectationsPath_InfHorz_shooting.m create mode 100644 RecursiveEqmAggShocks/MatchedExpectationsPath_InfHorz_shooting_nod.m create mode 100644 RecursiveEqmAggShocks/RecursiveGeneralEqmWithAggShocks_InfHorz.m diff --git a/Optimization/setupGEnewprice3_shooting.m b/Optimization/setupGEnewprice3_shooting.m index 772c3c22..b34b5fdc 100644 --- a/Optimization/setupGEnewprice3_shooting.m +++ b/Optimization/setupGEnewprice3_shooting.m @@ -30,6 +30,13 @@ error('Cannot call this unless GeneralEqmEqns is struct') end +if size(options.GEnewprice3.howtoupdate,2)~=4 + error('options.GEnewprice3.howtoupdate should have 4 columns: GECondnName, Price name, add, factor') +end +if size(options.GEnewprice3.howtoupdate,1)~=nGeneralEqmEqns + error('options.GEnewprice3.howtoupdate should have ones row for each general eqm eqn') +end + %% if ~isfield(options,'GEptype') % For models without permanent type diff --git a/RecursiveEqmAggShocks/MatchedExpectationsPath_CreateInitialGuess.m b/RecursiveEqmAggShocks/MatchedExpectationsPath_CreateInitialGuess.m new file mode 100644 index 00000000..58d1f0d8 --- /dev/null +++ b/RecursiveEqmAggShocks/MatchedExpectationsPath_CreateInitialGuess.m @@ -0,0 +1,100 @@ +function [PricePath,VPath,AgentDistPath,AggVarsPath,GEcheck]=MatchedExpectationsPath_CreateInitialGuess(T,ss_ind_T,n_d,n_a,n_z,n_S,N_a,N_z,N_S,d_grid,a_grid,initialguessobjects,AggShockNames,AggVarNames,ReturnFn,FnsToEvaluate,GeneralEqmEqnsStruct,Parameters,DiscountFactorParamNames, GEPriceParamNames,GEeqnNames,recursiveeqmoptions,vfoptions,simoptions) +% initialguessobjects.methodforguess +% =1: replace S with E[S] +% =2: treat S as idiosyncratic shock + +if initialguessobjects.methodforguess==1 + % Replace all instances of S with E[S], both in agent problem and everywhere else + + % General eqm should be able use S as an input, so I need to put in some kind of value of S into Parameters that can be used for the general eqm eqns + for SS_c=1:length(n_S) + Parameters.(AggShockNames{SS_c})=initialguessobjects.Svalue(SS_c); + end + % Because it is InfHorz, turn off divide-and-conquer if that is used + vfoptions.divideandconquer=0; + % initialguessobjects.heteroagentoptions.verbose=1 + [p_eqm,GEcheck]=HeteroAgentStationaryEqm_Case1(n_d, n_a, n_z, 0, initialguessobjects.pi_z, d_grid, a_grid, initialguessobjects.z_gridvals, ReturnFn, FnsToEvaluate, GeneralEqmEqnsStruct, Parameters, DiscountFactorParamNames, [], [], [], GEPriceParamNames, initialguessobjects.heteroagentoptions, simoptions, vfoptions); + for pp=1:length(GEPriceParamNames) + Parameters.(GEPriceParamNames{pp})=p_eqm.(GEPriceParamNames{pp}); + end + [V,Policy]=ValueFnIter_Case1(n_d,n_a,n_z,d_grid,a_grid,initialguessobjects.z_gridvals, initialguessobjects.pi_z, ReturnFn, Parameters, DiscountFactorParamNames, [], vfoptions); + StationaryDist=StationaryDist_Case1(Policy,n_d,n_a,n_z,initialguessobjects.pi_z,simoptions,Parameters); + AggVars=EvalFnOnAgentDist_AggVars_Case1(StationaryDist, Policy, FnsToEvaluate, Parameters, [], n_d, n_a, n_z, d_grid, a_grid, initialguessobjects.z_gridvals, simoptions); + % Create the objects needed as the initial guess setup for the matched expectations + VPath=repelem(reshape(V,[N_a,1,N_z]),1,T,1); % fastOLG means (a,t)-by-z + AgentDistPath=repelem(reshape(StationaryDist,[N_a,1,N_z]),1,T,1); % fastOLG means (a,t,z)-by-1 + VPath=reshape(VPath,[N_a*T,N_z]); + AgentDistPath=reshape(AgentDistPath,[N_a*T*N_z,1]); + for ff=1:length(AggVarNames) + AggVarsPath.(AggVarNames{ff}).Mean=repmat(AggVars.(AggVarNames{ff}).Mean,1,T); + end + % Setup PricePath as the general eqm prices + for pp=1:length(GEPriceParamNames) + PricePath.(GEPriceParamNames{pp})=p_eqm.(GEPriceParamNames{pp})*ones(1,T); + end + +elseif initialguessobjects.methodforguess==2 + % Just pretend that the aggregate shock is an idiosyncratic shock, solve the stationary general eqm of that model. + n_zS=[n_z,n_S]; + + % General eqm should be able use S as an input, so I need to put in some kind of value of S into Parameters that can be used for the general eqm eqns + for SS_c=1:length(n_S) + Parameters.(AggShockNames{SS_c})=initialguessobjects.Svalue(SS_c); + end + % Because it is InfHorz, turn off divide-and-conquer if that is used + vfoptions.divideandconquer=0; + % initialguessobjects.heteroagentoptions.verbose=1 + [p_eqm,GEcheck]=HeteroAgentStationaryEqm_Case1(n_d, n_a, n_zS, 0, initialguessobjects.pi_zS, d_grid, a_grid, initialguessobjects.zS_gridvals, ReturnFn, FnsToEvaluate, GeneralEqmEqnsStruct, Parameters, DiscountFactorParamNames, [], [], [], GEPriceParamNames, initialguessobjects.heteroagentoptions, simoptions, vfoptions); + for pp=1:length(GEPriceParamNames) + Parameters.(GEPriceParamNames{pp})=p_eqm.(GEPriceParamNames{pp}); + end + [V,Policy]=ValueFnIter_Case1(n_d,n_a,n_zS,d_grid,a_grid,initialguessobjects.zS_gridvals, initialguessobjects.pi_zS, ReturnFn, Parameters, DiscountFactorParamNames, [], vfoptions); + StationaryDist=StationaryDist_Case1(Policy,n_d,n_a,n_zS,initialguessobjects.pi_zS,simoptions,Parameters); + AggVars=EvalFnOnAgentDist_AggVars_Case1(StationaryDist, Policy, FnsToEvaluate, Parameters, [], n_d, n_a, n_zS, d_grid, a_grid, initialguessobjects.zS_gridvals, simoptions); + % Create the objects needed as the initial guess setup for the matched expectations + V=reshape(V,[N_a,1,N_z,N_S]); + StationaryDist=reshape(StationaryDist,[N_a,1,N_z,N_S]); + VPath=zeros(N_a,T,N_z,'gpuArray'); % fastOLG means (a,t)-by-z + AgentDistPath=zeros(N_a,T,N_z,'gpuArray'); % fastOLG means (a,t,z)-by-1 + for tt=1:T + VPath(:,tt,:)=V(:,1,:,ss_ind_T(tt)); + AgentDistPath(:,tt,:)=StationaryDist(:,1,:,ss_ind_T(tt)); % this will not be the whole mass, so renormalize immediately after we finish looping + end + AgentDistPath=AgentDistPath./sum(sum(AgentDistPath,3),1); + VPath=reshape(VPath,[N_a*T,N_z]); + AgentDistPath=reshape(AgentDistPath,[N_a*T*N_z,1]); + for ff=1:length(AggVarNames) + AggVarsPath.(AggVarNames{ff}).Mean=repmat(AggVars.(AggVarNames{ff}).Mean,1,T); + end + % Setup PricePath as the general eqm prices + for pp=1:length(GEPriceParamNames) + PricePath.(GEPriceParamNames{pp})=p_eqm.(GEPriceParamNames{pp})*ones(1,T); + end + +end + + +if recursiveeqmoptions.verbose==2 + fprintf(' \n') + fprintf(' \n') + fprintf(' \n') + fprintf('Finished solving the initial guess stationary eqm that will be used to setup initial guess for path \n') + fprintf('Following is info about it, \n') + fprintf('GE prices: \n') + for pp=1:length(GEPriceParamNames) + fprintf(' %s: %8.6f \n',GEPriceParamNames{pp},p_eqm.(GEPriceParamNames{pp})) + end + fprintf('Current aggregate variables: \n') + for aa=1:length(AggVarNames) + fprintf(' %s: %8.6f \n',AggVarNames{aa},AggVars.(AggVarNames{aa}).Mean) + end + fprintf('Current GeneralEqmEqns: \n') + for gg=1:length(GEeqnNames) + fprintf(' %s: %8.8f \n',GEeqnNames{gg},GEcheck.(GEeqnNames{gg})) + end + fprintf('End of info about the initial guess stationary eqm. \n') +end + + + +end \ No newline at end of file diff --git a/RecursiveEqmAggShocks/MatchedExpectationsPath_InfHorz_shooting.m b/RecursiveEqmAggShocks/MatchedExpectationsPath_InfHorz_shooting.m new file mode 100644 index 00000000..3c94a8c1 --- /dev/null +++ b/RecursiveEqmAggShocks/MatchedExpectationsPath_InfHorz_shooting.m @@ -0,0 +1,544 @@ +function [PricePath,GEcondnPath,VPath,PolicyIndexesPath,AgentDistPath,DistMatches]=MatchedExpectationsPath_InfHorz_shooting(AggShocksPath, AggShockNames, T,SSmask_T,SSprimemask_T,SSprimemask_T_indexes,ss_ind_T, n_d, n_a, n_z, n_S, l_d, l_a, l_z, d_grid, a_grid,z_gridvals_T,z_gridvals_T_fastOLG, pi_Sprime_T, pi_z_T, pi_z_T_sim, ReturnFn, FnsToEvaluate, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEPriceParamNames, GEeqnNames, GeneralEqmEqnsStruct, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, ReturnFnParamNames, initialguessobjects, vfoptions, simoptions, recursiveeqmoptions) + +N_a=prod(n_a); +N_z=prod(n_z); + +N_S=prod(n_S); + +l_aprime=length(n_a); + +%% +if recursiveeqmoptions.verbose>=1 + % Set up some things to be used later + pathnametitles=cell(1,2*length(GEPriceParamNames)); + for tt=1:length(GEPriceParamNames) + pathnametitles{tt}={['Old ',GEPriceParamNames{tt}]}; + pathnametitles{tt+length(GEPriceParamNames)}={['New ',GEPriceParamNames{tt}]}; + end + + priceverbosestr=' of which: '; + for pp=1:length(GEPriceParamNames) + priceverbosestr=[priceverbosestr,GEPriceParamNames{pp},' is %8.6f, ']; + end + priceverbosestr=[priceverbosestr,' \n']; + GEcondnverbosestr=' of which: '; + for gg=1:length(GEeqnNames) + GEcondnverbosestr=[GEcondnverbosestr,GEeqnNames{gg},' is %8.6f, ']; + end + GEcondnverbosestr=[GEcondnverbosestr,' \n']; +end + +%% Setup needed for the fastOLG agent dist iterations +if simoptions.gridinterplayer==0 + II1=1:1:N_a*(T-1)*N_z; + II2=ones(N_a*(T-1)*N_z,1); + exceptlastj=repmat((1:1:N_a)',(T-1)*N_z,1)+repmat(repelem(N_a*(0:1:T-2)',N_a,1),N_z,1)+repelem(N_a*T*(0:1:N_z-1)',N_a*(T-1),1); + exceptfirstj=repmat((1:1:N_a)',(T-1)*N_z,1)+repmat(repelem(N_a*(1:1:T-1)',N_a,1),N_z,1)+repelem(N_a*T*(0:1:N_z-1)',N_a*(T-1),1); + justfirstj=repmat((1:1:N_a)',N_z,1)+N_a*T*repelem((0:1:N_z-1)',N_a,1); +elseif simoptions.gridinterplayer==1 + N_probs=2; + II=repelem((1:1:N_a*(T-1)*N_z)',1,N_probs); + exceptlastj=repmat((1:1:N_a)',(T-1)*N_z,1)+repmat(repelem(N_a*(0:1:T-2)',N_a,1),N_z,1)+repelem(N_a*T*(0:1:N_z-1)',N_a*(T-1),1); + exceptfirstj=repmat((1:1:N_a)',(T-1)*N_z,1)+repmat(repelem(N_a*(1:1:T-1)',N_a,1),N_z,1)+repelem(N_a*T*(0:1:N_z-1)',N_a*(T-1),1); + justfirstj=repmat((1:1:N_a)',N_z,1)+N_a*T*repelem((0:1:N_z-1)',N_a,1); +end +% We don't have age weights here, as the mass of agents is the same in every t=1:T. +% I'm leaving it as a object as I can imagine there will be some firm +% entry-exit models where you would want this to change over time. +AgeWeights_T=repmat(repelem(ones(T,1,'gpuArray'),N_a,1),N_z,1); + +%% How to update the agent dist? +% Iteration i and time period t, call agent dist Phi_t^i +% There are two ways we could update this: +% Hanbaek Lee does the update by iterating on t +% - First Phi_2^{i+1} is created from Phi_1^{i} +% - Iterate on t=3:T, Phi_t^{i+1} is created from Phi_{t-1}^{i+1} +% Or we can take the fastOLG style approach +% - Parallel oever t=2:T, we create Phi_t^{i+1} from Phi_{t-1}^{i} +% For now I just use the fastOLG style approach +fastOLGtheAgentDist=1 +% But setting this to zero will do the time-loop version that Lee uses. + +%% Create the initial guess +if recursiveeqmoptions.verbose>=1 + fprintf('Solving preliminary stationary eqm problem \n') + tic; +end +[PricePath,VPath,AgentDistPath,AggVarsPath,GEcheck]=MatchedExpectationsPath_CreateInitialGuess(T,ss_ind_T,n_d,n_a,n_z,n_S,N_a,N_z,N_S,d_grid,a_grid,initialguessobjects,AggShockNames,AggVarNames,ReturnFn,FnsToEvaluate,GeneralEqmEqnsStruct,Parameters,DiscountFactorParamNames, GEPriceParamNames,GEeqnNames,recursiveeqmoptions,vfoptions,simoptions); +% And create a version of PricePath as the matrix +[PricePathOld,~,PricePathNames,~,PricePathSizeVec,~]=PricePathParamPath_StructToMatrix(PricePath,struct(),T); +if recursiveeqmoptions.verbose>=1 + fprintf('preliminary stationary eqm runtime was %4.8f seconds \n', toc) + fprintf(' \n') + fprintf(' \n') + fprintf(' \n') +end + +l_p=length(GEPriceParamNames); +PricePathNew=zeros(size(PricePathOld),'gpuArray'); PricePathNew(T,:)=PricePathOld(T,:); + +%% We do the time periods tt=1:T all in parallel +% This leverages the fastOLG commands, which use a different shape +% fastOLG so everything is (a,t,z) +% Shapes: +% VPath is [N_a,T,N_z] +% AgentDistPath for fastOLG is [N_a*T*N_z,1] + +%% +pathcounter=1; +TransPathConvergence=Inf; % ratio of 'Current Path Distance -to- recursiveeqmoptions.tolerance' + % Require convergence in both prices and general eqm conditions + + +GEcondnPath=zeros(T,length(GEeqnNames),'gpuArray'); + +a_gridvals=CreateGridvals(n_a,a_grid,1); +if simoptions.gridinterplayer==1 + PolicyProbsPath=zeros(N_a*(T-1)*N_z,N_probs,'gpuArray'); % preallocate +end + +AgentDistt0index=repmat(gpuArray(1:1:N_a)',N_z,1)+repelem(N_a*T*gpuArray(0:1:N_z-1)',N_a,1); + +%% Solve using the matched-expecations path algorithm +if recursiveeqmoptions.verbose==1 + fprintf('Start solving the matched expectations path \n') +end + +% VPath0=VPath; + +% The initial agent distribution does not get updated much, so just keep a copy rather than indexing it every iteration +if fastOLGtheAgentDist==1 + AgentDist_initial1=AgentDistPath(AgentDistt0index); % fastOLG means AgentDistPath is (a,t,z)-by-1 +else + AgentDist_initial0=AgentDistPath(AgentDistt0index); % fastOLG means AgentDistPath is (a,t,z)-by-1 + AgentDist_initial0=reshape(AgentDist_initial0,[N_a*N_z,1]); +end + + +while TransPathConvergence>1 && pathcounterrecursiveeqmoptions.burnin + % The match is this period and distance is zero + DistMatches(tt,SSprime_c,:,1)=tt; + DistMatches(tt,SSprime_c,:,2)=0; + % Put the next period value function into the MatchedEV + MatchedEV_full(:,tt,:,SSprime_c,:)=VPath(:,tt+1,:); + else + % SSmask_T(SS_c,:) is binary, and takes value of 1 for the time periods that have SS_c as the aggregate shock + % notSSmask_Tplus1(SS_c,:) is binary, and takes value of 1 for the next-period time periods that do NOT have SS_c as the aggregate shock + % potential=Distances(tt,:); + % potential(notSSmask_Tplus1(SSprime_c,:))=Inf; % is making distance=Inf for anything that is not SSprime_c tomorrow + potential=Distances(tt,SSprimemask_T(1,:,SSprime_c)); % Only consider distances that have (currSS,SSprime_c), that is, look for matching S, and then we find each of the Sprime (as we are looping over the Sprime) + [matchval,matchind]=mink(potential,recursiveeqmoptions.matchE_nnearest); % Of the time periods that match S, and have the Sprime we are considering at the moment, find the closest as measured by 'Distances' + % matchind is currently for the 1s in SSprimemask_T, convert to a tt index + matchind=SSprimemask_T_indexes(matchind,SSprime_c); + DistMatches(tt,SSprime_c,:,1)=matchind; + DistMatches(tt,SSprime_c,:,2)=matchval; + for nn=1:recursiveeqmoptions.matchE_nnearest + MatchedEV_full(:,tt,:,SSprime_c,:)=VPath(:,matchind+1,:); % matchind+1 is where we are the period after the match [we want next period value fn to create expectations] + end + end + end + end + elseif recursiveeqmoptions.matchingsetup==2 % Match (S,Sprime) based on Distances + for tt=1:T-1 + currSS=ss_ind_T(tt); + currSSprime=ss_ind_T(tt+1); + % Need to look for periods that are the closest today in terms of having the same S and smallest Distances (same AgentDist), but having a different next period S + for SSprime_c=1:N_S % Loop over the possible next-period aggregate shocks + if SSprime_c==currSSprime && tt>recursiveeqmoptions.burnin + % The match is this period and distance is zero + DistMatches(tt,SSprime_c,:,1)=tt; + DistMatches(tt,SSprime_c,:,2)=0; + % Put the next period value function into the MatchedEV + MatchedEV_full(:,tt,:,SSprime_c,:)=VPath(:,tt+1,:); + else + % SSmask_T(SS_c,:) is binary, and takes value of 1 for the time periods that have SS_c as the aggregate shock + % notSSmask_Tplus1(SS_c,:) is binary, and takes value of 1 for the next-period time periods that do NOT have SS_c as the aggregate shock + % potential=Distances(tt,:); + % potential(notSSmask_Tplus1(SSprime_c,:))=Inf; % is making distance=Inf for anything that is not SSprime_c tomorrow + potential=Distances(tt,SSprimemask_T(1,:,currSS,SSprime_c)); % Only consider distances that have (currSS,SSprime_c), that is, look for matching S, and then we find each of the Sprime (as we are looping over the Sprime) + [matchval,matchind]=mink(potential,recursiveeqmoptions.matchE_nnearest); % Of the time periods that match S, and have the Sprime we are considering at the moment, find the closest as measured by 'Distances' + % matchind is currently for the 1s in SSprimemask_T, convert to a tt index + matchind=SSprimemask_T_indexes(matchind,currSS,SSprime_c); + DistMatches(tt,SSprime_c,:,1)=matchind; + DistMatches(tt,SSprime_c,:,2)=matchval; + for nn=1:recursiveeqmoptions.matchE_nnearest + MatchedEV_full(:,tt,:,SSprime_c,:)=VPath(:,matchind+1,:); % matchind+1 is where we are the period after the match [we want next period value fn to create expectations] + end + end + end + end + end + % For period T, we just fill MatchedEV with the MatchedEV that is the period most similar in terms of S and 'Distances' [we cannot next period S, so this will do] + [~,matchindT]=min(Distances(T,:).*SSmask_T(ss_ind_T(T),:)); + MatchedEV_full(:,T,:,:,:)=MatchedEV_full(:,matchindT,:,:,:); + % Now that we have the 'matches' we construct the expected next period value fn + MatchedEV=mean(MatchedEV_full,5); % First, take the mean over the 'nearest' + % MatchedEV is now [N_a,T,N_z,N_S] + % Second, take expectations with respect to next period S + MatchedEV=sum(MatchedEV.*pi_Sprime_T,4); % pi_Sprime_T is [1,T,1,N_S], note that S is determined by t, so only needs the Sprime probabilities and does not have a dimension for S + % MatchedEV is now [N_a,T,N_z] + + matchtime=toc; + + % disp('HERE') + % DistMatches + % recursiveeqmoptions + % AggVarsPath.K.Mean(1:10) + + + + %% Update Params to contain the current price path + % Put the PricePathOld matrix into PricePath structure, and store a copy in Parameters + for pp=1:length(PricePathNames) + PricePath.(PricePathNames{pp})=PricePathOld(:,PricePathSizeVec(1,pp):PricePathSizeVec(2,pp)); + % Then store PricePath structure in Parameters + Parameters.(PricePathNames{pp})=PricePath.(PricePathNames{pp}); + end + + % disp('HERE2') + % PricePath.r(1:10) + % PricePath.w(1:10) + + %% Since we have all the 'next period value fns', we can compute all the value fns in parallel, there is no iterating in the time dimension + + tic; + if recursiveeqmoptions.divideT==1 + [VPath, PolicyIndexesPath]=ValueFnIter_FHorz_TPath_SingleStep_fastOLG(MatchedEV,n_d,n_a,n_z,T,d_grid, a_grid, z_gridvals_T, pi_z_T, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + % VPath in fastOLG is [N_a*T,N_z] + % PolicyIndexesPath in fastOLG is [:,N_a,T,N_z] and contains the joint-index for (d,aprime) + % Note: using vfoptions.EVpre + else + VPath=reshape(VPath,[N_a,T,N_z]); + for rr=1:recursiveeqmoptions.divideT + t1=recursiveeqmoptions.divideTindexes(rr,1); + t2=recursiveeqmoptions.divideTindexes(rr,2); + T_t1t2=t2-t1+1; + % These next lines about parameters could be much better done + % [only need to do this for price path (agg vars cannot be here + % and that is only other thing that changes each iteration)] + Parameters_rr=Parameters; + ParamNames_rr=fieldnames(Parameters_rr); + for pp=1:length(ParamNames_rr) + if size(Parameters_rr.(ParamNames_rr{pp}),1)==T + temp=Parameters_rr.(ParamNames_rr{pp}); + Parameters_rr.(ParamNames_rr{pp})=temp(t1:t2,:); + elseif size(Parameters_rr.(ParamNames_rr{pp}),2)==T + temp=Parameters_rr.(ParamNames_rr{pp}); + Parameters_rr.(ParamNames_rr{pp})=temp(:,t1:t2); + end + end + % Do the value fn problem for periods t1-to-t2 + [VPath_t1t2, PolicyIndexesPath_t1t2]=ValueFnIter_FHorz_TPath_SingleStep_fastOLG(MatchedEV(:,t1:t2,:),n_d,n_a,n_z,T_t1t2,d_grid, a_grid, z_gridvals_T(t1:t2,:,:), pi_z_T(t1:t2,:,:), ReturnFn, Parameters_rr, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + VPath(:,t1:t2,:)=reshape(VPath_t1t2,[N_a,T_t1t2,N_z]); + PolicyIndexesPath(:,:,t1:t2,:)=PolicyIndexesPath_t1t2; + end + VPath=reshape(VPath,[N_a*T,N_z]); + end + vfitime=toc; + + % disp('HERE3') + % size(MatchedEV) + % size(VPath) + % max(abs(MatchedEV(:)-VPath(:))) + % size(PolicyIndexesPath) + + %% Modify PolicyIndexesPath into forms needed for forward iteration + tic; + % Create version of PolicyIndexesPath in form we want for the agent distribution iteration + % Creates PolicyaprimezPath, and when using grid interpolation layer also PolicyProbsPath + if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:T-1,:),[N_a*(T-1)*N_z,1]); % aprime index + elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:T-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:T-1,:)-1),[N_a*(T-1)*N_z,1]); + elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:T-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:T-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,1:T-1,:)-1),[N_a*(T-1)*N_z,1]); + elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(l_d+1,:,1:T-1,:)+n_a(1)*(PolicyIndexesPath(l_d+2,:,1:T-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(l_d+3,:,1:T-1,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(l_d+4,:,1:T-1,:)-1),[N_a*(T-1)*N_z,1]); + end + PolicyaprimetzPath=PolicyaprimePath+repelem(N_a*gpuArray(0:1:(T-1)*N_z-1)',N_a,1); + if simoptions.gridinterplayer==1 + PolicyaprimetzPath=reshape(PolicyaprimetzPath,[N_a*(T-1)*N_z,1]); % reinterpret this as lower grid index + PolicyaprimetzPath=repelem(PolicyaprimetzPath,1,2); % create copy that will be the upper grid index + PolicyaprimetzPath(:,2)=PolicyaprimetzPath(:,2)+1; % upper grid index + PolicyProbsPath(:,2)=reshape(PolicyIndexesPath(l_d+l_aprime+1,:,1:T-1,:),[N_a*(T-1)*N_z,1]); % L2 index + PolicyProbsPath(:,2)=(PolicyProbsPath(:,2)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1)=1-PolicyProbsPath(:,2); % probability of lower grid point + end + % Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats + PolicyValuesPath=PolicyInd2Val_InfHorz_TPath(PolicyIndexesPath,n_d,n_a,n_z,T,d_grid,a_grid,vfoptions,1); + PolicyValuesPath=permute(reshape(PolicyValuesPath,[size(PolicyValuesPath,1),N_a,N_z,T]),[2,4,3,1]); %[N_a,T,N_z,l_daprime] + + modtime=toc; + + %% Update agent dist + % Normally does not update the t=1 agent dist + tic; + + % % Exception is that the preliminary stationary eqm is probably not quite 'typical', so get rid of it in the second path iteration + % if 2<=pathcounter && pathcounter<=5 + % % Replace the initial t=1 AgentDist with something arbitrary from later in the path. + % % Need to use something with the same S as in t=1 + % temp=1:1:T; + % arbitraryt=temp(SSmask_T(ss_ind_T(1),:)); + % arbitraryt=arbitraryt(round(length(arbitraryt)/2)); % pick one halfway along the path that has the same S + % arbitraryt + % [ss_ind_T(1),ss_ind_T(arbitraryt)] % should be the same + % AgentDistarbitrarytindex=repmat(gpuArray(1:1:N_a)',N_z,1)+N_a*(arbitraryt-1)+repelem(N_a*T*gpuArray(0:1:N_z-1)',N_a,1); + % AgentDist_initial=AgentDistPath(AgentDistarbitrarytindex); + % AgentDistPath(AgentDistt0index)=AgentDist_initial; + % if fastOLGtheAgentDist==0 + % AgentDist_initial=reshape(AgentDist_initial,[N_a*N_z,1]); % fastOLG means (a,t,z)-by-1 + % end + % end + % THIS DIDN'T WORK AS THEN GOT A MIX OF THIS AGENT DIST WITH THE + % EXISTING PERIOD 1 POLICY, ETC. AND THAT JUST TURNED INTO A MESS + + if fastOLGtheAgentDist==1 + if pathcounter<=5 + distiter=5; + else + distiter=10; + end + for distii=1:distiter + if simoptions.gridinterplayer==0 + AgentDistPath=AgentDist_FHorz_TPath_SingleStep_IterFast_raw(AgentDistPath,PolicyaprimetzPath,N_a,N_z,T,pi_z_T_sim,II1,II2,exceptlastj,exceptfirstj,justfirstj,AgentDist_initial1); % Policy for jj=1:N_j-1 + else + AgentDistPath=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_raw(AgentDistPath,PolicyaprimetzPath,PolicyProbsPath,N_a,N_z,T,pi_z_T_sim,II,exceptlastj,exceptfirstj,justfirstj,AgentDist_initial1); % Policy for jj=1:N_j-1 + end + end + else + % The loop approach appears much less stable (you get one bad iteration of the matched-expectations path and it blows up) + AgentDistPath=zeros([N_a*N_z,T],'gpuArray'); + AgentDist=AgentDist_initial0; + AgentDistPath(:,1)=AgentDist; + II1b=gpuArray(1:1:N_a*N_z); + IIones=ones(N_a*N_z,1,'gpuArray'); + if simoptions.gridinterplayer==0 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:T-1,:),[N_a,(T-1),N_z]); + for tt=1:T-1 + Policy_aprimez=reshape(PolicyaprimePath(:,tt,:),[N_a*N_z,1])+N_a*repelem((0:1:N_z-1)',N_a,1); + % AgentDist=sparse(reshape(AgentDistPathPre(:,tt,:),[N_a*N_z,1])); % CHECK THAT THEY GIVE THE SAME THING + AgentDist=AgentDist_InfHorz_TPath_SingleStep(AgentDist,Policy_aprimez,II1b,IIones,N_a,N_z,sparse(squeeze(pi_z_T(tt,:,:))')); % pi_z_T(tt,:,:)' as pi_z_T has shape designed for fastOLG + AgentDistPath(:,tt+1)=AgentDist; + end + AgentDistPath=reshape(permute(reshape(AgentDistPath,[N_a,N_z,T]),[1,3,2]),[N_a*T*N_z,1]); % fastOLG shape for use in AggVars + else + error('Not yet implemented') + end + end + + agentdisttime=toc; + + % disp('HERE4') + % size(AgentDist_initial1) + % size(AgentDistPath) + % temp=abs(repmat(reshape(AgentDist_initial1,[N_a,1,N_z]),1,T,1)-reshape(AgentDistPath,[N_a,T,N_z])); + % temp2=max(max(temp,3),1); + % temp2(1:10) + + %% AggVars + tic; + AggVarsPath=EvalFnOnAgentDist_AgeConditionalAggVars_FHorz_fastOLG(AgentDistPath.*AgeWeights_T,PolicyValuesPath(:,:,:,1:l_d),PolicyValuesPath(:,:,:,l_d+1:end), FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,T,l_d,l_a,l_a,l_z,N_a,N_z,a_gridvals,z_gridvals_T_fastOLG,1); + for ff=1:length(AggVarNames) + Parameters.(AggVarNames{ff})=AggVarsPath.(AggVarNames{ff}).Mean; + end + + aggvartime=toc; + + tic; + %% General Eqm Eqns + % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) + % I can parallel this, but for now just loop over tt + for tt=1:T + for pp=1:length(PricePathNames) + temp=PricePath.(PricePathNames{pp}); + Parameters.(PricePathNames{pp})=temp(tt); + end + for SS_c=1:length(n_S) + temp=AggShocksPath.(AggShockNames{SS_c}); + Parameters.(AggShockNames{SS_c})=temp(tt); + end + for ff=1:length(AggVarNames) + temp=AggVarsPath.(AggVarNames{ff}).Mean; + Parameters.(AggVarNames{ff})=temp(tt); + end + [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),recursiveeqmoptions); + PricePathNew(tt,:)=PricePathNew_tt; + GEcondnPath(tt,:)=GEcondnPath_tt; + end + % Put the aggregate price and shocks paths back into Parameters + for pp=1:length(PricePathNames) + Parameters.(PricePathNames{pp})=PricePath.(PricePathNames{pp}); + end + for SS_c=1:length(n_S) + Parameters.(AggShockNames{SS_c})=AggShocksPath.(AggShockNames{SS_c}); % Can just set it up as an exogenous parameter that has T as a dimension + end + for ff=1:length(AggVarNames) + Parameters.(AggVarNames{ff})=AggVarsPath.(AggVarNames{ff}).Mean; + end + + GEtime=toc; + + + % disp('HERE5: K and L') + % AggVarsPath.K.Mean(1:10) + % AggVarsPath.L.Mean(1:10) + % [min(AggVarsPath.K.Mean),max(AggVarsPath.K.Mean)] + % [min(AggVarsPath.L.Mean),max(AggVarsPath.L.Mean)] + % [~,iiK]=min(AggVarsPath.K.Mean); + % [~,iiL]=min(AggVarsPath.L.Mean); + % + % disp('Min K and L periods') + % [iiK,iiL] + % [AggVarsPath.K.Mean(iiK),AggVarsPath.L.Mean(iiK),PricePath.r(iiK),PricePath.w(iiK)] + % [AggVarsPath.K.Mean(iiL),AggVarsPath.L.Mean(iiL),PricePath.r(iiL),PricePath.w(iiL)] + % GEcondnPath(iiK,:) + % GEcondnPath(iiL,:) + % + % if pathcounter>1 + % [AggVarsPath.K.Mean(iiKlag),AggVarsPath.L.Mean(iiKlag),PricePath.r(iiKlag),PricePath.w(iiKlag)] + % [AggVarsPath.K.Mean(iiLlag),AggVarsPath.L.Mean(iiLlag),PricePath.r(iiLlag),PricePath.w(iiLlag)] + % GEcondnPath(iiKlag,:) + % GEcondnPath(iiLlag,:) + % end + % + % iiKlag=iiK; + % iiLlag=iiL; + + fprintf('Runtimes are: match, vfi, mod, agentdist, aggvar, GE \n') + [matchtime,vfitime,modtime,agentdisttime,aggvartime,GEtime] + fprintf('Solving agent dist using fastOLGtheAgentDist=%i (0=loop, 1=parallel) \n', fastOLGtheAgentDist) + + %% Perform update of prices and give feedback + + % See how far apart the price paths are + CurrentPathDist_price=max(abs(PricePathNew(1:T-1,:)-PricePathOld(1:T-1,:)),[],1); % 1-by-prices + % Notice that the distance is always calculated ignoring the time t=1 & t=T periods, as these needn't ever converges + % Why look at price paths, why just look at the general eqm conditions?? + + % CurrentPathDist=max(abs(GEcondnPath)); + CurrentPathDist_GEcondn=max(abs(GEcondnPath),[],1); % 1-by-GECondns + + % Create plots of the transition path (before we update pricepath) + createTPathFeedbackPlots(PricePathNames,AggVarNames,GEeqnNames,PricePathOld,AggVarsPath,GEcondnPath,recursiveeqmoptions); + + % Update PricePathOld + % Set price path to be 9/10ths the old path and 1/10th the new path (but making sure to leave prices in periods 1 & T unchanged). + if recursiveeqmoptions.weightscheme==0 + PricePathOld=PricePathNew; % The update weights are already in GEnewprice setup + elseif recursiveeqmoptions.weightscheme==1 % Just a constant weighting + PricePathOld(1:T-1,:)=recursiveeqmoptions.oldpathweight*PricePathOld(1:T-1)+(1-recursiveeqmoptions.oldpathweight)*PricePathNew(1:T-1,:); + elseif recursiveeqmoptions.weightscheme==2 % A exponentially decreasing weighting on new path from (1-oldpathweight) in first period, down to 0.1*(1-oldpathweight) in T-1 period. + % I should precalculate these weighting vectors + Ttheta=recursiveeqmoptions.Ttheta; + PricePathOld(1:Ttheta,:)=recursiveeqmoptions.oldpathweight*PricePathOld(1:Ttheta)+(1-recursiveeqmoptions.oldpathweight)*PricePathNew(1:Ttheta,:); + PricePathOld(Ttheta:T-1,:)=((recursiveeqmoptions.oldpathweight+(1-exp(linspace(0,log(0.2),T-Ttheta)))*(1-recursiveeqmoptions.oldpathweight))'*ones(1,l_p)).*PricePathOld(Ttheta:T-1,:)+((exp(linspace(0,log(0.2),T-Ttheta)).*(1-recursiveeqmoptions.oldpathweight))'*ones(1,l_p)).*PricePathNew(Ttheta:T-1,:); + elseif recursiveeqmoptions.weightscheme==3 % A gradually opening window. + if (pathcounter*3)=1 + fprintf(' \n') + fprintf('Number of iterations on matched-expecations path: %i \n',pathcounter) + fprintf('Current distance between old and new price path (in L-Infinity norm): %8.6f \n', max(CurrentPathDist_price)) + fprintf(priceverbosestr, CurrentPathDist_price') + fprintf('Current General Eqm conditions (in L-Infinity norm): %8.6f \n', max(CurrentPathDist_GEcondn)) + fprintf(GEcondnverbosestr, CurrentPathDist_GEcondn') + fprintf('Ratio of current distance to the convergence tolerance, in prices: %.2f (convergence when reaches 1) \n',TransPathConvergence_prices) + fprintf('Ratio of current distance to the convergence tolerance, in GE Condns: %.2f (convergence when reaches 1) \n',TransPathConvergence_GEcondns) + fprintf('Ratio of current distance to the convergence tolerance: %.2f (convergence when reaches 1; is the minimum of both prices and GEcondns) \n',TransPathConvergence) + fprintf(' \n') + end + + if recursiveeqmoptions.historyofpricepath==1 + % Store the whole history of the price path and save it every ten iterations + PricePathHistory{pathcounter,1}=CurrentPathDist_price; + PricePathHistory{pathcounter,2}=PricePathOld; + if rem(pathcounter,10)==1 + save ./SavedOutput/RecursiveGEwAggShocks_Internal.mat PricePathHistory + end + end + + pathcounter=pathcounter+1; +end + +%% Sort some stuff for output +% Put the PricePathOld matrix into PricePath structure for output +GEcondnPathMatrix=GEcondnPath; +clear GEcondnPath +for gg=1:length(GEeqnNames) + GEcondnPath.(GEeqnNames{gg})=GEcondnPathMatrix(:,gg); +end +% Put the PricePathOld matrix into PricePath structure for output +for pp=1:length(PricePathNames) + PricePath.(PricePathNames{pp})=PricePathOld(:,PricePathSizeVec(1,pp):PricePathSizeVec(2,pp)); +end + +if pathcounter>=recursiveeqmoptions.maxiter + warning('Stopped due to reaching maxiter (rather than convergence; while computing Recursive General Eqm using Matched Expectations Path algorithm)') +end + +end \ No newline at end of file diff --git a/RecursiveEqmAggShocks/MatchedExpectationsPath_InfHorz_shooting_nod.m b/RecursiveEqmAggShocks/MatchedExpectationsPath_InfHorz_shooting_nod.m new file mode 100644 index 00000000..94b40074 --- /dev/null +++ b/RecursiveEqmAggShocks/MatchedExpectationsPath_InfHorz_shooting_nod.m @@ -0,0 +1,498 @@ +function [PricePath,GEcondnPath,VPath,PolicyIndexesPath,AgentDistPath,DistMatches]=MatchedExpectationsPath_InfHorz_shooting_nod(AggShocksPath, AggShockNames, T,SSmask_T,SSprimemask_T,SSprimemask_T_indexes,ss_ind_T, n_a, n_z, n_S, l_a, l_z, a_grid,z_gridvals_T,z_gridvals_T_fastOLG, pi_Sprime_T, pi_z_T, pi_z_T_sim, ReturnFn, FnsToEvaluate, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEPriceParamNames, GEeqnNames, GeneralEqmEqnsStruct, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, ReturnFnParamNames, initialguessobjects, vfoptions, simoptions,recursiveeqmoptions) + +n_d=0; +d_grid=[]; + +N_a=prod(n_a); +N_z=prod(n_z); + +N_S=prod(n_S); + +l_aprime=length(n_a); + +%% +if recursiveeqmoptions.verbose>=1 + % Set up some things to be used later + pathnametitles=cell(1,2*length(GEPriceParamNames)); + for tt=1:length(GEPriceParamNames) + pathnametitles{tt}={['Old ',GEPriceParamNames{tt}]}; + pathnametitles{tt+length(GEPriceParamNames)}={['New ',GEPriceParamNames{tt}]}; + end + + priceverbosestr=' of which: '; + for pp=1:length(GEPriceParamNames) + priceverbosestr=[priceverbosestr,GEPriceParamNames{pp},' is %8.6f, ']; + end + priceverbosestr=[priceverbosestr,' \n']; + GEcondnverbosestr=' of which: '; + for gg=1:length(GEeqnNames) + GEcondnverbosestr=[GEcondnverbosestr,GEeqnNames{gg},' is %8.6f, ']; + end + GEcondnverbosestr=[GEcondnverbosestr,' \n']; +end + +%% Setup needed for the fastOLG agent dist iterations +if simoptions.gridinterplayer==0 + II1=1:1:N_a*(T-1)*N_z; + II2=ones(N_a*(T-1)*N_z,1); + exceptlastj=repmat((1:1:N_a)',(T-1)*N_z,1)+repmat(repelem(N_a*(0:1:T-2)',N_a,1),N_z,1)+repelem(N_a*T*(0:1:N_z-1)',N_a*(T-1),1); + exceptfirstj=repmat((1:1:N_a)',(T-1)*N_z,1)+repmat(repelem(N_a*(1:1:T-1)',N_a,1),N_z,1)+repelem(N_a*T*(0:1:N_z-1)',N_a*(T-1),1); + justfirstj=repmat((1:1:N_a)',N_z,1)+N_a*T*repelem((0:1:N_z-1)',N_a,1); +elseif simoptions.gridinterplayer==1 + N_probs=2; + II=repelem((1:1:N_a*(T-1)*N_z)',1,N_probs); + exceptlastj=repmat((1:1:N_a)',(T-1)*N_z,1)+repmat(repelem(N_a*(0:1:T-2)',N_a,1),N_z,1)+repelem(N_a*T*(0:1:N_z-1)',N_a*(T-1),1); + exceptfirstj=repmat((1:1:N_a)',(T-1)*N_z,1)+repmat(repelem(N_a*(1:1:T-1)',N_a,1),N_z,1)+repelem(N_a*T*(0:1:N_z-1)',N_a*(T-1),1); + justfirstj=repmat((1:1:N_a)',N_z,1)+N_a*T*repelem((0:1:N_z-1)',N_a,1); +end +% We don't have age weights here, as the mass of agents is the same in every t=1:T. +% I'm leaving it as a object as I can imagine there will be some firm +% entry-exit models where you would want this to change over time. +AgeWeights_T=repmat(repelem(ones(T,1,'gpuArray'),N_a,1),N_z,1); + +%% How to update the agent dist? +% Iteration i and time period t, call agent dist Phi_t^i +% There are two ways we could update this: +% Hanbaek Lee does the update by iterating on t +% - First Phi_2^{i+1} is created from Phi_1^{i} +% - Iterate on t=3:T, Phi_t^{i+1} is created from Phi_{t-1}^{i+1} +% Or we can take the fastOLG style approach +% - Parallel oever t=2:T, we create Phi_t^{i+1} from Phi_{t-1}^{i} +% For now I just use the fastOLG style approach +fastOLGtheAgentDist=1 +% But setting this to zero will do the time-loop version that Lee uses. + +%% Create the initial guess +if recursiveeqmoptions.verbose>=1 + fprintf('Solving preliminary stationary eqm problem \n') + tic; +end +[PricePath,VPath,AgentDistPath,AggVarsPath,GEcheck]=MatchedExpectationsPath_CreateInitialGuess(T,ss_ind_T,0,n_a,n_z,n_S,N_a,N_z,N_S,[],a_grid,initialguessobjects,AggShockNames,AggVarNames,ReturnFn,FnsToEvaluate,GeneralEqmEqnsStruct,Parameters,DiscountFactorParamNames, GEPriceParamNames,GEeqnNames,recursiveeqmoptions,vfoptions,simoptions); +% And create a version of PricePath as the matrix +[PricePathOld,~,PricePathNames,~,PricePathSizeVec,~]=PricePathParamPath_StructToMatrix(PricePath,struct(),T); +if recursiveeqmoptions.verbose>=1 + fprintf('preliminary stationary eqm runtime was %4.8f seconds \n', toc) + fprintf(' \n') + fprintf(' \n') + fprintf(' \n') +end + +l_p=length(GEPriceParamNames); +PricePathNew=zeros(size(PricePathOld),'gpuArray'); PricePathNew(T,:)=PricePathOld(T,:); + + +%% We do the time periods tt=1:T all in parallel +% This leverages the fastOLG commands, which use a different shape +% fastOLG so everything is (a,t,z) +% Shapes: +% VPath is [N_a,T,N_z] +% AgentDistPath for fastOLG is [N_a*T*N_z,1] + +%% +pathcounter=1; +TransPathConvergence=Inf; % ratio of 'Current Path Distance -to- recursiveeqmoptions.tolerance' + % Require convergence in both prices and general eqm conditions + + +GEcondnPath=zeros(T,length(GEeqnNames),'gpuArray'); + +a_gridvals=CreateGridvals(n_a,a_grid,1); +if simoptions.gridinterplayer==1 + PolicyProbsPath=zeros(N_a*(T-1)*N_z,N_probs,'gpuArray'); % preallocate +end + +AgentDistt0index=repmat(gpuArray(1:1:N_a)',N_z,1)+repelem(N_a*T*gpuArray(0:1:N_z-1)',N_a,1); + +%% Solve using the matched-expecations path algorithm +if recursiveeqmoptions.verbose==1 + fprintf('Start solving the matched expectations path \n') +end + +% VPath0=VPath; + +% The initial agent distribution does not get updated much, so just keep a copy rather than indexing it every iteration +if fastOLGtheAgentDist==1 + AgentDist_initial1=AgentDistPath(AgentDistt0index); % fastOLG means AgentDistPath is (a,t,z)-by-1 +else + AgentDist_initial0=AgentDistPath(AgentDistt0index); % fastOLG means AgentDistPath is (a,t,z)-by-1 + AgentDist_initial0=reshape(AgentDist_initial0,[N_a*N_z,1]); +end + + +while TransPathConvergence>1 && pathcounterrecursiveeqmoptions.burnin + % The match is this period and distance is zero + DistMatches(tt,SSprime_c,:,1)=tt; + DistMatches(tt,SSprime_c,:,2)=0; + % Put the next period value function into the MatchedEV + MatchedEV_full(:,tt,:,SSprime_c,:)=VPath(:,tt+1,:); + else + % SSmask_T(SS_c,:) is binary, and takes value of 1 for the time periods that have SS_c as the aggregate shock + % notSSmask_Tplus1(SS_c,:) is binary, and takes value of 1 for the next-period time periods that do NOT have SS_c as the aggregate shock + % potential=Distances(tt,:); + % potential(notSSmask_Tplus1(SSprime_c,:))=Inf; % is making distance=Inf for anything that is not SSprime_c tomorrow + potential=Distances(tt,SSprimemask_T(1,:,SSprime_c)); % Only consider distances that have (currSS,SSprime_c), that is, look for matching S, and then we find each of the Sprime (as we are looping over the Sprime) + [matchval,matchind]=mink(potential,recursiveeqmoptions.matchE_nnearest); % Of the time periods that match S, and have the Sprime we are considering at the moment, find the closest as measured by 'Distances' + % matchind is currently for the 1s in SSprimemask_T, convert to a tt index + matchind=SSprimemask_T_indexes(matchind,SSprime_c); + DistMatches(tt,SSprime_c,:,1)=matchind; + DistMatches(tt,SSprime_c,:,2)=matchval; + for nn=1:recursiveeqmoptions.matchE_nnearest + MatchedEV_full(:,tt,:,SSprime_c,:)=VPath(:,matchind+1,:); % matchind+1 is where we are the period after the match [we want next period value fn to create expectations] + end + end + end + end + elseif recursiveeqmoptions.matchingsetup==2 % Match (S,Sprime) based on Distances + for tt=1:T-1 + currSS=ss_ind_T(tt); + currSSprime=ss_ind_T(tt+1); + % Need to look for periods that are the closest today in terms of having the same S and smallest Distances (same AgentDist), but having a different next period S + for SSprime_c=1:N_S % Loop over the possible next-period aggregate shocks + if SSprime_c==currSSprime && tt>recursiveeqmoptions.burnin + % The match is this period and distance is zero + DistMatches(tt,SSprime_c,:,1)=tt; + DistMatches(tt,SSprime_c,:,2)=0; + % Put the next period value function into the MatchedEV + MatchedEV_full(:,tt,:,SSprime_c,:)=VPath(:,tt+1,:); + else + % SSmask_T(SS_c,:) is binary, and takes value of 1 for the time periods that have SS_c as the aggregate shock + % notSSmask_Tplus1(SS_c,:) is binary, and takes value of 1 for the next-period time periods that do NOT have SS_c as the aggregate shock + % potential=Distances(tt,:); + % potential(notSSmask_Tplus1(SSprime_c,:))=Inf; % is making distance=Inf for anything that is not SSprime_c tomorrow + potential=Distances(tt,SSprimemask_T(1,:,currSS,SSprime_c)); % Only consider distances that have (currSS,SSprime_c), that is, look for matching S, and then we find each of the Sprime (as we are looping over the Sprime) + [matchval,matchind]=mink(potential,recursiveeqmoptions.matchE_nnearest); % Of the time periods that match S, and have the Sprime we are considering at the moment, find the closest as measured by 'Distances' + % matchind is currently for the 1s in SSprimemask_T, convert to a tt index + matchind=SSprimemask_T_indexes(matchind,currSS,SSprime_c); + DistMatches(tt,SSprime_c,:,1)=matchind; + DistMatches(tt,SSprime_c,:,2)=matchval; + for nn=1:recursiveeqmoptions.matchE_nnearest + MatchedEV_full(:,tt,:,SSprime_c,:)=VPath(:,matchind+1,:); % matchind+1 is where we are the period after the match [we want next period value fn to create expectations] + end + end + end + end + end + % For period T, we just fill MatchedEV with the MatchedEV that is the period most similar in terms of S and 'Distances' [we cannot next period S, so this will do] + [~,matchindT]=min(Distances(T,:).*SSmask_T(ss_ind_T(T),:)); + MatchedEV_full(:,T,:,:,:)=MatchedEV_full(:,matchindT,:,:,:); + % Now that we have the 'matches' we construct the expected next period value fn + MatchedEV=mean(MatchedEV_full,5); % First, take the mean over the 'nearest' + % MatchedEV is now [N_a,T,N_z,N_S] + % Second, take expectations with respect to next period S + MatchedEV=sum(MatchedEV.*pi_Sprime_T,4); % pi_Sprime_T is [1,T,1,N_S], note that S is determined by t, so only needs the Sprime probabilities and does not have a dimension for S + % MatchedEV is now [N_a,T,N_z] + + matchtime=toc; + + %% Update Params to contain the current price path + % Put the PricePathOld matrix into PricePath structure, and store a copy in Parameters + for pp=1:length(PricePathNames) + PricePath.(PricePathNames{pp})=PricePathOld(:,PricePathSizeVec(1,pp):PricePathSizeVec(2,pp)); + % Then store PricePath structure in Parameters + Parameters.(PricePathNames{pp})=PricePath.(PricePathNames{pp}); + end + + %% Since we have all the 'next period value fns', we can compute all the value fns in parallel, there is no iterating in the time dimension + tic; + if recursiveeqmoptions.divideT==1 + [VPath, PolicyIndexesPath]=ValueFnIter_FHorz_TPath_SingleStep_fastOLG(MatchedEV,n_d,n_a,n_z,T,d_grid, a_grid, z_gridvals_T, pi_z_T, ReturnFn, Parameters, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + % VPath in fastOLG is [N_a*T,N_z] + % PolicyIndexesPath in fastOLG is [:,N_a,T,N_z] and contains the joint-index for (d,aprime) + % Note: using vfoptions.EVpre + else + VPath=reshape(VPath,[N_a,T,N_z]); + for rr=1:recursiveeqmoptions.divideT + t1=recursiveeqmoptions.divideTindexes(rr,1); + t2=recursiveeqmoptions.divideTindexes(rr,2); + T_t1t2=t2-t1+1; + % These next lines about parameters could be much better done + % [only need to do this for price path (agg vars cannot be here + % and that is only other thing that changes each iteration)] + Parameters_rr=Parameters; + ParamNames_rr=fieldnames(Parameters_rr); + for pp=1:length(ParamNames_rr) + if size(Parameters_rr.(ParamNames_rr{pp}),1)==T + temp=Parameters_rr.(ParamNames_rr{pp}); + Parameters_rr.(ParamNames_rr{pp})=temp(t1:t2,:); + elseif size(Parameters_rr.(ParamNames_rr{pp}),2)==T + temp=Parameters_rr.(ParamNames_rr{pp}); + Parameters_rr.(ParamNames_rr{pp})=temp(:,t1:t2); + end + end + % Do the value fn problem for periods t1-to-t2 + [VPath_t1t2, PolicyIndexesPath_t1t2]=ValueFnIter_FHorz_TPath_SingleStep_fastOLG(MatchedEV(:,t1:t2,:),n_d,n_a,n_z,T_t1t2,d_grid, a_grid, z_gridvals_T(t1:t2,:,:), pi_z_T(t1:t2,:,:), ReturnFn, Parameters_rr, DiscountFactorParamNames, ReturnFnParamNames, vfoptions); + VPath(:,t1:t2,:)=reshape(VPath_t1t2,[N_a,T_t1t2,N_z]); + PolicyIndexesPath(:,:,t1:t2,:)=PolicyIndexesPath_t1t2; + end + VPath=reshape(VPath,[N_a*T,N_z]); + end + vfitime=toc; + + %% Modify PolicyIndexesPath into forms needed for forward iteration + tic; + % Create version of PolicyIndexesPath in form we want for the agent distribution iteration + % Creates PolicyaprimezPath, and when using grid interpolation layer also PolicyProbsPath + if isscalar(n_a) + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:T-1,:),[N_a*(T-1)*N_z,1]); % aprime index + elseif length(n_a)==2 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:T-1,:)+n_a(1)*(PolicyIndexesPath(2,:,1:T-1,:)-1),[N_a*(T-1)*N_z,1]); + elseif length(n_a)==3 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:T-1,:)+n_a(1)*(PolicyIndexesPath(2,:,1:T-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(3,:,1:T-1,:)-1),[N_a*(T-1)*N_z,1]); + elseif length(n_a)==4 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:T-1,:)+n_a(1)*(PolicyIndexesPath(2,:,1:T-1,:)-1)+n_a(1)*n_a(2)*(PolicyIndexesPath(3,:,1:T-1,:)-1)+n_a(1)*n_a(2)*n_a(3)*(PolicyIndexesPath(4,:,1:T-1,:)-1),[N_a*(T-1)*N_z,1]); + end + PolicyaprimetzPath=PolicyaprimePath+repelem(N_a*gpuArray(0:1:(T-1)*N_z-1)',N_a,1); + if simoptions.gridinterplayer==1 + PolicyaprimetzPath=reshape(PolicyaprimetzPath,[N_a*(T-1)*N_z,1]); % reinterpret this as lower grid index + PolicyaprimetzPath=repelem(PolicyaprimetzPath,1,2); % create copy that will be the upper grid index + PolicyaprimetzPath(:,2)=PolicyaprimetzPath(:,2)+1; % upper grid index + PolicyProbsPath(:,2)=reshape(PolicyIndexesPath(l_aprime+1,:,1:T-1,:),[N_a*(T-1)*N_z,1]); % L2 index + PolicyProbsPath(:,2)=(PolicyProbsPath(:,2)-1)/(1+simoptions.ngridinterp); % probability of upper grid point + PolicyProbsPath(:,1)=1-PolicyProbsPath(:,2); % probability of lower grid point + end + % Create PolicyValuesPath from PolicyIndexesPath for use in calculating model stats + PolicyValuesPath=PolicyInd2Val_InfHorz_TPath(PolicyIndexesPath,0,n_a,n_z,T,[],a_grid,vfoptions,1); + PolicyValuesPath=permute(reshape(PolicyValuesPath,[size(PolicyValuesPath,1),N_a,N_z,T]),[2,4,3,1]); %[N_a,T,N_z,l_aprime] + + modtime=toc; + + %% Update agent dist + % Normally does not update the t=1 agent dist + tic; + + % % Exception is that the preliminary stationary eqm is probably not quite 'typical', so get rid of it in the second path iteration + % if 2<=pathcounter && pathcounter<=5 + % % Replace the initial t=1 AgentDist with something arbitrary from later in the path. + % % Need to use something with the same S as in t=1 + % temp=1:1:T; + % arbitraryt=temp(SSmask_T(ss_ind_T(1),:)); + % arbitraryt=arbitraryt(round(length(arbitraryt)/2)); % pick one halfway along the path that has the same S + % arbitraryt + % [ss_ind_T(1),ss_ind_T(arbitraryt)] % should be the same + % AgentDistarbitrarytindex=repmat(gpuArray(1:1:N_a)',N_z,1)+N_a*(arbitraryt-1)+repelem(N_a*T*gpuArray(0:1:N_z-1)',N_a,1); + % AgentDist_initial=AgentDistPath(AgentDistarbitrarytindex); + % AgentDistPath(AgentDistt0index)=AgentDist_initial; + % if fastOLGtheAgentDist==0 + % AgentDist_initial=reshape(AgentDist_initial,[N_a*N_z,1]); % fastOLG means (a,t,z)-by-1 + % end + % end + % THIS DIDN'T WORK AS THEN GOT A MIX OF THIS AGENT DIST WITH THE + % EXISTING PERIOD 1 POLICY, ETC. AND THAT JUST TURNED INTO A MESS + + if fastOLGtheAgentDist==1 + if pathcounter<=5 + distiter=5; + else + distiter=10; + end + for distii=1:distiter + if simoptions.gridinterplayer==0 + AgentDistPath=AgentDist_FHorz_TPath_SingleStep_IterFast_raw(AgentDistPath,PolicyaprimetzPath,N_a,N_z,T,pi_z_T_sim,II1,II2,exceptlastj,exceptfirstj,justfirstj,AgentDist_initial1); % Policy for jj=1:N_j-1 + else + AgentDistPath=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_raw(AgentDistPath,PolicyaprimetzPath,PolicyProbsPath,N_a,N_z,T,pi_z_T_sim,II,exceptlastj,exceptfirstj,justfirstj,AgentDist_initial1); % Policy for jj=1:N_j-1 + end + end + else + % The loop approach appears much less stable (you get one bad iteration of the matched-expectations path and it blows up) + AgentDistPath=zeros([N_a*N_z,T],'gpuArray'); + AgentDist=AgentDist_initial0; + AgentDistPath(:,1)=AgentDist; + II1b=gpuArray(1:1:N_a*N_z); + IIones=ones(N_a*N_z,1,'gpuArray'); + if simoptions.gridinterplayer==0 + PolicyaprimePath=reshape(PolicyIndexesPath(1,:,1:T-1,:),[N_a,(T-1),N_z]); + for tt=1:T-1 + Policy_aprimez=reshape(PolicyaprimePath(:,tt,:),[N_a*N_z,1])+N_a*repelem((0:1:N_z-1)',N_a,1); + % AgentDist=sparse(reshape(AgentDistPathPre(:,tt,:),[N_a*N_z,1])); % CHECK THAT THEY GIVE THE SAME THING + AgentDist=AgentDist_InfHorz_TPath_SingleStep(AgentDist,Policy_aprimez,II1b,IIones,N_a,N_z,sparse(squeeze(pi_z_T(tt,:,:))')); % pi_z_T(tt,:,:)' as pi_z_T has shape designed for fastOLG + AgentDistPath(:,tt+1)=AgentDist; + end + AgentDistPath=reshape(permute(reshape(AgentDistPath,[N_a,N_z,T]),[1,3,2]),[N_a*T*N_z,1]); % fastOLG shape for use in AggVars + else + error('Not yet implemented') + end + end + + agentdisttime=toc; + + %% AggVars + tic; + AggVarsPath=EvalFnOnAgentDist_AgeConditionalAggVars_FHorz_fastOLG(AgentDistPath.*AgeWeights_T,[],PolicyValuesPath, FnsToEvaluateCell,FnsToEvaluateParamNames,AggVarNames,Parameters,T,0,l_a,l_a,l_z,N_a,N_z,a_gridvals,z_gridvals_T_fastOLG,1); + for ff=1:length(AggVarNames) + Parameters.(AggVarNames{ff})=AggVarsPath.(AggVarNames{ff}).Mean; + end + + aggvartime=toc; + + tic; + %% General Eqm Eqns + % Evaluate the general eqm conditions, and based on them create PricePathNew (interpretation depends on transpathoptions) + % I can parallel this, but for now just loop over tt + for tt=1:T + for pp=1:length(PricePathNames) + temp=PricePath.(PricePathNames{pp}); + Parameters.(PricePathNames{pp})=temp(tt); + end + for SS_c=1:length(n_S) + temp=AggShocksPath.(AggShockNames{SS_c}); + Parameters.(AggShockNames{SS_c})=temp(tt); + end + for ff=1:length(AggVarNames) + temp=AggVarsPath.(AggVarNames{ff}).Mean; + Parameters.(AggVarNames{ff})=temp(tt); + end + [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld(tt,:),recursiveeqmoptions); + PricePathNew(tt,:)=PricePathNew_tt; + GEcondnPath(tt,:)=GEcondnPath_tt; + end + + % Put the aggregate price and shocks paths back into Parameters + for pp=1:length(PricePathNames) + Parameters.(PricePathNames{pp})=PricePath.(PricePathNames{pp}); + end + for SS_c=1:length(n_S) + Parameters.(AggShockNames{SS_c})=AggShocksPath.(AggShockNames{SS_c}); % Can just set it up as an exogenous parameter that has T as a dimension + end + for ff=1:length(AggVarNames) + Parameters.(AggVarNames{ff})=AggVarsPath.(AggVarNames{ff}).Mean; + end + + GEtime=toc; + + fprintf('Runtimes are: match, vfi, mod, agentdist, aggvar, GE \n') + [matchtime,vfitime,modtime,agentdisttime,aggvartime,GEtime] + fprintf('Solving agent dist using fastOLGtheAgentDist=%i (0=loop, 1=parallel) \n', fastOLGtheAgentDist) + + + %% Perform update of prices and give feedback + + % See how far apart the price paths are + CurrentPathDist_price=max(abs(PricePathNew(1:T-1,:)-PricePathOld(1:T-1,:)),[],1); % 1-by-prices + % Notice that the distance is always calculated ignoring the time t=1 & t=T periods, as these needn't ever converges + % Why look at price paths, why just look at the general eqm conditions?? + + % CurrentPathDist=max(abs(GEcondnPath)); + CurrentPathDist_GEcondn=max(abs(GEcondnPath),[],1); % 1-by-GECondns + + % Create plots of the transition path (before we update pricepath) + createTPathFeedbackPlots(PricePathNames,AggVarNames,GEeqnNames,PricePathOld,AggVarsPath,GEcondnPath,recursiveeqmoptions); + + % Update PricePathOld + % Set price path to be 9/10ths the old path and 1/10th the new path (but making sure to leave prices in periods 1 & T unchanged). + if recursiveeqmoptions.weightscheme==0 + PricePathOld=PricePathNew; % The update weights are already in GEnewprice setup + elseif recursiveeqmoptions.weightscheme==1 % Just a constant weighting + PricePathOld(1:T-1,:)=recursiveeqmoptions.oldpathweight*PricePathOld(1:T-1)+(1-recursiveeqmoptions.oldpathweight)*PricePathNew(1:T-1,:); + elseif recursiveeqmoptions.weightscheme==2 % A exponentially decreasing weighting on new path from (1-oldpathweight) in first period, down to 0.1*(1-oldpathweight) in T-1 period. + % I should precalculate these weighting vectors + Ttheta=recursiveeqmoptions.Ttheta; + PricePathOld(1:Ttheta,:)=recursiveeqmoptions.oldpathweight*PricePathOld(1:Ttheta)+(1-recursiveeqmoptions.oldpathweight)*PricePathNew(1:Ttheta,:); + PricePathOld(Ttheta:T-1,:)=((recursiveeqmoptions.oldpathweight+(1-exp(linspace(0,log(0.2),T-Ttheta)))*(1-recursiveeqmoptions.oldpathweight))'*ones(1,l_p)).*PricePathOld(Ttheta:T-1,:)+((exp(linspace(0,log(0.2),T-Ttheta)).*(1-recursiveeqmoptions.oldpathweight))'*ones(1,l_p)).*PricePathNew(Ttheta:T-1,:); + elseif recursiveeqmoptions.weightscheme==3 % A gradually opening window. + if (pathcounter*3)=1 + fprintf(' \n') + fprintf('Number of iterations on matched-expecations path: %i \n',pathcounter) + fprintf('Current distance between old and new price path (in L-Infinity norm): %8.6f \n', max(CurrentPathDist_price)) + fprintf(priceverbosestr, CurrentPathDist_price') + fprintf('Current General Eqm conditions (in L-Infinity norm): %8.6f \n', max(CurrentPathDist_GEcondn)) + fprintf(GEcondnverbosestr, CurrentPathDist_GEcondn') + fprintf('Ratio of current distance to the convergence tolerance, in prices: %.2f (convergence when reaches 1) \n',TransPathConvergence_prices) + fprintf('Ratio of current distance to the convergence tolerance, in GE Condns: %.2f (convergence when reaches 1) \n',TransPathConvergence_GEcondns) + fprintf('Ratio of current distance to the convergence tolerance: %.2f (convergence when reaches 1; is the minimum of both prices and GEcondns) \n',TransPathConvergence) + fprintf(' \n') + end + + if recursiveeqmoptions.historyofpricepath==1 + % Store the whole history of the price path and save it every ten iterations + PricePathHistory{pathcounter,1}=CurrentPathDist_price; + PricePathHistory{pathcounter,2}=PricePathOld; + if rem(pathcounter,10)==1 + save ./SavedOutput/RecursiveGEwAggShocks_Internal.mat PricePathHistory + end + end + + pathcounter=pathcounter+1; +end + +%% Sort some stuff for output +% Put the PricePathOld matrix into PricePath structure for output +GEcondnPathMatrix=GEcondnPath; +clear GEcondnPath +for gg=1:length(GEeqnNames) + GEcondnPath.(GEeqnNames{gg})=GEcondnPathMatrix(:,gg); +end +% Put the PricePathOld matrix into PricePath structure for output +for pp=1:length(PricePathNames) + PricePath.(PricePathNames{pp})=PricePathOld(:,PricePathSizeVec(1,pp):PricePathSizeVec(2,pp)); +end + +if pathcounter>=recursiveeqmoptions.maxiter + warning('Stopped due to reaching maxiter (rather than convergence; while computing Recursive General Eqm using Matched Expectations Path algorithm)') +end + +end \ No newline at end of file diff --git a/RecursiveEqmAggShocks/RecursiveGeneralEqmWithAggShocks_InfHorz.m b/RecursiveEqmAggShocks/RecursiveGeneralEqmWithAggShocks_InfHorz.m new file mode 100644 index 00000000..f0f62327 --- /dev/null +++ b/RecursiveEqmAggShocks/RecursiveGeneralEqmWithAggShocks_InfHorz.m @@ -0,0 +1,400 @@ +function GeneralizedTransitionFn=RecursiveGeneralEqmWithAggShocks_InfHorz(T,n_d,n_a,n_z,n_S,d_grid,a_grid,z_grid,S_grid,pi_z,pi_S,ReturnFn, FnsToEvaluate, GeneralEqmEqns, Parameters, DiscountFactorParamNames, GEPriceParamNames, AggShockNames, recursiveeqmoptions,vfoptions,simoptions, heteroagentoptions) +% Solve aggregate shock models using the matched-expecations path algorithm of Hanbaek Lee + +if ~isfield(recursiveeqmoptions,'divideT') + recursiveeqmoptions.divideT=1; % Number of pieces to divide T into while solving value fn +end +if ~isfield(recursiveeqmoptions,'tolerance') + recursiveeqmoptions.tolerance=10^(-4); % Accuracy of general eqm eqns +end +if ~isfield(recursiveeqmoptions,'verbose') + recursiveeqmoptions.verbose=1; +end +if ~isfield(recursiveeqmoptions,'maxiter') + recursiveeqmoptions.maxiter=1000; % maximum iterations of optimization routine +end +if ~isfield(recursiveeqmoptions,'burnin') + recursiveeqmoptions.burnin=100; % burnin on the aggregate shock +end +if ~isfield(recursiveeqmoptions,'graphpricepath') + recursiveeqmoptions.graphpricepath=0; +end +if ~isfield(recursiveeqmoptions,'graphaggvarspath') + recursiveeqmoptions.graphaggvarspath=0; +end +if ~isfield(recursiveeqmoptions,'graphGEcondns') + recursiveeqmoptions.graphGEcondns=0; +end +if ~isfield(recursiveeqmoptions,'historyofpricepath') + recursiveeqmoptions.historyofpricepath=0; +end +% Note: recursiveeqmoptions.heteroagentoptions can be used to set heteroagentoptions for the initial guess + +% vfoptions and simoptions are required inputs +if ~isfield(vfoptions,'gridinterplayer') + vfoptions.gridinterplayer=0; +end +if ~isfield(vfoptions,'divideandconquer') + vfoptions.divideandconquer=1; +end +if vfoptions.divideandconquer==1 + if ~isfield(vfoptions,'level1n') + vfoptions.level1n=ceil(sqrt(n_a)); + end +end +if ~isfield(vfoptions,'exoticpreferences') + vfoptions.exoticpreferences='None'; +end +if ~isfield(vfoptions,'lowmemory') + vfoptions.lowmemory=0; +end +vfoptions.EVpre=1; +vfoptions.outputkron=1; +vfoptions.policy_forceintegertype=0; +if ~isfield(simoptions,'gridinterplayer') + simoptions.gridinterplayer=0; +end +simoptions.outputkron=1; + +GeneralizedTransitionFn=struct(); + +%% +if recursiveeqmoptions.verbose>=1 + fprintf('VFI Toolkit uses the Matched-Expectations Path of Hanbaek Lee to solve models with Aggregate Shocks, please cite his paper if you use this in your publication: Global Nonlinear Solutions in Sequence Space and the Generalized Transition Function') +end + +%% Just treat burnin+T as T, and then remove the burnin while cleaning up at the end +T=recursiveeqmoptions.burnin+T; + +l_S=length(n_S); + +%% +N_d=prod(n_d); +N_a=prod(n_a); +N_z=prod(n_z); +N_S=prod(n_S); + +% Move things to GPU +d_grid=gpuArray(d_grid); +a_grid=gpuArray(a_grid); +z_grid=gpuArray(z_grid); +S_grid=gpuArray(S_grid); +pi_z=gpuArray(pi_z); +pi_S=gpuArray(pi_S); + +% Switch S_grid to joint-grid (if it not already) +if size(S_grid,2)==1 + S_gridvals=CreateGridvals(n_S,S_grid,1); +else + S_gridvals=S_grid; +end +clear S_grid % make sure I don't accidently use it later + +%% Implement new way of handling ReturnFn inputs +if length(AggShockNames)~=l_S + error('length(AggShockNames) must be the same as length(n_S). They disagree on the number of aggregate shocks.') +end + +for SS_c=1:l_S + Parameters.(AggShockNames{SS_c})=0; % Just a placeholder while we set up ReturnFnParamNames +end +ReturnFnParamNames=ReturnFnParamNamesFn(ReturnFn,n_d,n_a,n_z,0,vfoptions,Parameters); +for SS_c=1:l_S + Parameters=rmfield(Parameters,AggShockNames{SS_c});% To make sure I don't accidently use them +end + +%% Change to FnsToEvaluate as cell so that it is not being recomputed all the time +if N_d==0 + l_d=0; +else + l_d=length(n_d); +end +l_a=length(n_a); +if N_z==0 + l_z=0; +else + l_z=length(n_z); +end +l_e=0; % Not yet implemented for InfHorz + +l_daprime=l_d+l_a; + +AggVarNames=fieldnames(FnsToEvaluate); +FnsToEvaluateCell=cell(1,length(AggVarNames)); +for ff=1:length(AggVarNames) + temp=getAnonymousFnInputNames(FnsToEvaluate.(AggVarNames{ff})); + if length(temp)>(l_daprime+l_a+l_z+l_e) % Note: S is not counted here, as that is handled via Parameters + FnsToEvaluateParamNames(ff).Names={temp{l_daprime+l_a+l_z+l_e+1:end}}; % the first inputs will always be (d,aprime,a,z) + else + FnsToEvaluateParamNames(ff).Names={}; + end + FnsToEvaluateCell{ff}=FnsToEvaluate.(AggVarNames{ff}); +end +% Change FnsToEvaluate out of structure form, but want to still create AggVars as a structure +simoptions.outputasstructure=1; + +%% GE eqns, switch from structure to cell setup +GEeqnNames=fieldnames(GeneralEqmEqns); +nGeneralEqmEqns=length(GEeqnNames); + +GeneralEqmEqnsCell=cell(1,nGeneralEqmEqns); +for gg=1:nGeneralEqmEqns + temp=getAnonymousFnInputNames(GeneralEqmEqns.(GEeqnNames{gg})); + GeneralEqmEqnParamNames(gg).Names=temp; + GeneralEqmEqnsCell{gg}=GeneralEqmEqns.(GEeqnNames{gg}); +end +% Now: +% GeneralEqmEqns is still the structure +% GeneralEqmEqnsCell is cell +% GeneralEqmEqnParamNames(ff).Names contains the names + + +%% Set up the path: +% setup PricePath as the general eqm prices +% setup ParamPath as the aggregate shock path +% setup pi_z_T as the idiosyncratic transition probs, since they may depend on aggregate shocks +% setup z_gridvals_T as the idiosyncratic shock grids, since they may depend on aggregate shocks + +% I do not set up PricePath here, because it will be based on an initial guess made later. +cumsum_pi_S=cumsum(pi_S,2); + +% setup ParamPath as the aggregate shock path +AggShocksPathIndexesMatrix=zeros(l_S,T); +ss_ind=1+floor(rand(1,1)*N_S); % pick random initial S +for bb=1:recursiveeqmoptions.burnin + [~,ss_ind]=max(cumsum_pi_S(ss_ind,:)>rand(1,1)); +end +ss_ind_T=zeros(T,1); % one spare at end +pi_Sprime_T=zeros(1,T,1,N_S,'gpuArray'); +for tt=1:T + [~,ss_ind]=max(cumsum_pi_S(ss_ind,:)>rand(1,1)); + + ss_ind_T(tt)=ss_ind; + % Set up AggShocksPath + ss_sub=ind2sub_homemade(n_S,ss_ind); + for SS_c=1:length(n_S) + AggShocksPathIndexesMatrix(SS_c,tt)=ss_sub(SS_c); + end + % We also need to keep the pi_S row given S, so that it can be used later to create expectations + pi_Sprime_T(1,tt,1,:)=shiftdim(pi_S(ss_ind,:),-2); +end +% We actually just store the agg shock path in Params in terms of solving +for SS_c=1:length(n_S) + AggShocksIndexesPath.(AggShockNames{SS_c})=AggShocksPathIndexesMatrix(SS_c,:); + AggShocksPath.(AggShockNames{SS_c})=S_gridvals(AggShocksPathIndexesMatrix(SS_c,:),SS_c); + Parameters.(AggShockNames{SS_c})=AggShocksPath.(AggShockNames{SS_c}); +end + + +%% Matching setup +recursiveeqmoptions.matchingsetup=1; % Match based on Sprime and Distance +if ndims(pi_z)==4 % joint transition of z with S + recursiveeqmoptions.matchingsetup=2; % Match based on (S,Sprime) and Distance +end + +if recursiveeqmoptions.matchingsetup==1 + % To be able to speed up the code, we create a record of which t is which S + % For a given S, the row of SSmask_T indicates all the periods with the same S + SSmask_T=zeros(N_S,T,'gpuArray'); + SSprimemask_T=zeros(1,T,N_S,'gpuArray'); % For given SS_c and SSprime_c, it will give a vector of length T, with 1s where you get that combo (SS_c,SSprime_c) at tt + for tt=1:T + SSmask_T(ss_ind_T(tt),tt)=1; + if ttrand(1,1)); %t+1 + pi_z_T(:,:,T)=pi_z(:,:,ss_ind_T(T),ss_ind); +end +% pi_z_T is currently (z,z',t) [When using options.fastOLG=1 it will get converted later to (t,z',z)] +% We want pi_z_T_sim to map (t,z)-to-z', specifically [(T-1)*N_z,N_z] +pi_z_T_sim=gather(reshape(permute(pi_z_T(:,:,1:T-1),[3,1,2]),[(T-1)*N_z,N_z])); +% Now extend it to map (t,z)-to-(t+1,z') [omits t=T and t+1=1] +II1=repmat(1:1:(T-1)*N_z,1,N_z); % index for (t,z) +II2=repmat(1:1:(T-1),1,N_z*N_z)+repelem((T-1)*(0:1:N_z-1),1,N_z*(T-1)); % index for (t,z') +pi_z_T_sim=sparse(II1,II2,pi_z_T_sim,(T-1)*N_z,(T-1)*N_z); +% pi_z_T needs to be (t,zprime,z) for fastOLG +pi_z_T_fastOLG=permute(pi_z_T,[3,2,1]); % pi_z_T_fastOLG is [T,N_zprime,N_z] +% setup z_gridvals_T +% NOT REALLY DONE YET, JUST GOING TO ASSUME INPUT WAS A BASIC z_grid WITH NO DEPENDENCE ON S +z_gridvals_T=repmat(shiftdim(CreateGridvals(n_z,gpuArray(z_grid),1),1),T,1,1); % [T,N_z,l_z] for fastOLG +% For the fastOLG evaluation of AggVars we need +z_gridvals_T_fastOLG=shiftdim(z_gridvals_T,-1); % [1,T,N_z,l_z] need this for fastOLG agent dist, but need the standard still for the value fn without fastOLG +% Keep some of this stuff for the output +GeneralizedTransitionFn.OtherStuff.pi_z_T=pi_z_T(:,:,recursiveeqmoptions.burnin+1:end); +GeneralizedTransitionFn.OtherStuff.z_gridvals_T=z_gridvals_T(recursiveeqmoptions.burnin+1:end,:,:); + + +%% Things for the initial guess + +% Use the mean of S based on stationary dist of S as the value of S here +% (which makes sense with the way I treat S as idiosyncratic shock while doing the initial guess) +statdist_S=ones(N_S,1)/N_S; +for ii=1:1e3 + statdist_S=pi_S'*statdist_S; +end +initialguessobjects.Svalue=zeros(length(n_S),1); +for SS_c=1:length(n_S) + initialguessobjects.Svalue(SS_c)=sum(S_gridvals(:,SS_c).*statdist_S); +end + +% optional input +if isfield(recursiveeqmoptions,'heteroagentoptions') + initialguessobjects.heteroagentoptions=recursiveeqmoptions.heteroagentoptions; +else + initialguessobjects.heteroagentoptions.verbose=0; +end + +initialguessobjects.methodforguess=1; +% =1: replace S with E[S] +% =2: treat S as idiosyncratic shock (this is probably a better idea?, but the initial guess becomes a memory bottleneck, which seems a bit silly) + +if initialguessobjects.methodforguess==1 % Replace S with E[S] + % Put things for the initial guess into a structure + if ndims(pi_z)==2 % Does not depend on S + initialguessobjects.pi_z=pi_z; % note, reverse order + elseif ndims(pi_z)==3 % Depends on current S + initialguessobjects.pi_z=sum(pi_z.*shiftdim(statdist_S,-2),3); % Average across S based on stationary dist of S + elseif ndims(pi_z)==4 % joint transition of z with S + temp=sum(pi_z.*shiftdim(pi_S,-2),4); + temp=sum(temp.*shiftdim(statdist_S,-2),3); + initialguessobjects.pi_z=reshape(temp,[N_z,N_z]); + end + + % NOT REALLY DONE YET, JUST GOING TO ASSUME INPUT WAS A BASIC z_grid WITH NO DEPENDENCE ON S + initialguessobjects.z_gridvals=CreateGridvals(n_z,z_grid,1); + +elseif initialguessobjects.methodforguess==2 % treat S as idiosyncratic shock + % Put things for the initial guess into a structure + initialguessobjects.n_zS=[n_z,n_S]; + if ndims(pi_z)==2 % Does not depend on S + initialguessobjects.pi_zS=kron(pi_S,pi_z); % note, reverse order + elseif ndims(pi_z)==3 % Depends on current S + initialguessobjects.pi_zS=repmat(reshape(permute(pi_z,[1,3,2]),[N_z*N_S,N_z]),1,N_S).*repelem(pi_S,N_z,N_z); + elseif ndims(pi_z)==4 % joint transition of z with S + initialguessobjects.pi_zS=reshape(permute(pi_z,[1,3,2,4]),[N_z*N_S,N_z*N_S]).*repelem(pi_S,N_z,N_z); + end + % NOT REALLY DONE YET, JUST GOING TO ASSUME INPUT WAS A BASIC z_grid WITH NO DEPENDENCE ON S + initialguessobjects.zS_gridvals=[repmat(CreateGridvals(n_z,z_grid,1),N_S,1),repelem(S_gridvals,N_z,1)]; +end + +%% If you are dividing up the T dimension, so some setup for that +if recursiveeqmoptions.divideT>1 + t1vec=floor(1:T/recursiveeqmoptions.divideT:T)'; + recursiveeqmoptions.divideTindexes=[t1vec,[t1vec(2:end)-1;T]]; % (t1,t2), index for first and last t for each divideT-section +end + +%% Set up the shooting algorithm +recursiveeqmoptions=setupGEnewprice3_shooting(recursiveeqmoptions,GeneralEqmEqns,GEPriceParamNames); + +%% Now solve the Matched-expectations path +if N_d==0 + [PricePath,GEcondnPath,VPath,PolicyPath,AgentDistPath,DistMatches]=MatchedExpectationsPath_InfHorz_shooting_nod(AggShocksPath, AggShockNames, T, SSmask_T, SSprimemask_T,SSprimemask_T_indexes,ss_ind_T, n_a, n_z, n_S, l_a, l_z, a_grid,z_gridvals_T,z_gridvals_T_fastOLG, pi_Sprime_T, pi_z_T_fastOLG, pi_z_T_sim, ReturnFn, FnsToEvaluate, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEPriceParamNames, GEeqnNames, GeneralEqmEqns, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, ReturnFnParamNames, initialguessobjects, vfoptions, simoptions,recursiveeqmoptions); +else + [PricePath,GEcondnPath,VPath,PolicyPath,AgentDistPath,DistMatches]=MatchedExpectationsPath_InfHorz_shooting(AggShocksPath, AggShockNames, T, SSmask_T, SSprimemask_T,SSprimemask_T_indexes,ss_ind_T, n_d, n_a, n_z, n_S, l_d, l_a, l_z, d_grid, a_grid,z_gridvals_T,z_gridvals_T_fastOLG, pi_Sprime_T, pi_z_T_fastOLG, pi_z_T_sim, ReturnFn, FnsToEvaluate, FnsToEvaluateCell, AggVarNames, FnsToEvaluateParamNames, GEPriceParamNames, GEeqnNames, GeneralEqmEqns, GeneralEqmEqnsCell, GeneralEqmEqnParamNames, Parameters, DiscountFactorParamNames, ReturnFnParamNames, initialguessobjects, vfoptions, simoptions,recursiveeqmoptions); +end + +%% Need to reshape these for output, permute for fastOLG, and store in GeneralizedTransitionFn +GeneralizedTransitionFn.PricePath=PricePath; +GeneralizedTransitionFn.GEcondnPath=GEcondnPath; +GeneralizedTransitionFn.VPath=reshape(permute(reshape(VPath,[N_a,T,N_z]),[1,3,2]),[n_a,n_z,T]); +GeneralizedTransitionFn.PolicyPath=reshape(permute(reshape(PolicyPath,[size(PolicyPath,1),N_a,T,N_z]),[1,2,4,3]),[size(PolicyPath,1),n_a,n_z,T]); +GeneralizedTransitionFn.AgentDistPath=reshape(permute(reshape(AgentDistPath,[N_a,T,N_z]),[1,3,2]),[n_a,n_z,T]); + +%% Remove burnin from the outputs +for gg=1:length(GEeqnNames) + temp=GeneralizedTransitionFn.GEcondnPath.(GEeqnNames{gg}); + GeneralizedTransitionFn.GEcondnPath.(GEeqnNames{gg})=temp(recursiveeqmoptions.burnin+1:end)'; +end +for pp=1:length(GEPriceParamNames) + temp=GeneralizedTransitionFn.PricePath.(GEPriceParamNames{pp}); + GeneralizedTransitionFn.PricePath.(GEPriceParamNames{pp})=temp(recursiveeqmoptions.burnin+1:end)'; +end + +GeneralizedTransitionFn.VPath=GeneralizedTransitionFn.VPath(:,:,recursiveeqmoptions.burnin+1:end); +GeneralizedTransitionFn.PolicyPath=GeneralizedTransitionFn.PolicyPath(:,:,:,recursiveeqmoptions.burnin+1:end); +GeneralizedTransitionFn.AgentDistPath=GeneralizedTransitionFn.AgentDistPath(:,:,recursiveeqmoptions.burnin+1:end); + +%% Clean up the other outputs +% Use AggShockNames to describe the shock path +GeneralizedTransitionFn.OtherStuff.DistMatches=DistMatches; % reports the index and distance for the expectation matches +GeneralizedTransitionFn.AggShocksPath=AggShocksPath; +for aa=1:length(AggShockNames) + temp=GeneralizedTransitionFn.AggShocksPath.(AggShockNames{aa}); + GeneralizedTransitionFn.AggShocksPath.(AggShockNames{aa})=temp(recursiveeqmoptions.burnin+1:end)'; + temp=AggShocksIndexesPath.(AggShockNames{aa}); + GeneralizedTransitionFn.OtherStuff.AggShocksIndexesPath.(AggShockNames{aa})=temp(recursiveeqmoptions.burnin+1:end); % other commands find it useful to have the index rather than the value for the aggregate shocks +end + +end \ No newline at end of file diff --git a/TransitionPaths/Subcodes/updatePricePathNew_TPath_tt.m b/TransitionPaths/Subcodes/updatePricePathNew_TPath_tt.m index 5585f87d..2323cbc2 100644 --- a/TransitionPaths/Subcodes/updatePricePathNew_TPath_tt.m +++ b/TransitionPaths/Subcodes/updatePricePathNew_TPath_tt.m @@ -1,4 +1,5 @@ function [PricePathNew_tt,GEcondnPath_tt]=updatePricePathNew_TPath_tt(Parameters,GeneralEqmEqnsCell,GeneralEqmEqnParamNames,PricePathOld_tt,transpathoptions) +% Input size: PricePathOld_tt is 1-by-prices p_i=zeros(1,length(GeneralEqmEqnsCell)); for gg=1:length(GeneralEqmEqnsCell) @@ -19,4 +20,9 @@ PricePathNew_tt=PricePathOld_tt+transpathoptions.GEnewprice3.add.*transpathoptions.GEnewprice3.factor.*p_i-(1-transpathoptions.GEnewprice3.add).*transpathoptions.GEnewprice3.factor.*p_i; end +% We want output shapes to be +% PricePathNew_tt % output as a row vector of size 1-by-prices, because PricePath is T-by-prices +% GEcondnPath_tt % output as a row vector of size 1-by-GECondns, because PricePath is T-by-GECondns + + end \ No newline at end of file From 2b8f6ec3e8d2b22f43e88e7162203a7d602168d1 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Mon, 9 Mar 2026 13:41:08 +1300 Subject: [PATCH 55/67] minor fix --- .../StationaryDist_FHorz_ResidAsset.m | 13 +- ...lueFnIter_Case1_FHorz_ResidAsset_nod_raw.m | 123 +++--------------- ValueFnIter/FHorz/ValueFnIter_Case1_FHorz.m | 10 ++ 3 files changed, 39 insertions(+), 107 deletions(-) diff --git a/StationaryDist/FHorz/ResidAsset/StationaryDist_FHorz_ResidAsset.m b/StationaryDist/FHorz/ResidAsset/StationaryDist_FHorz_ResidAsset.m index 517eb546..05652539 100644 --- a/StationaryDist/FHorz/ResidAsset/StationaryDist_FHorz_ResidAsset.m +++ b/StationaryDist/FHorz/ResidAsset/StationaryDist_FHorz_ResidAsset.m @@ -32,6 +32,12 @@ rprimeFnParamNames={}; end +if isfield(simoptions,'n_e') + N_e=prod(simoptions.n_e); +else + N_e=0; +end + %% if n_z(1)==0 error('Not yet implemented n_z=0 with residualasset, (you can just pretend by using n_z=1 and pi_z=1, not using the value of z anywhere)') @@ -90,16 +96,15 @@ Policy_arprime(:,:,1,:)=Policy_aprime+N_a*(Policy_rprime-1); Policy_arprime(:,:,2,:)=Policy_aprime+N_a*(Policy_rprime+1-1); - %% if simoptions.gridinterplayer==0 % Note: N_z=0 && N_e=0 is a different code if N_e==0 % just z - StationaryDist=StationaryDist_FHorz_Iteration_nProbs_raw(jequaloneDist,AgeWeightParamNames,Policy_arprime,PolicyProbs,2,N_a,N_z,N_j,pi_z_J,Parameters); + StationaryDist=StationaryDist_FHorz_Iteration_nProbs_raw(jequaloneDist,AgeWeightParamNames,Policy_arprime,PolicyProbs,2,N_a*N_r,N_z,N_j,pi_z_J,Parameters); elseif N_z==0 % just e - StationaryDist=StationaryDist_FHorz_Iteration_nProbs_noz_e_raw(jequaloneDist,AgeWeightParamNames,Policy_arprime,PolicyProbs,2,N_a,N_e,N_j,simoptions.pi_e_J,Parameters); + StationaryDist=StationaryDist_FHorz_Iteration_nProbs_noz_e_raw(jequaloneDist,AgeWeightParamNames,Policy_arprime,PolicyProbs,2,N_a*N_r,N_e,N_j,simoptions.pi_e_J,Parameters); else % both z and e - StationaryDist=StationaryDist_FHorz_Iteration_nProbs_e_raw(jequaloneDist,AgeWeightParamNames,Policy_arprime,PolicyProbs,2,N_a,N_z,N_e,N_j,pi_z_J,simoptions.pi_e_J,Parameters); + StationaryDist=StationaryDist_FHorz_Iteration_nProbs_e_raw(jequaloneDist,AgeWeightParamNames,Policy_arprime,PolicyProbs,2,N_a*N_r,N_z,N_e,N_j,pi_z_J,simoptions.pi_e_J,Parameters); end elseif simoptions.gridinterplayer==1 error('grid interpolation layer not yet implemented for residual assets (contact me)') diff --git a/ValueFnIter/FHorz/ResidualAsset/ValueFnIter_Case1_FHorz_ResidAsset_nod_raw.m b/ValueFnIter/FHorz/ResidualAsset/ValueFnIter_Case1_FHorz_ResidAsset_nod_raw.m index 0d5a998b..ff414342 100644 --- a/ValueFnIter/FHorz/ResidualAsset/ValueFnIter_Case1_FHorz_ResidAsset_nod_raw.m +++ b/ValueFnIter/FHorz/ResidualAsset/ValueFnIter_Case1_FHorz_ResidAsset_nod_raw.m @@ -87,38 +87,17 @@ ReturnMatrix=CreateReturnFnMatrix_Case1_ResidAsset_Disc_Par2(ReturnFn, 0, n_a, n_r, n_z, 0, a_grid, r_grid, z_gridvals_J(:,:,N_j), ReturnFnParamsVec,0); - if vfoptions.paroverz==1 - - EV=V_Jplus1.*shiftdim(pi_z_J(:,:,N_j)',-2); % Note: shiftdim -3 - EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV=sum(EV,3); % sum over z', leaving a singular second dimension - - entireRHS=ReturnMatrix+DiscountFactorParamsVec*(reshape(EV,[N_a,N_a,1,N_z]); %.*ones(1,1,N_r,1)); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS,[],1); - - V(:,:,:,N_j)=shiftdim(Vtemp,1); - Policy(:,:,:,N_j)=shiftdim(maxindex,1); - - elseif vfoptions.paroverz==0 + EV=V_Jplus1.*shiftdim(pi_z_J(:,:,N_j)',-2); % Note: shiftdim -3 + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=sum(EV,3); % sum over z', leaving a singular second dimension - for z_c=1:N_z - ReturnMatrix_z=ReturnMatrix(:,:,:,z_c); + entireRHS=ReturnMatrix+DiscountFactorParamsVec*reshape(EV,[N_a,N_a,1,N_z]); - % Use sparse for a few lines until sum over zprime - EV_z=V_Jplus1.*shiftdim(pi_z_J(z_c,:,N_j)',-2); % Note: shiftdim -3 - EV_z(isnan(EV_z))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV_z=sum(EV_z,3); % sum over z', leaving a singular second dimension + %Calc the max and it's index + [Vtemp,maxindex]=max(entireRHS,[],1); - entireRHS_z=ReturnMatrix_z+DiscountFactorParamsVec*(reshape(EV_z,[N_a,N_a,1]); %.*ones(1,1,N_r)); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_z,[],1); - V(:,:,z_c,N_j)=Vtemp; - Policy(:,:,z_c,N_j)=maxindex; - end - end + V(:,:,:,N_j)=shiftdim(Vtemp,1); + Policy(:,:,:,N_j)=shiftdim(maxindex,1); elseif vfoptions.lowmemory==1 % loop over z @@ -132,33 +111,13 @@ EV_z(isnan(EV_z))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) EV_z=sum(EV_z,3); % sum over z', leaving a singular second dimension - entireRHS_z=ReturnMatrix_z+DiscountFactorParamsVec*(reshape(EV_z,[N_a,N_a,1])); %.*ones(1,1,N_r)); + entireRHS_z=ReturnMatrix_z+DiscountFactorParamsVec*reshape(EV_z,[N_a,N_a,1]); %Calc the max and it's index [Vtemp,maxindex]=max(entireRHS_z,[],1); V(:,:,z_c,N_j)=Vtemp; Policy(:,:,z_c,N_j)=maxindex; end - - elseif vfoptions.lowmemory==2 - % Loop over r - - EV=V_Jplus1.*shiftdim(pi_z_J(:,:,N_j)',-2); % Note: shiftdim -3 - EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV=sum(EV,3); % sum over z', leaving a singular second dimension - - for r_c=1:N_r - r_val=r_gridvals(r_c,:); - ReturnMatrix_r=CreateReturnFnMatrix_Case1_ResidAsset_Disc_Par2(ReturnFn, 0, n_a, special_n_r, n_z, 0, a_grid, r_val, z_gridvals_J(:,:,N_j), ReturnFnParamsVec,0); - - entireRHS_r=ReturnMatrix_r+DiscountFactorParamsVec*reshape(EV,[N_a,N_a,1,N_z]); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_r); - V(:,r_c,:,N_j)=Vtemp; - Policy(:,r_c,:,N_j)=maxindex; - end - end end @@ -202,40 +161,18 @@ if vfoptions.lowmemory==0 ReturnMatrix=CreateReturnFnMatrix_Case1_ResidAsset_Disc_Par2(ReturnFn, 0, n_a, n_r, n_z, 0, a_grid, r_grid, z_gridvals_J(:,:,jj), ReturnFnParamsVec,0); + + EV=VKronNext_j.*shiftdim(pi_z_J(:,:,jj)',-2); % Note: shiftdim -3 + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=sum(EV,3); % sum over z', leaving a singular second dimension + + entireRHS=ReturnMatrix+DiscountFactorParamsVec*reshape(EV,[N_a,N_a,1,N_z]); - if vfoptions.paroverz==1 + %Calc the max and it's index + [Vtemp,maxindex]=max(entireRHS,[],1); - EV=VKronNext_j.*shiftdim(pi_z_J(:,:,jj)',-2); % Note: shiftdim -3 - EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV=sum(EV,3); % sum over z', leaving a singular second dimension - - entireRHS=ReturnMatrix+DiscountFactorParamsVec*(reshape(EV,[N_a,N_a,1,N_z]); %.*ones(1,1,N_r,1)); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS,[],1); - - V(:,:,:,jj)=shiftdim(Vtemp,1); - Policy(:,:,:,jj)=shiftdim(maxindex,1); - - elseif vfoptions.paroverz==0 - - for z_c=1:N_z - ReturnMatrix_z=ReturnMatrix(:,:,:,z_c); - - - % Use sparse for a few lines until sum over zprime - EV_z=VKronNext_j.*shiftdim(pi_z_J(z_c,:,jj)',-2); % Note: shiftdim -3 - EV_z(isnan(EV_z))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV_z=sum(EV_z,3); % sum over z', leaving a singular second dimension - - entireRHS_z=ReturnMatrix_z+DiscountFactorParamsVec*(reshape(EV_z,[N_a,N_a,1]); %.*ones(1,1,N_r)); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_z,[],1); - V(:,:,z_c,jj)=Vtemp; - Policy(:,:,z_c,jj)=maxindex; - end - end + V(:,:,:,jj)=shiftdim(Vtemp,1); + Policy(:,:,:,jj)=shiftdim(maxindex,1); elseif vfoptions.lowmemory==1 % loop over z @@ -249,33 +186,13 @@ EV_z(isnan(EV_z))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) EV_z=sum(EV_z,3); % sum over z', leaving a singular second dimension - entireRHS_z=ReturnMatrix_z+DiscountFactorParamsVec*(reshape(EV_z,[N_a,N_a,1]); %.*ones(1,1,N_r)); + entireRHS_z=ReturnMatrix_z+DiscountFactorParamsVec*reshape(EV_z,[N_a,N_a,1]); %Calc the max and it's index [Vtemp,maxindex]=max(entireRHS_z,[],1); V(:,:,z_c,jj)=Vtemp; Policy(:,:,z_c,jj)=maxindex; end - - elseif vfoptions.lowmemory==2 - % Loop over r - - EV=VKronNext_j.*shiftdim(pi_z_J(:,:,jj)',-2); % Note: shiftdim -3 - EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV=sum(EV,3); % sum over z', leaving a singular second dimension - - for r_c=1:N_r - r_val=r_gridvals(r_c,:); - ReturnMatrix_r=CreateReturnFnMatrix_Case1_ResidAsset_Disc_Par2(ReturnFn, 0, n_a, special_n_r, n_z, 0, a_grid, r_val, z_gridvals_J(:,:,jj), ReturnFnParamsVec,0); - - entireRHS_r=ReturnMatrix_r+DiscountFactorParamsVec*reshape(EV,[N_a,N_a,1,N_z]); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_r); - V(:,r_c,:,jj)=Vtemp; - Policy(:,r_c,:,jj)=maxindex; - end - end end diff --git a/ValueFnIter/FHorz/ValueFnIter_Case1_FHorz.m b/ValueFnIter/FHorz/ValueFnIter_Case1_FHorz.m index 354e227d..0606af78 100644 --- a/ValueFnIter/FHorz/ValueFnIter_Case1_FHorz.m +++ b/ValueFnIter/FHorz/ValueFnIter_Case1_FHorz.m @@ -309,6 +309,16 @@ % It is simply assumed that the experience asset is the last asset, and that the decision that influences it is the last decision. % When using both semiexo and experience asset, the last decision variable influences semi-exo and the second last decision variable influences the experience asset + if vfoptions.experienceasset==1 + if ~isfield(vfoptions,'l_dexperienceasset') + vfoptions.l_dexperienceasset=1; % by default, only one decision variable influences the experienceasset + end + elseif vfoptions.experienceassetu==1 + if ~isfield(vfoptions,'l_dexperienceassetu') + vfoptions.l_dexperienceassetu=1; % by default, only one decision variable influences the experienceassetu + end + end + if isfield(vfoptions,'n_semiz') % Split decision variables (other, semiexo, experienceasset) if length(n_d)>2 From 85b26a00a23b7ca753a3c0244776ffb77e481fb9 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Mon, 9 Mar 2026 13:56:57 +1300 Subject: [PATCH 56/67] various minor --- .../ValueFnIter_Case1_FHorz_Ambiguity_e_raw.m | 3 +- ...ueFnIter_Case1_FHorz_Ambiguity_nod_e_raw.m | 3 +- ...alueFnIter_Case1_FHorz_Ambiguity_nod_raw.m | 200 +++------------- ...ueFnIter_Case1_FHorz_Ambiguity_noz_e_raw.m | 2 +- .../ValueFnIter_Case1_FHorz_Ambiguity_raw.m | 217 +++--------------- .../ValueFnIter_Case1_FHorz_ResidAsset_raw.m | 137 ++--------- 6 files changed, 91 insertions(+), 471 deletions(-) diff --git a/ValueFnIter/FHorz/ExoticPrefs/AmbiguityAversion/ValueFnIter_Case1_FHorz_Ambiguity_e_raw.m b/ValueFnIter/FHorz/ExoticPrefs/AmbiguityAversion/ValueFnIter_Case1_FHorz_Ambiguity_e_raw.m index 7f076013..d21cd70c 100644 --- a/ValueFnIter/FHorz/ExoticPrefs/AmbiguityAversion/ValueFnIter_Case1_FHorz_Ambiguity_e_raw.m +++ b/ValueFnIter/FHorz/ExoticPrefs/AmbiguityAversion/ValueFnIter_Case1_FHorz_Ambiguity_e_raw.m @@ -17,8 +17,7 @@ % e_gridvals is created below end if vfoptions.lowmemory>1 - l_z=length(n_z); - special_n_z=ones(1,l_z); + special_n_z=ones(1,length(n_z)); % z_gridvals is created below end diff --git a/ValueFnIter/FHorz/ExoticPrefs/AmbiguityAversion/ValueFnIter_Case1_FHorz_Ambiguity_nod_e_raw.m b/ValueFnIter/FHorz/ExoticPrefs/AmbiguityAversion/ValueFnIter_Case1_FHorz_Ambiguity_nod_e_raw.m index e03a5382..13810d83 100644 --- a/ValueFnIter/FHorz/ExoticPrefs/AmbiguityAversion/ValueFnIter_Case1_FHorz_Ambiguity_nod_e_raw.m +++ b/ValueFnIter/FHorz/ExoticPrefs/AmbiguityAversion/ValueFnIter_Case1_FHorz_Ambiguity_nod_e_raw.m @@ -14,8 +14,7 @@ special_n_e=ones(1,length(n_e)); end if vfoptions.lowmemory>1 - l_z=length(n_z); - special_n_z=ones(1,l_z); + special_n_z=ones(1,length(n_z)); end ambiguity_pi_e_J=shiftdim(ambiguity_pi_e_J,-2); % Move to third dimension for e_c=1:n_e diff --git a/ValueFnIter/FHorz/ExoticPrefs/AmbiguityAversion/ValueFnIter_Case1_FHorz_Ambiguity_nod_raw.m b/ValueFnIter/FHorz/ExoticPrefs/AmbiguityAversion/ValueFnIter_Case1_FHorz_Ambiguity_nod_raw.m index 69339227..8bc4984a 100644 --- a/ValueFnIter/FHorz/ExoticPrefs/AmbiguityAversion/ValueFnIter_Case1_FHorz_Ambiguity_nod_raw.m +++ b/ValueFnIter/FHorz/ExoticPrefs/AmbiguityAversion/ValueFnIter_Case1_FHorz_Ambiguity_nod_raw.m @@ -9,15 +9,9 @@ %% a_grid=gpuArray(a_grid); -if vfoptions.lowmemory>0 - l_z=length(n_z); - special_n_z=ones(1,l_z); +if vfoptions.lowmemory==1 + special_n_z=ones(1,length(n_z)); end -if vfoptions.lowmemory>1 - special_n_a=ones(1,length(n_a)); - a_gridvals=CreateGridvals(n_a,a_grid,1); % The 1 at end indicates want output in form of matrix. -end - %% j=N_j % Create a vector containing all the return function parameters (in order) @@ -42,22 +36,6 @@ V(:,z_c,N_j)=Vtemp; Policy(:,z_c,N_j)=maxindex; end - - elseif vfoptions.lowmemory==2 - - for z_c=1:N_z - z_val=z_gridvals_J(z_c,:,N_j); - for a_c=1:N_a - a_val=a_gridvals(a_c,:); - ReturnMatrix_az=CreateReturnFnMatrix_Case1_Disc_Par2(ReturnFn, 0, special_n_a, special_n_z, 0, a_val, z_val, ReturnFnParamsVec,0); - % Calc the max and it's index - [Vtemp,maxindex]=max(ReturnMatrix_az); - V(a_c,z_c,N_j)=Vtemp; - Policy(a_c,z_c,N_j)=maxindex; - - end - end - end else % Using V_Jplus1 @@ -71,52 +49,24 @@ ReturnMatrix=CreateReturnFnMatrix_Case1_Disc_Par2(ReturnFn, 0, n_a, n_z, 0, a_grid, z_gridvals_J(:,:,N_j), ReturnFnParamsVec,0); % (aprime,a,z) - if vfoptions.paroverz==1 - - ambEV=zeros(N_a,1,N_z,n_ambiguity(N_j)); % aprime, nothing, z, prior - for amb_c=1:n_ambiguity(N_j) % Evaluate expections under each of the multiple priors - EV=V_Jplus1.*shiftdim(ambiguity_pi_z_J(:,:,N_j,amb_c)',-1); - EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV=sum(EV,2); % sum over z', leaving a singular second dimension - ambEV(:,:,:,amb_c)=EV; - end - % Take the worst-case over the priors - EV=min(ambEV,[],4); - % From here, can just use EV as normal - - entireRHS=ReturnMatrix+DiscountFactorParamsVec*EV; %.*ones(1,N_a,1); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS,[],1); - - V(:,:,N_j)=shiftdim(Vtemp,1); - Policy(:,:,N_j)=shiftdim(maxindex,1); - - elseif vfoptions.paroverz==0 + ambEV=zeros(N_a,1,N_z,n_ambiguity(N_j)); % aprime, nothing, z, prior + for amb_c=1:n_ambiguity(N_j) % Evaluate expections under each of the multiple priors + EV=V_Jplus1.*shiftdim(ambiguity_pi_z_J(:,:,N_j,amb_c)',-1); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=sum(EV,2); % sum over z', leaving a singular second dimension + ambEV(:,:,:,amb_c)=EV; + end + % Take the worst-case over the priors + EV=min(ambEV,[],4); + % From here, can just use EV as normal - for z_c=1:N_z - ReturnMatrix_z=ReturnMatrix(:,:,z_c); + entireRHS=ReturnMatrix+DiscountFactorParamsVec*EV; %.*ones(1,N_a,1); - ambEV_z=zeros(N_a,n_ambiguity(N_j)); % aprime, prior - for amb_c=1:n_ambiguity(N_j) % Evaluate expections under each of the multiple priors - %Calc the condl expectation term (except beta), which depends on z but not on control variables - EV_z=V_Jplus1.*(ones(N_a,1,'gpuArray')*ambiguity_pi_z_J(z_c,:,N_j,amb_c)); - EV_z(isnan(EV_z))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV_z=sum(EV_z,2); - ambEV_z(:,amb_c)=EV_z; - end - % Take the worst-case over the priors - EV_z=min(ambEV_z,[],2); - % From here, can just use EV_z as normal - - entireRHS_z=ReturnMatrix_z+DiscountFactorParamsVec*EV_z; %*ones(1,N_a,1); + %Calc the max and it's index + [Vtemp,maxindex]=max(entireRHS,[],1); - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_z,[],1); - V(:,z_c,N_j)=Vtemp; - Policy(:,z_c,N_j)=maxindex; - end - end + V(:,:,N_j)=shiftdim(Vtemp,1); + Policy(:,:,N_j)=shiftdim(maxindex,1); elseif vfoptions.lowmemory==1 for z_c=1:N_z @@ -142,34 +92,6 @@ V(:,z_c,N_j)=Vtemp; Policy(:,z_c,N_j)=maxindex; end - - elseif vfoptions.lowmemory==2 - for z_c=1:N_z - ambEV_z=zeros(N_a,n_ambiguity(N_j)); % aprime, prior - for amb_c=1:n_ambiguity(N_j) % Evaluate expections under each of the multiple priors - %Calc the condl expectation term (except beta), which depends on z but not on control variables - EV_z=V_Jplus1.*(ones(N_a,1,'gpuArray')*ambiguity_pi_z_J(z_c,:,N_j,amb_c)); - EV_z(isnan(EV_z))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV_z=sum(EV_z,2); - ambEV_z(:,amb_c)=EV_z; - end - % Take the worst-case over the priors - EV_z=min(ambEV_z,[],2); - % From here, can just use EV_z as normal - - z_val=z_gridvals_J(z_c,:,N_j); - for a_c=1:N_a - a_val=a_gridvals(a_c,:); - ReturnMatrix_az=CreateReturnFnMatrix_Case1_Disc_Par2(ReturnFn, 0, special_n_a, special_n_z, 0, a_val, z_val, ReturnFnParamsVec,0); - - entireRHS_az=ReturnMatrix_az+DiscountFactorParamsVec*EV_z; - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_az); - V(a_c,z_c,N_j)=Vtemp; - Policy(a_c,z_c,N_j)=maxindex; - end - end - end end @@ -195,52 +117,24 @@ ReturnMatrix=CreateReturnFnMatrix_Case1_Disc_Par2(ReturnFn, 0, n_a, n_z, 0, a_grid, z_gridvals_J(:,:,jj), ReturnFnParamsVec,0); % (aprime,a,z) - if vfoptions.paroverz==1 - - ambEV=zeros(N_a,1,N_z,n_ambiguity(jj)); % aprime, nothing, z, prior - for amb_c=1:n_ambiguity(jj) % Evaluate expections under each of the multiple priors - EV=VKronNext_j.*shiftdim(ambiguity_pi_z_J(:,:,jj,amb_c)',-1); - EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV=sum(EV,2); % sum over z', leaving a singular second dimension + ambEV=zeros(N_a,1,N_z,n_ambiguity(jj)); % aprime, nothing, z, prior + for amb_c=1:n_ambiguity(jj) % Evaluate expections under each of the multiple priors + EV=VKronNext_j.*shiftdim(ambiguity_pi_z_J(:,:,jj,amb_c)',-1); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=sum(EV,2); % sum over z', leaving a singular second dimension ambEV(:,:,:,amb_c)=EV; - end - % Take the worst-case over the priors - EV=min(ambEV,[],4); - % From here, can just use EV as normal - - entireRHS=ReturnMatrix+DiscountFactorParamsVec*EV; %.*ones(1,N_a,1); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS,[],1); - - V(:,:,jj)=shiftdim(Vtemp,1); - Policy(:,:,jj)=shiftdim(maxindex,1); - - elseif vfoptions.paroverz==0 - - for z_c=1:N_z - ReturnMatrix_z=ReturnMatrix(:,:,z_c); - - ambEV_z=zeros(N_a,n_ambiguity(jj)); % aprime, prior - for amb_c=1:n_ambiguity(jj) % Evaluate expections under each of the multiple priors - %Calc the condl expectation term (except beta), which depends on z but not on control variables - EV_z=VKronNext_j.*(ones(N_a,1,'gpuArray')*ambiguity_pi_z_J(z_c,:,jj,amb_c)); - EV_z(isnan(EV_z))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV_z=sum(EV_z,2); - ambEV_z(:,amb_c)=EV_z; - end - % Take the worst-case over the priors - EV_z=min(ambEV_z,[],2); - % From here, can just use EV_z as normal - - entireRHS_z=ReturnMatrix_z+DiscountFactorParamsVec*EV_z; %*ones(1,N_a,1); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_z,[],1); - V(:,z_c,jj)=Vtemp; - Policy(:,z_c,jj)=maxindex; - end end + % Take the worst-case over the priors + EV=min(ambEV,[],4); + % From here, can just use EV as normal + + entireRHS=ReturnMatrix+DiscountFactorParamsVec*EV; %.*ones(1,N_a,1); + + %Calc the max and it's index + [Vtemp,maxindex]=max(entireRHS,[],1); + + V(:,:,jj)=shiftdim(Vtemp,1); + Policy(:,:,jj)=shiftdim(maxindex,1); elseif vfoptions.lowmemory==1 for z_c=1:N_z @@ -266,34 +160,6 @@ V(:,z_c,jj)=Vtemp; Policy(:,z_c,jj)=maxindex; end - - elseif vfoptions.lowmemory==2 - for z_c=1:N_z - ambEV_z=zeros(N_a,n_ambiguity(jj)); % aprime, prior - for amb_c=1:n_ambiguity(jj) % Evaluate expections under each of the multiple priors - %Calc the condl expectation term (except beta), which depends on z but not on control variables - EV_z=VKronNext_j.*(ones(N_a,1,'gpuArray')*ambiguity_pi_z_J(z_c,:,jj,amb_c)); - EV_z(isnan(EV_z))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV_z=sum(EV_z,2); - ambEV_z(:,amb_c)=EV_z; - end - % Take the worst-case over the priors - EV_z=min(ambEV_z,[],2); - % From here, can just use EV_z as normal - - z_val=z_gridvals_J(z_c,:,jj); - for a_c=1:N_a - a_val=a_gridvals(a_c,:); - ReturnMatrix_az=CreateReturnFnMatrix_Case1_Disc_Par2(ReturnFn, 0, special_n_a, special_n_z, 0, a_val, z_val, ReturnFnParamsVec,0); - - entireRHS_az=ReturnMatrix_az+DiscountFactorParamsVec*EV_z; - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_az); - V(a_c,z_c,jj)=Vtemp; - Policy(a_c,z_c,jj)=maxindex; - end - end - end end diff --git a/ValueFnIter/FHorz/ExoticPrefs/AmbiguityAversion/ValueFnIter_Case1_FHorz_Ambiguity_noz_e_raw.m b/ValueFnIter/FHorz/ExoticPrefs/AmbiguityAversion/ValueFnIter_Case1_FHorz_Ambiguity_noz_e_raw.m index a835c6a4..d18aff0e 100644 --- a/ValueFnIter/FHorz/ExoticPrefs/AmbiguityAversion/ValueFnIter_Case1_FHorz_Ambiguity_noz_e_raw.m +++ b/ValueFnIter/FHorz/ExoticPrefs/AmbiguityAversion/ValueFnIter_Case1_FHorz_Ambiguity_noz_e_raw.m @@ -11,7 +11,7 @@ d_grid=gpuArray(d_grid); a_grid=gpuArray(a_grid); -if vfoptions.lowmemory>0 +if vfoptions.lowmemory==1 special_n_e=ones(1,length(n_e)); end diff --git a/ValueFnIter/FHorz/ExoticPrefs/AmbiguityAversion/ValueFnIter_Case1_FHorz_Ambiguity_raw.m b/ValueFnIter/FHorz/ExoticPrefs/AmbiguityAversion/ValueFnIter_Case1_FHorz_Ambiguity_raw.m index 6cfeb7bf..c64c74eb 100644 --- a/ValueFnIter/FHorz/ExoticPrefs/AmbiguityAversion/ValueFnIter_Case1_FHorz_Ambiguity_raw.m +++ b/ValueFnIter/FHorz/ExoticPrefs/AmbiguityAversion/ValueFnIter_Case1_FHorz_Ambiguity_raw.m @@ -11,13 +11,8 @@ d_grid=gpuArray(d_grid); a_grid=gpuArray(a_grid); -if vfoptions.lowmemory>0 - l_z=length(n_z); - special_n_z=ones(1,l_z); -end -if vfoptions.lowmemory>1 - special_n_a=ones(1,length(n_a)); - a_gridvals=CreateGridvals(n_a,a_grid,1); % The 1 at end indicates want output in form of matrix. +if vfoptions.lowmemory==1 + special_n_z=ones(1,length(n_z)); end @@ -45,22 +40,6 @@ V(:,z_c,N_j)=Vtemp; Policy(:,z_c,N_j)=maxindex; end - - elseif vfoptions.lowmemory==2 - - for z_c=1:N_z - z_val=z_gridvals_J(z_c,:,N_j); - for a_c=1:N_a - a_val=a_gridvals(a_c,:); - ReturnMatrix_az=CreateReturnFnMatrix_Case1_Disc_Par2(ReturnFn, n_d, special_n_a, special_n_z, d_grid, a_val, z_val, ReturnFnParamsVec); - %Calc the max and it's index - [Vtemp,maxindex]=max(ReturnMatrix_az); - V(a_c,z_c,N_j)=Vtemp; - Policy(a_c,z_c,N_j)=maxindex; - - end - end - end else % Using V_Jplus1 @@ -74,56 +53,26 @@ ReturnMatrix=CreateReturnFnMatrix_Case1_Disc_Par2(ReturnFn, n_d, n_a, n_z, d_grid, a_grid, z_gridvals_J(:,:,N_j), ReturnFnParamsVec); % (d,aprime,a,z) - if vfoptions.paroverz==1 - - ambEV=zeros(N_a,1,N_z,n_ambiguity(N_j)); % aprime, nothing, z, prior - for amb_c=1:n_ambiguity(N_j) % Evaluate expections under each of the multiple priors - EV=V_Jplus1.*shiftdim(ambiguity_pi_z_J(:,:,N_j,amb_c)',-1); - EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV=sum(EV,2); % sum over z', leaving a singular second dimension - ambEV(:,:,:,amb_c)=EV; - end - % Take the worst-case over the priors - EV=min(ambEV,[],4); - % From here, can just use EV as normal + ambEV=zeros(N_a,1,N_z,n_ambiguity(N_j)); % aprime, nothing, z, prior + for amb_c=1:n_ambiguity(N_j) % Evaluate expections under each of the multiple priors + EV=V_Jplus1.*shiftdim(ambiguity_pi_z_J(:,:,N_j,amb_c)',-1); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=sum(EV,2); % sum over z', leaving a singular second dimension + ambEV(:,:,:,amb_c)=EV; + end + % Take the worst-case over the priors + EV=min(ambEV,[],4); + % From here, can just use EV as normal - entireEV=kron(EV,ones(N_d,1)); -% entireEV=repelem(EV,N_d,1,1); % I tried this instead but appears repelem() is slower than kron() - entireRHS=ReturnMatrix+DiscountFactorParamsVec*entireEV; %repmat(entireEV,1,N_a,1); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS,[],1); - - V(:,:,N_j)=shiftdim(Vtemp,1); - Policy(:,:,N_j)=shiftdim(maxindex,1); - - - elseif vfoptions.paroverz==0 - - for z_c=1:N_z - ReturnMatrix_z=ReturnMatrix(:,:,z_c); - - ambEV_z=zeros(N_a,n_ambiguity(N_j)); % aprime, prior - for amb_c=1:n_ambiguity(N_j) % Evaluate expections under each of the multiple priors - %Calc the condl expectation term (except beta), which depends on z but not on control variables - EV_z=V_Jplus1.*(ones(N_a,1,'gpuArray')*ambiguity_pi_z_J(z_c,:,N_j,amb_c)); - EV_z(isnan(EV_z))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV_z=sum(EV_z,2); - ambEV_z(:,amb_c)=EV_z; - end - % Take the worst-case over the priors - EV_z=min(ambEV_z,[],2); - % From here, can just use EV_z as normal + entireEV=kron(EV,ones(N_d,1)); + % entireEV=repelem(EV,N_d,1,1); % I tried this instead but appears repelem() is slower than kron() + entireRHS=ReturnMatrix+DiscountFactorParamsVec*entireEV; %repmat(entireEV,1,N_a,1); - entireEV_z=kron(EV_z,ones(N_d,1)); - entireRHS_z=ReturnMatrix_z+DiscountFactorParamsVec*entireEV_z; %*ones(1,N_a,1); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_z,[],1); - V(:,z_c,N_j)=Vtemp; - Policy(:,z_c,N_j)=maxindex; - end - end + %Calc the max and it's index + [Vtemp,maxindex]=max(entireRHS,[],1); + + V(:,:,N_j)=shiftdim(Vtemp,1); + Policy(:,:,N_j)=shiftdim(maxindex,1); elseif vfoptions.lowmemory==1 for z_c=1:N_z @@ -150,36 +99,6 @@ V(:,z_c,N_j)=Vtemp; Policy(:,z_c,N_j)=maxindex; end - - elseif vfoptions.lowmemory==2 - for z_c=1:N_z - ambEV_z=zeros(N_a,n_ambiguity(N_j)); % aprime, prior - for amb_c=1:n_ambiguity(N_j) % Evaluate expections under each of the multiple priors - %Calc the condl expectation term (except beta), which depends on z but not on control variables - EV_z=V_Jplus1.*(ones(N_a,1,'gpuArray')*ambiguity_pi_z_J(z_c,:,N_j,amb_c)); - EV_z(isnan(EV_z))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV_z=sum(EV_z,2); - ambEV_z(:,amb_c)=EV_z; - end - % Take the worst-case over the priors - EV_z=min(ambEV_z,[],2); - % From here, can just use EV_z as normal - - entireEV_z=kron(EV_z,ones(N_d,1)); - - z_val=z_gridvals_J(z_c,:,N_j); - for a_c=1:N_a - a_val=a_gridvals(a_c,:); - ReturnMatrix_az=CreateReturnFnMatrix_Case1_Disc_Par2(ReturnFn, n_d, special_n_a, special_n_z, d_grid, a_val, z_val, ReturnFnParamsVec); - - entireRHS_az=ReturnMatrix_az+DiscountFactorParamsVec*entireEV_z; - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_az); - V(a_c,z_c,N_j)=Vtemp; - Policy(a_c,z_c,N_j)=maxindex; - end - end - end end @@ -204,55 +123,25 @@ ReturnMatrix=CreateReturnFnMatrix_Case1_Disc_Par2(ReturnFn, n_d, n_a, n_z, d_grid, a_grid, z_gridvals_J(:,:,jj), ReturnFnParamsVec); % (d,aprime,a,z) - if vfoptions.paroverz==1 - - ambEV=zeros(N_a,1,N_z,n_ambiguity(jj)); % aprime, nothing, z, prior - for amb_c=1:n_ambiguity(jj) % Evaluate expections under each of the multiple priors - EV=VKronNext_j.*shiftdim(ambiguity_pi_z_J(:,:,jj,amb_c)',-1); - EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV=sum(EV,2); % sum over z', leaving a singular second dimension + ambEV=zeros(N_a,1,N_z,n_ambiguity(jj)); % aprime, nothing, z, prior + for amb_c=1:n_ambiguity(jj) % Evaluate expections under each of the multiple priors + EV=VKronNext_j.*shiftdim(ambiguity_pi_z_J(:,:,jj,amb_c)',-1); + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=sum(EV,2); % sum over z', leaving a singular second dimension ambEV(:,:,:,amb_c)=EV; - end - % Take the worst-case over the priors - EV=min(ambEV,[],4); - % From here, can just use EV as normal + end + % Take the worst-case over the priors + EV=min(ambEV,[],4); + % From here, can just use EV as normal - entireEV=repelem(EV,N_d,1,1); % I tried this instead but appears repelem() is slower than kron() - entireRHS=ReturnMatrix+DiscountFactorParamsVec*entireEV; - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS,[],1); - - V(:,:,jj)=shiftdim(Vtemp,1); - Policy(:,:,jj)=shiftdim(maxindex,1); - - - elseif vfoptions.paroverz==0 - - for z_c=1:N_z - ReturnMatrix_z=ReturnMatrix(:,:,z_c); - - ambEV_z=zeros(N_a,n_ambiguity(jj)); % aprime, prior - for amb_c=1:n_ambiguity(jj) % Evaluate expections under each of the multiple priors - %Calc the condl expectation term (except beta), which depends on z but not on control variables - EV_z=VKronNext_j.*(ones(N_a,1,'gpuArray')*ambiguity_pi_z_J(z_c,:,jj,amb_c)); - EV_z(isnan(EV_z))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV_z=sum(EV_z,2); - ambEV_z(:,amb_c)=EV_z; - end - % Take the worst-case over the priors - EV_z=min(ambEV_z,[],2); - % From here, can just use EV_z as normal + entireEV=repelem(EV,N_d,1,1); % I tried this instead but appears repelem() is slower than kron() + entireRHS=ReturnMatrix+DiscountFactorParamsVec*entireEV; - entireEV_z=kron(EV_z,ones(N_d,1)); - entireRHS_z=ReturnMatrix_z+DiscountFactorParamsVec*entireEV_z; %*ones(1,N_a,1); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_z,[],1); - V(:,z_c,jj)=Vtemp; - Policy(:,z_c,jj)=maxindex; - end - end + %Calc the max and it's index + [Vtemp,maxindex]=max(entireRHS,[],1); + + V(:,:,jj)=shiftdim(Vtemp,1); + Policy(:,:,jj)=shiftdim(maxindex,1); elseif vfoptions.lowmemory==1 @@ -279,39 +168,7 @@ [Vtemp,maxindex]=max(entireRHS_z,[],1); V(:,z_c,jj)=Vtemp; Policy(:,z_c,jj)=maxindex; - end - - elseif vfoptions.lowmemory==2 - - for z_c=1:N_z - - ambEV_z=zeros(N_a,n_ambiguity(jj)); % aprime, prior - for amb_c=1:n_ambiguity(jj) % Evaluate expections under each of the multiple priors - %Calc the condl expectation term (except beta), which depends on z but not on control variables - EV_z=VKronNext_j.*(ones(N_a,1,'gpuArray')*ambiguity_pi_z_J(z_c,:,jj,amb_c)); - EV_z(isnan(EV_z))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV_z=sum(EV_z,2); - ambEV_z(:,amb_c)=EV_z; - end - % Take the worst-case over the priors - EV_z=min(ambEV_z,[],2); - % From here, can just use EV_z as normal - - entireEV_z=kron(EV_z,ones(N_d,1)); - - z_val=z_gridvals_J(z_c,:,jj); - for a_c=1:N_a - a_val=a_gridvals(a_c,:); - ReturnMatrix_az=CreateReturnFnMatrix_Case1_Disc_Par2(ReturnFn, n_d, special_n_a, special_n_z, d_grid, a_val, z_val, ReturnFnParamsVec); - - entireRHS_az=ReturnMatrix_az+DiscountFactorParamsVec*entireEV_z; - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_az); - V(a_c,z_c,jj)=Vtemp; - Policy(a_c,z_c,jj)=maxindex; - end - end - + end end end diff --git a/ValueFnIter/FHorz/ResidualAsset/ValueFnIter_Case1_FHorz_ResidAsset_raw.m b/ValueFnIter/FHorz/ResidualAsset/ValueFnIter_Case1_FHorz_ResidAsset_raw.m index 93ac2294..44cba111 100644 --- a/ValueFnIter/FHorz/ResidualAsset/ValueFnIter_Case1_FHorz_ResidAsset_raw.m +++ b/ValueFnIter/FHorz/ResidualAsset/ValueFnIter_Case1_FHorz_ResidAsset_raw.m @@ -13,15 +13,9 @@ a_grid=gpuArray(a_grid); r_grid=gpuArray(r_grid); -if vfoptions.lowmemory>0 - l_z=length(n_z); +if vfoptions.lowmemory==1 special_n_z=ones(1,length(n_z)); end -if vfoptions.lowmemory>1 - special_n_r=ones(1,length(n_r)); - r_gridvals=CreateGridvals(n_r,r_grid,1); % The 1 at end indicates want output in form of matrix. -end - %% j=N_j @@ -47,18 +41,6 @@ V(:,:,z_c,N_j)=Vtemp; Policy(:,:,z_c,N_j)=maxindex; end - - elseif vfoptions.lowmemory==2 - - for r_c=1:N_r - r_val=r_gridvals(r_c,:); - ReturnMatrix_rz=CreateReturnFnMatrix_ResidAsset_Case1_Disc_Par2(ReturnFn, n_d, n_a, special_n_r, n_z, d_grid, a_grid, r_val, z_gridvals_J(:,:,N_j), ReturnFnParamsVec); - %Calc the max and it's index - [Vtemp,maxindex]=max(ReturnMatrix_rz); - V(:,r_c,:,N_j)=Vtemp; - Policy(:,r_c,:,N_j)=maxindex; - end - end else % Using V_Jplus1 @@ -92,39 +74,17 @@ ReturnMatrix=CreateReturnFnMatrix_Case1_ResidAsset_Disc_Par2(ReturnFn, n_d, n_a, n_r, n_z, d_grid, a_grid, r_grid, z_gridvals_J(:,:,N_j), ReturnFnParamsVec); % (d,aprime,a,z) - if vfoptions.paroverz==1 - - EV=V_Jplus1.*shiftdim(pi_z_J(:,:,N_j)',-2); % Note: shiftdim -3 - EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV=sum(EV,3); % sum over z', leaving a singular second dimension - - entireRHS=ReturnMatrix+DiscountFactorParamsVec*(reshape(EV,[N_d*N_a,N_a,1,N_z])); + EV=V_Jplus1.*shiftdim(pi_z_J(:,:,N_j)',-2); % Note: shiftdim -3 + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=sum(EV,3); % sum over z', leaving a singular second dimension - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS,[],1); - - V(:,:,:,N_j)=shiftdim(Vtemp,1); - Policy(:,:,:,N_j)=shiftdim(maxindex,1); - - - elseif vfoptions.paroverz==0 - - for z_c=1:N_z - ReturnMatrix_z=ReturnMatrix(:,:,:,z_c); - - % Use sparse for a few lines until sum over zprime - EV_z=V_Jplus1.*shiftdim(pi_z_J(z_c,:,N_j)',-2); % Note: shiftdim -3 - EV_z(isnan(EV_z))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV_z=sum(EV_z,3); % sum over z', leaving a singular second dimension - - entireRHS_z=ReturnMatrix_z+DiscountFactorParamsVec*(reshape(EV_z,[N_d*N_a,N_a,1])); + entireRHS=ReturnMatrix+DiscountFactorParamsVec*(reshape(EV,[N_d*N_a,N_a,1,N_z])); - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_z,[],1); - V(:,:,z_c,N_j)=Vtemp; - Policy(:,:,z_c,N_j)=maxindex; - end - end + %Calc the max and it's index + [Vtemp,maxindex]=max(entireRHS,[],1); + + V(:,:,:,N_j)=shiftdim(Vtemp,1); + Policy(:,:,:,N_j)=shiftdim(maxindex,1); elseif vfoptions.lowmemory==1 for z_c=1:N_z @@ -142,26 +102,6 @@ V(:,:,z_c,N_j)=Vtemp; Policy(:,:,z_c,N_j)=maxindex; end - - elseif vfoptions.lowmemory==2 - % Loop over r - - EV=V_Jplus1.*shiftdim(pi_z_J(:,:,N_j)',-2); % Note: shiftdim -3 - EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV=sum(EV,3); % sum over z', leaving a singular second dimension - - for r_c=1:N_r - r_val=r_gridvals(r_c,:); - ReturnMatrix_r=CreateReturnFnMatrix_Case1_ResidAsset_Disc_Par2(ReturnFn, n_d, n_a, special_n_r, n_z, d_grid, a_grid, r_val, z_gridvals_J(:,:,N_j), ReturnFnParamsVec,0); - - entireRHS_r=ReturnMatrix_r+DiscountFactorParamsVec*reshape(EV,[N_d*N_a,N_a,1,N_z]); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_r); - V(:,r_c,:,N_j)=Vtemp; - Policy(:,r_c,:,N_j)=maxindex; - end - end end @@ -204,39 +144,18 @@ ReturnMatrix=CreateReturnFnMatrix_Case1_ResidAsset_Disc_Par2(ReturnFn, n_d, n_a, n_r, n_z, d_grid, a_grid, r_grid, z_gridvals_J(:,:,jj), ReturnFnParamsVec,0); % (d,aprime,a,r,z) - - if vfoptions.paroverz==1 - - EV=VKronNext_j.*shiftdim(pi_z_J(:,:,jj)',-2); % Note: shiftdim -3 - EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV=sum(EV,3); % sum over z', leaving a singular second dimension - entireRHS=ReturnMatrix+DiscountFactorParamsVec*(reshape(EV,[N_d*N_a,N_a,1,N_z])); + EV=VKronNext_j.*shiftdim(pi_z_J(:,:,jj)',-2); % Note: shiftdim -3 + EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) + EV=sum(EV,3); % sum over z', leaving a singular second dimension - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS,[],1); - - V(:,:,:,jj)=shiftdim(Vtemp,1); - Policy(:,:,:,jj)=shiftdim(maxindex,1); - - elseif vfoptions.paroverz==0 - - for z_c=1:N_z - ReturnMatrix_z=ReturnMatrix(:,:,:,z_c); - - % Use sparse for a few lines until sum over zprime - EV_z=VKronNext_j.*shiftdim(pi_z_J(z_c,:,jj)',-2); % Note: shiftdim -3 - EV_z(isnan(EV_z))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV_z=sum(EV_z,3); % sum over z', leaving a singular second dimension + entireRHS=ReturnMatrix+DiscountFactorParamsVec*(reshape(EV,[N_d*N_a,N_a,1,N_z])); - entireRHS_z=ReturnMatrix_z+DiscountFactorParamsVec*(reshape(EV_z,[N_d*N_a,N_a,1])); + %Calc the max and it's index + [Vtemp,maxindex]=max(entireRHS,[],1); - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_z,[],1); - V(:,:,z_c,jj)=Vtemp; - Policy(:,:,z_c,jj)=maxindex; - end - end + V(:,:,:,jj)=shiftdim(Vtemp,1); + Policy(:,:,:,jj)=shiftdim(maxindex,1); elseif vfoptions.lowmemory==1 for z_c=1:N_z @@ -254,26 +173,6 @@ V(:,:,z_c,jj)=Vtemp; Policy(:,:,z_c,jj)=maxindex; end - - elseif vfoptions.lowmemory==2 - % Loop over r - - EV=VKronNext_j.*shiftdim(pi_z_J(:,:,jj)',-2); % Note: shiftdim -3 - EV(isnan(EV))=0; %multilications of -Inf with 0 gives NaN, this replaces them with zeros (as the zeros come from the transition probabilites) - EV=sum(EV,3); % sum over z', leaving a singular second dimension - - for r_c=1:N_r - r_val=r_gridvals(r_c,:); - ReturnMatrix_r=CreateReturnFnMatrix_Case1_ResidAsset_Disc_Par2(ReturnFn, n_d, n_a, special_n_r, n_z, d_grid, a_grid, r_val, z_gridvals_J(:,:,jj), ReturnFnParamsVec,0); - - entireRHS_r=ReturnMatrix_r+DiscountFactorParamsVec*reshape(EV,[N_d*N_a,N_a,1,N_z]); - - %Calc the max and it's index - [Vtemp,maxindex]=max(entireRHS_r); - V(:,r_c,:,jj)=Vtemp; - Policy(:,r_c,:,jj)=maxindex; - end - end end From f4ee524cdda505a23082316214413a291ac34577 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Mon, 9 Mar 2026 14:56:31 +1300 Subject: [PATCH 57/67] various minor --- .../subcodes/EvalFnOnSimPanelIndex.m | 1 - .../SimPanelIndexes/SimPanelIndexes_InfHorz.m | 78 +++++++++++-------- .../SimTimeSeriesIndexes_InfHorz_Exit2_raw.m | 20 +---- .../SimTimeSeriesIndexes_InfHorz_Exit_raw.m | 12 +-- .../InfHorz/SimPanelValues_Case1.m | 6 +- .../InfHorz/SimTimeSeriesValues_InfHorz.m | 22 ++---- 6 files changed, 57 insertions(+), 82 deletions(-) diff --git a/EvaluateFnOnAgentDist/subcodes/EvalFnOnSimPanelIndex.m b/EvaluateFnOnAgentDist/subcodes/EvalFnOnSimPanelIndex.m index f36e0ee3..6b35232d 100644 --- a/EvaluateFnOnAgentDist/subcodes/EvalFnOnSimPanelIndex.m +++ b/EvaluateFnOnAgentDist/subcodes/EvalFnOnSimPanelIndex.m @@ -2,7 +2,6 @@ % Note: This also handles e and semiz, just put them together with the z as for this function there is no difference % Note: z_grid needs to be a joint-grid - if l_daprime==1 if l_a==1 if l_z==0 diff --git a/SimulateTimeSeries/InfHorz/SimPanelIndexes/SimPanelIndexes_InfHorz.m b/SimulateTimeSeries/InfHorz/SimPanelIndexes/SimPanelIndexes_InfHorz.m index 1166e9db..926c3b82 100644 --- a/SimulateTimeSeries/InfHorz/SimPanelIndexes/SimPanelIndexes_InfHorz.m +++ b/SimulateTimeSeries/InfHorz/SimPanelIndexes/SimPanelIndexes_InfHorz.m @@ -13,6 +13,13 @@ simoptions.simperiods=gather(simoptions.simperiods); simoptions.burnin=gather(simoptions.burnin); +simoptions.simperiodsfinal=simoptions.simperiods; +simoptions.simperiods=simoptions.simperiods+simoptions.burnin; % just simulate this many periods, then burnin is removed later + +if ~isfield(simoptions,'exitinpanel') + simoptions.exitinpanel=0; +end + %% N_d=prod(n_d); if N_d>0 @@ -31,7 +38,12 @@ else l_z=0; end -N_e=prod(simoptions.n_e); + +if isfield(simoptions,'n_e') + N_e=prod(simoptions.n_e); +else + N_e=0; +end if N_e>0 l_e=length(simoptions.n_e); cumsumpi_e=gather(cumsum(simoptions.pi_e,1)); @@ -101,7 +113,7 @@ %% -SimPanel=nan(l_a+l_z,simoptions.simperiods,simoptions.numbersims); % preallocate +SimPanel=nan(l_a+l_z,simoptions.simperiodsfinal,simoptions.numbersims); % preallocate exitinpanel=simoptions.exitinpanel; % reduce overhead with parfor @@ -117,14 +129,14 @@ end % simoptions.simpanelindexkron==1 % Create the simulated data in kron form - SimPanel=nan(1,simoptions.simperiods,simoptions.numbersims); % (a) + SimPanel=nan(1,simoptions.simperiodsfinal,simoptions.numbersims); % (a) if simoptions.gridinterplayer==0 parfor ii=1:simoptions.numbersims [~,seedpoint]=max(cumsumInitialDistVec>rand(1,1)); % Get seedpoint from InitialDist seedpoint=ind2sub_homemade(N_a,seedpoint); seedpoint=round(seedpoint); % For some reason seedpoint had heaps of '.0000' decimal places and were not being treated as integers, this solves that. SimLifeCycleKron=SimTimeSeriesIndexes_InfHorz_noz_raw(Policy_aprime, simoptions, seedpoint); - SimPanel(:,:,ii)=SimLifeCycleKron; + SimPanel(:,:,ii)=SimLifeCycleKron(:,simoptions.burnin+1:end); end elseif simoptions.gridinterplayer==1 parfor ii=1:simoptions.numbersims @@ -132,16 +144,16 @@ seedpoint=ind2sub_homemade(N_a,seedpoint); seedpoint=round(seedpoint); % For some reason seedpoint had heaps of '.0000' decimal places and were not being treated as integers, this solves that. SimLifeCycleKron=SimTimeSeriesIndexes_InfHorz_PolicyProbs_noz_raw(Policy_aprime,CumPolicyProbs, simoptions, seedpoint); - SimPanel(:,:,ii)=SimLifeCycleKron; + SimPanel(:,:,ii)=SimLifeCycleKron(:,simoptions.burnin+1:end); end end if simoptions.simpanelindexkron==0 % Convert results out of kron - SimPanelKron=reshape(SimPanel,[1,simoptions.simperiods*simoptions.numbersims]); - SimPanel=nan(l_a,simoptions.simperiods*simoptions.numbersims); % (a) + SimPanelKron=reshape(SimPanel,[1,simoptions.simperiodsfinal*simoptions.numbersims]); + SimPanel=nan(l_a,simoptions.simperiodsfinal*simoptions.numbersims); % (a) SimPanel(1:l_a,:)=ind2sub_vec_homemade(n_a,SimPanelKron(1,:)')'; % a - SimPanel=reshape(SimPanel,[1,simoptions.simperiods,simoptions.numbersims]); + SimPanel=reshape(SimPanel,[1,simoptions.simperiodsfinal,simoptions.numbersims]); end else % No z, with e @@ -153,14 +165,14 @@ end % simoptions.simpanelindexkron==1 % Create the simulated data in kron form - SimPanel=nan(2,simoptions.simperiods,simoptions.numbersims); % (a,e) + SimPanel=nan(2,simoptions.simperiodsfinal,simoptions.numbersims); % (a,e) if simoptions.gridinterplayer==0 parfor ii=1:simoptions.numbersims [~,seedpoint]=max(cumsumInitialDistVec>rand(1,1)); % Get seedpoint from InitialDist seedpoint=ind2sub_homemade([N_a,N_e],seedpoint); seedpoint=round(seedpoint); % For some reason seedpoint had heaps of '.0000' decimal places and were not being treated as integers, this solves that. SimLifeCycleKron=SimTimeSeriesIndexes_InfHorz_noz_e_raw(Policy_aprime,cumsumpi_e, simoptions, seedpoint); - SimPanel(:,:,ii)=SimLifeCycleKron; + SimPanel(:,:,ii)=SimLifeCycleKron(:,simoptions.burnin+1:end); end elseif simoptions.gridinterplayer==1 parfor ii=1:simoptions.numbersims @@ -168,17 +180,17 @@ seedpoint=ind2sub_homemade([N_a,N_e],seedpoint); seedpoint=round(seedpoint); % For some reason seedpoint had heaps of '.0000' decimal places and were not being treated as integers, this solves that. SimLifeCycleKron=SimTimeSeriesIndexes_InfHorz_PolicyProbs_noz_e_raw(Policy_aprime,CumPolicyProbs,cumsumpi_e, simoptions, seedpoint); - SimPanel(:,:,ii)=SimLifeCycleKron; + SimPanel(:,:,ii)=SimLifeCycleKron(:,simoptions.burnin+1:end); end end if simoptions.simpanelindexkron==0 % Convert results out of kron - SimPanelKron=reshape(SimPanel,[2,simoptions.simperiods*simoptions.numbersims]); - SimPanel=nan(l_a+l_e,simoptions.simperiods*simoptions.numbersims); % (a,e) + SimPanelKron=reshape(SimPanel,[2,simoptions.simperiodsfinal*simoptions.numbersims]); + SimPanel=nan(l_a+l_e,simoptions.simperiodsfinal*simoptions.numbersims); % (a,e) SimPanel(1:l_a,:)=ind2sub_homemade(n_a,SimPanelKron(1,:)); % a SimPanel(l_a+1:l_a+l_e,:)=ind2sub_homemade(simoptions.n_e,SimPanelKron(2,:)); % e - SimPanel=reshape(SimPanel,[2,simoptions.simperiods,simoptions.numbersims]); + SimPanel=reshape(SimPanel,[2,simoptions.simperiodsfinal,simoptions.numbersims]); else % All exogenous states together % Only e, so already is @@ -194,14 +206,14 @@ end % simoptions.simpanelindexkron==1 % Create the simulated data in kron form - SimPanel=nan(2,simoptions.simperiods,simoptions.numbersims); % (a,z) + SimPanel=nan(2,simoptions.simperiodsfinal,simoptions.numbersims); % (a,z) if simoptions.gridinterplayer==0 parfor ii=1:simoptions.numbersims [~,seedpoint]=max(cumsumInitialDistVec>rand(1,1)); % Get seedpoint from InitialDist seedpoint=ind2sub_homemade([N_a,N_z],seedpoint); seedpoint=round(seedpoint); % For some reason seedpoint had heaps of '.0000' decimal places and were not being treated as integers, this solves that. SimLifeCycleKron=SimTimeSeriesIndexes_InfHorz_raw(Policy_aprime,cumsumpi_z, simoptions, seedpoint); - SimPanel(:,:,ii)=SimLifeCycleKron; + SimPanel(:,:,ii)=SimLifeCycleKron(:,simoptions.burnin+1:end); end elseif simoptions.gridinterplayer==1 parfor ii=1:simoptions.numbersims % This is only change from the simoptions.parallel==0 @@ -209,17 +221,18 @@ seedpoint=ind2sub_homemade([N_a,N_z],seedpoint); seedpoint=round(seedpoint); % For some reason seedpoint had heaps of '.0000' decimal places and were not being treated as integers, this solves that. SimLifeCycleKron=SimTimeSeriesIndexes_InfHorz_PolicyProbs_raw(Policy_aprime,CumPolicyProbs,cumsumpi_z, simoptions, seedpoint); - SimPanel(:,:,ii)=SimLifeCycleKron; + SimPanel(:,:,ii)=SimLifeCycleKron(:,simoptions.burnin+1:end); + end end if simoptions.simpanelindexkron==0 % Convert results out of kron - SimPanelKron=reshape(SimPanel,[2,simoptions.simperiods*simoptions.numbersims]); - SimPanel=nan(l_a+l_z,simoptions.simperiods*simoptions.numbersims); % (a,z) + SimPanelKron=reshape(SimPanel,[2,simoptions.simperiodsfinal*simoptions.numbersims]); + SimPanel=nan(l_a+l_z,simoptions.simperiodsfinal*simoptions.numbersims); % (a,z) SimPanel(1:l_a,:)=ind2sub_vec_homemade(n_a,SimPanelKron(1,:)')'; % a SimPanel(l_a+1:l_a+l_z,:)=ind2sub_vec_homemade(n_z,SimPanelKron(2,:)')'; % z - SimPanel=reshape(SimPanel,[2,simoptions.simperiods,simoptions.numbersims]); + SimPanel=reshape(SimPanel,[2,simoptions.simperiodsfinal,simoptions.numbersims]); else % All exogenous states together % Only z, so already is @@ -234,14 +247,14 @@ CumPolicyProbs=reshape(CumPolicyProbs,[N_a,N_z,N_e,2]); end - SimPanel=nan(3,simoptions.simperiods,simoptions.numbersims); % (a,z,e) + SimPanel=nan(3,simoptions.simperiodsfinal,simoptions.numbersims); % (a,z,e) if simoptions.gridinterplayer==0 parfor ii=1:simoptions.numbersims [~,seedpoint]=max(cumsumInitialDistVec>rand(1,1)); % Get seedpoint from InitialDist seedpoint=ind2sub_homemade([N_a,N_z,N_e],seedpoint); seedpoint=round(seedpoint); % For some reason seedpoint had heaps of '.0000' decimal places and were not being treated as integers, this solves that. SimLifeCycleKron=SimTimeSeriesIndexes_InfHorz_e_raw(Policy_aprime,cumsumpi_z,cumsumpi_e, simoptions, seedpoint); - SimPanel(:,:,ii)=SimLifeCycleKron; + SimPanel(:,:,ii)=SimLifeCycleKron(:,simoptions.burnin+1:end); end elseif simoptions.gridinterplayer==1 parfor ii=1:simoptions.numbersims @@ -249,18 +262,18 @@ seedpoint=ind2sub_homemade([N_a,N_z,N_e],seedpoint); seedpoint=round(seedpoint); % For some reason seedpoint had heaps of '.0000' decimal places and were not being treated as integers, this solves that. SimLifeCycleKron=SimTimeSeriesIndexes_InfHorz_PolicyProbs_e_raw(Policy_aprime,CumPolicyProbs,cumsumpi_z,cumsumpi_e, simoptions, seedpoint); - SimPanel(:,:,ii)=SimLifeCycleKron; + SimPanel(:,:,ii)=SimLifeCycleKron(:,simoptions.burnin+1:end); end end if simoptions.simpanelindexkron==0 % Convert results out of kron - SimPanelKron=reshape(SimPanel,[3,simoptions.simperiods*simoptions.numbersims]); - SimPanel=nan(l_a+l_z+l_e,simoptions.simperiods*simoptions.numbersims); % (a,z,e) + SimPanelKron=reshape(SimPanel,[3,simoptions.simperiodsfinal*simoptions.numbersims]); + SimPanel=nan(l_a+l_z+l_e,simoptions.simperiodsfinal*simoptions.numbersims); % (a,z,e) SimPanel(1:l_a,:)=ind2sub_homemade(n_a,SimPanelKron(1,:)); % a SimPanel(l_a+1:l_a+l_z,:)=ind2sub_homemade(n_z,SimPanelKron(2,:)); % z SimPanel(l_a+l_z+1:l_a+l_z+l_e,:)=ind2sub_homemade(simoptions.n_e,SimPanelKron(3,:)); % e - SimPanel=reshape(SimPanel,[3,simoptions.simperiods,simoptions.numbersims]); + SimPanel=reshape(SimPanel,[3,simoptions.simperiodsfinal,simoptions.numbersims]); else % All exogenous states together SimPanel(2,:,:)=SimPanel(2,:,:)+N_z*(SimPanel(3,:,:)-1); % put z and e together @@ -294,21 +307,20 @@ error('Entry/exit not yet impelemented for length(n_a)>1, ask on forum if you need this') end - %par - for ii=1:simoptions.numbersims % Parallel CPUs for the simulations + parfor ii=1:simoptions.numbersims % Parallel CPUs for the simulations seedpoint_ii=ind2sub_homemade([N_a,N_z],seedpointvec(ii)); seedpoint_ii=round(seedpoint_ii); % For some reason seedpoints had heaps of '.0000' decimal places and were not being treated as integers, this solves that. if endogenousexit==2 % Mixture of endogenous and exogenous exit - SimTimeSeriesKron=SimTimeSeriesIndexes_InfHorz_Exit2_raw(Policy_aprime, CondlProbOfSurvival,cumsumpi_z,simoptions.burnin,seedpoint_ii,simoptions.simperiods,exitprobs); + SimTimeSeriesKron=SimTimeSeriesIndexes_InfHorz_Exit2_raw(Policy_aprime, CondlProbOfSurvival,cumsumpi_z,seedpoint_ii,simoptions.burnin+simoptions.simperiods,exitprobs); else % Otherwise (either one of endogenous or exogenous exit; but not mixture) - SimTimeSeriesKron=SimTimeSeriesIndexes_InfHorz_Exit_raw(Policy_aprime, CondlProbOfSurvival,cumsumpi_z,simoptions.burnin,seedpoint_ii,simoptions.simperiods); + SimTimeSeriesKron=SimTimeSeriesIndexes_InfHorz_Exit_raw(Policy_aprime, CondlProbOfSurvival,cumsumpi_z,seedpoint_ii,simoptions.burnin+simoptions.simperiods); end - SimPanel_ii=nan(l_a+l_z,simoptions.simperiods); + SimPanel_ii=nan(l_a+l_z,simoptions.simperiodsfinal); - for t=1:simoptions.simperiods - temp=SimTimeSeriesKron(:,t); + for t=1:simoptions.simperiodsfinal + temp=SimTimeSeriesKron(:,simoptions.burnin+t); if ~isnan(temp) a_c_vec=ind2sub_homemade([n_a],temp(1)); z_c_vec=ind2sub_homemade([n_z],temp(2)); diff --git a/SimulateTimeSeries/InfHorz/SimPanelIndexes/SimTimeSeriesIndexes/SimTimeSeriesIndexes_InfHorz_Exit2_raw.m b/SimulateTimeSeries/InfHorz/SimPanelIndexes/SimTimeSeriesIndexes/SimTimeSeriesIndexes_InfHorz_Exit2_raw.m index 4a237db2..f4f83349 100644 --- a/SimulateTimeSeries/InfHorz/SimPanelIndexes/SimTimeSeriesIndexes/SimTimeSeriesIndexes_InfHorz_Exit2_raw.m +++ b/SimulateTimeSeries/InfHorz/SimPanelIndexes/SimTimeSeriesIndexes/SimTimeSeriesIndexes_InfHorz_Exit2_raw.m @@ -1,4 +1,4 @@ -function SimTimeSeriesKron=SimTimeSeriesIndexes_InfHorz_Exit2_raw(PolicyIndexesKron, CondlProbOfSurvivalKron,cumsum_pi_z,burnin,seedpoint,simperiods,exitprobabilities) +function SimTimeSeriesKron=SimTimeSeriesIndexes_InfHorz_Exit2_raw(PolicyIndexesKron, CondlProbOfSurvivalKron,cumsum_pi_z,seedpoint,simperiods,exitprobabilities) % Exit2 is same as Exit, but allowing for 'mix' of endogenous and exogenous exit. % burnin=simoptions.burnin; @@ -22,24 +22,6 @@ currstate=seedpoint; % cumsum_pi_z=cumsum(pi_z,2); -if burnin>0 - for t=1:burnin - - temp=rand(1,1); - if temp>exitprobabilities(1)+exitprobabilities(2) % exog exit - currstate(1)=0; - break - elseif temp>exitprobabilities(1) % endog exit (maybe, agent has to make decision)) - if CondlProbOfSurvivalKron(currstate(1),currstate(2))>0 % agent chooses Death/Exit (Note that CondlProbOfSurvivalKron contains 1-ExitPolicy, so really checking for ExitPolicy==1) - currstate(1)=0; - break - end - end - - currstate(1)=PolicyIndexesKron(currstate(1),currstate(2)); - [~,currstate(2)]=max(cumsum_pi_z(currstate(2),:)>rand(1,1)); - end -end if currstate(1)>0 % Still alive for t=1:simperiods SimTimeSeriesKron(1,t)=currstate(1); %a_c diff --git a/SimulateTimeSeries/InfHorz/SimPanelIndexes/SimTimeSeriesIndexes/SimTimeSeriesIndexes_InfHorz_Exit_raw.m b/SimulateTimeSeries/InfHorz/SimPanelIndexes/SimTimeSeriesIndexes/SimTimeSeriesIndexes_InfHorz_Exit_raw.m index 681b52d7..0e9844f5 100644 --- a/SimulateTimeSeries/InfHorz/SimPanelIndexes/SimTimeSeriesIndexes/SimTimeSeriesIndexes_InfHorz_Exit_raw.m +++ b/SimulateTimeSeries/InfHorz/SimPanelIndexes/SimTimeSeriesIndexes/SimTimeSeriesIndexes_InfHorz_Exit_raw.m @@ -1,4 +1,4 @@ -function SimTimeSeriesKron=SimTimeSeriesIndexes_InfHorz_Exit_raw(Policy_aprime, CondlProbOfSurvivalKron,cumsum_pi_z,burnin,seedpoint,simperiods) +function SimTimeSeriesKron=SimTimeSeriesIndexes_InfHorz_Exit_raw(Policy_aprime, CondlProbOfSurvivalKron,cumsum_pi_z,seedpoint,simperiods) % burnin=simoptions.burnin; % seedpoint=simoptions.seedpoint; @@ -15,16 +15,6 @@ currstate=seedpoint; % cumsum_pi_z=cumsum(pi_z,2); -if burnin>0 - for t=1:burnin - if rand(1,1)>CondlProbOfSurvivalKron(currstate(1),currstate(2)) % Death/Exit - currstate(1)=0; - break - end - currstate(1)=Policy_aprime(currstate(1),currstate(2)); - [~,currstate(2)]=max(cumsum_pi_z(currstate(2),:)>rand(1,1)); - end -end if currstate(1)>0 % Still alive for t=1:simperiods SimTimeSeriesKron(1,t)=currstate(1); %a_c diff --git a/SimulateTimeSeries/InfHorz/SimPanelValues_Case1.m b/SimulateTimeSeries/InfHorz/SimPanelValues_Case1.m index 6cb094be..4af55329 100644 --- a/SimulateTimeSeries/InfHorz/SimPanelValues_Case1.m +++ b/SimulateTimeSeries/InfHorz/SimPanelValues_Case1.m @@ -249,11 +249,11 @@ end end -a_gridvals=CreateGridvals(n_a,a_grid,1); % 1 at end indicates output as matrices. +a_gridvals=gpuArray(CreateGridvals(n_a,a_grid,1)); % 1 at end indicates output as matrices. if all(size(z_grid)==[prod(n_z),1]) - z_gridvals=CreateGridvals(n_z,z_grid,1); % 1 at end indicates output as matrices. + z_gridvals=gpuArray(CreateGridvals(n_z,z_grid,1)); % 1 at end indicates output as matrices. elseif all(size(z_grid)==[prod(n_z),length(n_z)]) - z_gridvals=z_grid; % already gridvals + z_gridvals=gpuArray(z_grid); % already gridvals end %% Now switch everything to gpu so can use arrayfun() to evaluates all the FnsToEvaluate diff --git a/SimulateTimeSeries/InfHorz/SimTimeSeriesValues_InfHorz.m b/SimulateTimeSeries/InfHorz/SimTimeSeriesValues_InfHorz.m index 590e5be5..4c1dbde2 100644 --- a/SimulateTimeSeries/InfHorz/SimTimeSeriesValues_InfHorz.m +++ b/SimulateTimeSeries/InfHorz/SimTimeSeriesValues_InfHorz.m @@ -1,30 +1,22 @@ function TimeSeries=SimTimeSeriesValues_InfHorz(Policy, FnsToEvaluate, Parameters, n_d, n_a, n_z, d_grid, a_grid, z_grid,pi_z,simoptions) % Simulate time series for the FnsToEvaluate for an infinite horizon model. -if ~exist(simoptions,'seedpoint') +N_a=prod(n_a); +N_z=prod(n_z); + +if ~exist('simoptions','var') simoptions.seedpoint=[ceil(N_a/2),ceil(N_z/2)]; else if ~isfield(simoptions,'seedpoint') simoptions.seedpoint=[ceil(N_a/2),ceil(N_z/2)]; end end - -N_d=prod(n_d); -N_a=prod(n_a); -N_z=prod(n_z); - -if N_d==0 - l_d=0; -else - l_d=length(n_d); -end -l_a=length(n_a); -l_z=length(n_z); - simoptions.numbersims=1; + % To make my life easy, this actully just uses the SimPanelValues command and creates just one simulation. InitialDist=zeros([N_a,N_z]); -InitialDist(simoptions.seedpoint)=1; +InitialDist(simoptions.seedpoint(1),simoptions.seedpoint(2))=1; + TimeSeries=SimPanelValues_Case1(InitialDist,Policy,FnsToEvaluate,[],Parameters,n_d,n_a,n_z,d_grid,a_grid,z_grid,pi_z, simoptions); end From 935ddf4dd2ff1e6e7f801d6c0794f298761378b8 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Mon, 9 Mar 2026 15:37:12 +1300 Subject: [PATCH 58/67] minor --- ValueFnIter/FHorz/ValueFnIter_Case1_FHorz.m | 28 ++++++++++++++------- 1 file changed, 19 insertions(+), 9 deletions(-) diff --git a/ValueFnIter/FHorz/ValueFnIter_Case1_FHorz.m b/ValueFnIter/FHorz/ValueFnIter_Case1_FHorz.m index 0606af78..96f77952 100644 --- a/ValueFnIter/FHorz/ValueFnIter_Case1_FHorz.m +++ b/ValueFnIter/FHorz/ValueFnIter_Case1_FHorz.m @@ -273,7 +273,7 @@ %% Print out vfoptions (if vfoptions.verbose=1) -if vfoptions.verbose==1 +if vfoptions.verbose>=1 vfoptions end @@ -319,15 +319,25 @@ end end + if vfoptions.experienceasset==1 + vfoptions.l_d2=vfoptions.l_dexperienceasset; + elseif vfoptions.experienceassetu==1 + vfoptions.l_d2=vfoptions.l_dexperienceassetu; + end + if isfield(vfoptions,'n_semiz') + if ~isfield(vfoptions,'l_dsemiz') + vfoptions.l_dsemiz=1; % by default, only one decision variable influences the semi-exogenous state + end + % Split decision variables (other, semiexo, experienceasset) - if length(n_d)>2 - n_d1=n_d(1:end-2); + if length(n_d)>(vfoptions.l_d2+vfoptions.l_dsemiz) + n_d1=n_d(1:end-vfoptions.l_d2-vfoptions.l_dsemiz); else n_d1=0; end - n_d2=n_d(end-1); % n_d2 is the decision variable that influences the experience asset - n_d3=n_d(end); % n_d3 is the decision variable that influences the transition probabilities of the semi-exogenous state + n_d2=n_d(end-vfoptions.l_d2-vfoptions.l_dsemiz+1:end-vfoptions.l_dsemiz); % n_d2 is the decision variable that influences the experience asset + n_d3=n_d(end-vfoptions.l_dsemiz+1:end); % n_d3 is the decision variable that influences the transition probabilities of the semi-exogenous state d1_grid=d_grid(1:sum(n_d1)); d2_grid=d_grid(sum(n_d1)+1:sum(n_d1)+sum(n_d2)); d3_grid=d_grid(sum(n_d1)+sum(n_d2)+1:end); @@ -343,12 +353,12 @@ else % no semiz % Split decision variables into the standard ones and the one relevant to the experience asset - if isscalar(n_d) - n_d1=0; - else + if length(n_d)>vfoptions.l_d2 n_d1=n_d(1:end-1); + else + n_d1=0; end - n_d2=n_d(end); % n_d2 is the decision variable that influences next period vale of the experience asset + n_d2=n_d(end-vfoptions.l_d2+1:end); % n_d2 is the decision variable that influences next period vale of the experience asset d1_grid=d_grid(1:sum(n_d1)); d2_grid=d_grid(sum(n_d1)+1:end); % Split endogenous assets into the standard ones and the experience asset From cde13dc3de46f7b44b4cd33222be468ea279cc69 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Tue, 10 Mar 2026 09:25:01 +1300 Subject: [PATCH 59/67] Tan improvement on cpu --- .../StationaryDist_FHorz_Iteration_SemiExo_nProbs_raw.m | 8 +++++--- .../FHorz/TransitionPath_FHorz_shooting_fastOLG_e.m | 4 ++-- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_raw.m b/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_raw.m index 5ff94c11..0c0c10e8 100644 --- a/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_raw.m +++ b/StationaryDist/FHorz/nProbs/StationaryDist_FHorz_Iteration_SemiExo_nProbs_raw.m @@ -20,21 +20,23 @@ PolicyProbs=reshape(PolicyProbs,[N_a*N_semiz*N_z,N_probs,N_j]); PolicyProbs=repelem(gather(PolicyProbs),1,N_semiz).*repmat(pi_semiz_J(semizindex),1,N_probs); +pi_z_J=gather(pi_z_J); + N_bothz=N_semiz*N_z; %% Use Tan improvement StationaryDist=zeros(N_a*N_semiz*N_z,N_j,'gpuArray'); % StationaryDist cannot be sparse StationaryDist(:,1)=jequaloneDistKron; -StationaryDist_jj=sparse(jequaloneDistKron); % use sparse matrix +StationaryDist_jj=sparse(gather(jequaloneDistKron)); % use sparse matrix % Precompute; II2 used only for sparse matrix creation...best done on CPU II2=repelem((1:1:N_a*N_semiz*N_z)',1,N_semiz*N_probs); % Index for this period (a,semiz), note the N_probs-copies for jj=1:(N_j-1) - + Gammatranspose=sparse(Policy_aprimesemizz(:,:,jj),II2,PolicyProbs(:,:,jj),N_a*N_bothz,N_a*N_bothz); % Note: sparse() will accumulate at repeated indices [only relevant at grid end points] - + % First step of Tan improvement StationaryDist_jj=reshape(Gammatranspose*StationaryDist_jj,[N_a*N_semiz,N_z]); diff --git a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_e.m b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_e.m index 328a3e65..99145c40 100644 --- a/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_e.m +++ b/TransitionPaths/FHorz/TransitionPath_FHorz_shooting_fastOLG_e.m @@ -173,9 +173,9 @@ % simoptions.fastOLG=1 is hardcoded if simoptions.gridinterplayer==0 - AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_e_raw(AgentDist,PolicyaprimejzPath(:,tt),N_a,N_z,N_e,N_j,pi_z_J_sim, pi_e_J_sim,II1orII,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % II1orII is II1 + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_e_raw(AgentDist,gather(PolicyaprimejzPath(:,tt)),N_a,N_z,N_e,N_j,pi_z_J_sim, pi_e_J_sim,II1orII,II2,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % II1orII is II1 elseif simoptions.gridinterplayer==1 - AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_e_raw(AgentDist,PolicyaprimejzPath(:,:,tt),PolicyProbsPath(:,:,tt),N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,II1orII,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % II1orII is II + AgentDistnext=AgentDist_FHorz_TPath_SingleStep_IterFast_nProbs_e_raw(AgentDist,gather(PolicyaprimejzPath(:,:,tt)),gather(PolicyProbsPath(:,:,tt)),N_a,N_z,N_e,N_j,pi_z_J_sim,pi_e_J_sim,II1orII,exceptlastj,exceptfirstj,justfirstj,jequalOneDist); % II1orII is II end %% AggVars From a4054fc6621d51a95e6ee87ec9bbdaf873d498cb Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Wed, 11 Mar 2026 09:11:19 +1300 Subject: [PATCH 60/67] add AllStats for AggShocks --- .../EvalFnOnAggShocksPath_AllStats_InfHorz.m | 103 ++++++++++++++++++ ...nOnTransPath_AutoCorrTransProbs_InfHorz.m} | 4 +- 2 files changed, 105 insertions(+), 2 deletions(-) create mode 100644 EvaluateFnOnAgentDist/AggShocksPath/EvalFnOnAggShocksPath_AllStats_InfHorz.m rename EvaluateFnOnAgentDist/TransPath/{EvalFnOnTransPath_CorrTransProbs_InfHorz.m => EvalFnOnTransPath_AutoCorrTransProbs_InfHorz.m} (98%) diff --git a/EvaluateFnOnAgentDist/AggShocksPath/EvalFnOnAggShocksPath_AllStats_InfHorz.m b/EvaluateFnOnAgentDist/AggShocksPath/EvalFnOnAggShocksPath_AllStats_InfHorz.m new file mode 100644 index 00000000..4429ceda --- /dev/null +++ b/EvaluateFnOnAgentDist/AggShocksPath/EvalFnOnAggShocksPath_AllStats_InfHorz.m @@ -0,0 +1,103 @@ +function AllStatsPath=EvalFnOnAggShocksPath_AllStats_InfHorz(GeneralizedTransitionFn,T,n_d,n_a,n_z,n_S,d_grid,a_grid,z_grid,FnsToEvaluate,Parameters,simoptions) + +if ~exist('simoptions','var') + simoptions.npoints=100; + simoptions.nquantiles=20; + simoptions.whichstats=ones(7,1); % See StatsFromWeightedGrid(), zeros skip some stats and can be used to reduce runtimes +else + if ~isfield(simoptions,'npoints') + simoptions.npoints=100; + end + if ~isfield(simoptions,'nquantiles') + simoptions.nquantiles=20; + end + if ~isfield(simoptions,'whichstats') + simoptions.whichstats=ones(7,1); % See StatsFromWeightedGrid(), zeros skip some stats and can be used to reduce runtimes + end +end + +%% Setup +PricePathNames=fieldnames(GeneralizedTransitionFn.PricePath); +AggShockNames=fieldnames(GeneralizedTransitionFn.AggShocksPath); + +FnsToEvalNames=fieldnames(FnsToEvaluate); +for ff=1:length(FnsToEvalNames) + AllStatsPath.(FnsToEvalNames{ff}).Mean=zeros(1,T); + AllStatsPath.(FnsToEvalNames{ff}).Median=zeros(1,T); + AllStatsPath.(FnsToEvalNames{ff}).RatioMeanToMedian=zeros(1,T); + AllStatsPath.(FnsToEvalNames{ff}).Variance=zeros(1,T); + AllStatsPath.(FnsToEvalNames{ff}).StdDeviation=zeros(1,T); + AllStatsPath.(FnsToEvalNames{ff}).LorenzCurve=zeros(simoptions.npoints,T); + AllStatsPath.(FnsToEvalNames{ff}).Gini=zeros(1,T); + AllStatsPath.(FnsToEvalNames{ff}).QuantileCutoffs=zeros(simoptions.nquantiles+1,T); % Includes the min and max values + AllStatsPath.(FnsToEvalNames{ff}).QuantileMeans=zeros(simoptions.nquantiles,T); +end + + +%% Loop over tt=1:T and get AllStats +% We already have GeneralizedTransitionFn.AgentDistPath so just calculate from this. +for tt=1:T + for pp=1:length(PricePathNames) + temp=GeneralizedTransitionFn.PricePath.(PricePathNames{pp}); + Parameters.(PricePathNames{pp})=temp(tt); + end + for SS_c=1:length(n_S) + temp=GeneralizedTransitionFn.AggShocksPath.(AggShockNames{SS_c}); + Parameters.(AggShockNames{SS_c})=temp(tt); + end + + AgentDist=GeneralizedTransitionFn.AgentDistPath(:,:,tt); + Policy=GeneralizedTransitionFn.PolicyPath(:,:,:,tt); + + % would be slightly faster if I pass FnsToEvaluateCell and FnsToEvaluateParamNames + AllStats_tt=EvalFnOnAgentDist_AllStats_Case1(AgentDist,Policy,FnsToEvaluate,Parameters,[],n_d,n_a,n_z,d_grid,a_grid,z_grid,simoptions); + + for ff=1:length(FnsToEvalNames) + temp=AllStatsPath.(FnsToEvalNames{ff}).Mean; + temp(tt)=AllStats_tt.(FnsToEvalNames{ff}).Mean; + AllStatsPath.(FnsToEvalNames{ff}).Mean=temp; + + temp=AllStatsPath.(FnsToEvalNames{ff}).Median; + temp(tt)=AllStats_tt.(FnsToEvalNames{ff}).Median; + AllStatsPath.(FnsToEvalNames{ff}).Median=temp; + + temp=AllStatsPath.(FnsToEvalNames{ff}).RatioMeanToMedian; + temp(tt)=AllStats_tt.(FnsToEvalNames{ff}).RatioMeanToMedian; + AllStatsPath.(FnsToEvalNames{ff}).RatioMeanToMedian=temp; + + temp=AllStatsPath.(FnsToEvalNames{ff}).Variance; + temp(tt)=AllStats_tt.(FnsToEvalNames{ff}).Variance; + AllStatsPath.(FnsToEvalNames{ff}).Variance=temp; + + temp=AllStatsPath.(FnsToEvalNames{ff}).StdDeviation; + temp(tt)=AllStats_tt.(FnsToEvalNames{ff}).StdDeviation; + AllStatsPath.(FnsToEvalNames{ff}).StdDeviation=temp; + + temp=AllStatsPath.(FnsToEvalNames{ff}).LorenzCurve; + temp(:,tt)=AllStats_tt.(FnsToEvalNames{ff}).LorenzCurve; + AllStatsPath.(FnsToEvalNames{ff}).LorenzCurve=temp; + + temp=AllStatsPath.(FnsToEvalNames{ff}).Gini; + temp(tt)=AllStats_tt.(FnsToEvalNames{ff}).Gini; + AllStatsPath.(FnsToEvalNames{ff}).Gini=temp; + + temp=AllStatsPath.(FnsToEvalNames{ff}).QuantileCutoffs; + temp(:,tt)=AllStats_tt.(FnsToEvalNames{ff}).QuantileCutoffs; + AllStatsPath.(FnsToEvalNames{ff}).QuantileCutoffs=temp; + + temp=AllStatsPath.(FnsToEvalNames{ff}).QuantileMeans; + temp(:,tt)=AllStats_tt.(FnsToEvalNames{ff}).QuantileMeans; + AllStatsPath.(FnsToEvalNames{ff}).QuantileMeans=temp; + end + +end + + + + + + + + + +end \ No newline at end of file diff --git a/EvaluateFnOnAgentDist/TransPath/EvalFnOnTransPath_CorrTransProbs_InfHorz.m b/EvaluateFnOnAgentDist/TransPath/EvalFnOnTransPath_AutoCorrTransProbs_InfHorz.m similarity index 98% rename from EvaluateFnOnAgentDist/TransPath/EvalFnOnTransPath_CorrTransProbs_InfHorz.m rename to EvaluateFnOnAgentDist/TransPath/EvalFnOnTransPath_AutoCorrTransProbs_InfHorz.m index 4e3322f9..47fdd0d1 100644 --- a/EvaluateFnOnAgentDist/TransPath/EvalFnOnTransPath_CorrTransProbs_InfHorz.m +++ b/EvaluateFnOnAgentDist/TransPath/EvalFnOnTransPath_AutoCorrTransProbs_InfHorz.m @@ -1,4 +1,4 @@ -function CorrTransProbsPath=EvalFnOnTransPath_CorrTransProbs_InfHorz(FnsToEvaluate,AgentDistPath,PolicyPath,PricePath,ParamPath, Parameters, T, n_d, n_a, n_z, d_grid, a_grid,z_grid, pi_z,simoptions) +function CorrTransProbsPath=EvalFnOnTransPath_AutoCorrTransProbs_InfHorz(FnsToEvaluate,AgentDistPath,PolicyPath,PricePath,ParamPath, Parameters, T, n_d, n_a, n_z, d_grid, a_grid,z_grid, pi_z,simoptions) % Returns stats on (auto) correlation and transition probabilities % You must input the names for the FnsToEvaluate that you want the transition probabilities for (by default it won't do any) % Done as simoptions.transprobs @@ -291,4 +291,4 @@ end end end -end \ No newline at end of file +end From 7156c55dc06472cc159d1bc705e5125ae7878287 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Wed, 11 Mar 2026 09:19:15 +1300 Subject: [PATCH 61/67] experienceasset with mutilple d vars --- .../FHorz/ExpAsset/StationaryDist_FHorz_ExpAsset.m | 5 +++-- .../FHorz/ExpAsset/StationaryDist_FHorz_ExpAssetSemiExo.m | 4 ++-- .../FHorz/ExpAssetu/StationaryDist_FHorz_ExpAssetu.m | 4 ++-- .../FHorz/ExpAssetu/StationaryDist_FHorz_ExpAssetuSemiExo.m | 4 ++-- StationaryDist/FHorz/StationaryDist_FHorz_Case1.m | 6 ++++++ 5 files changed, 15 insertions(+), 8 deletions(-) diff --git a/StationaryDist/FHorz/ExpAsset/StationaryDist_FHorz_ExpAsset.m b/StationaryDist/FHorz/ExpAsset/StationaryDist_FHorz_ExpAsset.m index 6d78e70b..d32a02b2 100644 --- a/StationaryDist/FHorz/ExpAsset/StationaryDist_FHorz_ExpAsset.m +++ b/StationaryDist/FHorz/ExpAsset/StationaryDist_FHorz_ExpAsset.m @@ -1,7 +1,7 @@ function StationaryDist=StationaryDist_FHorz_ExpAsset(jequaloneDist,AgeWeightParamNames,Policy,n_d,n_a,n_z,N_j,pi_z_J,Parameters,simoptions) %% Setup related to experience asset -n_d2=n_d(end); +n_d2=n_d(end-simoptions.l_dexperienceasset+1:end); % Split endogenous assets into the standard ones and the experience asset if isscalar(n_a) n_a1=0; @@ -79,7 +79,7 @@ % as that is what we need for simulation, and we can then just send it to standard Case1 commands. Policy_aprime=zeros(N_a,N_ze,2,N_j,'gpuArray'); % the lower grid point PolicyProbs=zeros(N_a,N_ze,2,N_j,'gpuArray'); % The fourth dimension is lower/upper grid point -whichisdforexpasset=length(n_d); % is just saying which is the decision variable that influences the experience asset (it is the 'last' decision variable) +whichisdforexpasset=length(n_d)-simoptions.l_dexperienceasset+1:length(n_d); % is just saying which is the decision variable that influences the experience asset (it is the 'last' decision variable) for jj=1:N_j aprimeFnParamsVec=CreateVectorFromParams(Parameters, aprimeFnParamNames,jj); [aprimeIndexes, aprimeProbs]=CreateaprimePolicyExperienceAsset_Case1(Policy(:,:,:,jj),simoptions.aprimeFn, whichisdforexpasset, n_d, n_a1,n_a2, N_ze, d_grid, a2_grid, aprimeFnParamsVec); @@ -107,6 +107,7 @@ end + %% if simoptions.gridinterplayer==0 % Note: N_z=0 && N_e=0 is a different code diff --git a/StationaryDist/FHorz/ExpAsset/StationaryDist_FHorz_ExpAssetSemiExo.m b/StationaryDist/FHorz/ExpAsset/StationaryDist_FHorz_ExpAssetSemiExo.m index d46d51e4..9e7328d3 100644 --- a/StationaryDist/FHorz/ExpAsset/StationaryDist_FHorz_ExpAssetSemiExo.m +++ b/StationaryDist/FHorz/ExpAsset/StationaryDist_FHorz_ExpAssetSemiExo.m @@ -2,7 +2,7 @@ %% Experience asset and semi-exogenous state n_d3=n_d(end-simoptions.l_dsemiz+1:end); % decision variable that controls semi-exogenous state -n_d2=n_d(end-simoptions.l_dsemiz); % decision variables that controls experience asset +n_d2=n_d(end-simoptions.l_dexperienceasset-simoptions.l_dsemiz+1:end-simoptions.l_dsemiz); % decision variables that controls experience asset if length(n_d)>2 n_d1=n_d(1:end-2); l_d1=length(n_d1); @@ -93,7 +93,7 @@ % as that is what we need for simulation, and we can then just send it to standard Case1 commands. Policy_aprime=zeros(N_a,N_bothze,2,N_j,'gpuArray'); % the lower grid point PolicyProbs=zeros(N_a,N_bothze,2,N_j,'gpuArray'); % The fourth dimension is lower/upper grid point -whichisdforexpasset=length(n_d)-1; % is just saying which is the decision variable that influences the experience asset (it is the 'second last' decision variable) +whichisdforexpasset=length(n_d)-simoptions.l_dexperienceasset-simoptions.l_dsemiz+1:length(n_d)-simoptions.l_dsemiz; % is just saying which is the decision variable that influences the experience asset (it is the 'second last' decision variable) for jj=1:N_j aprimeFnParamsVec=CreateVectorFromParams(Parameters, aprimeFnParamNames,jj); [aprimeIndexes, aprimeProbs]=CreateaprimePolicyExperienceAsset_Case1(Policy(:,:,:,jj),simoptions.aprimeFn, whichisdforexpasset, n_d, n_a1,n_a2, N_bothze, d_grid, a2_grid, aprimeFnParamsVec); diff --git a/StationaryDist/FHorz/ExpAssetu/StationaryDist_FHorz_ExpAssetu.m b/StationaryDist/FHorz/ExpAssetu/StationaryDist_FHorz_ExpAssetu.m index 9947e958..b8fa8efc 100644 --- a/StationaryDist/FHorz/ExpAssetu/StationaryDist_FHorz_ExpAssetu.m +++ b/StationaryDist/FHorz/ExpAssetu/StationaryDist_FHorz_ExpAssetu.m @@ -1,7 +1,7 @@ function StationaryDist=StationaryDist_FHorz_ExpAssetu(jequaloneDist,AgeWeightParamNames,Policy,n_d,n_a,n_z,N_j,pi_z_J,Parameters,simoptions) %% Setup related to experience asset -n_d2=n_d(end); +n_d2=n_d(end-simoptions.l_dexperienceassetu+1:end); % Split endogenous assets into the standard ones and the experience asset if isscalar(n_a) n_a1=0; @@ -105,7 +105,7 @@ % as that is what we need for simulation, and we can then just send it to standard Case1 commands. Policy_aprime=zeros(N_a,N_ze,N_u,2,N_j,'gpuArray'); % the lower grid point PolicyProbs=zeros(N_a,N_ze,N_u,2,N_j,'gpuArray'); % probabilities of grid points -whichisdforexpasset=length(n_d); % is just saying which is the decision variable that influences the experience asset (it is the 'last' decision variable) +whichisdforexpasset=length(n_d)-simoptions.l_dexperienceassetu+1:length(n_d); % is just saying which is the decision variable that influences the experience asset (it is the 'last' decision variable) for jj=1:N_j aprimeFnParamsVec=CreateVectorFromParams(Parameters, aprimeFnParamNames,jj); [aprimeIndexes, aprimeProbs]=CreateaprimePolicyExperienceAssetu_Case1(Policy(:,:,:,jj),simoptions.aprimeFn, whichisdforexpasset, n_d, n_a1,n_a2, N_ze,n_u, d_grid, a2_grid,u_grid, aprimeFnParamsVec); diff --git a/StationaryDist/FHorz/ExpAssetu/StationaryDist_FHorz_ExpAssetuSemiExo.m b/StationaryDist/FHorz/ExpAssetu/StationaryDist_FHorz_ExpAssetuSemiExo.m index 913fe7ab..370fc901 100644 --- a/StationaryDist/FHorz/ExpAssetu/StationaryDist_FHorz_ExpAssetuSemiExo.m +++ b/StationaryDist/FHorz/ExpAssetu/StationaryDist_FHorz_ExpAssetuSemiExo.m @@ -2,7 +2,7 @@ %% Experience asset and semi-exogenous state n_d3=n_d(end-simoptions.l_dsemiz+1:end); % decision variable that controls semi-exogenous state -n_d2=n_d(end-simoptions.l_dsemiz); % decision variables that controls experience asset +n_d2=n_d(end-simoptions.l_dexperienceassetu-simoptions.l_dsemiz+1:end-simoptions.l_dsemiz); % decision variables that controls experience asset if length(n_d)>2 n_d1=n_d(1:end-2); l_d1=length(n_d1); @@ -116,7 +116,7 @@ % as that is what we need for simulation, and we can then just send it to standard Case1 commands. Policy_aprime=zeros(N_a,N_bothze,N_u,2,N_j,'gpuArray'); % the lower grid point PolicyProbs=zeros(N_a,N_bothze,N_u,2,N_j,'gpuArray'); % probabilities of grid points -whichisdforexpasset=length(n_d)-1; % is just saying which is the decision variable that influences the experience asset (it is the 'second last' decision variable) +whichisdforexpasset=length(n_d)-simoptions.l_dexperienceasset-simoptions.l_dsemiz+1:length(n_d)-simoptions.l_dsemiz; % is just saying which is the decision variable that influences the experience asset (it is the 'second last' decision variable) for jj=1:N_j aprimeFnParamsVec=CreateVectorFromParams(Parameters, aprimeFnParamNames,jj); [aprimeIndexes, aprimeProbs]=CreateaprimePolicyExperienceAssetu_Case1(Policy(:,:,:,jj),simoptions.aprimeFn, whichisdforexpasset, n_d, n_a1,n_a2, N_bothze,n_u, d_grid, a2_grid,u_grid, aprimeFnParamsVec); diff --git a/StationaryDist/FHorz/StationaryDist_FHorz_Case1.m b/StationaryDist/FHorz/StationaryDist_FHorz_Case1.m index d299343d..04de9c3c 100644 --- a/StationaryDist/FHorz/StationaryDist_FHorz_Case1.m +++ b/StationaryDist/FHorz/StationaryDist_FHorz_Case1.m @@ -140,6 +140,9 @@ %% Non-standard endogenous states if simoptions.experienceasset==1 + if ~isfield(simoptions,'l_dexperienceasset') + simoptions.l_dexperienceasset=1; % by default, only one decision variable influences the experienceasset + end if N_semiz==0 StationaryDist=StationaryDist_FHorz_ExpAsset(jequaloneDist,AgeWeightParamNames,Policy,n_d,n_a,n_z,N_j,pi_z_J,Parameters,simoptions); return @@ -149,6 +152,9 @@ end end if simoptions.experienceassetu==1 + if ~isfield(simoptions,'l_dexperienceassetu') + simoptions.l_dexperienceassetu=1; % by default, only one decision variable influences the experienceasset + end if N_semiz==0 StationaryDist=StationaryDist_FHorz_ExpAssetu(jequaloneDist,AgeWeightParamNames,Policy,n_d,n_a,n_z,N_j,pi_z_J,Parameters,simoptions); return From ff9c0f3ce6e2f364e2f5f3cabe25e67e05567a15 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Thu, 12 Mar 2026 11:22:57 +1300 Subject: [PATCH 62/67] correct comment on fminalgo --- HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m | 2 +- .../FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m | 2 +- HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1.m | 2 +- .../InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m b/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m index ae8cbcf0..304bdde7 100644 --- a/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m +++ b/HeterogeneousAgent/FHorz/HeteroAgentStationaryEqm_Case1_FHorz.m @@ -40,7 +40,7 @@ end if ~exist('heteroagentoptions','var') - heteroagentoptions.fminalgo=1; % =1 use fminsearch. Main alternatives: =4 is shooting (you set update rules), =5 is CMA-ES (robust but slow), =8 is lsqnonlin() fast but requires Matlab Optimization Toolbox (and often not quite high accuracy of results) + heteroagentoptions.fminalgo=1; % =1 use fminsearch. Main alternatives: =4 is CMA-ES (robust but slow), =5 is shooting (you set update rules), =8 is lsqnonlin() fast but requires Matlab Optimization Toolbox (and often not quite high accuracy of results) heteroagentoptions.multiGEcriterion=1; % How to combine multiple GE condns (default is sum-of-squares) heteroagentoptions.multiGEweights=ones(1,length(fieldnames(GeneralEqmEqns))); % Weights on GECondns, when being combined heteroagentoptions.toleranceGEprices=10^(-4); % Accuracy of general eqm prices diff --git a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m index 252d2c34..07db5983 100644 --- a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m +++ b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType.m @@ -66,7 +66,7 @@ end if exist('heteroagentoptions','var')==0 - heteroagentoptions.fminalgo=1; % =1 use fminsearch. Main alternatives: =4 is shooting (you set update rules), =5 is CMA-ES (robust but slow), =8 is lsqnonlin() fast but requires Matlab Optimization Toolbox (and often not quite high accuracy of results) + heteroagentoptions.fminalgo=1; % =1 use fminsearch. Main alternatives: =4 is CMA-ES (robust but slow), =5 is shooting (you set update rules), =8 is lsqnonlin() fast but requires Matlab Optimization Toolbox (and often not quite high accuracy of results) heteroagentoptions.multiGEcriterion=1; % How to combine multiple GE condns (default is sum-of-squares) heteroagentoptions.multiGEweights=ones(1,length(fieldnames(GeneralEqmEqns))); % Weights on GECondns, when being combined heteroagentoptions.toleranceGEprices=10^(-4); % Accuracy of general eqm prices diff --git a/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1.m b/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1.m index 2dae0194..c55fadee 100644 --- a/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1.m +++ b/HeterogeneousAgent/InfHorz/HeteroAgentStationaryEqm_Case1.m @@ -76,7 +76,7 @@ end if exist('heteroagentoptions','var')==0 - heteroagentoptions.fminalgo=1; % =1 use fminsearch. Main alternatives: =4 is shooting (you set update rules), =5 is CMA-ES (robust but slow), =8 is lsqnonlin() fast but requires Matlab Optimization Toolbox (and often not quite high accuracy of results) + heteroagentoptions.fminalgo=1; % =1 use fminsearch. Main alternatives: =4 is CMA-ES (robust but slow), =5 is shooting (you set update rules), =8 is lsqnonlin() fast but requires Matlab Optimization Toolbox (and often not quite high accuracy of results) heteroagentoptions.multiGEcriterion=1; % How to combine multiple GE condns (default is sum-of-squares) heteroagentoptions.multiGEweights=ones(1,length(fieldnames(GeneralEqmEqns))); % Weights on GECondns, when being combined heteroagentoptions.toleranceGEprices=10^(-4); % Accuracy of general eqm prices diff --git a/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m b/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m index 9881174d..c40c3025 100644 --- a/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m +++ b/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType.m @@ -58,7 +58,7 @@ end if exist('heteroagentoptions','var')==0 - heteroagentoptions.fminalgo=1; % =1 use fminsearch. Main alternatives: =4 is shooting (you set update rules), =5 is CMA-ES (robust but slow), =8 is lsqnonlin() fast but requires Matlab Optimization Toolbox (and often not quite high accuracy of results) + heteroagentoptions.fminalgo=1; % =1 use fminsearch. Main alternatives: =4 is CMA-ES (robust but slow), =5 is shooting (you set update rules), =8 is lsqnonlin() fast but requires Matlab Optimization Toolbox (and often not quite high accuracy of results) heteroagentoptions.multiGEcriterion=1; % How to combine multiple GE condns (default is sum-of-squares) heteroagentoptions.multiGEweights=ones(1,length(fieldnames(GeneralEqmEqns))); % Weights on GECondns, when being combined heteroagentoptions.toleranceGEprices=10^(-4); % Accuracy of general eqm prices From 5bc73bd284af23a8ab81a59294691580de5225f8 Mon Sep 17 00:00:00 2001 From: robertdkirkby Date: Thu, 12 Mar 2026 12:11:42 +1300 Subject: [PATCH 63/67] value fn from policy --- .../ValueFnFromPolicyOnTransPath_InfHorz.m | 108 ++++++++++++++++++ ValueFnFromPolicy/ValueFnFromPolicy_InfHorz.m | 2 +- 2 files changed, 109 insertions(+), 1 deletion(-) create mode 100644 ValueFnFromPolicy/ValueFnFromPolicyOnTransPath_InfHorz.m diff --git a/ValueFnFromPolicy/ValueFnFromPolicyOnTransPath_InfHorz.m b/ValueFnFromPolicy/ValueFnFromPolicyOnTransPath_InfHorz.m new file mode 100644 index 00000000..d9322895 --- /dev/null +++ b/ValueFnFromPolicy/ValueFnFromPolicyOnTransPath_InfHorz.m @@ -0,0 +1,108 @@ +function VPath=ValueFnFromPolicyOnTransPath_InfHorz(PolicyPath,V_final,ParamPath,PricePath,n_d,n_a,n_z,d_grid,a_grid,z_grid, pi_z, ReturnFn, Parameters, DiscountFactorParamNames, vfoptions) + +if isfield(vfoptions,'exoticpreferences') + error('ValueFnFromPolicyOnTransPath_InfHorz() does not yet work with exotic preferences. Please ask on forum if you want/need this feature. \n'); +end +if isfield(vfoptions,'experienceasset') + if vfoptions.experienceasset==1 + error('ValueFnFromPolicyOnTransPath_InfHorz() does not yet work with experienceasset. Please ask on forum if you want/need this feature. \n'); + end +end + +N_d=prod(n_d); +N_a=prod(n_a); +N_z=prod(n_z); + +PolicyPath=reshape(PolicyPath,[size(PolicyPath,1),N_a,N_z,T]); + +if N_d==0 && isscalar(n_a) && vfoptions.gridinterplayer==0 + l_daprime=1; +else + l_daprime=size(PolicyPath,1); + if vfoptions.gridinterplayer==1 + l_daprime=l_daprime-1; + end +end +a_gridvals=CreateGridvals(n_a,a_grid,1); + +%% Switch to z_gridvals +l_z=length(n_z); +if all(size(z_grid)==[sum(n_z),1]) + z_gridvals=CreateGridvals(n_z,z_grid,1); % The 1 at end indicates want output in form of matrix. +elseif all(size(z_grid)==[prod(n_z),l_z]) + z_gridvals=z_grid; +end + +%% +% Note: Internally PricePath is matrix of size T-by-'number of prices'. +% ParamPath is matrix of size T-by-'number of parameters that change over the transition path'. +[PricePath,ParamPath,PricePathNames,ParamPathNames,PricePathSizeVec,ParamPathSizeVec]=PricePathParamPath_StructToMatrix(PricePath,ParamPath,T); + +% This code will work for all transition paths except those that involve at +% change in the transition matrix pi_z (can handle a change in pi_z, but +% only if it is a 'surprise', not anticipated changes) + +% PricePath is matrix of size T-by-'number of prices' +% ParamPath is matrix of size T-by-'number of parameters that change over path' + +% Remark to self: No real need for T as input, as this is anyway the length of PricePathOld + +% AgeWeightsParamNames are not actually needed as an input, but require +% them anyway to make it easier to 'copy-paste' input lists from other +% similar functions the user is likely to be using. + +%% Implement new way of handling ReturnFn inputs +ReturnFnParamNames=ReturnFnParamNamesFn(ReturnFn,n_d,n_a,n_z,0,vfoptions,Parameters); + +%% +d_grid=gpuArray(d_grid); +a_grid=gpuArray(a_grid); +pi_z=gpuArray(pi_z); +PricePath=gpuArray(PricePath); + +pi_z_howards=repelem(pi_z,N_a,1); + +%% +VPath=zeros(N_a,N_z,T,'gpuArray'); +VPath(:,:,T)=reshape(V_final,[N_a,N_z]); + +for ttr=1:T-1 + tt=T-ttr; % T-1 to 1 + + for kk=1:length(PricePathNames) + Parameters.(PricePathNames{kk})=PricePath(T-ttr,kk); + end + for kk=1:length(ParamPathNames) + Parameters.(ParamPathNames{kk})=ParamPath(T-ttr,kk); + end + + %% Calculate FofPolicy (the return fn evaluated at the Policy) + PolicyValues=PolicyInd2Val_Case1(PolicyPath(:,:,:,tt),n_d,n_a,n_z,d_grid,a_grid, vfoptions); + PolicyValuesPermute=permute(reshape(PolicyValues,[size(PolicyValues,1),N_a,N_z]),[2,3,1]); %[N_a,N_z,l_d+l_a] + + ReturnFnParamsCell=CreateCellFromParams(Parameters,ReturnFnParamNames); + FofPolicy=EvalFnOnAgentDist_Grid(ReturnFn, ReturnFnParamsCell,PolicyValuesPermute,l_daprime,n_a,n_z,a_gridvals,z_gridvals); + + %% Now that we have FofPolicy, calculate V. + DiscountFactorParamsVec=prod(CreateVectorFromParams(Parameters, DiscountFactorParamNames)); + + Policy=KronPolicyIndexes_Case1(PolicyPath(:,:,:,tt), n_d, n_a, n_z, vfoptions); + if N_d==0 + Policy_a=Policy; + else + Policy_a=shiftdim(ceil(Policy(2,:,:)),1); + end + + EVKrontemp=VPath(Policy_a,:,tt+1); + + EVKrontemp=EVKrontemp.*pi_z_howards; + EVKrontemp(isnan(EVKrontemp))=0; + EVKrontemp=reshape(sum(EVKrontemp,2),[N_a,N_z]); + + VPath(:,:,tt)=FofPolicy+DiscountFactorParamsVec*EVKrontemp; + +end + +VPath=reshape(VKron,[n_a,n_z,T]); + +end diff --git a/ValueFnFromPolicy/ValueFnFromPolicy_InfHorz.m b/ValueFnFromPolicy/ValueFnFromPolicy_InfHorz.m index 9735e1d8..98a005c6 100644 --- a/ValueFnFromPolicy/ValueFnFromPolicy_InfHorz.m +++ b/ValueFnFromPolicy/ValueFnFromPolicy_InfHorz.m @@ -7,7 +7,7 @@ else vfoptions.tolerance=10^(-9); if isfield(vfoptions,'exoticpreferences') - error('ValueFnFromPolicy_Case1() does not yet work with exotic preferences. Please ask on forum if you want/need this feature. \n'); + error('ValueFnFromPolicy_InfHorz() does not yet work with exotic preferences. Please ask on forum if you want/need this feature. \n'); end end From 5e144fd9fa7880eb238abde200c5e56d82feb675 Mon Sep 17 00:00:00 2001 From: Michael Tiemann Date: Thu, 12 Mar 2026 15:06:36 +1300 Subject: [PATCH 64/67] Ignored PTypes now listed with proper ordinal suffixes Fix a few typos and spell ordinals (1st, 2nd, 3rd, 4th) with proper suffixes. --- .../FHorz/PType/LifeCycleProfiles_FHorz_Case1_PType.m | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/EvaluateFnOnAgentDist/FHorz/PType/LifeCycleProfiles_FHorz_Case1_PType.m b/EvaluateFnOnAgentDist/FHorz/PType/LifeCycleProfiles_FHorz_Case1_PType.m index 03711775..98b31408 100644 --- a/EvaluateFnOnAgentDist/FHorz/PType/LifeCycleProfiles_FHorz_Case1_PType.m +++ b/EvaluateFnOnAgentDist/FHorz/PType/LifeCycleProfiles_FHorz_Case1_PType.m @@ -11,13 +11,13 @@ % jequaloneDist can either be same for all permanent types, or must be passed as a structure. % AgeWeightParamNames is either same for all permanent types, or must be passed as a structure. % -% The stationary distribution be a structure and will contain both the +% The stationary distribution must be a structure and will contain both the % weights/distribution across the permenant types, as well as a pdf for the % stationary distribution of each specific permanent type. % % How exactly to handle these differences between permanent (fixed) types % is to some extent left to the user. You can, for example, input -% parameters that differ by permanent type as a vector with different rows f +% parameters that differ by permanent type as a vector with different rows % for each type, or as a structure with different fields for each type. % % Any input that does not depend on the permanent type is just passed in @@ -176,7 +176,12 @@ ii=ii+1; Names_i{ii}=Names_i2{ii2}; else % tell the user about it - fprintf(['LifeCycleProfiles_FHorz_Case1_PType: Ignoring the ', num2str(ii2), '-th PType, ',Names_i2{ii2}, ' because it is infinite horizon \n']); + suffix='th'; + if ii2<4 % Good up to 20 PTypes + suffix_cells={'st', 'nd', 'rd'}; + suffix=suffix_cells{ii2}; + end + fprintf('LifeCycleProfiles_FHorz_Case1_PType: Ignoring the %d%s PType { %s } because it is infinite horizon \n', ii2, suffix, Names_i2{ii2}); end end % Eliminate any no longer relevant functions from FnsToEvaluate (those which are only used for infinite horizon) From 447e3265c4c157e4908536f1a17f0439b1ef43c6 Mon Sep 17 00:00:00 2001 From: Michael Tiemann Date: Thu, 12 Mar 2026 15:14:19 +1300 Subject: [PATCH 65/67] Relocate error message concerning non-finite return values Howards-greedy does not work with non-finite return values. Rather than testing whether we get any such and warning, we move the test inside the loop so that errors can be flagged closer to their initial appearance. This makes understanding and fixing such errors easier when debugging. --- ValueFnIter/InfHorz/ValueFnIter_nod_HowardGreedy_raw.m | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/ValueFnIter/InfHorz/ValueFnIter_nod_HowardGreedy_raw.m b/ValueFnIter/InfHorz/ValueFnIter_nod_HowardGreedy_raw.m index b1fb35bd..62c78ed9 100644 --- a/ValueFnIter/InfHorz/ValueFnIter_nod_HowardGreedy_raw.m +++ b/ValueFnIter/InfHorz/ValueFnIter_nod_HowardGreedy_raw.m @@ -37,7 +37,9 @@ if isfinite(currdist) && currdist/Tolerance>10 && tempcounter=maxiter warning('Value fn iteration has stopped due to reaching the maximum number of iterations (not due to convergence); can be set by vfoptions.maxiter.') end From d858db71515b6f767f4b7291091d21a4e587e796 Mon Sep 17 00:00:00 2001 From: Michael Tiemann Date: Fri, 13 Mar 2026 07:21:38 +1300 Subject: [PATCH 66/67] Incrementally push AggVars into PType parameter lists When evaluating agents in PType structures (such as firms and households), it happens that we can inject just-calculated AggVars into the Parameter lists of to-be evaluated PType structures, increasing the power and generality of using PTypes. Also update `HeteroAgentStationaryEqm_Case1_PType_subfn` to handle CustomModelStats. --- ...onaryEqm_Case1_FHorz_PType_GEptype_subfn.m | 44 +++++++++++- ...teroAgentStationaryEqm_Case1_PType_subfn.m | 68 +++++++++++-------- 2 files changed, 81 insertions(+), 31 deletions(-) diff --git a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_GEptype_subfn.m b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_GEptype_subfn.m index d2ffc13a..a158ecc3 100644 --- a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_GEptype_subfn.m +++ b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_GEptype_subfn.m @@ -31,7 +31,8 @@ Parameters.(GEPriceParamNames{pp})=GEpricesvec(GEpriceindexes(pp,1):GEpriceindexes(pp,2)); end -AggVars_ConditionalOnPType=zeros(PTypeStructure.numFnsToEvaluate,PTypeStructure.N_i,'gpuArray'); % Create AggVars conditional on ptype. +Ptype_cells=cell(1,PTypeStructure.N_i); % Hold results in case needed for CustomStats +AggVars_ConditionalOnPType=zeros(PTypeStructure.numFnsToEvaluate,PTypeStructure.N_i); % Create AggVars conditional on ptype. for ii=1:PTypeStructure.N_i @@ -66,18 +67,31 @@ AggVars_ii=EvalFnOnAgentDist_AggVars_Case1(StationaryDist_ii, Policy_ii, PTypeStructure.(iistr).FnsToEvaluate, PTypeStructure.(iistr).Parameters, PTypeStructure.(iistr).FnsToEvaluateParamNames, PTypeStructure.(iistr).n_d, PTypeStructure.(iistr).n_a, PTypeStructure.(iistr).n_z, PTypeStructure.(iistr).d_grid, PTypeStructure.(iistr).a_grid, PTypeStructure.(iistr).z_gridvals_J, PTypeStructure.(iistr).simoptions); end + if heteroagentoptions.useCustomModelStats==1 + Ptype_cells{ii}={V_ii,Policy_ii,StationaryDist_ii}; + end AggVars_ConditionalOnPType(PTypeStructure.(iistr).FnsAndPTypeIndicator_ii,ii)=AggVars_ii; + % Put updated AggVars into subsequent PTypeStructure Parameters, so they can be used for subsequent PType evaluations + FnsToEvaluate_aa=fieldnames(PTypeStructure.(iistr).FnsToEvaluate); + for jj=ii+1:PTypeStructure.N_i + jjstr=PTypeStructure.iistr{jj}; + for aa=1:length(AggVars_ii) + PTypeStructure.(jjstr).Parameters.(FnsToEvaluate_aa{aa})=AggVars_ii(aa); + end + end end AggVars=sum(AggVars_ConditionalOnPType.*PTypeStructure.ptweights,2); % Note: AggVars is a vector -%% Put GE parameters and AggVars in structure, so they can be used for intermediateEqns and GeneralEqmEqns +%% Put GE parameters and AggVars in structure, so they can be used for intermediateEqns and GeneralEqmEqns % already did the basic GE params % for pp=1:nGEprices % Parameters.(GEPriceParamNames{pp})=GEprices(GEpriceindexes(pp,1):GEpriceindexes(pp,2)); % end + +% We pushed AggVars down into the PTypeStructure parameters; this puts them into the unified Parameter structure for aa=1:length(AggVarNames) Parameters.(AggVarNames{aa})=AggVars(aa); end @@ -138,6 +152,32 @@ end end +%% Custom Model Stats +customstatnames=struct(); +if heteroagentoptions.useCustomModelStats==1 + if isfield(heteroagentoptions, 'CustomModelStats') + error("Universal PType handler for CustomModelStats not yet implemented") + else + for ii=1:PTypeStructure.N_i + iistr=PTypeStructure.iistr{ii}; + if ~isfield(heteroagentoptions, iistr) || ~isfield(heteroagentoptions.(iistr), 'CustomModelStats') + continue + end + if isfinite(PTypeStructure.(iistr).N_j) + CustomStats.(iistr)=heteroagentoptions.(iistr).CustomModelStats(Ptype_cells{ii}{1},Ptype_cells{ii}{2},Ptype_cells{ii}{3},PTypeStructure.(iistr).Parameters,PTypeStructure.(iistr).FnsToEvaluate,PTypeStructure.(iistr).n_d,PTypeStructure.(iistr).n_a,PTypeStructure.(iistr).n_z,PTypeStructure.(iistr).N_j,PTypeStructure.(iistr).d_grid,PTypeStructure.(iistr).a_grid,PTypeStructure.(iistr).z_gridvals_J,PTypeStructure.(iistr).pi_z_J,heteroagentoptions,PTypeStructure.(iistr).vfoptions,PTypeStructure.(iistr).simoptions); + else + CustomStats.(iistr)=heteroagentoptions.(iistr).CustomModelStats(Ptype_cells{ii}{1},Ptype_cells{ii}{2},Ptype_cells{ii}{3},PTypeStructure.(iistr).Parameters,PTypeStructure.(iistr).FnsToEvaluate,PTypeStructure.(iistr).n_d,PTypeStructure.(iistr).n_a,PTypeStructure.(iistr).n_z,PTypeStructure.(iistr).d_grid,PTypeStructure.(iistr).a_grid,PTypeStructure.(iistr).z_gridvals,PTypeStructure.(iistr).pi_z,heteroagentoptions,PTypeStructure.(iistr).vfoptions,PTypeStructure.(iistr).simoptions); + end + % Note: anything else you want, just 'hide' it in heteroagentoptions + customstatnames.(iistr)=fieldnames(CustomStats.(iistr)); + for pp=1:length(customstatnames.(iistr)) + PTypeStructure.(iistr).Parameters.(customstatnames.(iistr){pp})=CustomStats.(iistr).(customstatnames.(iistr){pp}); + end + end + end +end + + %% Evaluate the General Eqm Eqns % use of real() is a hack that could disguise errors, but I couldn't find why matlab was treating output as complex diff --git a/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType_subfn.m b/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType_subfn.m index 71c7625f..c42c3c97 100644 --- a/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType_subfn.m +++ b/HeterogeneousAgent/InfHorz/PType/HeteroAgentStationaryEqm_Case1_PType_subfn.m @@ -32,11 +32,8 @@ %% -if heteroagentoptions.parallel==2 - AggVars=zeros(PTypeStructure.numFnsToEvaluate,1,'gpuArray'); % numFnsToEvaluate is independent of the ptype -else - AggVars=zeros(PTypeStructure.numFnsToEvaluate,1); % numFnsToEvaluate is independent of the ptype -end +Ptype_cells=cell(1,PTypeStructure.N_i); % Hold results in case needed for CustomStats +AggVars_ConditionalOnPType=zeros(PTypeStructure.numFnsToEvaluate,PTypeStructure.N_i); % Create AggVars conditional on ptype. for ii=1:PTypeStructure.N_i @@ -59,22 +56,21 @@ StationaryDist_ii=StationaryDist_Case1(Policy_ii,PTypeStructure.(iistr).n_d,PTypeStructure.(iistr).n_a,PTypeStructure.(iistr).n_z,PTypeStructure.(iistr).pi_z,PTypeStructure.(iistr).simoptions,PTypeStructure.(iistr).Parameters); % PTypeStructure.(iistr).simoptions.outputasstructure=0; % Want AggVars_ii as matrix to make it easier to add them across the PTypes (is set outside this script) AggVars_ii=EvalFnOnAgentDist_AggVars_Case1(StationaryDist_ii, Policy_ii, PTypeStructure.(iistr).FnsToEvaluate, PTypeStructure.(iistr).Parameters, PTypeStructure.(iistr).FnsToEvaluateParamNames, PTypeStructure.(iistr).n_d, PTypeStructure.(iistr).n_a, PTypeStructure.(iistr).n_z, PTypeStructure.(iistr).d_grid, PTypeStructure.(iistr).a_grid, PTypeStructure.(iistr).z_grid, PTypeStructure.(iistr).simoptions); - - for kk=1:PTypeStructure.numFnsToEvaluate - jj=PTypeStructure.(iistr).WhichFnsForCurrentPType(kk); - if jj>0 - AggVars(kk)=AggVars(kk)+PTypeStructure.(iistr).PTypeWeight*AggVars_ii(jj); + if heteroagentoptions.useCustomModelStats==1 + Ptype_cells{ii}={V_ii,Policy_ii,StationaryDist_ii}; + end + AggVars_ConditionalOnPType(PTypeStructure.(iistr).FnsAndPTypeIndicator_ii,ii)=AggVars_ii; + % Put updated AggVars into subsequent PTypeStructure Parameters, so they can be used for subsequent PType evaluations + FnsToEvaluate_aa=fieldnames(PTypeStructure.(iistr).FnsToEvaluate); + for jj=ii+1:PTypeStructure.N_i + jjstr=PTypeStructure.iistr{jj}; + for aa=1:length(AggVars_ii) + PTypeStructure.(jjstr).Parameters.(FnsToEvaluate_aa{aa})=AggVars_ii(aa); end end - - % if heteroagentoptions.useCustomModelStats==1 - % % Need to keep a bunch of stuff just in case - % V.(iistr)=V_ii; - % Policy.(iistr)=Policy_ii; - % StationaryDist.(iistr)=StationaryDist_ii; - % end end - +AggVars=sum(AggVars_ConditionalOnPType.*PTypeStructure.ptweights,2); +% Note: AggVars is a vector %% Put GE parameters and AggVars in structure, so they can be used for intermediateEqns and GeneralEqmEqns @@ -82,21 +78,12 @@ % for pp=1:nGEprices % Parameters.(GEPriceParamNames{pp})=GEprices(pp); % end + +% We pushed AggVars down into the PTypeStructure parameters; this puts them into the unified Parameter structure for aa=1:length(AggVarNames) Parameters.(AggVarNames{aa})=AggVars(aa); end -%% Custom Model Stats -if heteroagentoptions.useCustomModelStats==1 - error('CustomModelStats not yet implemented for use with permanent types in InfHorz') - % CustomStats=heteroagentoptions.CustomModelStats(V,Policy,StationaryDist,Parameters,FnsToEvaluate,n_d,n_a,n_z,d_grid,a_grid,z_gridvals,pi_z,heteroagentoptions,vfoptions,simoptions); - % % Note: anything else you want, just 'hide' it in heteroagentoptions - % customstatnames=fieldnames(CustomStats); - % for pp=1:length(customstatnames) - % Parameters.(customstatnames{pp})=CustomStats.(customstatnames{pp}); - % end -end - %% Intermediate Eqns if heteroagentoptions.useintermediateEqns==1 % Note: intermediateEqns just take in things from the Parameters structure, as do GeneralEqmEqns (AggVars get put into structure), hence just use the GeneralEqmConditions_Case1_v3g(). @@ -109,6 +96,29 @@ end end +%% Custom Model Stats +customstatnames=struct(); +if heteroagentoptions.useCustomModelStats==1 + if isfield(heteroagentoptions, 'CustomModelStats') + error("Universal PType handler for CustomModelStats not yet implemented") + else + for ii=1:PTypeStructure.N_i + iistr=PTypeStructure.iistr{ii}; + if ~isfield(heteroagentoptions, iistr) || ~isfield(heteroagentoptions.(iistr), 'CustomModelStats') + continue + end + CustomStats.(iistr)=heteroagentoptions.(iistr).CustomModelStats(Ptype_cells{ii}{1},Ptype_cells{ii}{2},Ptype_cells{ii}{3},PTypeStructure.(iistr).Parameters,PTypeStructure.(iistr).FnsToEvaluate,PTypeStructure.(iistr).n_d,PTypeStructure.(iistr).n_a,PTypeStructure.(iistr).n_z,PTypeStructure.(iistr).d_grid,PTypeStructure.(iistr).a_grid,PTypeStructure.(iistr).z_gridvals,PTypeStructure.(iistr).pi_z,heteroagentoptions,PTypeStructure.(iistr).vfoptions,PTypeStructure.(iistr).simoptions); + % Note: anything else you want, just 'hide' it in heteroagentoptions + customstatnames.(iistr)=fieldnames(CustomStats.(iistr)); + for pp=1:length(customstatnames.(iistr)) + PTypeStructure.(iistr).Parameters.(customstatnames.(iistr){pp})=CustomStats.(iistr).(customstatnames.(iistr){pp}); + end + end + end +end + + + %% Evaluate General Eqm Eqns % use of real() is a hack that could disguise errors, but I couldn't find why matlab was treating output as complex GeneralEqmConditionsVec=zeros(1,length(GEeqnNames)); From 281b314fc2168cd44f4a86e07dc67bf05dac24a5 Mon Sep 17 00:00:00 2001 From: Michael Tiemann Date: Fri, 13 Mar 2026 07:21:38 +1300 Subject: [PATCH 67/67] Incrementally push AggVars into PType parameter lists When evaluating agents in PType structures (such as firms and households), it happens that we can inject just-calculated AggVars into the Parameter lists of to-be evaluated PType structures, increasing the power and generality of using PTypes. Also update `HeteroAgentStationaryEqm_Case1_PType_subfn` to handle CustomModelStats. --- ...entStationaryEqm_Case1_FHorz_PType_subfn.m | 63 ++++++++++++++----- 1 file changed, 48 insertions(+), 15 deletions(-) diff --git a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_subfn.m b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_subfn.m index d268e3d1..78ff6ef9 100644 --- a/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_subfn.m +++ b/HeterogeneousAgent/FHorz/PType/HeteroAgentStationaryEqm_Case1_FHorz_PType_subfn.m @@ -32,7 +32,8 @@ end %% -AggVars_ConditionalOnPType=zeros(PTypeStructure.numFnsToEvaluate,PTypeStructure.N_i,'gpuArray'); % Create AggVars conditional on ptype. +Ptype_cells=cell(1,PTypeStructure.N_i); % Hold results in case needed for CustomStats +AggVars_ConditionalOnPType=zeros(PTypeStructure.numFnsToEvaluate,PTypeStructure.N_i); % Create AggVars conditional on ptype. for ii=1:PTypeStructure.N_i @@ -52,29 +53,41 @@ if isfinite(PTypeStructure.(iistr).N_j) - [~, Policy_ii]=ValueFnIter_Case1_FHorz(PTypeStructure.(iistr).n_d,PTypeStructure.(iistr).n_a,PTypeStructure.(iistr).n_z,PTypeStructure.(iistr).N_j,PTypeStructure.(iistr).d_grid, PTypeStructure.(iistr).a_grid, PTypeStructure.(iistr).z_gridvals_J, PTypeStructure.(iistr).pi_z_J, PTypeStructure.(iistr).ReturnFn, PTypeStructure.(iistr).Parameters, PTypeStructure.(iistr).DiscountFactorParamNames, PTypeStructure.(iistr).ReturnFnParamNames, PTypeStructure.(iistr).vfoptions); + [V_ii, Policy_ii]=ValueFnIter_Case1_FHorz(PTypeStructure.(iistr).n_d,PTypeStructure.(iistr).n_a,PTypeStructure.(iistr).n_z,PTypeStructure.(iistr).N_j,PTypeStructure.(iistr).d_grid, PTypeStructure.(iistr).a_grid, PTypeStructure.(iistr).z_gridvals_J, PTypeStructure.(iistr).pi_z_J, PTypeStructure.(iistr).ReturnFn, PTypeStructure.(iistr).Parameters, PTypeStructure.(iistr).DiscountFactorParamNames, PTypeStructure.(iistr).ReturnFnParamNames, PTypeStructure.(iistr).vfoptions); StationaryDist_ii=StationaryDist_FHorz_Case1(PTypeStructure.(iistr).jequaloneDist,PTypeStructure.(iistr).AgeWeightParamNames,Policy_ii,PTypeStructure.(iistr).n_d,PTypeStructure.(iistr).n_a,PTypeStructure.(iistr).n_z,PTypeStructure.(iistr).N_j,PTypeStructure.(iistr).pi_z_J,PTypeStructure.(iistr).Parameters,PTypeStructure.(iistr).simoptions); % PTypeStructure.(iistr).simoptions.outputasstructure=0; % Want AggVars_ii as matrix to make it easier to add them across the PTypes (is set outside this script) AggVars_ii=EvalFnOnAgentDist_AggVars_FHorz_Case1(StationaryDist_ii, Policy_ii, PTypeStructure.(iistr).FnsToEvaluate, PTypeStructure.(iistr).Parameters, PTypeStructure.(iistr).FnsToEvaluateParamNames, PTypeStructure.(iistr).n_d, PTypeStructure.(iistr).n_a, PTypeStructure.(iistr).n_z, PTypeStructure.(iistr).N_j, PTypeStructure.(iistr).d_grid, PTypeStructure.(iistr).a_grid, PTypeStructure.(iistr).z_gridvals_J, PTypeStructure.(iistr).simoptions); else % PType actually allows for infinite horizon as well - [~, Policy_ii]=ValueFnIter_Case1(PTypeStructure.(iistr).n_d,PTypeStructure.(iistr).n_a,PTypeStructure.(iistr).n_z,PTypeStructure.(iistr).d_grid, PTypeStructure.(iistr).a_grid, PTypeStructure.(iistr).z_gridvals_J, PTypeStructure.(iistr).pi_z_J, PTypeStructure.(iistr).ReturnFn, PTypeStructure.(iistr).Parameters, PTypeStructure.(iistr).DiscountFactorParamNames, PTypeStructure.(iistr).ReturnFnParamNames, PTypeStructure.(iistr).vfoptions); - StationaryDist_ii=StationaryDist_Case1(Policy_ii,PTypeStructure.(iistr).n_d,PTypeStructure.(iistr).n_a,PTypeStructure.(iistr).n_z,PTypeStructure.(iistr).pi_z_J,PTypeStructure.(iistr).simoptions,PTypeStructure.(iistr).Parameters); + [V_ii, Policy_ii]=ValueFnIter_Case1(PTypeStructure.(iistr).n_d,PTypeStructure.(iistr).n_a,PTypeStructure.(iistr).n_z,PTypeStructure.(iistr).d_grid, PTypeStructure.(iistr).a_grid, PTypeStructure.(iistr).z_gridvals, PTypeStructure.(iistr).pi_z, PTypeStructure.(iistr).ReturnFn, PTypeStructure.(iistr).Parameters, PTypeStructure.(iistr).DiscountFactorParamNames, PTypeStructure.(iistr).ReturnFnParamNames, PTypeStructure.(iistr).vfoptions); + StationaryDist_ii=StationaryDist_Case1(Policy_ii,PTypeStructure.(iistr).n_d,PTypeStructure.(iistr).n_a,PTypeStructure.(iistr).n_z,PTypeStructure.(iistr).pi_z,PTypeStructure.(iistr).simoptions,PTypeStructure.(iistr).Parameters); % PTypeStructure.(iistr).simoptions.outputasstructure=0; % Want AggVars_ii as matrix to make it easier to add them across the PTypes (is set outside this script) - AggVars_ii=EvalFnOnAgentDist_AggVars_Case1(StationaryDist_ii, Policy_ii, PTypeStructure.(iistr).FnsToEvaluate, PTypeStructure.(iistr).Parameters, PTypeStructure.(iistr).FnsToEvaluateParamNames, PTypeStructure.(iistr).n_d, PTypeStructure.(iistr).n_a, PTypeStructure.(iistr).n_z, PTypeStructure.(iistr).d_grid, PTypeStructure.(iistr).a_grid, PTypeStructure.(iistr).z_gridvals_J, PTypeStructure.(iistr).simoptions); + AggVars_ii=EvalFnOnAgentDist_AggVars_Case1(StationaryDist_ii, Policy_ii, PTypeStructure.(iistr).FnsToEvaluate, PTypeStructure.(iistr).Parameters, PTypeStructure.(iistr).FnsToEvaluateParamNames, PTypeStructure.(iistr).n_d, PTypeStructure.(iistr).n_a, PTypeStructure.(iistr).n_z, PTypeStructure.(iistr).d_grid, PTypeStructure.(iistr).a_grid, PTypeStructure.(iistr).z_gridvals, PTypeStructure.(iistr).simoptions); + end + if heteroagentoptions.useCustomModelStats==1 + Ptype_cells{ii}={V_ii,Policy_ii,StationaryDist_ii}; end - AggVars_ConditionalOnPType(PTypeStructure.(iistr).FnsAndPTypeIndicator_ii,ii)=AggVars_ii; + % Put updated AggVars into subsequent PTypeStructure Parameters, so they can be used for subsequent PType evaluations + FnsToEvaluate_aa=fieldnames(PTypeStructure.(iistr).FnsToEvaluate); + for jj=ii+1:PTypeStructure.N_i + jjstr=PTypeStructure.iistr{jj}; + for aa=1:length(AggVars_ii) + PTypeStructure.(jjstr).Parameters.(FnsToEvaluate_aa{aa})=AggVars_ii(aa); + end + end end -AggVars=gather(sum(AggVars_ConditionalOnPType.*PTypeStructure.ptweights,2)); +AggVars=sum(AggVars_ConditionalOnPType.*PTypeStructure.ptweights,2); % Note: AggVars is a vector -%% Put GE parameters and AggVars in structure, so they can be used for intermediateEqns and GeneralEqmEqns +%% Put GE parameters and AggVars in structure, so they can be used for intermediateEqns and GeneralEqmEqns % already did the basic GE params % for pp=1:nGEprices % Parameters.(GEPriceParamNames{pp})=GEprices(pp); % end + +% We pushed AggVars down into the PTypeStructure parameters; this puts them into the unified Parameter structure for aa=1:length(AggVarNames) Parameters.(AggVarNames{aa})=AggVars(aa); end @@ -92,12 +105,27 @@ end %% Custom Model Stats +customstatnames=struct(); if heteroagentoptions.useCustomModelStats==1 - CustomStats=heteroagentoptions.CustomModelStats(V,Policy,StationaryDist,Parameters,FnsToEvaluate,n_d,n_a,n_z,d_grid,a_grid,z_gridvals,pi_z,heteroagentoptions,vfoptions,simoptions); - % Note: anything else you want, just 'hide' it in heteroagentoptions - customstatnames=fieldnames(CustomStats); - for pp=1:length(customstatnames) - Parameters.(customstatnames{pp})=CustomStats.(customstatnames{pp}); + if isfield(heteroagentoptions, 'CustomModelStats') + error("Universal PType handler for CustomModelStats not yet implemented") + else + for ii=1:PTypeStructure.N_i + iistr=PTypeStructure.iistr{ii}; + if ~isfield(heteroagentoptions, iistr) || ~isfield(heteroagentoptions.(iistr), 'CustomModelStats') + continue + end + if isfinite(PTypeStructure.(iistr).N_j) + CustomStats.(iistr)=heteroagentoptions.(iistr).CustomModelStats(Ptype_cells{ii}{1},Ptype_cells{ii}{2},Ptype_cells{ii}{3},PTypeStructure.(iistr).Parameters,PTypeStructure.(iistr).FnsToEvaluate,PTypeStructure.(iistr).n_d,PTypeStructure.(iistr).n_a,PTypeStructure.(iistr).n_z,PTypeStructure.(iistr).N_j,PTypeStructure.(iistr).d_grid,PTypeStructure.(iistr).a_grid,PTypeStructure.(iistr).z_gridvals_J,PTypeStructure.(iistr).pi_z_J,heteroagentoptions,PTypeStructure.(iistr).vfoptions,PTypeStructure.(iistr).simoptions); + else + CustomStats.(iistr)=heteroagentoptions.(iistr).CustomModelStats(Ptype_cells{ii}{1},Ptype_cells{ii}{2},Ptype_cells{ii}{3},PTypeStructure.(iistr).Parameters,PTypeStructure.(iistr).FnsToEvaluate,PTypeStructure.(iistr).n_d,PTypeStructure.(iistr).n_a,PTypeStructure.(iistr).n_z,PTypeStructure.(iistr).d_grid,PTypeStructure.(iistr).a_grid,PTypeStructure.(iistr).z_gridvals,PTypeStructure.(iistr).pi_z,heteroagentoptions,PTypeStructure.(iistr).vfoptions,PTypeStructure.(iistr).simoptions); + end + % Note: anything else you want, just 'hide' it in heteroagentoptions + customstatnames.(iistr)=fieldnames(CustomStats.(iistr)); + for pp=1:length(customstatnames.(iistr)) + PTypeStructure.(iistr).Parameters.(customstatnames.(iistr){pp})=CustomStats.(iistr).(customstatnames.(iistr){pp}); + end + end end end @@ -154,8 +182,13 @@ end if heteroagentoptions.useCustomModelStats==1 fprintf('Current CustomModelStats variables: \n') - for ii=1:length(customstatnames) - fprintf(heteroagentoptions.verboseaccuracy1,customstatnames{ii},CustomStats.(customstatnames{ii})) + for ii=1:PTypeStructure.N_i + iistr=PTypeStructure.iistr{ii}; + if isfield(customstatnames, iistr) + for pp=1:length(customstatnames.(iistr)) + fprintf(heteroagentoptions.verboseaccuracy1,customstatnames.(iistr){pp},CustomStats.(iistr).(customstatnames.(iistr){pp})) + end + end end end fprintf('Current GeneralEqmEqns: \n')