250403.192158.CST revert unwanted changes in checkexit.f90, evaluate.f90, and checkbreak.py; add comment to the top of cobyla_example.py

Author: zaikunzhang

fortran/common/checkexit.f90

@@ -7,12 +7,12 @@ module checkexit_mod
 !
 ! Started: September 2021
 !
-! Last Modified: Thu 03 Apr 2025 05:43:33 PM CST
+! Last Modified: Tuesday, September 26, 2023 AM10:51:16
 !--------------------------------------------------------------------------------------------------!
 
 implicit none
 private
-public:: checkexit
+public :: checkexit
 
 interface checkexit
     module procedure checkexit_unc, checkexit_con
@@ -28,25 +28,25 @@ function checkexit_unc(maxfun, nf, f, ftarget, x) result(info)
 !--------------------------------------------------------------------------------------------------!
 
 ! Common modules
-use, non_intrinsic:: consts_mod, only : RP, IK, DEBUGGING
-use, non_intrinsic:: debug_mod, only : assert
-use, non_intrinsic:: infnan_mod, only : is_nan, is_posinf, is_inf
-use, non_intrinsic:: infos_mod, only : INFO_DFT, NAN_INF_X, NAN_INF_F, FTARGET_ACHIEVED, MAXFUN_REACHED
+use, non_intrinsic :: consts_mod, only : RP, IK, DEBUGGING
+use, non_intrinsic :: debug_mod, only : assert
+use, non_intrinsic :: infnan_mod, only : is_nan, is_posinf, is_inf
+use, non_intrinsic :: infos_mod, only : INFO_DFT, NAN_INF_X, NAN_INF_F, FTARGET_ACHIEVED, MAXFUN_REACHED
 
 implicit none
 
 ! Inputs
-integer(IK), intent(in):: maxfun
-integer(IK), intent(in):: nf
-real(RP), intent(in):: f
-real(RP), intent(in):: ftarget
-real(RP), intent(in):: x(:)
+integer(IK), intent(in) :: maxfun
+integer(IK), intent(in) :: nf
+real(RP), intent(in) :: f
+real(RP), intent(in) :: ftarget
+real(RP), intent(in) :: x(:)
 
 ! Outputs
-integer(IK):: info
+integer(IK) :: info
 
 ! Local variables
-character(len=*), parameter:: srname = 'CHECKEXIT_UNC'
+character(len=*), parameter :: srname = 'CHECKEXIT_UNC'
 
 ! Preconditions
 if (DEBUGGING) then
@@ -66,7 +66,7 @@ function checkexit_unc(maxfun, nf, f, ftarget, x) result(info)
 info = INFO_DFT  ! Default info, indicating that the solver should not exit.
 
 ! Although X should not contain NaN unless there is a bug, we include the following for security.
-! X can be Inf, as finite+finite can be Inf numerically.
+! X can be Inf, as finite + finite can be Inf numerically.
 if (any(is_nan(x) .or. is_inf(x))) then
     info = NAN_INF_X
 end if
@@ -103,27 +103,27 @@ function checkexit_con(maxfun, nf, cstrv, ctol, f, ftarget, x) result(info)
 !--------------------------------------------------------------------------------------------------!
 
 ! Common modules
-use, non_intrinsic:: consts_mod, only : RP, IK, DEBUGGING
-use, non_intrinsic:: debug_mod, only : assert
-use, non_intrinsic:: infnan_mod, only : is_nan, is_posinf, is_inf
-use, non_intrinsic:: infos_mod, only : INFO_DFT, NAN_INF_X, NAN_INF_F, FTARGET_ACHIEVED, MAXFUN_REACHED
+use, non_intrinsic :: consts_mod, only : RP, IK, DEBUGGING
+use, non_intrinsic :: debug_mod, only : assert
+use, non_intrinsic :: infnan_mod, only : is_nan, is_posinf, is_inf
+use, non_intrinsic :: infos_mod, only : INFO_DFT, NAN_INF_X, NAN_INF_F, FTARGET_ACHIEVED, MAXFUN_REACHED
 
 implicit none
 
 ! Inputs
