! Copyright © 2025-2026 Dynare Team
!
! This file is part of Dynare.
!
! Dynare is free software: you can redistribute it and/or modify it under the terms of the
! GNU General Public License as published by the Free Software Foundation, either version 3 of
! the License, or (at your option) any later version.
!
! Dynare is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
! even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! GNU General Public License for more details.
!
! You should have received a copy of the GNU General Public License along with Dynare. If not,
! see .
!
! Original author: Normann Rion
!
! Expected value and derivative computation for policy functions
module expectations
use iso_fortran_env, only: real64, int32
use blas
use gray_code
implicit none (type, external)
contains
! Compute 𝔼[x̄ₐ|θ,a], one-state case
subroutine compute_expected_dx_1d(E, x, mu, ind, inv_h)
! Inputs/Outpus
real(real64), contiguous, intent(out) :: E(:,:,:)
real(real64), contiguous, intent(in), target :: x(:,:)
real(real64), contiguous, intent(in) :: mu(:,:), inv_h(:,:)
integer(int32), contiguous, intent(in) :: ind(:,:)
! Useful variables
real(real64), allocatable :: Y_flat(:,:)
real(real64), target, allocatable :: Dx_flat(:,:)
real(real64), pointer, contiguous :: x_bar_dash(:,:,:)
integer(int32) :: N_x, N_sp, N_a, N_e, i, a, j, j_a, j_e
! Sizes
N_x = size(x,1,int32)
N_sp = size(x,2,int32)
N_e = size(mu,1,int32)
N_a = N_sp / N_e
! Reshape of x
x_bar_dash(1:N_x,1:N_e,1:N_a) => x
! First difference w.r.t the state
allocate(Dx_flat(N_x*(N_a-1),N_e))
do concurrent (j=1:N_a-1, i=1:N_x)
Dx_flat((j-1)*N_x+i,:) = x_bar_dash(i,:,j+1)-x_bar_dash(i,:,j)
end do
! Weighting with the transition matrix
allocate(Y_flat(N_x*(N_a-1), N_e))
call matmul_add("N", "T", 1.0_real64, Dx_flat, mu, 0.0_real64, Y_flat)
! Final calculation
do concurrent (j_a=1:N_a, j_e=1:N_e)
j = (j_a-1)*N_e+j_e
a = ind(j,1)
E(:,1,j) = inv_h(j,1) * Y_flat((a-1)*N_x+1:a*N_x, j_e)
end do
end subroutine compute_expected_dx_1d
! Compute 𝔼[x̄ₐ|θ,a], n-state case
subroutine compute_expected_dx_nd(E, x, mu, ind, w, inv_h, dims)
! Inputs/Outpus
real(real64), contiguous, intent(out) :: E(:,:,:)
real(real64), contiguous, intent(in), target :: x(:,:), w(:,:)
real(real64), contiguous, intent(in) :: mu(:,:), inv_h(:,:)
integer(int32), contiguous, intent(in), target :: ind(:,:)
integer(int32), contiguous, intent(in) :: dims(:)
! Useful variables
real(real64) :: beta
real(real64), pointer, contiguous :: x_bar_dash(:,:,:)
real(real64), allocatable :: Y(:,:), beta_0(:), beta_k(:), r_up(:,:), r_down(:,:), x_bar_dash_mat(:,:)
integer(int32) :: N_x, N_sp, N_a, N_e, n, Kcorn, t, i, j_a, j_e, j, k, l_a, kf, z
integer(int32), allocatable :: flip_idx(:), a(:), stride(:)
logical, allocatable :: is_hard_one(:,:), is_hard_zero(:,:), sk(:)
N_x = size(x,1,int32)
N_sp = size(x,2,int32)
N_e = size(mu,1,int32)
N_a = N_sp / N_e
n = size(E,2,int32)
! Useful reshape of x
x_bar_dash(1:N_x,1:N_e,1:N_a) => x
! Generate flip indices using Gray code
call generate_flip_indices(n, flip_idx)
Kcorn = ishft(1, n)
! ---- Strides for state-only linear indices (1..N_a) ----
call compute_strides(dims, stride)
! Low-corner linear indices in 1, ..., N_a
allocate(a(N_sp))
call compute_linear_indices(ind, stride, a)
! Coefficient updates and hard dimensions
allocate(r_up(N_sp, n), r_down(N_sp, n), is_hard_one(N_sp, n), is_hard_zero(N_sp, n))
call compute_coefficient_updates(w, r_up, r_down, is_hard_one, is_hard_zero)
! Low corner initial weight
allocate(beta_0(N_sp))
beta_0 = product(w, dim=2, mask=(.not. is_hard_zero))
! Weighting with the transition matrix
allocate(Y(N_x*N_a,N_e), x_bar_dash_mat(N_x*N_a,N_e))
do concurrent (j_a=1:N_a,j_e=1:N_e,i=1:N_x)
x_bar_dash_mat((j_a-1)*N_x+i,j_e) = x_bar_dash(i,j_e,j_a)
end do
call matmul_add("N", "T", 1.0_real64, x_bar_dash_mat, mu, 0.0_real64, Y)
! ---- Expectations ----
allocate(sk(n), beta_k(N_sp))
do k=1, n
beta_k = beta_0
where (.not. is_hard_zero(:,k)) beta_k = beta_k / w(:,k)
do j_a=1,N_a
do j_e=1,N_e
! do concurrent (j_a=1:N_a, j_e=1:N_e)
! Linear index
j = (j_a-1)*N_e+j_e
! Initialization
beta = -inv_h(j,k)*beta_k(j)
sk = .false.
z = count(is_hard_zero(j,:))
l_a = a(j)
if (z == 0_int32) then
E(:,k,j) = beta*Y((l_a-1)*N_x+1:l_a*N_x,j_e)
else
E(:,k,j) = 0.0_real64
end if
! Remaining corners
do t=1, Kcorn-1
kf = flip_idx(t)
if (kf == k) then
beta = -beta
if (.not. sk(kf)) then
! lower -> upper on dim kf
l_a = l_a + stride(kf)
sk(kf) = .true.
else
! upper -> lower
l_a = l_a - stride(kf)
sk(kf) = .false.
end if
else
if (.not. sk(kf)) then
! lower -> upper on dim kf
l_a = l_a + stride(kf)
sk(kf) = .true.
if (is_hard_one(j,kf)) then
! No contribution. The number of
! hard-one dims flipped to upper increases
z = z+1_int32
else if (is_hard_zero(j,kf)) then
! No contribution. The number of
! hard-zero dims flipped to lower decreases
z = z-1_int32
else
! Both sides are higher than 0, but
! there is a contribution if and only
! if no hard dims is flipped to upper
beta = beta*r_up(j,kf)
end if
else
! upper -> lower on dim kf
l_a = l_a - stride(kf)
sk(kf) = .false.
if (is_hard_one(j,kf)) then
z = z-1_int32
else if (is_hard_zero(j,kf)) then
z = z+1_int32
else
! Both sides are higher than 0, but
! there is a contribution if and only
! if no hard dims is flipped to upper
beta = beta*r_down(j,kf)
end if
end if
end if
if (z==0_int32) E(:,k,j) = E(:,k,j)+beta*Y((l_a-1)*N_x+1:l_a*N_x,j_e)
end do
end do
end do
end do
end subroutine compute_expected_dx_nd
subroutine compute_expected_y(E, y, mu, ind, w, dims)
! Inputs/Outpus
real(real64), contiguous, intent(out) :: E(:,:)
real(real64), contiguous, intent(in), target :: y(:,:)
real(real64), contiguous, intent(in) :: mu(:,:), w(:,:)
integer(int32), contiguous, intent(in), target :: ind(:,:)
integer(int32), contiguous, intent(in) :: dims(:)
! Local variables
real(real64), pointer, contiguous :: y_ptr(:,:) => null()
real(real64), allocatable, target :: y_mat(:,:)
real(real64), allocatable :: beta(:), r_up(:,:), r_down(:,:)
integer(int32) :: n, N_e, N_a, N_om, S, Kcorn, t, kf, i, j, m
integer(int32), allocatable :: flip_idx(:), z(:), stride(:), a(:)
logical, allocatable :: sk(:), is_hard_one(:,:), is_hard_zero(:,:)
! Size variables
n = size(dims, 1, int32)
N_e = size(mu, 1, int32)
N_om = size(y, 1, int32)
N_a = N_om/N_e
S = size(y, 2, int32)
! Generate flip indices using Gray code
call generate_flip_indices(n, flip_idx)
Kcorn = ishft(1, n)
! ---- Strides for state-only linear indices (1..N_a) ----
call compute_strides(dims, stride)
! Low-corner linear indices in 1, ..., N_a
allocate(a(N_om))
call compute_linear_indices(ind, stride, a)
! Fetch it into 1, ..., N_om
do concurrent (j=1:N_a, i=1:N_e)
a((j-1_int32)*N_e+i) = (a((j-1_int32)*N_e+i)-1)*N_e+i
end do
! Coefficient updates and hard dimensions
allocate(r_up(N_om, n), r_down(N_om, n), is_hard_one(N_om, n), is_hard_zero(N_om, n))
call compute_coefficient_updates(w, r_up, r_down, is_hard_one, is_hard_zero)
! Low corner initial weight
allocate(beta(N_om))
beta = product(w, dim=2, mask=(.not. is_hard_zero))
! Weighting with the Mu matrix
y_ptr(1:N_e,1:(N_a*S))=>y
allocate(y_mat(N_e,N_a*S))
call matmul_add("N", "N", 1.0_real64, mu, y_ptr, 0.0_real64, y_mat)
y_ptr(1:N_om,1:S)=>y_mat
! Computes ℰ(i, j, s) = sum_{i'} sum_{j'} [ ∏_ℓ (B^ℓ)_{j'_ℓ, i, j} ] *
! y_{i', j', s} * μ_{i,i'}. Note that the i and j dimensions are merged
! in the following calculation
allocate(sk(n),z(N_om))
! Initialization at the low corner
sk = .false.
z = count(is_hard_zero, dim=2)
do concurrent (j=1:N_om, m=1:S)
if (z(j) == 0_int32) then
E(j,m) = beta(j)*y_ptr(a(j),m)
else
E(j,m) = 0.0_real64
end if
end do
stride = stride * N_e
! Going through the remaining corners
do t=1,Kcorn-1
kf = flip_idx(t)
if (.not. sk(kf)) then
! lower -> upper on dim kf
a = a + stride(kf)
sk(kf) = .true.
do concurrent (j=1:N_om)
if (is_hard_one(j,kf)) then
! For nodes with a hard-one kf dim, the number of hard dims flipped
! to upper increases
z(j) = z(j)+1_int32
else if (is_hard_zero(j,kf)) then
! For nodes with a hard-zero kf dim, the number of hard dims flipped
! to lower decreases
z(j) = z(j)-1_int32
else
! For nodes with a soft kf dim, we update the beta
! coefficient
beta(j) = beta(j)*r_up(j,kf)
end if
end do
else
! upper -> lower on dim kf
a = a - stride(kf)
sk(kf) = .false.
do concurrent (j=1:N_om)
if (is_hard_one(j,kf)) then
! For nodes with a hard-one kf dim, the number of hard dims flipped
! to upper decreases
z(j) = z(j)-1_int32
else if (is_hard_zero(j,kf)) then
! For nodes with a hard-zero kf dim, the number of hard dims flipped
! to lower increases
z(j) = z(j)+1_int32
else
! For nodes with a soft kf dim, we update the beta
! coefficient
beta(j) = beta(j)*r_down(j,kf)
end if
end do
end if
do concurrent (j=1:N_om)
if (z(j) == 0_int32) then
do m=1,S
E(j,m) = E(j,m) + beta(j) * y_ptr(a(j),m)
end do
end if
end do
end do
end subroutine compute_expected_y
end module expectations