250404.113453.CST update documentation about the difference between PRIMA and Powell's solvers

Author: zaikunzhang

README.md

@@ -269,10 +269,10 @@ Thanks to the improvements introduced into the new implementation, PRIMA
 generally produces better solutions with less function evaluations compared with Powell's Fortran 77 implementation.
 This makes PRIMA preferable **if function evaluations are expensive**,
 which is typically the case for [derivative-free optimization problems](https://github.com/orgs/libprima/discussions/145).
-However, if function evaluations are not the dominant cost in your application,
-The Fortran 77
+However, if function evaluations are not the dominant cost in your application (e.g., a function
+evaluation takes only milliseconds), the Fortran 77
 solvers are likely to be faster, as they are more efficient in terms of memory usage and flops
-thanks to the careful and unique (but unmaintained) implementation by Powell.
+thanks to the careful and ingenious (but unmaintained and unmaintainable) implementation by Powell.
 
 Below are the [performance profiles](https://arxiv.org/pdf/cs/0102001.pdf)
 of the PRIMA solvers compared with Powell's implementation in terms of the **number of function evaluations**,

pyprima/README.md

@@ -12,12 +12,12 @@ behaves differently from the original Fortran 77 implementation by [M. J. D. Pow
 even though the algorithms are essentially the same. Therefore, it is important to point out that you are using
 PRIMA rather than the original solvers if you want your results to be reproducible.
 
-Compared to Powell's Fortran 77 implementation, the modern-Fortran implementation and hence this Python
-translation generally [produce better solutions with less function evaluations](https://github.com/libprima/prima#improvements),
+Compared to Powell's Fortran 77 implementation, the modern-Fortran implementation and hence any faithful
+translation like this one generally [produce better solutions with less function evaluations](https://github.com/libprima/prima#improvements),
 making them preferable for [applications with expensive function evaluations](https://github.com/orgs/libprima/discussions/145).
 However, if function evaluations are not the dominant cost in your application, the Fortran 77
 solvers are likely to be faster, as they are more efficient in terms of memory usage and flops
-thanks to the careful and unique (but unmaintained) implementation by Powell.
+thanks to the careful and ingenious (but unmaintained and unmaintainable) implementation by Powell.
 
 As of April 2025, only the COBYLA solver is available in this Python translation
 (many thanks to [Nickolai Belakovski](http://www.nickolai.me/)), and SciPy 1.16.0

pyprima/src/pyprima/cobyla/cobyla.py

@@ -6,6 +6,22 @@
 Dedicated to late Professor M. J. D. Powell FRS (1936--2015).
 
 Python implementation by Nickolai Belakovski
+
+N.B.:
+
+1. The modern-Fortran reference implementation in PRIMA contains bug fixes and improvements over the
+original Fortran 77 implementation by Powell. Consequently, the PRIMA implementation behaves differently
+from the original Fortran 77 implementation by Powell. Therefore, it is important to point out that
+you are using PRIMA rather than the original solvers if you want your results to be reproducible.
+
+2. Compared to Powell's Fortran 77 implementation, the modern-Fortran implementation and hence any
+faithful translation like this one generally produce better solutions with less function evaluations,
+making them preferable for applications with expensive function evaluations. However, if function
+evaluations are not the dominant cost in your application, the Fortran 77 solvers are likely to be
+faster, as they are more efficient in terms of memory usage and flops thanks to the careful and
+ingenious (but unmaintained and unmaintainable) implementation by Powell.
+
+See the PRIMA documentation (www.libprima.net) for more information.
 '''
 
 from ..common.evaluate import evaluate, moderatex, moderatef, moderatec