-integer(IK), intent(in):: maxfun
-integer(IK), intent(in):: nf
-real(RP), intent(in):: cstrv
-real(RP), intent(in):: ctol
-real(RP), intent(in):: f
-real(RP), intent(in):: ftarget
-real(RP), intent(in):: x(:)
+integer(IK), intent(in) :: maxfun
+integer(IK), intent(in) :: nf
+real(RP), intent(in) :: cstrv
+real(RP), intent(in) :: ctol
+real(RP), intent(in) :: f
+real(RP), intent(in) :: ftarget
+real(RP), intent(in) :: x(:)
 
 ! Outputs
-integer(IK):: info
+integer(IK) :: info
 
 ! Local variables
-character(len=*), parameter:: srname = 'CHECKEXIT_CON'
+character(len=*), parameter :: srname = 'CHECKEXIT_CON'
 
 ! Preconditions
 if (DEBUGGING) then
@@ -144,7 +144,7 @@ function checkexit_con(maxfun, nf, cstrv, ctol, f, ftarget, x) result(info)
 info = INFO_DFT   ! Default info, indicating that the solver should not exit.
 
 ! Although X should not contain NaN unless there is a bug, we include the following for security.
-! X can be Inf, as finite+finite can be Inf numerically.
+! X can be Inf, as finite + finite can be Inf numerically.
 if (any(is_nan(x) .or. is_inf(x))) then
     info = NAN_INF_X
 end if

fortran/common/evaluate.f90

@@ -6,15 +6,15 @@ module evaluate_mod
 !
 ! Started: August 2021
 !
-! Last Modified: Thu 03 Apr 2025 05:48:45 PM CST
+! Last Modified: Monday, September 25, 2023 PM08:52:04
 !--------------------------------------------------------------------------------------------------!
 
 implicit none
 private
-public:: moderatex
-public:: moderatef
-public:: moderatec
-public:: evaluate
+public :: moderatex
+public :: moderatef
+public :: moderatec
+public :: evaluate
 
 interface evaluate
     module procedure evaluatef, evaluatefc
@@ -28,15 +28,15 @@ function moderatex(x) result(y)
 !--------------------------------------------------------------------------------------------------!
 ! This function moderates a decision variable. It replaces NaN by 0 and Inf/-Inf by REALMAX/-REALMAX.
 !--------------------------------------------------------------------------------------------------!
-use, non_intrinsic:: consts_mod, only : RP, ZERO, REALMAX
-use, non_intrinsic:: infnan_mod, only : is_nan
-use, non_intrinsic:: linalg_mod, only : trueloc
+use, non_intrinsic :: consts_mod, only : RP, ZERO, REALMAX
+use, non_intrinsic :: infnan_mod, only : is_nan
+use, non_intrinsic :: linalg_mod, only : trueloc
 implicit none
 
 ! Inputs
-real(RP), intent(in):: x(:)
+real(RP), intent(in) :: x(:)
 ! Outputs
-real(RP):: y(size(x))
+real(RP) :: y(size(x))
 
 y = x
 y(trueloc(is_nan(x))) = ZERO
@@ -49,14 +49,14 @@ pure elemental function moderatef(f) result(y)
 ! This function moderates the function value of a MINIMIZATION problem. It replaces NaN and any
 ! value above FUNCMAX by FUNCMAX.
 !--------------------------------------------------------------------------------------------------!
-use, non_intrinsic:: consts_mod, only : RP, REALMAX, FUNCMAX
-use, non_intrinsic:: infnan_mod, only : is_nan
+use, non_intrinsic :: consts_mod, only : RP, REALMAX, FUNCMAX
+use, non_intrinsic :: infnan_mod, only : is_nan
 implicit none
 
 ! Inputs
-real(RP), intent(in):: f
+real(RP), intent(in) :: f
 ! Outputs
