From ccc45918f6bdccbb8d62290f48eaabe43aa1ceea Mon Sep 17 00:00:00 2001
From: Luigi Ballabio <luigi.ballabio@gmail.com>
Date: Tue, 16 Feb 2021 12:20:25 +0100
Subject: [PATCH] More lambdas

---
 test-suite/basketoption.cpp                 | 17 ++++-----
 test-suite/cdo.cpp                          | 16 ++++-----
 test-suite/fdmlinearop.cpp                  | 20 +++++------
 test-suite/hybridhestonhullwhiteprocess.cpp |  6 +---
 test-suite/marketmodel.cpp                  | 39 +++++++++++----------
 test-suite/normalclvmodel.cpp               |  5 ++-
 test-suite/nthorderderivativeop.cpp         | 13 ++-----
 test-suite/paralleltestrunner.hpp           |  6 ++--
 test-suite/riskneutraldensitycalculator.cpp |  7 ++--
 test-suite/squarerootclvmodel.cpp           |  4 +--
 10 files changed, 53 insertions(+), 80 deletions(-)

diff --git a/test-suite/basketoption.cpp b/test-suite/basketoption.cpp
index a1192d8edac..cd7718d2578 100644
--- a/test-suite/basketoption.cpp
+++ b/test-suite/basketoption.cpp
@@ -36,8 +36,6 @@
 #include <ql/termstructures/volatility/equityfx/hestonblackvolsurface.hpp>
 #include <ql/pricingengines/basket/fd2dblackscholesvanillaengine.hpp>
 #include <ql/utilities/dataformatters.hpp>
-#include <ql/functional.hpp>
-#include <boost/preprocessor/iteration/local.hpp>
 
 using namespace QuantLib;
 using namespace boost::unit_test_framework;
