Index: QuantLib/ql/math/solvers1d/bisection.hpp
===================================================================
--- QuantLib/ql/math/solvers1d/bisection.hpp	(revision 18356)
+++ QuantLib/ql/math/solvers1d/bisection.hpp	(working copy)
@@ -62,8 +62,11 @@
                 ++evaluationNumber_;
                 if (fMid <= 0.0)
                     root_ = xMid;
-                if (std::fabs(dx) < xAccuracy || (close(fMid, 0.0)))
+                if (std::fabs(dx) < xAccuracy || (close(fMid, 0.0))) {
+                    f(root_);
+                    ++evaluationNumber_;
                     return root_;
+                }
             }
             QL_FAIL("maximum number of function evaluations ("
                     << maxEvaluations_ << ") exceeded");
Index: QuantLib/ql/math/solvers1d/brent.hpp
===================================================================
--- QuantLib/ql/math/solvers1d/brent.hpp	(revision 18356)
+++ QuantLib/ql/math/solvers1d/brent.hpp	(working copy)
@@ -82,8 +82,11 @@
                 // Convergence check
                 xAcc1=2.0*QL_EPSILON*std::fabs(root_)+0.5*xAccuracy;
                 xMid=(xMax_-root_)/2.0;
-                if (std::fabs(xMid) <= xAcc1 || (close(froot, 0.0)))
+                if (std::fabs(xMid) <= xAcc1 || (close(froot, 0.0))) {
+                    f(root_);
+                    ++evaluationNumber_;
                     return root_;
+                }
                 if (std::fabs(e) >= xAcc1 &&
                     std::fabs(fxMin_) > std::fabs(froot)) {
 
Index: QuantLib/ql/math/solvers1d/newton.hpp
===================================================================
--- QuantLib/ql/math/solvers1d/newton.hpp	(revision 18356)
+++ QuantLib/ql/math/solvers1d/newton.hpp	(working copy)
@@ -64,8 +64,11 @@
                     s.setMaxEvaluations(maxEvaluations_-evaluationNumber_);
                     return s.solve(f, xAccuracy, root_+dx, xMin_, xMax_);
                 }
-                if (std::fabs(dx) < xAccuracy)
+                if (std::fabs(dx) < xAccuracy) {
+                    f(root_);
+                    ++evaluationNumber_;
                     return root_;
+                }
                 froot = f(root_);
                 dfroot = f.derivative(root_);
                 ++evaluationNumber_;
Index: QuantLib/ql/math/solvers1d/newtonsafe.hpp
===================================================================
--- QuantLib/ql/math/solvers1d/newtonsafe.hpp	(revision 18356)
+++ QuantLib/ql/math/solvers1d/newtonsafe.hpp	(working copy)
@@ -88,8 +88,11 @@
                     root_ -= dx;
                 }
                 // Convergence criterion
-                if (std::fabs(dx) < xAccuracy)
+                if (std::fabs(dx) < xAccuracy) {
+                    f(root_);
+                    ++evaluationNumber_;
                     return root_;
+                }
                 froot = f(root_);
                 dfroot = f.derivative(root_);
                 ++evaluationNumber_;
Index: QuantLib/ql/math/solvers1d/ridder.hpp
===================================================================
--- QuantLib/ql/math/solvers1d/ridder.hpp	(revision 18356)
+++ QuantLib/ql/math/solvers1d/ridder.hpp	(working copy)
@@ -60,13 +60,19 @@
                 fxMid = f(xMid);
                 ++evaluationNumber_;
                 s = std::sqrt(fxMid*fxMid-fxMin_*fxMax_);
-                if (close(s, 0.0))
+                if (close(s, 0.0)) {
+                    f(root_);
+                    ++evaluationNumber_;
                     return root_;
+                }
                 // Updating formula
                 nextRoot = xMid + (xMid - xMin_) *
                     ((fxMin_ >= fxMax_ ? 1.0 : -1.0) * fxMid / s);
-                if (std::fabs(nextRoot-root_) <= xAccuracy)
+                if (std::fabs(nextRoot-root_) <= xAccuracy) {
+                    f(root_);
+                    ++evaluationNumber_;
                     return root_;
+                }
 
                 root_ = nextRoot;
                 // Second of two function evaluations per iteration
@@ -91,7 +97,11 @@
                     QL_FAIL("never get here.");
                 }
 
-                if (std::fabs(xMax_-xMin_) <= xAccuracy) return root_;
+                if (std::fabs(xMax_-xMin_) <= xAccuracy) {
+                    f(root_);
+                    ++evaluationNumber_;
+                    return root_;
+                }
             }
 
             QL_FAIL("maximum number of function evaluations ("