-real(RP):: y
+real(RP) :: y
 
 y = f
 if (is_nan(y)) then
@@ -71,18 +71,18 @@ end function moderatef
 function moderatec(c) result(y)
 !--------------------------------------------------------------------------------------------------!
 ! This function moderates the constraint value, the constraint demanding this value to be NONNEGATIVE.
-! It replaces any value below-CONSTRMAX by-CONSTRMAX, and any NaN or value above CONSTRMAX by
+! It replaces any value below -CONSTRMAX by -CONSTRMAX, and any NaN or value above CONSTRMAX by
 ! CONSTRMAX.
 !--------------------------------------------------------------------------------------------------!
-use, non_intrinsic:: consts_mod, only : RP, CONSTRMAX
-use, non_intrinsic:: infnan_mod, only : is_nan
-use, non_intrinsic:: linalg_mod, only : trueloc
+use, non_intrinsic :: consts_mod, only : RP, CONSTRMAX
+use, non_intrinsic :: infnan_mod, only : is_nan
+use, non_intrinsic :: linalg_mod, only : trueloc
 implicit none
 
 ! Inputs
-real(RP), intent(in):: c(:)
+real(RP), intent(in) :: c(:)
 ! Outputs
-real(RP):: y(size(c))
+real(RP) :: y(size(c))
 
 y = c
 y(trueloc(is_nan(c))) = CONSTRMAX
@@ -96,21 +96,21 @@ subroutine evaluatef(calfun, x, f)
 ! handled by a moderated extreme barrier.
 !--------------------------------------------------------------------------------------------------!
 ! Common modules
-use, non_intrinsic:: consts_mod, only : RP, DEBUGGING
-use, non_intrinsic:: debug_mod, only : assert
-use, non_intrinsic:: infnan_mod, only : is_nan, is_posinf
-use, non_intrinsic:: pintrf_mod, only : OBJ
+use, non_intrinsic :: consts_mod, only : RP, DEBUGGING
+use, non_intrinsic :: debug_mod, only : assert
+use, non_intrinsic :: infnan_mod, only : is_nan, is_posinf
+use, non_intrinsic :: pintrf_mod, only : OBJ
 implicit none
 
 ! Inputs
-procedure(OBJ):: calfun  ! N.B.: INTENT cannot be specified if a dummy procedure is not a POINTER
-real(RP), intent(in):: x(:)
+procedure(OBJ) :: calfun  ! N.B.: INTENT cannot be specified if a dummy procedure is not a POINTER
+real(RP), intent(in) :: x(:)
 
 ! Output
-real(RP), intent(out):: f
+real(RP), intent(out) :: f
 
 ! Local variables
-character(len=*), parameter:: srname = 'EVALUATEF'
+character(len=*), parameter :: srname = 'EVALUATEF'
 
 ! Preconditions
 if (DEBUGGING) then
@@ -154,22 +154,22 @@ subroutine evaluatefc(calcfc, x, f, constr)
 ! constraint value. Nan/Inf are handled by a moderated extreme barrier.
 !--------------------------------------------------------------------------------------------------!
 ! Common modules
-use, non_intrinsic:: consts_mod, only : RP, DEBUGGING
-use, non_intrinsic:: debug_mod, only : assert
-use, non_intrinsic:: infnan_mod, only : is_nan, is_posinf
-use, non_intrinsic:: pintrf_mod, only : OBJCON
+use, non_intrinsic :: consts_mod, only : RP, DEBUGGING
+use, non_intrinsic :: debug_mod, only : assert
+use, non_intrinsic :: infnan_mod, only : is_nan, is_posinf
+use, non_intrinsic :: pintrf_mod, only : OBJCON
 implicit none
 
 ! Inputs
-procedure(OBJCON):: calcfc  ! N.B.: INTENT cannot be specified if a dummy procedure is not a POINTER
-real(RP), intent(in):: x(:)
+procedure(OBJCON) :: calcfc ! N.B.: INTENT cannot be specified if a dummy procedure is not a POINTER
+real(RP), intent(in) :: x(:)
 
 ! Outputs
