Explicit return type for lambdas with expressions to allow expression templates

auto-differentiation-dev · auto-differentiation-dev · commit d7de07f72a46 · 2023-04-01T09:04:22.000Z
diff --git a/ql/experimental/math/convolvedstudentt.cpp b/ql/experimental/math/convolvedstudentt.cpp
@@ -172,7 +172,7 @@ namespace QuantLib {
         // (q is very close to 1.), in a bad combination fails around 1.-1.e-7
         Real xMax = 1.e6;
         return sign *
-            Brent().solve([&](Real x){ return distrib_(x) - effectiveq; },
+            Brent().solve([&](Real x) -> Real { return distrib_(x) - effectiveq; },
                           accuracy_, (xMin+xMax)/2., xMin, xMax);
     }
 
diff --git a/ql/experimental/math/gaussiancopulapolicy.hpp b/ql/experimental/math/gaussiancopulapolicy.hpp
@@ -84,7 +84,7 @@ namespace QuantLib {
         */
         Probability density(const std::vector<Real>& m) const {
             return std::accumulate(m.begin(), m.end(), Real(1.),
-                                   [&](Real x, Real y){ return x*density_(y); });
+                                   [&](Real x, Real y) -> Real { return x*density_(y); });
         }
         /*! Returns the inverse of the cumulative distribution of the (modelled) 
           latent variable (as indexed by iVariable). The normal stability avoids
diff --git a/ql/experimental/math/multidimquadrature.hpp b/ql/experimental/math/multidimquadrature.hpp
@@ -60,15 +60,15 @@ namespace QuantLib {
                 Integer i = order()-1;
                 std::vector<Real> term = f(x_[i]);// potential copy! @#$%^!!!
                 std::for_each(term.begin(), term.end(),
-                              [&](Real x){ return x * w_[i]; });
+                              [&](Real x) -> Real { return x * w_[i]; });
                 std::vector<Real> sum = term;
            
                 for (i--; i >= 0; --i) {
                     term = f(x_[i]);// potential copy! @#$%^!!!
                     // sum[j] += term[j] * w_[i];
                     std::transform(term.begin(), term.end(), sum.begin(), 
                                    sum.begin(),
-                                   [&](Real x, Real y){ return w_[i]*x + y; });
+                                   [&](Real x, Real y) -> Real { return w_[i]*x + y; });
                 }
                 return sum;
             }
diff --git a/ql/legacy/libormarketmodels/lfmcovarproxy.cpp b/ql/legacy/libormarketmodels/lfmcovarproxy.cpp
@@ -51,7 +51,7 @@ namespace QuantLib {
         for (Size i=0; i<size_; ++i) {
             std::transform(pca.row_begin(i), pca.row_end(i),
                            pca.row_begin(i),
-                           [&](Real x){ return x * vol[i]; });
+                           [&](Real x) -> Real { return x * vol[i]; });
         }
 
         return pca;
diff --git a/ql/methods/finitedifferences/meshers/concentrating1dmesher.cpp b/ql/methods/finitedifferences/meshers/concentrating1dmesher.cpp
@@ -162,7 +162,7 @@ namespace QuantLib {
 
         OdeIntegrationFct fct(points, betas, tol);
         const Real a = Brent().solve(
-            [&](Real x) { return fct.solve(x, start, 0.0, 1.0) - end; },
+            [&](Real x) -> Real { return fct.solve(x, start, 0.0, 1.0) - end; },
             tol, aInit, 0.1*aInit);
 
         // solve ODE for all grid points
@@ -192,7 +192,7 @@ namespace QuantLib {
                         std::lower_bound(y.begin(), y.end(), points[i]));
 
                 const Real e = Brent().solve(
-                    [&](Real x){ return odeSolution(x, true) - points[i]; },
+                    [&](Real x) -> Real { return odeSolution(x, true) - points[i]; },
                     QL_EPSILON, x[j], 0.5/size);
 
                 w.emplace_back(std::min(x[size - 2], x[j]), e);
diff --git a/ql/methods/finitedifferences/utilities/gbsmrndcalculator.cpp b/ql/methods/finitedifferences/utilities/gbsmrndcalculator.cpp
@@ -96,7 +96,7 @@ namespace QuantLib {
                 << cdf(lower, t) << ", " << cdf(upper, t) << ")");
 
         return Brent().solve(
-            [&](Real _k){ return cdf(_k, t) - q; },
+            [&](Real _k) -> Real { return cdf(_k, t) - q; },
             1e-10, 0.5*(lower+upper), lower, upper);
     }
 }
diff --git a/ql/methods/finitedifferences/utilities/riskneutraldensitycalculator.cpp b/ql/methods/finitedifferences/utilities/riskneutraldensitycalculator.cpp
@@ -36,7 +36,7 @@ namespace QuantLib {
     Real RiskNeutralDensityCalculator::InvCDFHelper::inverseCDF(Real p, Time t) const {
         Brent solver;
         solver.setMaxEvaluations(maxEvaluations_);
-        return solver.solve([&](Real _x){ return calculator_->cdf(_x, t) - p; },
+        return solver.solve([&](Real _x) -> Real { return calculator_->cdf(_x, t) - p; },
                             accuracy_, guess_, stepSize_);
     }
 
diff --git a/ql/models/volatility/garch.cpp b/ql/models/volatility/garch.cpp
@@ -71,7 +71,7 @@ namespace QuantLib {
             Real retval(0.0);
             Real sigma2 = 0;
             Real u2 = 0;
-            for (const auto r2 : r2_) {
+            for (const auto& r2 : r2_) {
                 sigma2 = x[0] + x[1] * u2 + x[2] * sigma2;
                 u2 = r2;
                 retval += std::log(sigma2) + u2 / sigma2;
@@ -84,7 +84,7 @@ namespace QuantLib {
             Real sigma2 = 0;
             Real u2 = 0;
             Size i = 0;
-            for (const auto r2 : r2_) {
+            for (const auto& r2 : r2_) {
                 sigma2 = x[0] + x[1] * u2 + x[2] * sigma2;
                 u2 = r2;
                 retval[i++] = (std::log(sigma2) + u2 / sigma2)/(2.0*r2_.size());
@@ -99,7 +99,7 @@ namespace QuantLib {
             Real sigma2prev = sigma2;
             Real u2prev = u2;
             Real norm = 2.0 * r2_.size();
-            for (const auto r2 : r2_) {
+            for (const auto& r2 : r2_) {
                 sigma2 = x[0] + x[1] * u2 + x[2] * sigma2;
                 u2 = r2;
                 Real w = (sigma2 - u2) / (sigma2*sigma2);
@@ -122,7 +122,7 @@ namespace QuantLib {
             Real sigma2prev = sigma2;
             Real u2prev = u2;
             Real norm = 2.0 * r2_.size();
-            for (const auto r2 : r2_) {
+            for (const auto& r2 : r2_) {
                 sigma2 = x[0] + x[1] * u2 + x[2] * sigma2;
                 u2 = r2;
                 retval += std::log(sigma2) + u2 / sigma2;
diff --git a/ql/pricingengines/vanilla/qdplusamericanengine.cpp b/ql/pricingengines/vanilla/qdplusamericanengine.cpp
@@ -209,7 +209,7 @@ namespace QuantLib {
                                 vol*std::sqrt(T), std::exp(-r*T)).value());
 
         if (close(vol, 0.0)) {
-            const auto intrinsic = [&](Real t) {
+            const auto intrinsic = [&](Real t)  -> Real {
                 return std::max(0.0, K*std::exp(-r*t)-S*std::exp(-q*t));
             };
             const Real npv0 = intrinsic(0.0);
diff --git a/test-suite/distributions.cpp b/test-suite/distributions.cpp
@@ -263,7 +263,7 @@ void DistributionTest::testNormal() {
 
     MaddockInverseCumulativeNormal mInvCum(average, sigma);
     std::transform(x.begin(), x.end(), diff.begin(),
-                   [&](Real x) {
+                   [&](Real x) -> Real {
                        return x - mInvCum(cum(x));
                    });
 
diff --git a/test-suite/hestonslvmodel.cpp b/test-suite/hestonslvmodel.cpp
@@ -665,7 +665,7 @@ namespace {
         const AnalyticPDFHestonEngine pdfEngine(model);
         const Real sInit = model->process()->s0()->value();
         const Real xMin = Brent().solve(
-                        [&](Real x){ return pdfEngine.cdf(x, maturity) - eps; },
+                        [&](Real x) -> Real { return pdfEngine.cdf(x, maturity) - eps; },
                         sInit*1e-3, sInit, sInit*0.001, 1000*sInit);
 
         return xMin;
diff --git a/test-suite/riskneutraldensitycalculator.cpp b/test-suite/riskneutraldensitycalculator.cpp
@@ -737,7 +737,7 @@ void RiskNeutralDensityCalculatorTest::testMassAtZeroCEVProcessRND() {
         const Real ax = 15.0*std::sqrt(t)*alpha*std::pow(f0, beta);
 
         const Real calculated = GaussLobattoIntegral(1000, 1e-8)(
-            [&](Real _x) { return calculator->pdf(_x, t); }, std::max(QL_EPSILON, f0-ax), f0+ax) +
+            [&](Real _x) -> Real { 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
@@ -140,7 +140,7 @@ void SquareRootCLVModelTest::testSquareRootCLVVanillaPricing() {
 
         const CLVModelPayoff clvModelPayoff(optionType, strike, g);
 
-        const ext::function<Real(Real)> f = [&](Real xi) {
+        const ext::function<Real(Real)> f = [&](Real xi) -> Real {
             return clvModelPayoff(xi) * boost::math::pdf(dist, xi);
         };
 
@@ -238,7 +238,7 @@ void SquareRootCLVModelTest::testSquareRootCLVMappingFunction() {
 
             const CLVModelPayoff clvModelPayoff(optionType, strike, [&](Real x) { return g(t, x); });
 
-            const ext::function<Real(Real)> f = [&](Real xi) {
+            const ext::function<Real(Real)> f = [&](Real xi) -> Real {
                 return clvModelPayoff(xi) * boost::math::pdf(dist, xi);
             };
 

Original file line number	Diff line number	Diff line change
`@@ -172,7 +172,7 @@ namespace QuantLib {`
`172`	`172`	`// (q is very close to 1.), in a bad combination fails around 1.-1.e-7`
`173`	`173`	`Real xMax = 1.e6;`
`174`	`174`	`return sign *`
`175`		`- Brent().solve([&](Real x){ return distrib_(x) - effectiveq; },`
	`175`	`+ Brent().solve([&](Real x) -> Real { return distrib_(x) - effectiveq; },`
`176`	`176`	`accuracy_, (xMin+xMax)/2., xMin, xMax);`
`177`	`177`	`}`
`178`	`178`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ namespace QuantLib {`
`84`	`84`	`*/`
`85`	`85`	`Probability density(const std::vector<Real>& m) const {`
`86`	`86`	`return std::accumulate(m.begin(), m.end(), Real(1.),`
`87`		`- [&](Real x, Real y){ return x*density_(y); });`
	`87`	`+ [&](Real x, Real y) -> Real { return x*density_(y); });`
`88`	`88`	`}`
`89`	`89`	`/*! Returns the inverse of the cumulative distribution of the (modelled)`
`90`	`90`	`latent variable (as indexed by iVariable). The normal stability avoids`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ namespace QuantLib {`
`51`	`51`	`for (Size i=0; i<size_; ++i) {`
`52`	`52`	`std::transform(pca.row_begin(i), pca.row_end(i),`
`53`	`53`	`pca.row_begin(i),`
`54`		`- [&](Real x){ return x * vol[i]; });`
	`54`	`+ [&](Real x) -> Real { return x * vol[i]; });`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`return pca;`
Original file line number	Diff line number	Diff line change
`@@ -96,7 +96,7 @@ namespace QuantLib {`
`96`	`96`	`<< cdf(lower, t) << ", " << cdf(upper, t) << ")");`
`97`	`97`
`98`	`98`	`return Brent().solve(`
`99`		`- [&](Real _k){ return cdf(_k, t) - q; },`
	`99`	`+ [&](Real _k) -> Real { return cdf(_k, t) - q; },`
`100`	`100`	`1e-10, 0.5*(lower+upper), lower, upper);`
`101`	`101`	`}`
`102`	`102`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ namespace QuantLib {`
`36`	`36`	`Real RiskNeutralDensityCalculator::InvCDFHelper::inverseCDF(Real p, Time t) const {`
`37`	`37`	`Brent solver;`
`38`	`38`	`solver.setMaxEvaluations(maxEvaluations_);`
`39`		`- return solver.solve([&](Real _x){ return calculator_->cdf(_x, t) - p; },`
	`39`	`+ return solver.solve([&](Real _x) -> Real { return calculator_->cdf(_x, t) - p; },`
`40`	`40`	`accuracy_, guess_, stepSize_);`
`41`	`41`	`}`
`42`	`42`