! 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
!
! Markov chain utilities (Rouwenhorst discretization, stationary distribution)
module markov
use iso_fortran_env, only: real64, int32
implicit none (type, external)
contains
!---------------------------------------------------------------------------
! Discretize AR(1) process using Rouwenhorst method
!
! Computes transition matrix P_mat, stationary distribution p_vec, and
! productivity grid y = exp(s) normalized so that E[y] = 1.
!
! Arguments:
! rho [in] : AR(1) persistence parameter
! sigma [in] : AR(1) innovation standard deviation
! N [in] : Number of grid points
! tol [in] : Tolerance for stationary distribution
! maxiter [in] : Maximum iterations for stationary distribution
! y [inout] : Productivity grid [N]
! p_vec [inout] : Stationary distribution [N]
! P_mat [inout] : Transition matrix [N × N]
!---------------------------------------------------------------------------
subroutine markov_rouwenhorst(rho, sigma, N, tol, maxiter, y, p_vec, P_mat)
integer(int32), intent(in) :: N, maxiter
real(real64), intent(in) :: rho, sigma, tol
real(real64), dimension(N), intent(inout) :: y, p_vec
real(real64), dimension(N, N), intent(inout) :: P_mat
integer(int32) :: i, k
real(real64) :: p, scale_factor
real(real64), allocatable :: P1(:, :), P2(:, :), P3(:, :), P4(:, :)
real(real64), allocatable :: s(:)
logical :: flag
! Step 1: Initialize transition matrix for N=2
p = (1.0_real64 + rho) / 2.0_real64
P_mat(1, 1) = p
P_mat(1, 2) = 1.0_real64 - p
P_mat(2, 1) = 1.0_real64 - p
P_mat(2, 2) = p
allocate(P1(N, N), P2(N, N), P3(N, N), P4(N, N))
! Step 2: Build transition matrix for N >= 3 using recursion
do k = 3, N
P1 = 0.0_real64
P2 = 0.0_real64
P3 = 0.0_real64
P4 = 0.0_real64
! Construct new transition matrix
P1(1:k-1, 1:k-1) = p * P_mat(1:k-1,1:k-1)
P2(1:k-1, 2:k) = (1.0_real64 - p) * P_mat(1:k-1,1:k-1)
P3(2:k, 1:k-1) = (1.0_real64 - p) * P_mat(1:k-1,1:k-1)
P4(2:k, 2:k) = p * P_mat(1:k-1,1:k-1)
P_mat(1:k,1:k) = P1(1:k,1:k) + P2(1:k,1:k) + P3(1:k,1:k) + P4(1:k,1:k)
! Divide middle rows by 2
do i = 2, k - 1
P_mat(i, :) = P_mat(i, :) / 2.0_real64
end do
end do
deallocate(P1, P2, P3, P4)
! Step 3: Compute stationary distribution p_vec
call compute_stationary(P_mat, N, p_vec, tol, maxiter, flag)
! Step 4: Construct the grid (Equivalent of `np.linspace(-1, 1, N)`)
allocate(s(N))
do i = 1, N
s(i) = -1.0_real64 + (i - 1) * (2.0_real64 / (N - 1))
end do
! Step 5: Scale `s` using sigma and variance correction
scale_factor = sigma / sqrt(compute_variance(s, p_vec, N))
s = s * scale_factor
! Step 6: Compute y values
do i = 1, N
y(i) = exp(s(i))
end do
! Normalize y so that sum(p_vec * y) = 1
y = y / sum(p_vec * y)
deallocate(s)
end subroutine markov_rouwenhorst
!---------------------------------------------------------------------------
! Compute stationary distribution via power iteration: p = p·P
!
! Arguments:
! P_mat [in] : Transition matrix [N × N]
! N [in] : Number of grid points
! p_vec [out] : Stationary distribution [N]
! tol [in] : Convergence tolerance
! maxiter [in] : Maximum iterations
! converged [out] : True if converged within tolerance
!---------------------------------------------------------------------------
subroutine compute_stationary(P_mat, N, p_vec, tol, maxiter, converged)
integer(int32), intent(in) :: N, maxiter
real(real64), intent(in) :: P_mat(N, N), tol
real(real64), intent(out) :: p_vec(N)
logical, intent(out) :: converged
integer(int32) :: iter
real(real64) :: diff, temp(N)
p_vec = 1.0_real64 / real(N, real64) ! Start with a uniform guess
converged = .false.
do iter = 1, maxiter
temp = matmul(p_vec, P_mat)
diff = maxval(abs(temp - p_vec))
p_vec = temp
if (diff < tol) then
converged = .true.
exit
end if
end do
end subroutine compute_stationary
!---------------------------------------------------------------------------
! Compute variance of discrete distribution: Var(s) = E[(s - E[s])²]
!---------------------------------------------------------------------------
function compute_variance(s, p_vec, N) result(var)
integer(int32), intent(in) :: N
real(real64), intent(in) :: s(N), p_vec(N)
real(real64) :: mean_s, var
mean_s = sum(s * p_vec)
var = sum(p_vec * (s - mean_s)**2)
end function compute_variance
end module markov