-real(RP), intent(out):: f
-real(RP), intent(out):: constr(:)
+real(RP), intent(out) :: f
+real(RP), intent(out) :: constr(:)
 
 ! Local variables
-character(len=*), parameter:: srname = 'EVALUATEFC'
+character(len=*), parameter :: srname = 'EVALUATEFC'
 
 ! Preconditions
 if (DEBUGGING) then

pyprima/src/pyprima/common/checkbreak.py

@@ -8,15 +8,6 @@
 Python implementation by Nickolai Belakovski
 '''
 
-from ..common.evaluate import evaluate, moderatex, moderatef, moderatec
-from ..common.consts import (EPS, RHOBEG_DEFAULT, RHOEND_DEFAULT, CTOL_DEFAULT,
-                                   CWEIGHT_DEFAULT, FTARGET_DEFAULT, IPRINT_DEFAULT,
-                                   MAXFUN_DIM_DEFAULT, DEBUGGING, BOUNDMAX,
-                                   ETA1_DEFAULT, ETA2_DEFAULT, GAMMA1_DEFAULT,
-                                   GAMMA2_DEFAULT)
-from ..common.preproc import preproc
-from ..common.present import present
-from ..common.linalg import matprod
 from .infos import INFO_DEFAULT, NAN_INF_X, NAN_INF_F, FTARGET_ACHIEVED, MAXFUN_REACHED
 
 import numpy as np

pyprima/src/pyprima/common/history.py

@@ -1,6 +1,6 @@
 '''
 This module provides subroutines that handle the X/F/C histories of the solver, taking into
-! account that MAXHIST may be smaller than NF.
+account that MAXHIST may be smaller than NF.
 
 Translated from the modern-Fortran reference implementation in PRIMA by Zaikun ZHANG (www.zhangzk.net).
 

pyprima/src/pyprima/common/preproc.py

@@ -248,9 +248,9 @@ def preproc(solver, num_vars, iprint, maxfun, maxhist, ftarget, rhobeg, rhoend,
             if (is_constrained):
                 warn(f'{solver}: Invalid CWEIGHT; it should be a nonnegative number; it is set to {cweight}')
 
-    #====================!
-    #  Calculation ends  !
-    #====================!
+    #====================#
+    #  Calculation ends  #
+    #====================#
 
     # Postconditions
     if DEBUGGING:

pyprima/src/pyprima/examples/cobyla/cobyla_example.py

@@ -1,3 +1,13 @@
+'''
+This is an example to illustrate the usage of the solver.
+
+Translated from the modern-Fortran reference implementation in PRIMA by Zaikun ZHANG (www.zhangzk.net).
+
+Dedicated to late Professor M. J. D. Powell FRS (1936--2015).
+
+Python implementation by Nickolai Belakovski
+'''
+
 import numpy as np
 from pyprima.cobyla.cobyla import cobyla
 
@@ -27,9 +37,9 @@ def calcfc_chebyquad(x):
 
 def calcfc_hexagon(x):
     # Test problem 10 in Powell's original algorithm
-    
+
     assert len(x) == 9
-    
+
     f = -0.5 * (x[0] * x[3] - x[1] * x[2] + x[2] * x[8] - x[4] * x[8] + x[4] * x[7] - x[5] * x[6])
     constr = np.zeros(14)
     constr[0] = -1 + x[2]**2 + x[3]**2
@@ -52,7 +62,7 @@ def calcfc_hexagon(x):
 
 if __name__ == "__main__":
     n_chebyquad = 6
-    
+
     # The following lines illustrates how to call the solver to solve the Chebyquad problem.
     x_chebyquad = np.array([i/(n_chebyquad+1) for i in range(1, n_chebyquad+1)])  # Starting point
     m = 0  # Dimension of constraints. M must be specified correctly, or the program will crash!