! 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
!
! Fischer-Burmeister reformulation for complementarity problems
!
! For a complementarity problem F(x) = 0 ⟂ lb ≤ x ≤ ub, the FB function transforms
! the problem into an unconstrained system Φ(x) = 0 where:
! - φ(a,b) = a + b - sqrt(a² + b² + ε) satisfies φ(a,b) = 0 ⟺ a ≥ 0, b ≥ 0, ab = 0
! - Lower bound only: Φ = φ(x-lb, F) (standard MCP: F ≥ 0 at lower-bound binding)
! - Upper bound only: Φ = φ(ub-x, -F) (standard MCP: F ≤ 0 at upper-bound binding)
! - Double bounds: Φ = φ(x-lb, φ(ub-x, -F)) (nested formulation from LMMCP)
module fischer_burmeister
use iso_fortran_env, only: real64, int32
use calibration_types, only: BOUND_NONE, BOUND_LOWER, BOUND_UPPER, BOUND_BOTH
implicit none (type, external)
private
public :: FB_EPS, fb_phi, fb_phi_derivative, fb_transform, fb_transform_jacobian
! Regularization parameter to avoid division by zero
real(real64), parameter :: FB_EPS = 1.0e-14_real64
contains
!---------------------------------------------------------------------------
! Core Fischer-Burmeister function
! φ(a,b) = a + b - sqrt(a² + b² + ε)
! Property: φ(a,b) = 0 ⟺ a ≥ 0, b ≥ 0, ab = 0
!---------------------------------------------------------------------------
pure elemental function fb_phi(a, b) result(phi)
real(real64), intent(in) :: a, b
real(real64) :: phi
real(real64) :: r
r = sqrt(a*a + b*b + FB_EPS)
phi = a + b - r
end function fb_phi
!---------------------------------------------------------------------------
! Derivatives of the Fischer-Burmeister function
! ∂φ/∂a = 1 - a/r
! ∂φ/∂b = 1 - b/r
! where r = sqrt(a² + b² + ε)
!---------------------------------------------------------------------------
pure subroutine fb_phi_derivative(a, b, dphi_da, dphi_db)
real(real64), intent(in) :: a, b
real(real64), intent(out) :: dphi_da, dphi_db
real(real64) :: r
r = sqrt(a*a + b*b + FB_EPS)
dphi_da = 1.0_real64 - a / r
dphi_db = 1.0_real64 - b / r
end subroutine fb_phi_derivative
!---------------------------------------------------------------------------
! Transform residuals F(x) → Φ(x) using Fischer-Burmeister
!
! For each component i:
! BOUND_NONE: Φ_i = -F_i (just negate, no bounds)
! BOUND_LOWER: Φ_i = φ(x_i - lb_i, F_i)
! BOUND_UPPER: Φ_i = φ(ub_i - x_i, -F_i)
! BOUND_BOTH: Φ_i = φ(x_i - lb_i, φ(ub_i - x_i, -F_i)) (nested)
!---------------------------------------------------------------------------
pure subroutine fb_transform(n, x, fvec, lb, ub, bound_type, phi_vec)
integer(int32), intent(in) :: n
real(real64), intent(in) :: x(:)
real(real64), intent(in) :: fvec(:)
real(real64), intent(in) :: lb(:)
real(real64), intent(in) :: ub(:)
integer(int32), intent(in) :: bound_type(:)
real(real64), intent(out) :: phi_vec(:)
integer(int32) :: i
real(real64) :: phi_inner
do i = 1, n
select case (bound_type(i))
case (BOUND_NONE)
! Unconstrained: just negate
phi_vec(i) = -fvec(i)
case (BOUND_LOWER)
! Lower bound only: φ(x-lb, F)
phi_vec(i) = fb_phi(x(i) - lb(i), fvec(i))
case (BOUND_UPPER)
! Upper bound only: φ(ub-x, -F)
phi_vec(i) = fb_phi(ub(i) - x(i), -fvec(i))
case (BOUND_BOTH)
! Double bounds (nested): φ(x-lb, φ(ub-x, -F))
phi_inner = fb_phi(ub(i) - x(i), -fvec(i))
phi_vec(i) = fb_phi(x(i) - lb(i), phi_inner)
end select
end do
end subroutine fb_transform
!---------------------------------------------------------------------------
! Transform Jacobian using FB chain rule
!
! For Φ_i = φ(a_i, b_i), the chain rule gives:
! ∂Φ_i/∂x_j = (∂φ/∂a)·(∂a_i/∂x_j) + (∂φ/∂b)·(∂b_i/∂x_j)
!
! For different bound types:
! BOUND_NONE: ∂Φ_i/∂x_j = -∂F_i/∂x_j
! BOUND_LOWER: a=x-lb, b=F → ∂Φ_i/∂x_j = (∂φ/∂a)·δ_ij + (∂φ/∂b)·(∂F_i/∂x_j)
! BOUND_UPPER: a=ub-x, b=-F → ∂Φ_i/∂x_j = (∂φ/∂a)·(-δ_ij) + (∂φ/∂b)·(-∂F_i/∂x_j)
! BOUND_BOTH: nested chain rule (see implementation)
!---------------------------------------------------------------------------
pure subroutine fb_transform_jacobian(n, x, fvec, fjac, lb, ub, bound_type, phi_jac)
integer(int32), intent(in) :: n
real(real64), intent(in) :: x(:)
real(real64), intent(in) :: fvec(:)
real(real64), intent(in) :: fjac(:,:) ! [n × n]
real(real64), intent(in) :: lb(:)
real(real64), intent(in) :: ub(:)
integer(int32), intent(in) :: bound_type(:)
real(real64), intent(out) :: phi_jac(:,:) ! [n × n]
integer(int32) :: i, j
real(real64) :: a, b, dphi_da, dphi_db
real(real64) :: a_inner, b_inner, dphi_inner_da, dphi_inner_db
real(real64) :: phi_inner, dphi_outer_da, dphi_outer_db
real(real64) :: dphiinner_dxj
do i = 1, n
select case (bound_type(i))
case (BOUND_NONE)
! Unconstrained: ∂Φ_i/∂x_j = -∂F_i/∂x_j
do j = 1, n
phi_jac(i, j) = -fjac(i, j)
end do
case (BOUND_LOWER)
! Lower bound only: Φ = φ(x-lb, F)
a = x(i) - lb(i)
b = fvec(i)
call fb_phi_derivative(a, b, dphi_da, dphi_db)
do j = 1, n
if (i == j) then
! ∂a/∂x_i = 1, ∂b/∂x_j = ∂F_i/∂x_j
phi_jac(i, j) = dphi_da + dphi_db * fjac(i, j)
else
! ∂a/∂x_j = 0
phi_jac(i, j) = dphi_db * fjac(i, j)
end if
end do
case (BOUND_UPPER)
! Upper bound only: Φ = φ(ub-x, -F)
a = ub(i) - x(i)
b = -fvec(i)
call fb_phi_derivative(a, b, dphi_da, dphi_db)
do j = 1, n
if (i == j) then
! ∂a/∂x_i = -1, ∂b/∂x_j = -∂F_i/∂x_j
phi_jac(i, j) = dphi_da * (-1.0_real64) + dphi_db * (-fjac(i, j))
else
! ∂a/∂x_j = 0
phi_jac(i, j) = dphi_db * (-fjac(i, j))
end if
end do
case (BOUND_BOTH)
! Double bounds (nested): Φ = φ_outer(x-lb, φ_inner(ub-x, -F))
! Inner: φ_inner = φ(ub-x, -F)
a_inner = ub(i) - x(i)
b_inner = -fvec(i)
phi_inner = fb_phi(a_inner, b_inner)
call fb_phi_derivative(a_inner, b_inner, dphi_inner_da, dphi_inner_db)
! Outer: Φ = φ(x-lb, φ_inner)
a = x(i) - lb(i)
b = phi_inner
call fb_phi_derivative(a, b, dphi_outer_da, dphi_outer_db)
do j = 1, n
! ∂φ_inner/∂x_j = (∂φ_inner/∂a_inner)·(∂a_inner/∂x_j) + (∂φ_inner/∂b_inner)·(∂b_inner/∂x_j)
! where ∂a_inner/∂x_j = -δ_ij, ∂b_inner/∂x_j = -∂F_i/∂x_j
if (i == j) then
dphiinner_dxj = dphi_inner_da * (-1.0_real64) + dphi_inner_db * (-fjac(i, j))
else
dphiinner_dxj = dphi_inner_db * (-fjac(i, j))
end if
! ∂Φ/∂x_j = (∂φ_outer/∂a)·(∂a/∂x_j) + (∂φ_outer/∂b)·(∂φ_inner/∂x_j)
! where ∂a/∂x_j = δ_ij
if (i == j) then
phi_jac(i, j) = dphi_outer_da + dphi_outer_db * dphiinner_dxj
else
phi_jac(i, j) = dphi_outer_db * dphiinner_dxj
end if
end do
end select
end do
end subroutine fb_transform_jacobian
end module fischer_burmeister