@@ -1066,15 +1064,12 @@ test_suite* BasketOptionTest::suite(SpeedLevel speed) {
     suite->add(QUANTLIB_TEST_CASE(&BasketOptionTest::test2DPDEGreeks));
 
     if (speed <= Fast) {
-        #define N_TEST_CASES 5
-        #define BOOST_PP_LOCAL_MACRO(n)                                \
-            suite->add(QUANTLIB_TEST_CASE(                             \
-                ext::bind(&BasketOptionTest::testOneDAmericanValues, \
-                    (n    *LENGTH(oneDataValues))/N_TEST_CASES,        \
-                    ((n+1)*LENGTH(oneDataValues))/N_TEST_CASES)));
-
-        #define BOOST_PP_LOCAL_LIMITS (0, N_TEST_CASES-1)
-        #include BOOST_PP_LOCAL_ITERATE()
+        // unrolled to get different test names
+        suite->add(QUANTLIB_TEST_CASE([=](){ BasketOptionTest::testOneDAmericanValues( 0,  5); }));
+        suite->add(QUANTLIB_TEST_CASE([=](){ BasketOptionTest::testOneDAmericanValues( 5, 11); }));
+        suite->add(QUANTLIB_TEST_CASE([=](){ BasketOptionTest::testOneDAmericanValues(11, 17); }));
+        suite->add(QUANTLIB_TEST_CASE([=](){ BasketOptionTest::testOneDAmericanValues(17, 23); }));
+        suite->add(QUANTLIB_TEST_CASE([=](){ BasketOptionTest::testOneDAmericanValues(23, 29); }));
     }
 
     if (speed == Slow) {
diff --git a/test-suite/cdo.cpp b/test-suite/cdo.cpp
index bc9a75456e6..80721b82fce 100644
--- a/test-suite/cdo.cpp
+++ b/test-suite/cdo.cpp
@@ -34,8 +34,6 @@
 #include <ql/time/daycounters/actualactual.hpp>
 #include <ql/quotes/simplequote.hpp>
 #include <ql/currencies/europe.hpp>
-#include <ql/functional.hpp>
-#include <boost/preprocessor/iteration/local.hpp>
 #include <iomanip>
 #include <iostream>
 
@@ -369,13 +367,15 @@ void CdoTest::testHW(unsigned dataSet) {
 
 test_suite* CdoTest::suite(SpeedLevel speed) {
     auto* suite = BOOST_TEST_SUITE("CDO tests");
-#ifndef QL_PATCH_SOLARIS
-    if (speed == Slow) {
-        #define BOOST_PP_LOCAL_MACRO(n) \
-            suite->add(QUANTLIB_TEST_CASE(ext::bind(&CdoTest::testHW, n)));
 
-        #define BOOST_PP_LOCAL_LIMITS (0, 4)
-        #include BOOST_PP_LOCAL_ITERATE()
+    #ifndef QL_PATCH_SOLARIS
+    if (speed == Slow) {
+        // unrolled to get different test names
+        suite->add(QUANTLIB_TEST_CASE([=](){ CdoTest::testHW(0); }));
+        suite->add(QUANTLIB_TEST_CASE([=](){ CdoTest::testHW(1); }));
+        suite->add(QUANTLIB_TEST_CASE([=](){ CdoTest::testHW(2); }));
+        suite->add(QUANTLIB_TEST_CASE([=](){ CdoTest::testHW(3); }));
+        suite->add(QUANTLIB_TEST_CASE([=](){ CdoTest::testHW(4); }));
     }
     #endif
     return suite;
diff --git a/test-suite/fdmlinearop.cpp b/test-suite/fdmlinearop.cpp
index ca4ab82d497..66414e52e57 100644
--- a/test-suite/fdmlinearop.cpp
+++ b/test-suite/fdmlinearop.cpp
@@ -1284,19 +1284,17 @@ void FdmLinearOpTest::testBiCGstab() {
     BOOST_TEST_MESSAGE(
         "Testing bi-conjugated gradient stabilized algorithm...");
 
-    using namespace ext::placeholders;
-
     const Size n=41, m=21;
     const Real theta = 1.0;
     const boost::numeric::ublas::compressed_matrix<Real> a
         = createTestMatrix(n, m, theta);
 
-    const ext::function<Disposable<Array>(const Array&)> matmult(
-                                                ext::bind(&axpy, a, _1));
+    const ext::function<Disposable<Array>(const Array&)> matmult
+        = [&](const Array& _x) { return axpy(a, _x); };
 
     SparseILUPreconditioner ilu(a, 4);
-    ext::function<Disposable<Array>(const Array&)> precond(
-         ext::bind(&SparseILUPreconditioner::apply, &ilu, _1));
+    ext::function<Disposable<Array>(const Array&)> precond
+        = [&](const Array& _x) { return ilu.apply(_x); };
 
     Array b(n*m);
     MersenneTwisterUniformRng rng(1234);
@@ -1324,19 +1322,17 @@ void FdmLinearOpTest::testGMRES() {
 #if !defined(QL_NO_UBLAS_SUPPORT)
     BOOST_TEST_MESSAGE("Testing GMRES algorithm...");
 
-    using namespace ext::placeholders;
-
     const Size n=41, m=21;
     const Real theta = 1.0;
     const boost::numeric::ublas::compressed_matrix<Real> a
         = createTestMatrix(n, m, theta);
 
-    const ext::function<Disposable<Array>(const Array&)> matmult(
-                                                ext::bind(&axpy, a, _1));
+    const ext::function<Disposable<Array>(const Array&)> matmult
+        = [&](const Array& _x) { return axpy(a, _x); };
     
     SparseILUPreconditioner ilu(a, 4);
-    ext::function<Disposable<Array>(const Array&)> precond(
-         ext::bind(&SparseILUPreconditioner::apply, &ilu, _1));
+    ext::function<Disposable<Array>(const Array&)> precond
+        = [&](const Array& _x) { return ilu.apply(_x); };
     
     Array b(n*m);
     MersenneTwisterUniformRng rng(1234);
diff --git a/test-suite/hybridhestonhullwhiteprocess.cpp b/test-suite/hybridhestonhullwhiteprocess.cpp
index 4f3e070d02a..fa4b10db593 100644
--- a/test-suite/hybridhestonhullwhiteprocess.cpp
+++ b/test-suite/hybridhestonhullwhiteprocess.cpp
@@ -50,7 +50,6 @@
 #include <ql/pricingengines/vanilla/analytichestonhullwhiteengine.hpp>
 #include <ql/pricingengines/vanilla/fdhestonvanillaengine.hpp>
 #include <ql/pricingengines/vanilla/fdhestonhullwhitevanillaengine.hpp>
-#include <ql/functional.hpp>
 #include <cmath>
 
 using namespace QuantLib;
@@ -628,8 +627,6 @@ void HybridHestonHullWhiteProcessTest::testAnalyticHestonHullWhitePricing() {
 void HybridHestonHullWhiteProcessTest::testCallableEquityPricing() {
     BOOST_TEST_MESSAGE("Testing the pricing of a callable equity product...");
 
-    using namespace ext::placeholders;
-
     SavedSettings backup;
 
     /*
@@ -671,8 +668,7 @@ void HybridHestonHullWhiteProcessTest::testCallableEquityPricing() {
 
     std::vector<Time> times(maturity+1);
     std::transform(schedule.begin(), schedule.end(), times.begin(),
-                   ext::bind(&Actual365Fixed::yearFraction,
-                               dc, today, _1, Date(), Date()));
+                   [&](const Date& d) { return dc.yearFraction(today, d); });
 
     for (Size i=0; i<=maturity; ++i)
         times[i] = static_cast<Time>(i);
diff --git a/test-suite/marketmodel.cpp b/test-suite/marketmodel.cpp
index df428e62afa..aba9be8e284 100644
--- a/test-suite/marketmodel.cpp
+++ b/test-suite/marketmodel.cpp
@@ -110,8 +110,6 @@ FOR A PARTICULAR PURPOSE.  See the license for more details.
 #include <ql/models/marketmodels/products/multistep/multisteppathwisewrapper.hpp>
 
 #include <boost/math/special_functions/fpclassify.hpp>
-#include <boost/preprocessor/iteration/local.hpp>
-#include <ql/functional.hpp>
 #include <sstream>
 
 using namespace QuantLib;
@@ -4749,26 +4747,29 @@ test_suite* MarketModelTest::suite(SpeedLevel speed) {
 
         setup();
 
-        MarketModelType marketModels[] = {
-            ExponentialCorrelationFlatVolatility,
-            ExponentialCorrelationAbcdVolatility
-        };
-
-        Size testedFactors[] = { 4, 8, todaysForwards.size() };
-        #define BOOST_PP_LOCAL_MACRO(n)                                 \
-            suite->add(QUANTLIB_TEST_CASE(                              \
-                ext::bind(&MarketModelTest::testCallableSwapAnderson, \
-                    marketModels[n/LENGTH(testedFactors)],              \
-                    testedFactors[n%LENGTH(testedFactors)])));
-
-        #define BOOST_PP_LOCAL_LIMITS (0, 5)
-        #include BOOST_PP_LOCAL_ITERATE()
-#include <utility>
+        // unrolled to get different test names
+        suite->add(QUANTLIB_TEST_CASE([=](){
+            MarketModelTest::testCallableSwapAnderson(ExponentialCorrelationFlatVolatility, 4);
+        }));
+        suite->add(QUANTLIB_TEST_CASE([=](){
+            MarketModelTest::testCallableSwapAnderson(ExponentialCorrelationFlatVolatility, 8);
+        }));
+        suite->add(QUANTLIB_TEST_CASE([=](){
+            MarketModelTest::testCallableSwapAnderson(ExponentialCorrelationFlatVolatility, todaysForwards.size());
+        }));
+        suite->add(QUANTLIB_TEST_CASE([=](){
+            MarketModelTest::testCallableSwapAnderson(ExponentialCorrelationAbcdVolatility, 4);
+        }));
+        suite->add(QUANTLIB_TEST_CASE([=](){
+            MarketModelTest::testCallableSwapAnderson(ExponentialCorrelationAbcdVolatility, 8);
+        }));
+        suite->add(QUANTLIB_TEST_CASE([=](){
+            MarketModelTest::testCallableSwapAnderson(ExponentialCorrelationAbcdVolatility, todaysForwards.size());
+        }));
     }
 
     if (speed == Slow) {
-        suite->add(QUANTLIB_TEST_CASE(
-            &MarketModelTest::testAllMultiStepProducts));
+        suite->add(QUANTLIB_TEST_CASE(&MarketModelTest::testAllMultiStepProducts));
         suite->add(QUANTLIB_TEST_CASE(&MarketModelTest::testCallableSwapNaif));
         suite->add(QUANTLIB_TEST_CASE(&MarketModelTest::testCallableSwapLS));
     }
diff --git a/test-suite/normalclvmodel.cpp b/test-suite/normalclvmodel.cpp
index 238e2430b73..d040016f9a9 100644
--- a/test-suite/normalclvmodel.cpp
+++ b/test-suite/normalclvmodel.cpp
@@ -284,7 +284,6 @@ namespace normal_clv_model_test {
 void NormalCLVModelTest::testMonteCarloBSOptionPricing() {
     BOOST_TEST_MESSAGE("Testing Monte Carlo BS option pricing...");
 
-    using namespace ext::placeholders;
     using namespace normal_clv_model_test;
 
     SavedSettings backup;
@@ -362,8 +361,8 @@ void NormalCLVModelTest::testMonteCarloBSOptionPricing() {
     }
 
     VanillaOption fdmOption(
-         ext::make_shared<CLVModelPayoff>(
-             payoff->optionType(), payoff->strike(), ext::bind(g, t, _1)),
+         ext::make_shared<CLVModelPayoff>(payoff->optionType(), payoff->strike(),
+                                          [&](Real _x) { return g(t, _x); }),
          exercise);
 
     fdmOption.setPricingEngine(
diff --git a/test-suite/nthorderderivativeop.cpp b/test-suite/nthorderderivativeop.cpp
index c71ff3a8666..b874c4fcb10 100644
--- a/test-suite/nthorderderivativeop.cpp
+++ b/test-suite/nthorderderivativeop.cpp
@@ -19,7 +19,6 @@
 
 #include "nthorderderivativeop.hpp"
 #include "utilities.hpp"
-#include <ql/functional.hpp>
 #include <ql/math/comparison.hpp>
 #include <ql/math/initializers.hpp>
 #include <ql/math/integrals/gausslobattointegral.hpp>
@@ -418,19 +417,13 @@ namespace {
 
         Disposable<Array> solve_splitting(Size direction, const Array& r, Real dt) const override {
 
-            using namespace ext::placeholders;
             if (direction == direction_) {
                 BiCGStabResult result =
                     QuantLib::BiCGstab(
-                        ext::function<Disposable<Array>(const Array&)>(
-                            ext::bind(
-                                &FdmHeatEquationOp::solve_apply,
-                                this, _1, -dt)),
+                        [&](const Array& a){ return solve_apply(a, -dt); },
                         std::max(Size(10), r.size()), 1e-14,
-                        ext::function<Disposable<Array>(const Array&)>(
-                            ext::bind(&FdmLinearOpComposite::preconditioner,
-                                        this, _1, dt))
-                    ).solve(r, r);
+                        [&](const Array& a){ return preconditioner(a, dt); })
+                        .solve(r, r);
 
                 return result.x;
             }
diff --git a/test-suite/paralleltestrunner.hpp b/test-suite/paralleltestrunner.hpp
index 895a0a8f77c..09a3784f362 100644
--- a/test-suite/paralleltestrunner.hpp
+++ b/test-suite/paralleltestrunner.hpp
@@ -32,7 +32,6 @@
 
 #include <ql/types.hpp>
 #include <ql/errors.hpp>
-#include <ql/functional.hpp>
 
 #ifdef VERSION
 /* This comes from ./configure, and for some reason it interferes with
@@ -287,7 +286,7 @@ int main( int argc, char* argv[] )
             // fork worker processes
             boost::thread_group threadGroup;
             for (unsigned i=0; i < nProc; ++i) {
-                threadGroup.create_thread(QuantLib::ext::bind(worker, cmd.str()));
+                threadGroup.create_thread([&]() { worker(cmd.str()); });
             }
 
             struct mutex_remove {
@@ -416,8 +415,7 @@ int main( int argc, char* argv[] )
                 #if BOOST_VERSION < 106200
                     BOOST_TEST_FOREACH( test_observer*, to,
                         framework::impl::s_frk_state().m_observers )
-                        framework::impl::s_frk_state().m_aux_em.vexecute(
-                            ext::bind( &test_observer::test_start, to, 1 ) );
+                        framework::impl::s_frk_state().m_aux_em.vexecute([&](){ to->test_start(1); });
 
                     framework::impl::s_frk_state().execute_test_tree( id.id );
 
diff --git a/test-suite/riskneutraldensitycalculator.cpp b/test-suite/riskneutraldensitycalculator.cpp
index eea90e95579..c5690dcbafe 100644
--- a/test-suite/riskneutraldensitycalculator.cpp
+++ b/test-suite/riskneutraldensitycalculator.cpp
@@ -20,7 +20,6 @@
 
 #include "riskneutraldensitycalculator.hpp"
 #include "utilities.hpp"
-#include <ql/functional.hpp>
 #include <ql/instruments/vanillaoption.hpp>
 #include <ql/math/distributions/normaldistribution.hpp>
 #include <ql/math/functional.hpp>
@@ -493,8 +492,7 @@ void RiskNeutralDensityCalculatorTest::testSquareRootProcessRND() {
 
             const Real cdfCalculated = rndCalculator.cdf(v, t);
             const Real cdfExpected = GaussLobattoIntegral(10000, 0.01*tol)(
-                ext::bind(&SquareRootProcessRNDCalculator::pdf,
-                          &rndCalculator, ext::placeholders::_1, t), 0, v);
+                [&](Real _x) { return rndCalculator.pdf(_x, t); }, 0, v);
 
             if (std::fabs(cdfCalculated - cdfExpected) > tol) {
                 BOOST_FAIL("failed to calculate cdf"
@@ -741,8 +739,7 @@ void RiskNeutralDensityCalculatorTest::testMassAtZeroCEVProcessRND() {
         const Real ax = 15.0*std::sqrt(t)*alpha*std::pow(f0, beta);
 
         const Real calculated = GaussLobattoIntegral(1000, 1e-8)(
-            ext::bind(&CEVRNDCalculator::pdf, calculator, ext::placeholders::_1, t),
-                      std::max(QL_EPSILON, f0-ax), f0+ax) +
+            [&](Real _x) { return calculator->pdf(_x, t); }, std::max(QL_EPSILON, f0-ax), f0+ax) +
             calculator->massAtZero(t);
 
         if (std::fabs(calculated - 1.0) > tol) {
diff --git a/test-suite/squarerootclvmodel.cpp b/test-suite/squarerootclvmodel.cpp
index 045174ae56e..4d96b010325 100644
--- a/test-suite/squarerootclvmodel.cpp
+++ b/test-suite/squarerootclvmodel.cpp
@@ -90,7 +90,6 @@ void SquareRootCLVModelTest::testSquareRootCLVVanillaPricing() {
     BOOST_TEST_MESSAGE(
         "Testing vanilla option pricing with square-root kernel process...");
 
-    using namespace ext::placeholders;
     using namespace square_root_clv_model;
 
     SavedSettings backup;
@@ -249,8 +248,7 @@ void SquareRootCLVModelTest::testSquareRootCLVMappingFunction() {
                 std::sqrt(sabrVol->blackVariance(m, strike)),
                 rTS->discount(m)).value();
 
-            const CLVModelPayoff clvModelPayoff(
-                optionType, strike, ext::bind(g, t, ext::placeholders::_1));
+            const CLVModelPayoff clvModelPayoff(optionType, strike, [&](Real x) { return g(t, x); });
 
             const ext::function<Real(Real)> f = [&](Real xi) {
                 return clvModelPayoff(xi) * boost::math::pdf(dist, xi);