diff --git a/.clang-tidy b/.clang-tidy
index cbec3cc4416..fe09f0bcd72 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -1,5 +1,5 @@
 ---
-Checks:          '-*,readability-*,bugprone-*,misc-*,performance-*,modernize-redundant-void-arg,modernize-deprecated-headers,modernize-use-override,modernize-use-auto,modernize-use-nullptr,modernize-use-default-member-init,modernize-use-equals-default,modernize-use-equals-delete,modernize-pass-by-value,-readability-else-after-return,-readability-named-parameter,-readability-braces-around-statements,-readability-inconsistent-declaration-parameter-name,-readability-isolate-declaration,-readability-magic-numbers,-readability-convert-member-functions-to-static,-bugprone-macro-parentheses,-bugprone-narrowing-conversions,-bugprone-branch-clone,-misc-non-private-member-variables-in-classes,-misc-unused-parameters'
+Checks:          '-*,readability-*,bugprone-*,misc-*,performance-*,modernize-redundant-void-arg,modernize-deprecated-headers,modernize-use-override,modernize-use-auto,modernize-use-nullptr,modernize-use-default-member-init,modernize-use-equals-default,modernize-use-equals-delete,modernize-pass-by-value,modernize-loop-convert,-readability-else-after-return,-readability-named-parameter,-readability-braces-around-statements,-readability-inconsistent-declaration-parameter-name,-readability-isolate-declaration,-readability-magic-numbers,-readability-convert-member-functions-to-static,-bugprone-macro-parentheses,-bugprone-narrowing-conversions,-bugprone-branch-clone,-misc-non-private-member-variables-in-classes,-misc-unused-parameters'
 WarningsAsErrors: ''
 HeaderFilterRegex: '.*'
 AnalyzeTemporaryDtors: false
diff --git a/Examples/BasketLosses/BasketLosses.cpp b/Examples/BasketLosses/BasketLosses.cpp
index 5d263f08d8d..5b380055aae 100644
--- a/Examples/BasketLosses/BasketLosses.cpp
+++ b/Examples/BasketLosses/BasketLosses.cpp
@@ -77,10 +77,9 @@ int main(int, char* []) {
             names.push_back(std::string("Acme") + 
                 boost::lexical_cast<std::string>(i));
         std::vector<Handle<DefaultProbabilityTermStructure> > defTS;
-        for(Size i=0; i<hazardRates.size(); i++) {
+        for (double& hazardRate : hazardRates) {
             defTS.push_back(Handle<DefaultProbabilityTermStructure>(
-                ext::make_shared<FlatHazardRate>(0, TARGET(), hazardRates[i], 
-                    Actual365Fixed())));
+                ext::make_shared<FlatHazardRate>(0, TARGET(), hazardRate, Actual365Fixed())));
             defTS.back()->enableExtrapolation();
         }
         std::vector<Issuer> issuers;
diff --git a/Examples/Bonds/Bonds.cpp b/Examples/Bonds/Bonds.cpp
index 621cdcd83bb..11bf9466a2f 100644
--- a/Examples/Bonds/Bonds.cpp
+++ b/Examples/Bonds/Bonds.cpp
@@ -163,8 +163,8 @@ int main(int, char* []) {
         };
 
         std::vector< ext::shared_ptr<SimpleQuote> > quote;
-        for (Size i=0; i<numberOfBonds; i++) {
-            ext::shared_ptr<SimpleQuote> cp(new SimpleQuote(marketQuotes[i]));
+        for (double marketQuote : marketQuotes) {
+            ext::shared_ptr<SimpleQuote> cp(new SimpleQuote(marketQuote));
             quote.push_back(cp);
         }
 
diff --git a/Examples/CDS/CDS.cpp b/Examples/CDS/CDS.cpp
index 2f4a1001b9f..7d4290ecdd8 100644
--- a/Examples/CDS/CDS.cpp
+++ b/Examples/CDS/CDS.cpp
@@ -119,9 +119,8 @@ void example01() {
     vector<pair<Date, Real> > hr_curve_data = hazardRateStructure->nodes();
 
     cout << "Calibrated hazard rate values: " << endl;
-    for (Size i = 0; i < hr_curve_data.size(); i++) {
-        cout << "hazard rate on " << hr_curve_data[i].first << " is "
-             << hr_curve_data[i].second << endl;
+    for (auto& i : hr_curve_data) {
+        cout << "hazard rate on " << i.first << " is " << i.second << endl;
     }
     cout << endl;
 
@@ -345,8 +344,8 @@ std::copy(cdsSchedule.begin(), cdsSchedule.end(),
 
     // output rate curve
     std::cout << "ISDA rate curve: " << std::endl;
-    for(Size i=0;i<isdaRateHelper.size(); i++) {
-        Date d = isdaRateHelper[i]->latestDate();
+    for (auto& i : isdaRateHelper) {
+        Date d = i->latestDate();
         std::cout << d << "\t" << setprecision(6) <<
             rateTs->zeroRate(d,Actual365Fixed(),Continuous).rate() << "\t" <<
             rateTs->discount(d) << std::endl;
@@ -395,8 +394,8 @@ std::copy(cdsSchedule.begin(), cdsSchedule.end(),
         0, WeekendsOnly(), isdaCdsHelper, Actual365Fixed()));
 
     std::cout << "ISDA credit curve: " << std::endl;
-    for(Size i=0;i<isdaCdsHelper.size();i++) {
-        Date d = isdaCdsHelper[i]->latestDate();
+    for (auto& i : isdaCdsHelper) {
+        Date d = i->latestDate();
         Real pd = defaultTs->defaultProbability(d);
         Real t = defaultTs->timeFromReference(d);
         std::cout << d << ";" << pd << ";" << 1.0 - pd << ";" <<
@@ -404,7 +403,6 @@ std::copy(cdsSchedule.begin(), cdsSchedule.end(),
     }
 
 
-
     // // set up sample CDS trade
 
     // ext::shared_ptr<CreditDefaultSwap> trade =
@@ -613,8 +611,8 @@ void example03() {
     // check the curves
     std::cout << "ISDA yield curve:" << std::endl;
     std::cout << "date;time;zeroyield" << std::endl;
-    for (Size i = 0; i < isdaYieldHelpers.size(); i++) {
-        Date d = isdaYieldHelpers[i]->latestDate();
+    for (auto& isdaYieldHelper : isdaYieldHelpers) {
+        Date d = isdaYieldHelper->latestDate();
         Real t = isdaYts->timeFromReference(d);
         std::cout << d << ";" << t << ";"
                   << isdaYts->zeroRate(d, Actual365Fixed(), Continuous).rate()
@@ -623,8 +621,8 @@ void example03() {
 
     std::cout << "ISDA credit curve:" << std::endl;
     std::cout << "date;time;survivalprob" << std::endl;
-    for (Size i = 0; i < isdaCdsHelpers.size(); i++) {
-        Date d = isdaCdsHelpers[i]->latestDate();
+    for (auto& isdaCdsHelper : isdaCdsHelpers) {
+        Date d = isdaCdsHelper->latestDate();
         Real t = isdaCts->timeFromReference(d);
         std::cout << d << ";" << t << ";" << isdaCts->survivalProbability(d)
                   << std::endl;
diff --git a/Examples/FittedBondCurve/FittedBondCurve.cpp b/Examples/FittedBondCurve/FittedBondCurve.cpp
index 860051f72aa..f491dac9b72 100644
--- a/Examples/FittedBondCurve/FittedBondCurve.cpp
+++ b/Examples/FittedBondCurve/FittedBondCurve.cpp
@@ -89,13 +89,13 @@ int main(int, char* []) {
         const Size numberOfBonds = 15;
         Real cleanPrice[numberOfBonds];
 
-        for (Size i=0; i<numberOfBonds; i++) {
-            cleanPrice[i]=100.0;
+        for (double& i : cleanPrice) {
+            i = 100.0;
         }
 
         std::vector< ext::shared_ptr<SimpleQuote> > quote;
-        for (Size i=0; i<numberOfBonds; i++) {
-            ext::shared_ptr<SimpleQuote> cp(new SimpleQuote(cleanPrice[i]));
+        for (double i : cleanPrice) {
+            ext::shared_ptr<SimpleQuote> cp(new SimpleQuote(i));
             quote.push_back(cp);
         }
 
@@ -227,8 +227,8 @@ int main(int, char* []) {
                            20.0,  25.0, 30.0, 40.0, 50.0 };
 
         std::vector<Time> knotVector;
-        for (Size i=0; i< LENGTH(knots); i++) {
-            knotVector.push_back(knots[i]);
+        for (double& knot : knots) {
+            knotVector.push_back(knot);
         }
 
         CubicBSplinesFitting cubicBSplines(knotVector, constrainAtZero);
diff --git a/Examples/Gaussian1dModels/Gaussian1dModels.cpp b/Examples/Gaussian1dModels/Gaussian1dModels.cpp
index 559a6be5693..b86cd934322 100644
--- a/Examples/Gaussian1dModels/Gaussian1dModels.cpp
+++ b/Examples/Gaussian1dModels/Gaussian1dModels.cpp
@@ -70,9 +70,8 @@ void printBasket(
                  "===================="
                  "===================="
                  "==================" << std::endl;
-    for (Size j = 0; j < basket.size(); ++j) {
-        ext::shared_ptr<SwaptionHelper> helper =
-            ext::dynamic_pointer_cast<SwaptionHelper>(basket[j]);
+    for (const auto& j : basket) {
+        ext::shared_ptr<SwaptionHelper> helper = ext::dynamic_pointer_cast<SwaptionHelper>(j);
         Date endDate = helper->underlyingSwap()->fixedSchedule().dates().back();
         Real nominal = helper->underlyingSwap()->nominal();
         Real vol = helper->volatility()->value();
@@ -266,8 +265,8 @@ int main(int argc, char *argv[]) {
                "\nthe calibrating vanilla swaptions. The result of this is as "
                "follows:" << std::endl;
 
-        for (Size i = 0; i < basket.size(); ++i)
-            basket[i]->setPricingEngine(swaptionEngine);
+        for (auto& i : basket)
+            i->setPricingEngine(swaptionEngine);
 
         LevenbergMarquardt method;
         EndCriteria ec(1000, 10, 1E-8, 1E-8,
@@ -318,10 +317,10 @@ int main(int argc, char *argv[]) {
         std::cout << "\nLet's see how this affects the exotics npv. The "
                      "\nrecalibrated model is:" << std::endl;
 
-        for (Size i = 0; i < basket.size(); ++i)
-            basket[i]->setPricingEngine(swaptionEngine);
+        for (auto& i : basket)
+            i->setPricingEngine(swaptionEngine);
+
 
-        
         gsr->calibrateVolatilitiesIterative(basket, method, ec);
         
 
@@ -434,10 +433,10 @@ int main(int argc, char *argv[]) {
             << "\nThe npv of the call right is (after recalibrating the model)"
             << std::endl;
 
-        for (Size i = 0; i < basket.size(); i++)
-            basket[i]->setPricingEngine(swaptionEngine);
+        for (auto& i : basket)
+            i->setPricingEngine(swaptionEngine);
+
 
-        
         gsr->calibrateVolatilitiesIterative(basket, method, ec);
         Real npv3 = swaption3->NPV();
         
@@ -469,10 +468,10 @@ int main(int argc, char *argv[]) {
 
         std::cout << "\nThe npv becomes:" << std::endl;
 
-        for (Size i = 0; i < basket.size(); i++)
-            basket[i]->setPricingEngine(swaptionEngine);
+        for (auto& i : basket)
+            i->setPricingEngine(swaptionEngine);
+
 
-        
         gsr->calibrateVolatilitiesIterative(basket, method, ec);
         Real npv4 = swaption3->NPV();
         
@@ -541,8 +540,8 @@ int main(int argc, char *argv[]) {
         
         basket = swaption4->calibrationBasket(swapBase, *swaptionVol,
                                               BasketGeneratingEngine::Naive);
-        for (Size i = 0; i < basket.size(); ++i)
-            basket[i]->setPricingEngine(swaptionEngine);
+        for (auto& i : basket)
+            i->setPricingEngine(swaptionEngine);
         gsr->calibrateVolatilitiesIterative(basket, method, ec);
         
 
@@ -637,10 +636,10 @@ int main(int argc, char *argv[]) {
                      "\ndepending on your machine, this may take a"
                      "\nwhile now..." << std::endl;
 
-        for (Size i = 0; i < basket.size(); ++i)
-            basket[i]->setPricingEngine(swaptionEngineMarkov);
+        for (auto& i : basket)
+            i->setPricingEngine(swaptionEngineMarkov);
+
 
-        
         markov->calibrate(basket, method, ec);
         
 
diff --git a/Examples/GlobalOptimizer/GlobalOptimizer.cpp b/Examples/GlobalOptimizer/GlobalOptimizer.cpp
index 696fe7c9c27..6a46b9ee605 100644
--- a/Examples/GlobalOptimizer/GlobalOptimizer.cpp
+++ b/Examples/GlobalOptimizer/GlobalOptimizer.cpp
@@ -56,9 +56,9 @@ Real ackley(const Array& x) {
     //Minimum is found at 0
     Real p1 = 0.0, p2 = 0.0;
 
-    for (Size i = 0; i < x.size(); i++) {
-        p1 += x[i] * x[i];
-        p2 += std::cos(M_TWOPI*x[i]);
+    for (double i : x) {
+        p1 += i * i;
+        p2 += std::cos(M_TWOPI * i);
     }
     p1 = -0.2*std::sqrt(0.5*p1);
     p2 *= 0.5;
@@ -103,9 +103,9 @@ Real rosenbrock(const Array& x) {
 Real easom(const Array& x) {
     //Minimum is found at f(\pi, \pi, ...)
     Real p1 = 1.0, p2 = 0.0;
-    for (Size i = 0; i < x.size(); i++) {
-        p1 *= std::cos(x[i]);
-        p2 += (x[i] - M_PI)*(x[i] - M_PI);
+    for (double i : x) {
+        p1 *= std::cos(i);
+        p2 += (i - M_PI) * (i - M_PI);
     }
     return -p1*std::exp(-p2);
 }
diff --git a/Examples/LatentModel/LatentModel.cpp b/Examples/LatentModel/LatentModel.cpp
index beebb9bd7f2..af75fccd804 100644
--- a/Examples/LatentModel/LatentModel.cpp
+++ b/Examples/LatentModel/LatentModel.cpp
@@ -71,10 +71,10 @@ int main(int, char* []) {
             names.push_back(std::string("Acme") + 
                 boost::lexical_cast<std::string>(i));
         std::vector<Handle<DefaultProbabilityTermStructure> > defTS;
-        for(Size i=0; i<hazardRates.size(); i++)
+        defTS.reserve(hazardRates.size());
+        for (double& hazardRate : hazardRates)
             defTS.push_back(Handle<DefaultProbabilityTermStructure>(
-                ext::make_shared<FlatHazardRate>(0, TARGET(), hazardRates[i], 
-                    Actual365Fixed())));
+                ext::make_shared<FlatHazardRate>(0, TARGET(), hazardRate, Actual365Fixed())));
         std::vector<Issuer> issuers;
         for(Size i=0; i<hazardRates.size(); i++) {
             std::vector<QuantLib::Issuer::key_curve_pair> curves(1, 
diff --git a/Examples/MarketModels/MarketModels.cpp b/Examples/MarketModels/MarketModels.cpp
index 955d8c523ca..f045a4b2329 100644
--- a/Examples/MarketModels/MarketModels.cpp
+++ b/Examples/MarketModels/MarketModels.cpp
@@ -323,8 +323,8 @@ int Bermudan()
 
     std::vector<Real> means(stats.mean());
 
-    for (Size i=0; i < means.size(); ++i)
-        std::cout << means[i] << "\n";
+    for (double mean : means)
+        std::cout << mean << "\n";
 
     std::cout << " time to build strategy, " << (t2-t1)/static_cast<Real>(CLOCKS_PER_SEC)<< ", seconds.\n";
     std::cout << " time to price, " << (t3-t2)/static_cast<Real>(CLOCKS_PER_SEC)<< ", seconds.\n";
@@ -656,8 +656,8 @@ int InverseFloater(Real rateLevel)
 
     std::vector<Real> means(stats.mean());
 
-    for (Size i=0; i < means.size(); ++i)
-        std::cout << means[i] << "\n";
+    for (double mean : means)
+        std::cout << mean << "\n";
 
     std::cout << " time to build strategy, " << (t2-t1)/static_cast<Real>(CLOCKS_PER_SEC)<< ", seconds.\n";
     std::cout << " time to price, " << (t3-t2)/static_cast<Real>(CLOCKS_PER_SEC)<< ", seconds.\n";
diff --git a/Examples/MultidimIntegral/MultidimIntegral.cpp b/Examples/MultidimIntegral/MultidimIntegral.cpp
index ae9b6781704..02b069f2ee5 100644
--- a/Examples/MultidimIntegral/MultidimIntegral.cpp
+++ b/Examples/MultidimIntegral/MultidimIntegral.cpp
@@ -46,8 +46,8 @@ namespace QuantLib {
 struct integrand {
     Real operator()(const std::vector<Real>& arg) const {
         Real sum = 1.;
-        for(Size i=0; i<arg.size(); i++) 
-            sum *= std::exp(-arg[i]*arg[i]) * std::cos(arg[i]);
+        for (double i : arg)
+            sum *= std::exp(-i * i) * std::cos(i);
         return sum;
     }
 };
diff --git a/ql/cashflows/cashflows.cpp b/ql/cashflows/cashflows.cpp
index 3f8b5f424ad..a154a1c0201 100644
--- a/ql/cashflows/cashflows.cpp
+++ b/ql/cashflows/cashflows.cpp
@@ -39,12 +39,12 @@ namespace QuantLib {
         QL_REQUIRE(!leg.empty(), "empty leg");
 
         Date d = Date::maxDate();
-        for (Size i=0; i<leg.size(); ++i) {
-            ext::shared_ptr<Coupon> c = ext::dynamic_pointer_cast<Coupon>(leg[i]);
+        for (const auto& i : leg) {
+            ext::shared_ptr<Coupon> c = ext::dynamic_pointer_cast<Coupon>(i);
             if (c != nullptr)
                 d = std::min(d, c->accrualStartDate());
             else
-                d = std::min(d, leg[i]->date());
+                d = std::min(d, i->date());
         }
         return d;
     }
@@ -53,12 +53,12 @@ namespace QuantLib {
         QL_REQUIRE(!leg.empty(), "empty leg");
 
         Date d = Date::minDate();
-        for (Size i=0; i<leg.size(); ++i) {
-            ext::shared_ptr<Coupon> c = ext::dynamic_pointer_cast<Coupon>(leg[i]);
+        for (const auto& i : leg) {
+            ext::shared_ptr<Coupon> c = ext::dynamic_pointer_cast<Coupon>(i);
             if (c != nullptr)
                 d = std::max(d, c->accrualEndDate());
             else
-                d = std::max(d, leg[i]->date());
+                d = std::max(d, i->date());
         }
         return d;
     }
@@ -434,12 +434,10 @@ namespace QuantLib {
             npvDate = settlementDate;
 
         Real totalNPV = 0.0;
-        for (Size i=0; i<leg.size(); ++i) {
-            if (!leg[i]->hasOccurred(settlementDate,
-                                     includeSettlementDateFlows) &&
-                !leg[i]->tradingExCoupon(settlementDate))
-                totalNPV += leg[i]->amount() *
-                            discountCurve.discount(leg[i]->date());
+        for (const auto& i : leg) {
+            if (!i->hasOccurred(settlementDate, includeSettlementDateFlows) &&
+                !i->tradingExCoupon(settlementDate))
+                totalNPV += i->amount() * discountCurve.discount(i->date());
         }
 
         return totalNPV/discountCurve.discount(npvDate);
@@ -460,11 +458,10 @@ namespace QuantLib {
             npvDate = settlementDate;
 
         BPSCalculator calc(discountCurve);
-        for (Size i=0; i<leg.size(); ++i) {
-            if (!leg[i]->hasOccurred(settlementDate,
-                                     includeSettlementDateFlows) &&
-                !leg[i]->tradingExCoupon(settlementDate))
-                leg[i]->accept(calc);
+        for (const auto& i : leg) {
+            if (!i->hasOccurred(settlementDate, includeSettlementDateFlows) &&
+                !i->tradingExCoupon(settlementDate))
+                i->accept(calc);
         }
         return basisPoint_*calc.bps()/discountCurve.discount(npvDate);
     }
@@ -483,13 +480,12 @@ namespace QuantLib {
             return;
         }
 
-        for (Size i=0; i<leg.size(); ++i) {
-            CashFlow& cf = *leg[i];
+        for (const auto& i : leg) {
+            CashFlow& cf = *i;
             if (!cf.hasOccurred(settlementDate,
                                 includeSettlementDateFlows) &&
                 !cf.tradingExCoupon(settlementDate)) {
-                ext::shared_ptr<Coupon> cp =
-                    ext::dynamic_pointer_cast<Coupon>(leg[i]);
+                ext::shared_ptr<Coupon> cp = ext::dynamic_pointer_cast<Coupon>(i);
                 Real df = discountCurve.discount(cf.date());
                 npv += cf.amount() * df;
                 if (cp != nullptr)
@@ -518,8 +514,8 @@ namespace QuantLib {
 
         Real npv = 0.0;
         BPSCalculator calc(discountCurve);
-        for (Size i=0; i<leg.size(); ++i) {
-            CashFlow& cf = *leg[i];
+        for (const auto& i : leg) {
+            CashFlow& cf = *i;
             if (!cf.hasOccurred(settlementDate,
                                 includeSettlementDateFlows) &&
                 !cf.tradingExCoupon(settlementDate)) {
@@ -613,22 +609,21 @@ namespace QuantLib {
             Time t = 0.0;
             Date lastDate = npvDate;
             const DayCounter& dc = y.dayCounter();
-            for (Size i=0; i<leg.size(); ++i) {
-                if (leg[i]->hasOccurred(settlementDate,
-                                        includeSettlementDateFlows))
+            for (const auto& i : leg) {
+                if (i->hasOccurred(settlementDate, includeSettlementDateFlows))
                     continue;
 
-                Real c = leg[i]->amount();
-                if (leg[i]->tradingExCoupon(settlementDate)) {
+                Real c = i->amount();
+                if (i->tradingExCoupon(settlementDate)) {
                     c = 0.0;
                 }
 
-                t += getStepwiseDiscountTime(leg[i], dc, npvDate, lastDate);
+                t += getStepwiseDiscountTime(i, dc, npvDate, lastDate);
                 DiscountFactor B = y.discountFactor(t);
                 P += c * B;
                 dPdy += t * c * B;
-                
-                lastDate = leg[i]->date();
+
+                lastDate = i->date();
             }
             if (P == 0.0) // no cashflows
                 return 0.0;
@@ -656,17 +651,16 @@ namespace QuantLib {
             Natural N = y.frequency();
             Date lastDate = npvDate;
             const DayCounter& dc = y.dayCounter();
-            for (Size i=0; i<leg.size(); ++i) {
-                if (leg[i]->hasOccurred(settlementDate,
-                                        includeSettlementDateFlows))
+            for (const auto& i : leg) {
+                if (i->hasOccurred(settlementDate, includeSettlementDateFlows))
                     continue;
 
-                Real c = leg[i]->amount();
-                if (leg[i]->tradingExCoupon(settlementDate)) {
+                Real c = i->amount();
+                if (i->tradingExCoupon(settlementDate)) {
                     c = 0.0;
                 }
 
-                t += getStepwiseDiscountTime(leg[i], dc, npvDate, lastDate);
+                t += getStepwiseDiscountTime(i, dc, npvDate, lastDate);
                 DiscountFactor B = y.discountFactor(t);
                 P += c * B;
                 switch (y.compounding()) {
@@ -695,7 +689,7 @@ namespace QuantLib {
                     QL_FAIL("unknown compounding convention (" <<
                             Integer(y.compounding()) << ")");
                 }
-                lastDate = leg[i]->date();
+                lastDate = i->date();
             }
 
             if (P == 0.0) // no cashflows
@@ -770,11 +764,10 @@ namespace QuantLib {
 
         Integer lastSign = sign(-npv_),
                 signChanges = 0;
-        for (Size i = 0; i < leg_.size(); ++i) {
-            if (!leg_[i]->hasOccurred(settlementDate_,
-                                      includeSettlementDateFlows_) &&
-                !leg_[i]->tradingExCoupon(settlementDate_)) {
-                Integer thisSign = sign(leg_[i]->amount());
+        for (const auto& i : leg_) {
+            if (!i->hasOccurred(settlementDate_, includeSettlementDateFlows_) &&
+                !i->tradingExCoupon(settlementDate_)) {
+                Integer thisSign = sign(i->amount());
                 if (lastSign * thisSign < 0) // sign change
                     signChanges++;
 
@@ -831,19 +824,18 @@ namespace QuantLib {
         DiscountFactor discount = 1.0;
         Date lastDate = npvDate;
         const DayCounter& dc = y.dayCounter();
-        for (Size i=0; i<leg.size(); ++i) {
-            if (leg[i]->hasOccurred(settlementDate,
-                                    includeSettlementDateFlows))
+        for (const auto& i : leg) {
+            if (i->hasOccurred(settlementDate, includeSettlementDateFlows))
                 continue;
 
-            Real amount = leg[i]->amount();
-            if (leg[i]->tradingExCoupon(settlementDate)) {
+            Real amount = i->amount();
+            if (i->tradingExCoupon(settlementDate)) {
                 amount = 0.0;
             }
 
-            DiscountFactor b = y.discountFactor(getStepwiseDiscountTime(leg[i], dc, npvDate, lastDate));
+            DiscountFactor b = y.discountFactor(getStepwiseDiscountTime(i, dc, npvDate, lastDate));
             discount *= b;
-            lastDate = leg[i]->date();
+            lastDate = i->date();
 
             npv += amount * discount;
         }
@@ -991,17 +983,16 @@ namespace QuantLib {
         Rate r = y.rate();
         Natural N = y.frequency();
         Date lastDate = npvDate;
-        for (Size i=0; i<leg.size(); ++i) {
-            if (leg[i]->hasOccurred(settlementDate,
-                                        includeSettlementDateFlows))
+        for (const auto& i : leg) {
+            if (i->hasOccurred(settlementDate, includeSettlementDateFlows))
                 continue;
-            
-            Real c = leg[i]->amount();
-            if (leg[i]->tradingExCoupon(settlementDate)) {
+
+            Real c = i->amount();
+            if (i->tradingExCoupon(settlementDate)) {
                 c = 0.0;
             }
 
-            t += getStepwiseDiscountTime(leg[i], dc, npvDate, lastDate);
+            t += getStepwiseDiscountTime(i, dc, npvDate, lastDate);
             DiscountFactor B = y.discountFactor(t);
             P += c * B;
             switch (y.compounding()) {
@@ -1030,7 +1021,7 @@ namespace QuantLib {
                 QL_FAIL("unknown compounding convention (" <<
                         Integer(y.compounding()) << ")");
             }
-            lastDate = leg[i]->date();
+            lastDate = i->date();
         }
 
         if (P == 0.0)
diff --git a/ql/cashflows/cashflows.hpp b/ql/cashflows/cashflows.hpp
index fb7f0e389ca..d6ccc220f42 100644
--- a/ql/cashflows/cashflows.hpp
+++ b/ql/cashflows/cashflows.hpp
@@ -40,9 +40,6 @@ namespace QuantLib {
     /*! \todo add tests */
     class CashFlows {
       private:
-        CashFlows() = delete;
-        CashFlows(const CashFlows&) = delete;
-
         class IrrFinder {
           public:
             IrrFinder(const Leg& leg,
@@ -68,6 +65,9 @@ namespace QuantLib {
             Date settlementDate_, npvDate_;
         };
       public:
+        CashFlows() = delete;
+        CashFlows(const CashFlows&) = delete;
+
         //! \name Date functions
         //@{
         static Date startDate(const Leg& leg);
diff --git a/ql/cashflows/conundrumpricer.cpp b/ql/cashflows/conundrumpricer.cpp
index 231a1286fee..fa3a816cb5e 100644
--- a/ql/cashflows/conundrumpricer.cpp
+++ b/ql/cashflows/conundrumpricer.cpp
@@ -603,8 +603,8 @@ namespace QuantLib {
 
     Real GFunctionFactory::GFunctionExactYield::operator()(Real x) {
         Real product = 1.;
-        for(Size i=0; i<accruals_.size(); i++) {
-            product *= 1./(1.+ accruals_[i]*x);
+        for (double accrual : accruals_) {
+            product *= 1. / (1. + accrual * x);
         }
         return x*std::pow(1.+ accruals_[0]*x,-delta_)*(1./(1.-product));
     }
@@ -614,11 +614,11 @@ namespace QuantLib {
         Real derC = 0.;
         std::vector<Real> b;
         b.reserve(accruals_.size());
-        for (Size i=0; i<accruals_.size(); i++) {
-            Real temp = 1.0/(1.0+ accruals_[i]*x);
+        for (double accrual : accruals_) {
+            Real temp = 1.0 / (1.0 + accrual * x);
             b.push_back(temp);
             c *= temp;
-            derC += accruals_[i]*temp;
+            derC += accrual * temp;
         }
         c += 1.;
         c = 1./c;
@@ -636,12 +636,12 @@ namespace QuantLib {
         Real sumOfSquare = 0.;
         std::vector<Real> b;
         b.reserve(accruals_.size());
-        for(Size i=0; i<accruals_.size(); i++) {
-            Real temp = 1.0/(1.0+ accruals_[i]*x);
+        for (double accrual : accruals_) {
+            Real temp = 1.0 / (1.0 + accrual * x);
             b.push_back(temp);
             c *= temp;
-            sum += accruals_[i]*temp;
-            sumOfSquare += std::pow(accruals_[i]*temp, 2.0);
+            sum += accrual * temp;
+            sumOfSquare += std::pow(accrual * temp, 2.0);
         }
         c += 1.;
         c = 1./c;
diff --git a/ql/cashflows/conundrumpricer.hpp b/ql/cashflows/conundrumpricer.hpp
index e415c215fff..b0ee7620e53 100644
--- a/ql/cashflows/conundrumpricer.hpp
+++ b/ql/cashflows/conundrumpricer.hpp
@@ -74,6 +74,9 @@ namespace QuantLib {
                                ParallelShifts,
                                NonParallelShifts
         };
+
+        GFunctionFactory() = delete;
+
         static ext::shared_ptr<GFunction>
         newGFunctionStandard(Size q,
                              Real delta,
@@ -84,8 +87,6 @@ namespace QuantLib {
         newGFunctionWithShifts(const CmsCoupon& coupon,
                                const Handle<Quote>& meanReversion);
       private:
-        GFunctionFactory() = delete;
-
         class GFunctionStandard : public GFunction {
           public:
             GFunctionStandard(Size q,
diff --git a/ql/cashflows/couponpricer.cpp b/ql/cashflows/couponpricer.cpp
index bc648060820..1cc2146aa4e 100644
--- a/ql/cashflows/couponpricer.cpp
+++ b/ql/cashflows/couponpricer.cpp
@@ -329,14 +329,15 @@ namespace QuantLib {
         void setCouponPricersFirstMatching(const Leg& leg,
                                            const std::vector<ext::shared_ptr<FloatingRateCouponPricer> >& p) {
             std::vector<PricerSetter> setter;
-            for (Size i = 0; i < p.size(); ++i) {
-                setter.push_back(PricerSetter(p[i]));
+            setter.reserve(p.size());
+            for (const auto& i : p) {
+                setter.push_back(PricerSetter(i));
             }
-            for (Size i = 0; i < leg.size(); ++i) {
+            for (const auto& i : leg) {
                 Size j = 0;
                 do {
                     try {
-                        leg[i]->accept(setter[j]);
+                        i->accept(setter[j]);
                         j = p.size();
                     } catch (...) {
                         ++j;
@@ -349,8 +350,8 @@ namespace QuantLib {
 
     void setCouponPricer(const Leg& leg, const ext::shared_ptr<FloatingRateCouponPricer>& pricer) {
             PricerSetter setter(pricer);
-            for (Size i = 0; i < leg.size(); ++i) {
-                leg[i]->accept(setter);
+            for (const auto& i : leg) {
+                i->accept(setter);
             }
     }
 
diff --git a/ql/cashflows/inflationcouponpricer.cpp b/ql/cashflows/inflationcouponpricer.cpp
index 7f7247668d0..4d47fced65b 100644
--- a/ql/cashflows/inflationcouponpricer.cpp
+++ b/ql/cashflows/inflationcouponpricer.cpp
@@ -26,9 +26,8 @@ namespace QuantLib {
 
     void setCouponPricer(const Leg& leg,
                          const ext::shared_ptr<InflationCouponPricer>& p) {
-        for (Size i=0; i<leg.size(); ++i) {
-            ext::shared_ptr<InflationCoupon> c =
-                ext::dynamic_pointer_cast<InflationCoupon>(leg[i]);
+        for (const auto& i : leg) {
+            ext::shared_ptr<InflationCoupon> c = ext::dynamic_pointer_cast<InflationCoupon>(i);
             if (c != nullptr)
                 c->setPricer(p);
         }
diff --git a/ql/cashflows/lineartsrpricer.cpp b/ql/cashflows/lineartsrpricer.cpp
index 2e10b4875cf..2496d1d5ab2 100644
--- a/ql/cashflows/lineartsrpricer.cpp
+++ b/ql/cashflows/lineartsrpricer.cpp
@@ -169,9 +169,8 @@ namespace QuantLib {
             // compute linear model's parameters
 
             Real gx = 0.0, gy = 0.0;
-            for (Size i = 0; i < swap_->fixedLeg().size(); i++) {
-                ext::shared_ptr<Coupon> c =
-                    ext::dynamic_pointer_cast<Coupon>(swap_->fixedLeg()[i]);
+            for (const auto& i : swap_->fixedLeg()) {
+                ext::shared_ptr<Coupon> c = ext::dynamic_pointer_cast<Coupon>(i);
                 Real yf = c->accrualPeriod();
                 Date d = c->date();
                 Real pv = yf * discountCurve_->discount(d);
diff --git a/ql/cashflows/timebasket.cpp b/ql/cashflows/timebasket.cpp
index b74407c7206..d9e467e8525 100644
--- a/ql/cashflows/timebasket.cpp
+++ b/ql/cashflows/timebasket.cpp
@@ -41,12 +41,12 @@ namespace QuantLib {
 
         TimeBasket result;
 
-        for (Size i = 0; i < sbuckets.size(); i++)
-            result[sbuckets[i]] = 0.0;
+        for (auto& sbucket : sbuckets)
+            result[sbucket] = 0.0;
 
-        for (auto j = begin(); j != end(); ++j) {
-            Date date = j->first;
-            Real value = j->second;
+        for (auto j : *this) {
+            Date date = j.first;
+            Real value = j.second;
             Date pDate = Null<Date>(), nDate = Null<Date>();
 
             std::vector<Date>::const_iterator bi =
diff --git a/ql/cashflows/timebasket.hpp b/ql/cashflows/timebasket.hpp
index 2fa9092a51d..733d410204d 100644
--- a/ql/cashflows/timebasket.hpp
+++ b/ql/cashflows/timebasket.hpp
@@ -80,15 +80,15 @@ namespace QuantLib {
 
     inline TimeBasket& TimeBasket::operator+=(const TimeBasket& other) {
         super& self = *this;
-        for (auto j = other.begin(); j != other.end(); ++j)
-            self[j->first] += j->second;
+        for (auto j : other)
+            self[j.first] += j.second;
         return *this;
     }
 
     inline TimeBasket& TimeBasket::operator-=(const TimeBasket& other) {
         super& self = *this;
-        for (auto j = other.begin(); j != other.end(); ++j)
-            self[j->first] -= j->second;
+        for (auto j : other)
+            self[j.first] -= j.second;
         return *this;
     }
 
diff --git a/ql/experimental/asian/analytic_discr_geom_av_price_heston.cpp b/ql/experimental/asian/analytic_discr_geom_av_price_heston.cpp
index 0e4289bb8db..bf6ef562c80 100644
--- a/ql/experimental/asian/analytic_discr_geom_av_price_heston.cpp
+++ b/ql/experimental/asian/analytic_discr_geom_av_price_heston.cpp
@@ -235,8 +235,8 @@ namespace QuantLib {
 
         Time startTime = 0.0;
         std::vector<Time> fixingTimes, tauK;
-        for (Size i=0; i<arguments_.fixingDates.size(); i++) {
-            fixingTimes.push_back(this->process_->time(arguments_.fixingDates[i]));
+        for (auto& fixingDate : arguments_.fixingDates) {
+            fixingTimes.push_back(this->process_->time(fixingDate));
         }
         std::sort(fixingTimes.begin(), fixingTimes.end());
         tauK = fixingTimes;
@@ -262,12 +262,12 @@ namespace QuantLib {
         tkr_tk_ = std::vector<Real>();
         tr_t_ = -std::log(riskFreeRate_->discount(startTime) / dividendYield_->discount(startTime));
         Tr_T_ = -std::log(riskFreeRate_->discount(expiryTime) / dividendYield_->discount(expiryTime));
-        for (Size i=0; i<fixingTimes.size(); i++) {
-            if (fixingTimes[i] < 0) {
+        for (double fixingTime : fixingTimes) {
+            if (fixingTime < 0) {
                 tkr_tk_.push_back(1.0);
             } else {
-                tkr_tk_.push_back(-std::log(riskFreeRate_->discount(fixingTimes[i])
-                                            / dividendYield_->discount(fixingTimes[i])));
+                tkr_tk_.push_back(-std::log(riskFreeRate_->discount(fixingTime) /
+                                            dividendYield_->discount(fixingTime)));
             }
         }
 
diff --git a/ql/experimental/averageois/arithmeticaverageois.cpp b/ql/experimental/averageois/arithmeticaverageois.cpp
index 1956391c589..4e5f235bee5 100644
--- a/ql/experimental/averageois/arithmeticaverageois.cpp
+++ b/ql/experimental/averageois/arithmeticaverageois.cpp
@@ -82,15 +82,15 @@ namespace QuantLib {
         ext::shared_ptr<FloatingRateCouponPricer> arithmeticPricer(
                 new ArithmeticAveragedOvernightIndexedCouponPricer(mrs_, vol_, byApprox_));
 
-        for (Size i = 0; i < legs_[1].size(); i++) {
-            ext::shared_ptr<OvernightIndexedCoupon> 
-                c = ext::dynamic_pointer_cast<OvernightIndexedCoupon> (legs_[1][i]);
+        for (auto& i : legs_[1]) {
+            ext::shared_ptr<OvernightIndexedCoupon> c =
+                ext::dynamic_pointer_cast<OvernightIndexedCoupon>(i);
             c->setPricer(arithmeticPricer);
         }
 
         for (Size j=0; j<2; ++j) {
-            for (auto i = legs_[j].begin(); i != legs_[j].end(); ++i)
-                registerWith(*i);
+            for (auto& i : legs_[j])
+                registerWith(i);
         }
 
         switch (type_) {
diff --git a/ql/experimental/barrieroption/discretizeddoublebarrieroption.cpp b/ql/experimental/barrieroption/discretizeddoublebarrieroption.cpp
index 36f09e9cc92..2ef8f006752 100644
--- a/ql/experimental/barrieroption/discretizeddoublebarrieroption.cpp
+++ b/ql/experimental/barrieroption/discretizeddoublebarrieroption.cpp
@@ -70,12 +70,12 @@ namespace QuantLib {
                 stoppingTime = true;
             break;
           case Exercise::Bermudan:
-            for (Size i=0; i<stoppingTimes_.size(); i++) {
-                if (isOnTime(stoppingTimes_[i])) {
-                    stoppingTime = true;
-                    break;
-                }
-            }
+              for (double i : stoppingTimes_) {
+                  if (isOnTime(i)) {
+                      stoppingTime = true;
+                      break;
+                  }
+              }
             break;
           default:
             QL_FAIL("invalid option type");
diff --git a/ql/experimental/basismodels/swaptioncfs.cpp b/ql/experimental/basismodels/swaptioncfs.cpp
index 7781a1a3411..9831f852f7b 100644
--- a/ql/experimental/basismodels/swaptioncfs.cpp
+++ b/ql/experimental/basismodels/swaptioncfs.cpp
@@ -85,10 +85,10 @@ namespace QuantLib {
         // assemble raw cash flow data...
         Actual365Fixed dc;
         // ... float times/weights
-        for (Size k = 0; k < floatLeg_.size(); ++k)
-            floatTimes_.push_back(dc.yearFraction(refDate_, floatLeg_[k]->date()));
-        for (Size k = 0; k < floatLeg_.size(); ++k)
-            floatWeights_.push_back(floatLeg_[k]->amount());
+        for (auto& k : floatLeg_)
+            floatTimes_.push_back(dc.yearFraction(refDate_, k->date()));
+        for (auto& k : floatLeg_)
+            floatWeights_.push_back(k->amount());
     }
 
     SwapCashFlows::SwapCashFlows(const ext::shared_ptr<VanillaSwap>& swap,
@@ -97,18 +97,18 @@ namespace QuantLib {
     : IborLegCashFlows(swap->floatingLeg(), discountCurve, contTenorSpread) {
         // copy fixed leg coupons
         Leg fixedLeg = swap->fixedLeg();
-        for (Size k = 0; k < fixedLeg.size(); ++k) {
-            if (ext::dynamic_pointer_cast<Coupon>(fixedLeg[k])->accrualStartDate() >= refDate_)
-                fixedLeg_.push_back(fixedLeg[k]);
+        for (auto& k : fixedLeg) {
+            if (ext::dynamic_pointer_cast<Coupon>(k)->accrualStartDate() >= refDate_)
+                fixedLeg_.push_back(k);
         }
         Actual365Fixed dc;
         // ... fixed times/weights
-        for (Size k = 0; k < fixedLeg_.size(); ++k)
-            fixedTimes_.push_back(dc.yearFraction(refDate_, fixedLeg_[k]->date()));
-        for (Size k = 0; k < fixedLeg_.size(); ++k)
-            fixedWeights_.push_back(fixedLeg_[k]->amount());
-        for (Size k = 0; k < fixedLeg_.size(); ++k) {
-            ext::shared_ptr<Coupon> coupon = ext::dynamic_pointer_cast<Coupon>(fixedLeg_[k]);
+        for (auto& k : fixedLeg_)
+            fixedTimes_.push_back(dc.yearFraction(refDate_, k->date()));
+        for (auto& k : fixedLeg_)
+            fixedWeights_.push_back(k->amount());
+        for (auto& k : fixedLeg_) {
+            ext::shared_ptr<Coupon> coupon = ext::dynamic_pointer_cast<Coupon>(k);
             if (coupon != nullptr)
                 annuityWeights_.push_back(coupon->nominal() * coupon->accrualPeriod());
         }
diff --git a/ql/experimental/basismodels/tenoroptionletvts.cpp b/ql/experimental/basismodels/tenoroptionletvts.cpp
index c48814adc2f..9527c3e88f0 100644
--- a/ql/experimental/basismodels/tenoroptionletvts.cpp
+++ b/ql/experimental/basismodels/tenoroptionletvts.cpp
@@ -87,8 +87,8 @@ namespace QuantLib {
 
     Volatility TenorOptionletVTS::TenorOptionletSmileSection::volatilityImpl(Rate strike) const {
         Real sum_v = 0.0;
-        for (Size k = 0; k < v_.size(); ++k)
-            sum_v += v_[k];
+        for (double k : v_)
+            sum_v += k;
         std::vector<Real> volBase(v_.size());
         for (Size k = 0; k < fraRateBase_.size(); ++k) {
             Real strike_k = (strike - (fraRateTarg_ - sum_v * fraRateBase_[k])) / sum_v;
diff --git a/ql/experimental/basismodels/tenorswaptionvts.cpp b/ql/experimental/basismodels/tenorswaptionvts.cpp
index 74dd8f2f803..723a4839df7 100644
--- a/ql/experimental/basismodels/tenorswaptionvts.cpp
+++ b/ql/experimental/basismodels/tenorswaptionvts.cpp
@@ -91,8 +91,8 @@ namespace QuantLib {
         // calculate affine TSR model u and v
         // Sum tau_j   (fixed leg)
         Real sumTauj = 0.0;
-        for (Size k = 0; k < cfs.annuityWeights().size(); ++k)
-            sumTauj += cfs.annuityWeights()[k];
+        for (double k : cfs.annuityWeights())
+            sumTauj += k;
         // Sum tau_j (T_M - T_j)   (fixed leg)
         Real sumTaujDeltaT = 0.0;
         for (Size k = 0; k < cfs.annuityWeights().size(); ++k)
@@ -100,8 +100,8 @@ namespace QuantLib {
                 cfs.annuityWeights()[k] * (cfs.fixedTimes().back() - cfs.fixedTimes()[k]);
         // Sum w_i   (float leg)
         Real sumWi = 0.0;
-        for (Size k = 0; k < cfs.floatWeights().size(); ++k)
-            sumWi += cfs.floatWeights()[k];
+        for (double k : cfs.floatWeights())
+            sumWi += k;
         // Sum w_i (T_N - T_i)    (float leg)
         Real sumWiDeltaT = 0.0;
         for (Size k = 0; k < cfs.floatWeights().size(); ++k)
diff --git a/ql/experimental/callablebonds/callablebond.cpp b/ql/experimental/callablebonds/callablebond.cpp
index c5d22c02c33..a556b321e74 100644
--- a/ql/experimental/callablebonds/callablebond.cpp
+++ b/ql/experimental/callablebonds/callablebond.cpp
@@ -40,9 +40,8 @@ namespace QuantLib {
 
         if (!putCallSchedule_.empty()) {
             Date finalOptionDate = Date::minDate();
-            for (Size i=0; i<putCallSchedule_.size();++i) {
-                finalOptionDate=std::max(finalOptionDate,
-                                         putCallSchedule_[i]->date());
+            for (auto& i : putCallSchedule_) {
+                finalOptionDate = std::max(finalOptionDate, i->date());
             }
             QL_REQUIRE(finalOptionDate <= maturityDate_ ,
                        "Bond cannot mature before last call/put date");
@@ -415,11 +414,10 @@ namespace QuantLib {
         if (settlement == Date()) settlement = settlementDate();
 
         const bool IncludeToday = false;
-        for (Size i = 0; i<cashflows_.size(); ++i) {
+        for (const auto& cashflow : cashflows_) {
             // the first coupon paying after d is the one we're after
-            if (!cashflows_[i]->hasOccurred(settlement,IncludeToday)) {
-                ext::shared_ptr<Coupon> coupon =
-                    ext::dynamic_pointer_cast<Coupon>(cashflows_[i]);
+            if (!cashflow->hasOccurred(settlement, IncludeToday)) {
+                ext::shared_ptr<Coupon> coupon = ext::dynamic_pointer_cast<Coupon>(cashflow);
                 if (coupon != nullptr)
                     // !!!
                     return coupon->accruedAmount(settlement) /
@@ -470,21 +468,18 @@ namespace QuantLib {
         arguments->frequency = frequency_;
 
         arguments->putCallSchedule = putCallSchedule_;
-        for (Size i=0; i<putCallSchedule_.size(); i++) {
-            if (!putCallSchedule_[i]->hasOccurred(settlement, false)) {
-                arguments->callabilityDates.push_back(
-                                                 putCallSchedule_[i]->date());
-                arguments->callabilityPrices.push_back(
-                                       putCallSchedule_[i]->price().amount());
-
-                if (putCallSchedule_[i]->price().type() == Bond::Price::Clean) {
+        for (const auto& i : putCallSchedule_) {
+            if (!i->hasOccurred(settlement, false)) {
+                arguments->callabilityDates.push_back(i->date());
+                arguments->callabilityPrices.push_back(i->price().amount());
+
+                if (i->price().type() == Bond::Price::Clean) {
                     /* calling accrued() forces accrued interest to be zero
                        if future option date is also coupon date, so that dirty
                        price = clean price. Use here because callability is
                        always applied before coupon in the tree engine.
                     */
-                    arguments->callabilityPrices.back() +=
-                        this->accrued(putCallSchedule_[i]->date());
+                    arguments->callabilityPrices.back() += this->accrued(i->date());
                 }
             }
         }
diff --git a/ql/experimental/callablebonds/discretizedcallablefixedratebond.cpp b/ql/experimental/callablebonds/discretizedcallablefixedratebond.cpp
index 750bc0bf30d..f5c8252ecee 100644
--- a/ql/experimental/callablebonds/discretizedcallablefixedratebond.cpp
+++ b/ql/experimental/callablebonds/discretizedcallablefixedratebond.cpp
@@ -53,11 +53,10 @@ namespace QuantLib {
                                         args.callabilityDates[i]);
 
         // To avoid mispricing, we snap exercise dates to the closest coupon date.
-        for (Size i=0; i<callabilityTimes_.size(); i++) {
-            Time& exerciseTime = callabilityTimes_[i];
-            for (Size j=0; j<couponTimes_.size(); j++) {
-                if (withinNextWeek(exerciseTime, couponTimes_[j])) {
-                    exerciseTime = couponTimes_[j];
+        for (double& exerciseTime : callabilityTimes_) {
+            for (double couponTime : couponTimes_) {
+                if (withinNextWeek(exerciseTime, couponTime)) {
+                    exerciseTime = couponTime;
                     break;
                 }
             }
diff --git a/ql/experimental/catbonds/montecarlocatbondengine.cpp b/ql/experimental/catbonds/montecarlocatbondengine.cpp
index 3fe5345ed95..fdc8bd4dd5b 100644
--- a/ql/experimental/catbonds/montecarlocatbondengine.cpp
+++ b/ql/experimental/catbonds/montecarlocatbondengine.cpp
@@ -118,11 +118,10 @@ namespace QuantLib {
                                           Date settlementDate, 
                                           const NotionalPath& notionalPath) const {
         Real totalNPV = 0.0;
-        for (Size i=0; i<arguments_.cashflows.size(); ++i) {
-            if (!arguments_.cashflows[i]->hasOccurred(settlementDate, 
-                                        includeSettlementDateFlows)) {
-                Real amount = cashFlowRiskyValue(arguments_.cashflows[i], notionalPath);
-                totalNPV += amount * discountCurve_->discount(arguments_.cashflows[i]->date());
+        for (auto& cashflow : arguments_.cashflows) {
+            if (!cashflow->hasOccurred(settlementDate, includeSettlementDateFlows)) {
+                Real amount = cashFlowRiskyValue(cashflow, notionalPath);
+                totalNPV += amount * discountCurve_->discount(cashflow->date());
             }
         }
         return totalNPV;
diff --git a/ql/experimental/catbonds/riskynotional.cpp b/ql/experimental/catbonds/riskynotional.cpp
index 63994c257c2..934ca33eac9 100644
--- a/ql/experimental/catbonds/riskynotional.cpp
+++ b/ql/experimental/catbonds/riskynotional.cpp
@@ -50,9 +50,9 @@ namespace QuantLib
     void DigitalNotionalRisk::updatePath(const std::vector<std::pair<Date, Real> >  &events, 
                                          NotionalPath &path) const {
         path.reset();
-        for(size_t i=0; i<events.size(); ++i) {
-            if(events[i].second>=threshold_) {
-                path.addReduction(paymentOffset_->paymentDate(events[i].first), Rate(0.0));
+        for (const auto& event : events) {
+            if (event.second >= threshold_) {
+                path.addReduction(paymentOffset_->paymentDate(event.first), Rate(0.0));
             }
         }
     }
diff --git a/ql/experimental/catbonds/riskynotional.hpp b/ql/experimental/catbonds/riskynotional.hpp
index 2b0e1d034d4..3fed62368b5 100644
--- a/ql/experimental/catbonds/riskynotional.hpp
+++ b/ql/experimental/catbonds/riskynotional.hpp
@@ -103,13 +103,12 @@ namespace QuantLib {
             path.reset();
             Real losses = 0;
             Real previousNotional = 1;
-            for(size_t i=0; i<events.size(); ++i)
-            {
-                losses+=events[i].second;
+            for (const auto& event : events) {
+                losses += event.second;
                 if(losses>attachement_ && previousNotional>0)
                 {
                     previousNotional = std::max(0.0, (exhaustion_-losses)/(exhaustion_-attachement_));
-                    path.addReduction(paymentOffset_->paymentDate(events[i].first), previousNotional);
+                    path.addReduction(paymentOffset_->paymentDate(event.first), previousNotional);
                 }
             }
         }
diff --git a/ql/experimental/commodities/commodity.cpp b/ql/experimental/commodities/commodity.cpp
index 846eacac2de..81aeff18dac 100644
--- a/ql/experimental/commodities/commodity.cpp
+++ b/ql/experimental/commodities/commodity.cpp
@@ -47,14 +47,13 @@ namespace QuantLib {
         Real totalAmount = 0;
 
         out << "secondary costs" << std::endl;
-        for (auto i = secondaryCostAmounts.begin(); i != secondaryCostAmounts.end(); ++i) {
-            Real amount = i->second.value();
+        for (const auto& secondaryCostAmount : secondaryCostAmounts) {
+            Real amount = secondaryCostAmount.second.value();
             if (currencyCode.empty())
-                currencyCode = i->second.currency().code();
+                currencyCode = secondaryCostAmount.second.currency().code();
             totalAmount += amount;
-            out << std::setw(28) << std::left << i->first
-                << std::setw(12) << std::right << std::fixed
-                << std::setprecision(2) << amount << " " << currencyCode
+            out << std::setw(28) << std::left << secondaryCostAmount.first << std::setw(12)
+                << std::right << std::fixed << std::setprecision(2) << amount << " " << currencyCode
                 << std::endl;
         }
         out << std::setw(28) << std::left << "total"
@@ -89,8 +88,8 @@ namespace QuantLib {
     std::ostream& operator<<(std::ostream& out, const PricingErrors& errors) {
         if (!errors.empty()) {
             out << "*** pricing errors" << std::endl;
-            for (auto i = errors.begin(); i != errors.end(); ++i)
-                out << *i << std::endl;
+            for (const auto& error : errors)
+                out << error << std::endl;
         }
         return out;
     }
diff --git a/ql/experimental/commodities/commoditycashflow.cpp b/ql/experimental/commodities/commoditycashflow.cpp
index 5fb833849ca..553cad980ee 100644
--- a/ql/experimental/commodities/commoditycashflow.cpp
+++ b/ql/experimental/commodities/commoditycashflow.cpp
@@ -39,20 +39,16 @@ namespace QuantLib {
         std::string currencyCode; //= cashFlows[0]->discountedAmount().currency().code();
         Real totalDiscounted = 0;
         Real totalUndiscounted = 0;
-        for (auto i = cashFlows.begin(); i != cashFlows.end(); ++i) {
+        for (const auto& i : cashFlows) {
             //const ext::shared_ptr<CommodityCashFlow> cashFlow = *i;
-            const ext::shared_ptr<CommodityCashFlow> cashFlow = i->second;
+            const ext::shared_ptr<CommodityCashFlow> cashFlow = i.second;
             totalDiscounted += cashFlow->discountedAmount().value();
             totalUndiscounted += cashFlow->undiscountedAmount().value();
             //out << io::iso_date(cashFlow->date()) << " " <<
-            out << io::iso_date(i->first) << " "
-                << std::setw(16) << std::right << std::fixed
-                << std::setprecision(2) << cashFlow->discountedAmount().value()
-                << " " << currencyCode <<
-                std::setw(16) << std::right << std::fixed
-                << std::setprecision(2)
-                << cashFlow->undiscountedAmount().value() << " " <<
-                currencyCode << std::endl;
+            out << io::iso_date(i.first) << " " << std::setw(16) << std::right << std::fixed
+                << std::setprecision(2) << cashFlow->discountedAmount().value() << " "
+                << currencyCode << std::setw(16) << std::right << std::fixed << std::setprecision(2)
+                << cashFlow->undiscountedAmount().value() << " " << currencyCode << std::endl;
         }
         out << "total      "
             << std::setw(16) << std::right << std::fixed
diff --git a/ql/experimental/commodities/commodityindex.hpp b/ql/experimental/commodities/commodityindex.hpp
index 49018d0fd68..8ad50e5bd9b 100644
--- a/ql/experimental/commodities/commodityindex.hpp
+++ b/ql/experimental/commodities/commodityindex.hpp
@@ -70,8 +70,8 @@ namespace QuantLib {
         void addQuotes(const std::map<Date, Real>& quotes) {
             std::string tag = name();
             quotes_ = IndexManager::instance().getHistory(tag);
-            for (auto ii = quotes.begin(); ii != quotes.end(); ++ii) {
-                quotes_[ii->first] = ii->second;
+            for (auto quote : quotes) {
+                quotes_[quote.first] = quote.second;
             }
             IndexManager::instance().setHistory(tag, quotes_);
         }
diff --git a/ql/experimental/commodities/energybasisswap.cpp b/ql/experimental/commodities/energybasisswap.cpp
index eca18448623..d70814bcb74 100644
--- a/ql/experimental/commodities/energybasisswap.cpp
+++ b/ql/experimental/commodities/energybasisswap.cpp
@@ -155,9 +155,7 @@ namespace QuantLib {
             Real totalQuantityAmount = 0;
 
             // price each period
-            for (auto pi = pricingPeriods_.begin(); pi != pricingPeriods_.end(); ++pi) {
-                const ext::shared_ptr<PricingPeriod>& pricingPeriod = *pi;
-
+            for (const auto& pricingPeriod : pricingPeriods_) {
                 Integer periodDayCount = 0;
 
                 // get the index quotes
diff --git a/ql/experimental/commodities/energycommodity.cpp b/ql/experimental/commodities/energycommodity.cpp
index 286ca6e33a7..8d4f50cddfb 100644
--- a/ql/experimental/commodities/energycommodity.cpp
+++ b/ql/experimental/commodities/energycommodity.cpp
@@ -45,21 +45,16 @@ namespace QuantLib {
             << std::setw(14) << std::right << "delta"
             << std::setw(10) << std::right << "open" << std::endl;
 
-        for (auto i = dailyPositions.begin(); i != dailyPositions.end(); ++i) {
-            const EnergyDailyPosition& dailyPosition = i->second;
-            out << std::setw(4) << io::iso_date(i->first) << "  "
-                << std::setw(12) << std::right << std::fixed
-                << std::setprecision(6) << dailyPosition.payLegPrice
-                << std::setw(12) << std::right << std::fixed
-                << std::setprecision(6) << dailyPosition.receiveLegPrice
-                << std::setw(10) << std::right << std::fixed
-                << std::setprecision(2) << dailyPosition.quantityAmount
-                << std::setw(14) << std::right << std::fixed
-                << std::setprecision(2) << dailyPosition.riskDelta
-                << std::setw(10) << std::right << std::fixed
-                << std::setprecision(2)
-                << (dailyPosition.unrealized ? dailyPosition.quantityAmount : 0)
-                << std::endl;
+        for (const auto& i : dailyPositions) {
+            const EnergyDailyPosition& dailyPosition = i.second;
+            out << std::setw(4) << io::iso_date(i.first) << "  " << std::setw(12) << std::right
+                << std::fixed << std::setprecision(6) << dailyPosition.payLegPrice << std::setw(12)
+                << std::right << std::fixed << std::setprecision(6) << dailyPosition.receiveLegPrice
+                << std::setw(10) << std::right << std::fixed << std::setprecision(2)
+                << dailyPosition.quantityAmount << std::setw(14) << std::right << std::fixed
+                << std::setprecision(2) << dailyPosition.riskDelta << std::setw(10) << std::right
+                << std::fixed << std::setprecision(2)
+                << (dailyPosition.unrealized ? dailyPosition.quantityAmount : 0) << std::endl;
         }
 
         return out;
diff --git a/ql/experimental/commodities/energyswap.cpp b/ql/experimental/commodities/energyswap.cpp
index e29e8fb53c3..7d912207e9d 100644
--- a/ql/experimental/commodities/energyswap.cpp
+++ b/ql/experimental/commodities/energyswap.cpp
@@ -40,8 +40,8 @@ namespace QuantLib {
 
     Quantity EnergySwap::quantity() const {
         Real totalQuantityAmount = 0;
-        for (auto pi = pricingPeriods_.begin(); pi != pricingPeriods_.end(); ++pi) {
-            totalQuantityAmount += (*pi)->quantity().amount();
+        for (const auto& pricingPeriod : pricingPeriods_) {
+            totalQuantityAmount += pricingPeriod->quantity().amount();
         }
         return Quantity(pricingPeriods_[0]->quantity().commodityType(),
                         pricingPeriods_[0]->quantity().unitOfMeasure(),
diff --git a/ql/experimental/commodities/energyvanillaswap.cpp b/ql/experimental/commodities/energyvanillaswap.cpp
index 8b93896ce91..c6c26e06ef5 100644
--- a/ql/experimental/commodities/energyvanillaswap.cpp
+++ b/ql/experimental/commodities/energyvanillaswap.cpp
@@ -124,11 +124,8 @@ namespace QuantLib {
             Real totalQuantityAmount = 0;
 
             // price each period
-            for (auto pi = pricingPeriods_.begin(); pi != pricingPeriods_.end(); ++pi) {
-                const ext::shared_ptr<PricingPeriod>& pricingPeriod = *pi;
-
-                QL_REQUIRE(pricingPeriod->quantity().amount() != 0,
-                           "quantity is zero");
+            for (const auto& pricingPeriod : pricingPeriods_) {
+                QL_REQUIRE(pricingPeriod->quantity().amount() != 0, "quantity is zero");
 
                 Integer periodDayCount = 0;
 
diff --git a/ql/experimental/commodities/unitofmeasureconversionmanager.cpp b/ql/experimental/commodities/unitofmeasureconversionmanager.cpp
index 01b96e55c75..bbd770df9f7 100644
--- a/ql/experimental/commodities/unitofmeasureconversionmanager.cpp
+++ b/ql/experimental/commodities/unitofmeasureconversionmanager.cpp
@@ -139,9 +139,9 @@ namespace QuantLib {
                                            const UnitOfMeasure& source,
                                            const UnitOfMeasure& target) const {
 
-        for (auto i = data_.begin(); i != data_.end(); ++i) {
-            if (matches(*i, commodityType, source, target)) {
-                return *i;
+        for (const auto& i : data_) {
+            if (matches(i, commodityType, source, target)) {
+                return i;
             }
         }
 
@@ -178,11 +178,10 @@ namespace QuantLib {
         // to avoid cycles.
         forbidden.push_back(source.code());
 
-        for (auto i = data_.begin(); i != data_.end(); ++i) {
+        for (const auto& i : data_) {
             // we look for conversion data which involve our source unit...
-            if (matches(*i, commodityType, source)) {
-                const UnitOfMeasure& other =
-                    source == i->source() ? i->target() : i->source();
+            if (matches(i, commodityType, source)) {
+                const UnitOfMeasure& other = source == i.source() ? i.target() : i.source();
                 if (find(forbidden.begin(),forbidden.end(),
                          other.code()) == forbidden.end()) {
                     // if we can get to the target from here...
@@ -190,7 +189,7 @@ namespace QuantLib {
                         UnitOfMeasureConversion tail =
                             smartLookup(commodityType,other,target);
                         // ..we're done.
-                        return UnitOfMeasureConversion::chain(*i,tail);
+                        return UnitOfMeasureConversion::chain(i, tail);
                     } catch (Error&) {
                         // otherwise, we just discard this conversion.
                         ;
diff --git a/ql/experimental/convertiblebonds/convertiblebond.cpp b/ql/experimental/convertiblebonds/convertiblebond.cpp
index d24cac4c3e0..a33a86101af 100644
--- a/ql/experimental/convertiblebonds/convertiblebond.cpp
+++ b/ql/experimental/convertiblebonds/convertiblebond.cpp
@@ -258,10 +258,10 @@ namespace QuantLib {
 
         moreArgs->dividends.clear();
         moreArgs->dividendDates.clear();
-        for (Size i=0; i<dividends_.size(); i++) {
-            if (!dividends_[i]->hasOccurred(settlement, false)) {
-                moreArgs->dividends.push_back(dividends_[i]);
-                moreArgs->dividendDates.push_back(dividends_[i]->date());
+        for (const auto& dividend : dividends_) {
+            if (!dividend->hasOccurred(settlement, false)) {
+                moreArgs->dividends.push_back(dividend);
+                moreArgs->dividendDates.push_back(dividend->date());
             }
         }
 
diff --git a/ql/experimental/convertiblebonds/discretizedconvertible.cpp b/ql/experimental/convertiblebonds/discretizedconvertible.cpp
index adf73070eba..fab9c5b0539 100644
--- a/ql/experimental/convertiblebonds/discretizedconvertible.cpp
+++ b/ql/experimental/convertiblebonds/discretizedconvertible.cpp
@@ -72,14 +72,14 @@ namespace QuantLib {
 
         if (!grid.empty()) {
             // adjust times to grid
-            for (Size i=0; i<stoppingTimes_.size(); i++)
-                stoppingTimes_[i] = grid.closestTime(stoppingTimes_[i]);
-            for (Size i=0; i<couponTimes_.size(); i++)
-                couponTimes_[i] = grid.closestTime(couponTimes_[i]);
-            for (Size i=0; i<callabilityTimes_.size(); i++)
-                callabilityTimes_[i] = grid.closestTime(callabilityTimes_[i]);
-            for (Size i=0; i<dividendTimes_.size(); i++)
-                dividendTimes_[i] = grid.closestTime(dividendTimes_[i]);
+            for (double& stoppingTime : stoppingTimes_)
+                stoppingTime = grid.closestTime(stoppingTime);
+            for (double& couponTime : couponTimes_)
+                couponTime = grid.closestTime(couponTime);
+            for (double& callabilityTime : callabilityTimes_)
+                callabilityTime = grid.closestTime(callabilityTime);
+            for (double& dividendTime : dividendTimes_)
+                dividendTime = grid.closestTime(dividendTime);
         }
     }
 
@@ -128,10 +128,10 @@ namespace QuantLib {
                 convertible = true;
             break;
           case Exercise::Bermudan:
-            for (Size i=0; i<stoppingTimes_.size(); ++i) {
-                if (isOnTime(stoppingTimes_[i]))
-                    convertible = true;
-            }
+              for (double stoppingTime : stoppingTimes_) {
+                  if (isOnTime(stoppingTime))
+                      convertible = true;
+              }
             break;
           default:
             QL_FAIL("invalid option type");
@@ -224,8 +224,8 @@ namespace QuantLib {
                 DiscountFactor dividendDiscount =
                     process_->riskFreeRate()->discount(dividendTime) /
                     process_->riskFreeRate()->discount(t);
-                for (Size j=0; j<grid.size(); j++)
-                    grid[j] += d->amount(grid[j])*dividendDiscount;
+                for (double& j : grid)
+                    j += d->amount(j) * dividendDiscount;
             }
         }
         return grid;
diff --git a/ql/experimental/coupons/strippedcapflooredcoupon.cpp b/ql/experimental/coupons/strippedcapflooredcoupon.cpp
index eb4b25515f2..020cc13c44c 100644
--- a/ql/experimental/coupons/strippedcapflooredcoupon.cpp
+++ b/ql/experimental/coupons/strippedcapflooredcoupon.cpp
@@ -112,12 +112,12 @@ namespace QuantLib {
         Leg resultLeg;
         resultLeg.reserve(underlyingLeg_.size());
         ext::shared_ptr<CappedFlooredCoupon> c;
-        for (auto i = underlyingLeg_.begin(); i != underlyingLeg_.end(); ++i) {
-            if ((c = ext::dynamic_pointer_cast<CappedFlooredCoupon>(*i)) != nullptr) {
+        for (const auto& i : underlyingLeg_) {
+            if ((c = ext::dynamic_pointer_cast<CappedFlooredCoupon>(i)) != nullptr) {
                 resultLeg.push_back(
                     ext::make_shared<StrippedCappedFlooredCoupon>(c));
             } else {
-                resultLeg.push_back(*i);
+                resultLeg.push_back(i);
             }
         }
         return resultLeg;
diff --git a/ql/experimental/credit/basecorrelationstructure.hpp b/ql/experimental/credit/basecorrelationstructure.hpp
index 10eb2989ae6..ead60f56571 100644
--- a/ql/experimental/credit/basecorrelationstructure.hpp
+++ b/ql/experimental/credit/basecorrelationstructure.hpp
@@ -75,13 +75,10 @@ namespace QuantLib {
           lossLevel_(lossLevel),
           trancheTimes_(tenors.size(), 0.) {
               checkTrancheTenors();
-               
-              for(Size i=0; i<tenors_.size(); i++)
+
+              for (auto& tenor : tenors_)
                   trancheDates_.push_back(
-                      calendar().advance(referenceDate(),
-                                         tenors_[i],
-                                         businessDayConvention())
-                                          );
+                      calendar().advance(referenceDate(), tenor, businessDayConvention()));
 
               initializeTrancheTimes();
               checkInputs(correlations_.rows(), correlations_.columns());
diff --git a/ql/experimental/credit/basket.cpp b/ql/experimental/credit/basket.cpp
index db94f1a2fdb..f29397184a1 100644
--- a/ql/experimental/credit/basket.cpp
+++ b/ql/experimental/credit/basket.cpp
@@ -59,10 +59,10 @@ namespace QuantLib {
         //   probability term structures for the defultKeys(eventType+
         //   currency+seniority) entering in this basket. This is not
         //   necessarily a problem.
-        for (Size i = 0; i < notionals_.size(); i++) {
-            basketNotional_ += notionals_[i];
-            attachmentAmount_ += notionals_[i] * attachmentRatio_;
-            detachmentAmount_ += notionals_[i] * detachmentRatio_;
+        for (double notional : notionals_) {
+            basketNotional_ += notional;
+            attachmentAmount_ += notional * attachmentRatio_;
+            detachmentAmount_ += notional * detachmentRatio_;
         }
         trancheNotional_ = detachmentAmount_ - attachmentAmount_;
     }
@@ -254,8 +254,9 @@ namespace QuantLib {
 
         const std::vector<Size>& alive = liveList(endDate);
         std::vector<std::string> calcBufferNames;
-        for(Size i=0; i<alive.size(); i++)
-            calcBufferNames.push_back(pool_->names()[alive[i]]);
+        calcBufferNames.reserve(alive.size());
+        for (unsigned long i : alive)
+            calcBufferNames.push_back(pool_->names()[i]);
         return calcBufferNames;
     }
 
@@ -267,8 +268,9 @@ namespace QuantLib {
 
         const std::vector<Size>& alive = liveList(endDate);
         vector<DefaultProbKey> defKeys;
-        for(Size i=0; i<alive.size(); i++)
-            defKeys.push_back(pool_->defaultKeys()[alive[i]]);
+        defKeys.reserve(alive.size());
+        for (unsigned long i : alive)
+            defKeys.push_back(pool_->defaultKeys()[i]);
         return defKeys;
     }
 
diff --git a/ql/experimental/credit/binomiallossmodel.hpp b/ql/experimental/credit/binomiallossmodel.hpp
index 6d00980b7ed..32ae467bdd7 100644
--- a/ql/experimental/credit/binomiallossmodel.hpp
+++ b/ql/experimental/credit/binomiallossmodel.hpp
@@ -127,9 +127,9 @@ namespace QuantLib {
         {
             std::vector<Real> condLgds;
             const std::vector<Size>& evalDateLives = basket_->liveList();
-            for(Size i=0; i<evalDateLives.size(); i++) 
-                condLgds.push_back(1.-copula_->conditionalRecovery(d, 
-                    evalDateLives[i], mktFactors));
+            condLgds.reserve(evalDateLives.size());
+            for (unsigned long evalDateLive : evalDateLives)
+                condLgds.push_back(1. - copula_->conditionalRecovery(d, evalDateLive, mktFactors));
             return condLgds;
         }
 
diff --git a/ql/experimental/credit/cdo.cpp b/ql/experimental/credit/cdo.cpp
index 5172c0ec675..a31d48caf25 100644
--- a/ql/experimental/credit/cdo.cpp
+++ b/ql/experimental/credit/cdo.cpp
@@ -53,8 +53,8 @@ namespace QuantLib {
 
         registerWith (yieldTS_);
         registerWith (copula_);
-        for (Size i = 0; i < basket_.size(); i++)
-            registerWith (basket_[i]);
+        for (auto& i : basket_)
+            registerWith(i);
 
         QL_REQUIRE (nominals_.size() <= basket_.size(),
                     "nominal vector size too large");
diff --git a/ql/experimental/credit/defaultevent.cpp b/ql/experimental/credit/defaultevent.cpp
index faec3888460..9ced640409f 100644
--- a/ql/experimental/credit/defaultevent.cpp
+++ b/ql/experimental/credit/defaultevent.cpp
@@ -66,8 +66,8 @@ namespace QuantLib {
         const Real recoveryRate)
     : settlementDate_(date), recoveryRates_(makeIsdaConvMap()) {
         if (seniority == NoSeniority) {
-            for (auto i = recoveryRates_.begin(); i != recoveryRates_.end(); ++i) {
-                i->second = recoveryRate;
+            for (auto& i : recoveryRates_) {
+                i.second = recoveryRate;
             }
         } else {
             recoveryRates_[seniority] = recoveryRate;
diff --git a/ql/experimental/credit/distribution.cpp b/ql/experimental/credit/distribution.cpp
index b85d4de9a90..13da2846de8 100644
--- a/ql/experimental/credit/distribution.cpp
+++ b/ql/experimental/credit/distribution.cpp
@@ -267,9 +267,8 @@ namespace QuantLib {
         dx_.erase(dx_.begin() + size_, dx_.end());
 
         // truncate
-        for (Size i = 0; i < x_.size(); i++) {
-            x_[i] = std::min(std::max(x_[i] - attachmentPoint, 0.), 
-                detachmentPoint - attachmentPoint);
+        for (double& i : x_) {
+            i = std::min(std::max(i - attachmentPoint, 0.), detachmentPoint - attachmentPoint);
         }
 
         density_.clear(); 
diff --git a/ql/experimental/credit/gaussianlhplossmodel.cpp b/ql/experimental/credit/gaussianlhplossmodel.cpp
index 1e2d9ad6d96..e1a6c173b27 100644
--- a/ql/experimental/credit/gaussianlhplossmodel.cpp
+++ b/ql/experimental/credit/gaussianlhplossmodel.cpp
@@ -44,8 +44,8 @@ namespace QuantLib {
           biphi_(-sqrt(correlQuote->value()))
         {
             registerWith(correl_);
-            for(Size i=0; i<quotes.size(); i++)
-                registerWith(quotes[i]);
+            for (const auto& quote : quotes)
+                registerWith(quote);
     }
 
     GaussianLHPLossModel::GaussianLHPLossModel(
@@ -60,9 +60,9 @@ namespace QuantLib {
           beta_(sqrt(correlation)),
           biphi_(-sqrt(correlation))
         {
-            for(Size i=0; i<recoveries.size(); i++)
-                rrQuotes_.push_back(Handle<RecoveryRateQuote>(
-                ext::make_shared<RecoveryRateQuote>(recoveries[i])));
+        for (double recoverie : recoveries)
+            rrQuotes_.push_back(
+                Handle<RecoveryRateQuote>(ext::make_shared<RecoveryRateQuote>(recoverie)));
         }
 
         GaussianLHPLossModel::GaussianLHPLossModel(
@@ -78,9 +78,9 @@ namespace QuantLib {
           biphi_(-sqrt(correlQuote->value()))
         {
             registerWith(correl_);
-            for(Size i=0; i<recoveries.size(); i++)
-                rrQuotes_.push_back(Handle<RecoveryRateQuote>(
-                ext::make_shared<RecoveryRateQuote>(recoveries[i])));
+            for (double recoverie : recoveries)
+                rrQuotes_.push_back(
+                    Handle<RecoveryRateQuote>(ext::make_shared<RecoveryRateQuote>(recoverie)));
         }
 
 
diff --git a/ql/experimental/credit/integralcdoengine.cpp b/ql/experimental/credit/integralcdoengine.cpp
index 4b6a95c476b..86ea7bcbd39 100644
--- a/ql/experimental/credit/integralcdoengine.cpp
+++ b/ql/experimental/credit/integralcdoengine.cpp
@@ -52,16 +52,14 @@ namespace QuantLib {
                     arguments_.normalizedLeg[0])->accrualStartDate()); 
         results_.expectedTrancheLoss.push_back(e1);// zero or realized losses?
 
-        for (Size i = 0; i < arguments_.normalizedLeg.size(); i++) {
-            if(arguments_.normalizedLeg[i]->hasOccurred(today)) {
+        for (auto& i : arguments_.normalizedLeg) {
+            if (i->hasOccurred(today)) {
                 // add includeSettlement date flows variable to engine.
                 results_.expectedTrancheLoss.push_back(0.);
                 continue;
             }
 
-            const ext::shared_ptr<Coupon> coupon =
-                ext::dynamic_pointer_cast<Coupon>(
-                    arguments_.normalizedLeg[i]);
+            const ext::shared_ptr<Coupon> coupon = ext::dynamic_pointer_cast<Coupon>(i);
 
             Date d1 = coupon->accrualStartDate();
             Date d2 = coupon->date();
diff --git a/ql/experimental/credit/integralntdengine.cpp b/ql/experimental/credit/integralntdengine.cpp
index 7f5ef470487..c4bb8a52d7f 100644
--- a/ql/experimental/credit/integralntdengine.cpp
+++ b/ql/experimental/credit/integralntdengine.cpp
@@ -45,11 +45,9 @@ namespace QuantLib {
         */
         bool basketIsHomogeneous = true;// hardcoded by now
 
-        for (Size i = 0; i < arguments_.premiumLeg.size(); i++) {
-            ext::shared_ptr<FixedRateCoupon> coupon =
-                ext::dynamic_pointer_cast<FixedRateCoupon>(
-                    arguments_.premiumLeg[i]);
-            Date d = arguments_.premiumLeg[i]->date();
+        for (auto& i : arguments_.premiumLeg) {
+            ext::shared_ptr<FixedRateCoupon> coupon = ext::dynamic_pointer_cast<FixedRateCoupon>(i);
+            Date d = i->date();
             if (d > discountCurve_->referenceDate()) {
                 /*
                 std::vector<Probability> probsTriggering =
@@ -66,10 +64,9 @@ namespace QuantLib {
                     1. - arguments_.basket->probAtLeastNEvents(
                         arguments_.ntdOrder, d);
 
-                results_.premiumValue += arguments_.premiumLeg[i]->amount()
-                    * discountCurve_->discount(d)
-                    * probNonTriggered;
-                 ////   * (1.0 - defaultProb);
+                results_.premiumValue +=
+                    i->amount() * discountCurve_->discount(d) * probNonTriggered;
+                ////   * (1.0 - defaultProb);
 
                 if (coupon->accrualStartDate() >= 
                     discountCurve_->referenceDate())
diff --git a/ql/experimental/credit/issuer.cpp b/ql/experimental/credit/issuer.cpp
index 2c0a5e3fbdf..473cbd3557a 100644
--- a/ql/experimental/credit/issuer.cpp
+++ b/ql/experimental/credit/issuer.cpp
@@ -58,9 +58,9 @@ namespace QuantLib {
 
     const Handle<DefaultProbabilityTermStructure>&
         Issuer::defaultProbability(const DefaultProbKey& key) const {
-        for(Size i=0; i<probabilities_.size(); i++)
-            if(key == probabilities_[i].first)
-                return probabilities_[i].second;
+        for (const auto& probabilitie : probabilities_)
+            if (key == probabilitie.first)
+                return probabilitie.second;
         QL_FAIL("Probability curve not available.");
     }
 
@@ -72,13 +72,9 @@ namespace QuantLib {
                              ) const
     {
         // to do: the set is ordered, see how to use it to speed this up
-        for (auto itev = events_.begin();
-             // am i really speeding things up with the date comp?
-             itev != events_.end(); // && (*itev)->date() > start;
-             ++itev) {
-            if((*itev)->matchesDefaultKey(contractKey) &&
-                between(*itev, start, end, includeRefDate))
-                return *itev;
+        for (const auto& event : events_) {
+            if (event->matchesDefaultKey(contractKey) && between(event, start, end, includeRefDate))
+                return event;
         }
         return ext::shared_ptr<DefaultEvent>();
     }
@@ -93,13 +89,9 @@ namespace QuantLib {
     {
         std::vector<ext::shared_ptr<DefaultEvent> > defaults;
         // to do: the set is ordered, see how to use it to speed this up
-        for (auto itev = events_.begin();
-             // am i really speeding things up with the date comp?
-             itev != events_.end(); // && (*itev)->date() > start;
-             ++itev) {
-            if((*itev)->matchesDefaultKey(contractKey) &&
-                between(*itev, start, end, includeRefDate))
-                defaults.push_back(*itev);
+        for (const auto& event : events_) {
+            if (event->matchesDefaultKey(contractKey) && between(event, start, end, includeRefDate))
+                defaults.push_back(event);
         }
         return defaults;
     }
diff --git a/ql/experimental/credit/midpointcdoengine.cpp b/ql/experimental/credit/midpointcdoengine.cpp
index 6b22409d527..330d0bcc751 100644
--- a/ql/experimental/credit/midpointcdoengine.cpp
+++ b/ql/experimental/credit/midpointcdoengine.cpp
@@ -55,13 +55,12 @@ namespace QuantLib {
                     arguments_.normalizedLeg[0])->accrualStartDate());
         results_.expectedTrancheLoss.push_back(e1);
         //'e1'  should contain the existing loses.....? use remaining amounts?
-        for (Size i = 0; i < arguments_.normalizedLeg.size(); i++) {
-            if(arguments_.normalizedLeg[i]->hasOccurred(today)) {
+        for (auto& i : arguments_.normalizedLeg) {
+            if (i->hasOccurred(today)) {
                 results_.expectedTrancheLoss.push_back(0.);
                 continue;
             }
-            ext::shared_ptr<Coupon> coupon =
-              ext::dynamic_pointer_cast<Coupon>(arguments_.normalizedLeg[i]);
+            ext::shared_ptr<Coupon> coupon = ext::dynamic_pointer_cast<Coupon>(i);
             Date paymentDate = coupon->date();
             Date startDate = std::max(coupon->accrualStartDate(),
                                       discountCurve_->referenceDate());
diff --git a/ql/experimental/credit/riskybond.cpp b/ql/experimental/credit/riskybond.cpp
index e2f8dc96118..09d262a7eb8 100644
--- a/ql/experimental/credit/riskybond.cpp
+++ b/ql/experimental/credit/riskybond.cpp
@@ -60,14 +60,13 @@ namespace QuantLib {
         Date npvDate = calendar_.advance(today, settlementDays_, Days);
         std::vector<ext::shared_ptr<CashFlow> > cf = cashflows();
         Date d1 = effectiveDate();
-        for (Size i = 0; i < cf.size(); i++) {
-            Date d2 = cf[i]->date();
+        for (auto& i : cf) {
+            Date d2 = i->date();
             if (d2 > npvDate) {
                 d1 = max(npvDate , d1);
                 Date defaultDate = d1 + (d2-d1)/2;
 
-                Real coupon = cf[i]->amount()
-                    * defaultTS_->survivalProbability(d2);
+                Real coupon = i->amount() * defaultTS_->survivalProbability(d2);
                 Real recovery = notional(defaultDate) * recoveryRate_
                     * (defaultTS_->survivalProbability(d1)
                        -defaultTS_->survivalProbability(d2));
@@ -84,10 +83,10 @@ namespace QuantLib {
         Date npvDate = calendar_.advance(today, settlementDays_, Days);
         Real npv = 0;
         std::vector<ext::shared_ptr<CashFlow> > cf = cashflows();
-        for (Size i = 0; i < cf.size(); i++) {
-            Date d2 = cf[i]->date();
+        for (auto& i : cf) {
+            Date d2 = i->date();
             if (d2 > npvDate)
-                npv += cf[i]->amount() * yieldTS()->discount(d2);
+                npv += i->amount() * yieldTS()->discount(d2);
         }
         return npv;
     }
@@ -97,9 +96,9 @@ namespace QuantLib {
         Date npvDate = calendar_.advance(today, settlementDays_, Days);
         Real flow = 0;
         std::vector<ext::shared_ptr<CashFlow> > cf = cashflows();
-        for (Size i = 0; i < cf.size(); i++) {
-            if (cf[i]->date() > npvDate)
-                flow += cf[i]->amount();
+        for (auto& i : cf) {
+            if (i->date() > npvDate)
+                flow += i->amount();
         }
         return flow;
     }
@@ -110,14 +109,13 @@ namespace QuantLib {
         Date today = Settings::instance().evaluationDate();
         Date npvDate = calendar_.advance(today, settlementDays_, Days);
         Date d1 = effectiveDate();
-        for (Size i = 0; i < cf.size(); i++) {
-            Date d2 = cf[i]->date();
+        for (auto& i : cf) {
+            Date d2 = i->date();
             if (d2 > npvDate) {
                 d1 = max(npvDate, d1);
                 Date defaultDate = d1 + (d2-d1)/2;
 
-                Real coupon = cf[i]->amount()
-                    * defaultTS_->survivalProbability(d2);
+                Real coupon = i->amount() * defaultTS_->survivalProbability(d2);
                 Real recovery = notional(defaultDate) * recoveryRate_
                     * (defaultTS_->survivalProbability(d1)
                        -defaultTS_->survivalProbability(d2));
diff --git a/ql/experimental/finitedifferences/fdsimpleextoustorageengine.cpp b/ql/experimental/finitedifferences/fdsimpleextoustorageengine.cpp
index d281569f8b1..b1d36ce860b 100644
--- a/ql/experimental/finitedifferences/fdsimpleextoustorageengine.cpp
+++ b/ql/experimental/finitedifferences/fdsimpleextoustorageengine.cpp
@@ -136,10 +136,8 @@ namespace QuantLib {
 
         // 4.1 Bermudan step conditions
         std::vector<Time> exerciseTimes;
-        for (Size i=0; i<arguments_.exercise->dates().size(); ++i) {
-            const Time t = rTS_->dayCounter()
-                           .yearFraction(rTS_->referenceDate(),
-                                         arguments_.exercise->dates()[i]);
+        for (auto i : arguments_.exercise->dates()) {
+            const Time t = rTS_->dayCounter().yearFraction(rTS_->referenceDate(), i);
 
             QL_REQUIRE(t >= 0, "exercise dates must not contain past date");
             exerciseTimes.push_back(t);
diff --git a/ql/experimental/math/convolvedstudentt.cpp b/ql/experimental/math/convolvedstudentt.cpp
index efa1e0e27e1..c434391ed6d 100644
--- a/ql/experimental/math/convolvedstudentt.cpp
+++ b/ql/experimental/math/convolvedstudentt.cpp
@@ -43,11 +43,9 @@ namespace QuantLib {
     {
         QL_REQUIRE(degreesFreedom.size() == factors.size(),
             "Incompatible sizes in convolution.");
-        for(Size i=0; i<degreesFreedom.size(); i++) {
-            QL_REQUIRE(degreesFreedom[i]%2 != 0,
-                "Even degree of freedom not allowed");
-            QL_REQUIRE(degreesFreedom[i] >= 0,
-                "Negative degree of freedom not allowed");
+        for (int i : degreesFreedom) {
+            QL_REQUIRE(i % 2 != 0, "Even degree of freedom not allowed");
+            QL_REQUIRE(i >= 0, "Negative degree of freedom not allowed");
         }
         for(Size i=0; i<degreesFreedom_.size(); i++)
             polynCharFnc_.push_back(polynCharactT((degreesFreedom[i]-1)/2));
@@ -61,10 +59,9 @@ namespace QuantLib {
             }
         }
         //convolution, here it is a product of polynomials and exponentials
-        for(Size i=0; i<polynCharFnc_.size(); i++)
-            polyConvolved_ =
-                convolveVectorPolynomials(polyConvolved_, polynCharFnc_[i]);
-          // trim possible zeros that might have arised:
+        for (auto& i : polynCharFnc_)
+            polyConvolved_ = convolveVectorPolynomials(polyConvolved_, i);
+        // trim possible zeros that might have arised:
         auto it = polyConvolved_.rbegin();
         while (it != polyConvolved_.rend()) {
             if (*it == 0.) {
diff --git a/ql/experimental/math/gaussiancopulapolicy.hpp b/ql/experimental/math/gaussiancopulapolicy.hpp
index 2ee33eab0ff..1a7f10700dc 100644
--- a/ql/experimental/math/gaussiancopulapolicy.hpp
+++ b/ql/experimental/math/gaussiancopulapolicy.hpp
@@ -45,11 +45,9 @@ namespace QuantLib {
         : numFactors_(factorWeights.size() + factorWeights[0].size())
         {
             /* check factors in LM are normalized. */
-            for(Size iLVar=0; iLVar<factorWeights.size(); iLVar++) {
-                Real factorsNorm = 
-                    std::inner_product(factorWeights[iLVar].begin(), 
-                        factorWeights[iLVar].end(), 
-                        factorWeights[iLVar].begin(), 0.);
+            for (const auto& factorWeight : factorWeights) {
+                Real factorsNorm = std::inner_product(factorWeight.begin(), factorWeight.end(),
+                                                      factorWeight.begin(), 0.);
                 QL_REQUIRE(factorsNorm < 1., 
                     "Non normal random factor combination.");
             }
diff --git a/ql/experimental/math/hybridsimulatedannealing.hpp b/ql/experimental/math/hybridsimulatedannealing.hpp
index 45e8e0b6ff9..71b04e182e2 100644
--- a/ql/experimental/math/hybridsimulatedannealing.hpp
+++ b/ql/experimental/math/hybridsimulatedannealing.hpp
@@ -179,8 +179,8 @@ namespace QuantLib {
             //Increase steps
             k++;
             kStationary++;
-            for (Size i = 0; i < annealStep.size(); i++)
-                annealStep[i]++;
+            for (double& i : annealStep)
+                i++;
 
             //Reanneal if necessary
             if (kReAnneal == reAnnealSteps_) {
diff --git a/ql/experimental/math/latentmodel.hpp b/ql/experimental/math/latentmodel.hpp
index c5b5ae5b68a..2f186f2e88b 100644
--- a/ql/experimental/math/latentmodel.hpp
+++ b/ql/experimental/math/latentmodel.hpp
@@ -685,12 +685,10 @@ namespace QuantLib {
     : nFactors_(1),
       nVariables_(factorWeights.size())
     {
-        for(Size iName=0; iName < factorWeights.size(); iName++)
-            factorWeights_.push_back(std::vector<Real>(1, 
-                factorWeights[iName]));
-        for(Size iName=0; iName < factorWeights.size(); iName++)
-            idiosyncFctrs_.push_back(std::sqrt(1. - 
-                factorWeights[iName]*factorWeights[iName]));
+        for (double factorWeight : factorWeights)
+            factorWeights_.push_back(std::vector<Real>(1, factorWeight));
+        for (double factorWeight : factorWeights)
+            idiosyncFctrs_.push_back(std::sqrt(1. - factorWeight * factorWeight));
         //convert row to column vector....
         copula_ = copulaType(factorWeights_, ini);
     }
@@ -797,9 +795,8 @@ namespace QuantLib {
           urng_(seed) {
             // 1 == urng.dimension() is enforced by the sample type
             const std::vector<Real>& varF = copula.varianceFactors();
-            for(Size i=0; i<varF.size(); i++)// ...use back inserter lambda
-                trng_.push_back(
-                    PolarStudentTRng<urng_type>(2./(1.-varF[i]*varF[i]), urng_));
+            for (double i : varF) // ...use back inserter lambda
+                trng_.push_back(PolarStudentTRng<urng_type>(2. / (1. - i * i), urng_));
         }
         const sample_type& nextSequence() const {
             Size i=0;
diff --git a/ql/experimental/math/tcopulapolicy.cpp b/ql/experimental/math/tcopulapolicy.cpp
index d16c28bf1e0..0a8f839ab33 100644
--- a/ql/experimental/math/tcopulapolicy.cpp
+++ b/ql/experimental/math/tcopulapolicy.cpp
@@ -28,38 +28,34 @@ namespace QuantLib {
         const std::vector<std::vector<Real> >& factorWeights, 
         const initTraits& vals)
     {
-        for(Size iFactor=0; iFactor<vals.tOrders.size(); iFactor++) {
+        for (int tOrder : vals.tOrders) {
             // require no T is of order 2 (finite variance)
-            QL_REQUIRE(vals.tOrders[iFactor] > 2, 
-                "Non finite variance T in latent model.");
+            QL_REQUIRE(tOrder > 2, "Non finite variance T in latent model.");
 
-            distributions_.push_back(boost::math::students_t_distribution<>(
-                vals.tOrders[iFactor]));
+            distributions_.push_back(boost::math::students_t_distribution<>(tOrder));
             // inverses T variaces used in normalization of the random factors
             // For low values of the T order this number is very close to zero 
             // and it enters the expressions dividing them, which introduces 
             // numerical errors.
-            varianceFactors_.push_back(std::sqrt(
-                (vals.tOrders[iFactor]-2.)/vals.tOrders[iFactor]));
+            varianceFactors_.push_back(std::sqrt((tOrder - 2.) / tOrder));
         }
 
-        for(Size iLVar=0; iLVar<factorWeights.size(); iLVar++) {
+        for (const auto& factorWeight : factorWeights) {
             // This ensures the latent model is 'canonical'
-            QL_REQUIRE(vals.tOrders.size() == factorWeights[iLVar].size()+1, 
-                // num factors plus one
-                "Incompatible number of T functions and number of factors."); 
+            QL_REQUIRE(vals.tOrders.size() == factorWeight.size() + 1,
+                       // num factors plus one
+                       "Incompatible number of T functions and number of factors.");
 
-            Real factorsNorm = std::inner_product(factorWeights[iLVar].begin(), 
-                factorWeights[iLVar].end(), factorWeights[iLVar].begin(), 0.);
+            Real factorsNorm = std::inner_product(factorWeight.begin(), factorWeight.end(),
+                                                  factorWeight.begin(), 0.);
             QL_REQUIRE(factorsNorm < 1., 
                 "Non normal random factor combination.");
             Real idiosyncFctr = std::sqrt(1.-factorsNorm);
 
             // linear comb factors ajusted for the variance renormalization:
             std::vector<Real> normFactorWeights;
-            for(Size iFactor=0; iFactor<factorWeights[iLVar].size(); iFactor++)
-                normFactorWeights.push_back(factorWeights[iLVar][iFactor] * 
-                    varianceFactors_[iFactor]);
+            for (Size iFactor = 0; iFactor < factorWeight.size(); iFactor++)
+                normFactorWeights.push_back(factorWeight[iFactor] * varianceFactors_[iFactor]);
             // idiosincratic term, all Z factors are assumed identical.
             normFactorWeights.push_back(idiosyncFctr * varianceFactors_.back());
             latentVarsCumul_.push_back( 
diff --git a/ql/experimental/models/hestonslvfdmmodel.cpp b/ql/experimental/models/hestonslvfdmmodel.cpp
index a7a06ed17d5..696e2add28d 100644
--- a/ql/experimental/models/hestonslvfdmmodel.cpp
+++ b/ql/experimental/models/hestonslvfdmmodel.cpp
@@ -339,9 +339,8 @@ namespace QuantLib {
             times.push_back(std::min(T, tIdx+=dt));
         }
 
-        for (Size i=0; i < mandatoryDates_.size(); ++i) {
-            times.push_back(
-                dc.yearFraction(referenceDate, mandatoryDates_[i]));
+        for (auto mandatoryDate : mandatoryDates_) {
+            times.push_back(dc.yearFraction(referenceDate, mandatoryDate));
         }
 
         const ext::shared_ptr<TimeGrid> timeGrid(
diff --git a/ql/experimental/models/hestonslvmcmodel.cpp b/ql/experimental/models/hestonslvmcmodel.cpp
index 803f863c87e..b664ab0eeed 100644
--- a/ql/experimental/models/hestonslvmcmodel.cpp
+++ b/ql/experimental/models/hestonslvmcmodel.cpp
@@ -59,9 +59,8 @@ namespace QuantLib {
 
         std::vector<Time> gridTimes;
         gridTimes.reserve(mandatoryDates.size()+1);
-        for (Size i=0; i < mandatoryDates.size(); ++i) {
-            gridTimes.push_back(dc.yearFraction(refDate, mandatoryDates[i]));
-
+        for (auto mandatoryDate : mandatoryDates) {
+            gridTimes.push_back(dc.yearFraction(refDate, mandatoryDate));
         }
         gridTimes.push_back(dc.yearFraction(refDate, endDate));
 
diff --git a/ql/experimental/models/squarerootclvmodel.cpp b/ql/experimental/models/squarerootclvmodel.cpp
index fe4314349c6..67749242d7f 100644
--- a/ql/experimental/models/squarerootclvmodel.cpp
+++ b/ql/experimental/models/squarerootclvmodel.cpp
@@ -94,8 +94,8 @@ namespace QuantLib {
         const Real b = xMin - x.front();
         const Real a = (xMax - xMin)/(x.back() - x.front());
 
-        for (Size i=0, n=x.size(); i < n; ++i) {
-            x[i] = a*x[i] + b;
+        for (double& i : x) {
+            i = a * i + b;
         }
 
         return x;
diff --git a/ql/experimental/shortrate/generalizedhullwhite.hpp b/ql/experimental/shortrate/generalizedhullwhite.hpp
index 0a2351e3cbd..ce59f46a404 100644
--- a/ql/experimental/shortrate/generalizedhullwhite.hpp
+++ b/ql/experimental/shortrate/generalizedhullwhite.hpp
@@ -189,10 +189,10 @@ namespace QuantLib {
 
             DayCounter dc = yieldtermStructure->dayCounter();
             Date ref = yieldtermStructure->referenceDate();
-            for (Size i=0;i<speedstructure.size();i++)
-                speedperiods_.push_back(dc.yearFraction(ref,speedstructure[i]));
-            for (Size i=0;i<volstructure.size();i++)
-                volperiods_.push_back(dc.yearFraction(ref,volstructure[i]));
+            for (auto i : speedstructure)
+                speedperiods_.push_back(dc.yearFraction(ref, i));
+            for (auto i : volstructure)
+                volperiods_.push_back(dc.yearFraction(ref, i));
 
             // interpolator x points to *periods_ vector, y points to
             // the internal Array in the parameter
diff --git a/ql/experimental/swaptions/haganirregularswaptionengine.cpp b/ql/experimental/swaptions/haganirregularswaptionengine.cpp
index be493c45dc6..df44425801d 100644
--- a/ql/experimental/swaptions/haganirregularswaptionengine.cpp
+++ b/ql/experimental/swaptions/haganirregularswaptionengine.cpp
@@ -77,10 +77,9 @@ namespace QuantLib {
 
             floatCFS.clear();
 
-            for (Size j = 0; j < floatLeg.size(); ++j) {
+            for (const auto& j : floatLeg) {
                 // retrieve ibor coupon from floating leg
-                ext::shared_ptr<IborCoupon> coupon =
-                    ext::dynamic_pointer_cast<IborCoupon>(floatLeg[j]);
+                ext::shared_ptr<IborCoupon> coupon = ext::dynamic_pointer_cast<IborCoupon>(j);
                 QL_REQUIRE(coupon, "dynamic cast of float leg coupon failed.");
 
                 if (coupon->date() <= expiries_[i]) {
@@ -261,9 +260,9 @@ namespace QuantLib {
 
         floatCFS.clear();
 
-        for(Size j = 0; j < floatLeg.size(); ++j){
+        for (auto& j : floatLeg) {
             //retrieve ibor coupon from floating leg
-            ext::shared_ptr<IborCoupon> coupon = ext::dynamic_pointer_cast<IborCoupon>(floatLeg[j]);
+            ext::shared_ptr<IborCoupon> coupon = ext::dynamic_pointer_cast<IborCoupon>(j);
             QL_REQUIRE(coupon,"dynamic cast of float leg coupon failed.");
 
             ext::shared_ptr<IborCoupon> newCpn = ext::shared_ptr<IborCoupon> (
@@ -297,10 +296,9 @@ namespace QuantLib {
 
         fixedCFS.clear();
 
-        for(Size i = 0; i < fixedLeg.size(); ++i)  
-        {
+        for (auto& i : fixedLeg) {
             //retrieve fixed rate coupon from fixed leg
-            ext::shared_ptr<FixedRateCoupon> coupon = ext::dynamic_pointer_cast<FixedRateCoupon>(fixedLeg[i]);
+            ext::shared_ptr<FixedRateCoupon> coupon = ext::dynamic_pointer_cast<FixedRateCoupon>(i);
             QL_REQUIRE(coupon,"dynamic cast of fixed leg coupon failed.");
 
             ext::shared_ptr<FixedRateCoupon> newCpn = ext::make_shared<FixedRateCoupon> (
diff --git a/ql/experimental/termstructures/multicurvesensitivities.hpp b/ql/experimental/termstructures/multicurvesensitivities.hpp
index c354f7d55d6..ce73670731b 100644
--- a/ql/experimental/termstructures/multicurvesensitivities.hpp
+++ b/ql/experimental/termstructures/multicurvesensitivities.hpp
@@ -76,10 +76,10 @@ class MultiCurveSensitivities : public LazyObject {
               ext::dynamic_pointer_cast<PiecewiseYieldCurve<ZeroYield, Linear> >(
                   it->second.currentLink());
           QL_REQUIRE(curve != nullptr, "Couldn't cast curvename: " << it->first);
-          for (auto inst = curve->instruments_.begin(); inst != curve->instruments_.end(); ++inst) {
-              allQuotes_.push_back((*inst)->quote());
+          for (auto& instrument : curve->instruments_) {
+              allQuotes_.push_back(instrument->quote());
               std::stringstream tmp;
-              tmp << QuantLib::io::iso_date((*inst)->latestRelevantDate());
+              tmp << QuantLib::io::iso_date(instrument->latestRelevantDate());
               headers_.push_back(it->first + "_" + tmp.str());
           }
       }
@@ -108,10 +108,11 @@ class MultiCurveSensitivities : public LazyObject {
 inline void MultiCurveSensitivities::performCalculations() const {
   std::vector< Rate > sensiVector;
   origZeros_ = allZeros();
-  for (auto it = allQuotes_.begin(); it != allQuotes_.end(); ++it) {
+  for (const auto& allQuote : allQuotes_) {
       Rate bps = +1e-4;
-      Rate origQuote = (*it)->value();
-      ext::shared_ptr<SimpleQuote> q = ext::dynamic_pointer_cast<SimpleQuote>((*it).currentLink());
+      Rate origQuote = allQuote->value();
+      ext::shared_ptr<SimpleQuote> q =
+          ext::dynamic_pointer_cast<SimpleQuote>(allQuote.currentLink());
       q->setValue(origQuote + bps);
       try {
           std::vector<Rate> tmp(allZeros());
@@ -140,10 +141,10 @@ inline Matrix MultiCurveSensitivities::inverseSensitivities() const {
 
 inline std::vector< std::pair< Date, Real > > MultiCurveSensitivities::allNodes() const {
   std::vector< std::pair< Date, Real > > result;
-  for (auto it = curves_.begin(); it != curves_.end(); ++it) {
+  for (const auto& it : curves_) {
       ext::shared_ptr<PiecewiseYieldCurve<ZeroYield, Linear> > curve =
           ext::dynamic_pointer_cast<PiecewiseYieldCurve<ZeroYield, Linear> >(
-              it->second.currentLink());
+              it.second.currentLink());
       result.reserve(result.size() + curve->nodes().size() - 1);
       for (std::vector<std::pair<Date, Real> >::const_iterator p = curve->nodes().begin() + 1;
            p != curve->nodes().end(); ++p)
diff --git a/ql/experimental/variancegamma/fftengine.cpp b/ql/experimental/variancegamma/fftengine.cpp
index 0c05f73a63e..6cd6c6ca69b 100644
--- a/ql/experimental/variancegamma/fftengine.cpp
+++ b/ql/experimental/variancegamma/fftengine.cpp
@@ -85,8 +85,8 @@ namespace QuantLib {
         typedef std::map<Date, PayoffList> PayoffMap;
         PayoffMap payoffMap;
 
-        for (auto optIt = optionList.begin(); optIt != optionList.end(); ++optIt) {
-            ext::shared_ptr<VanillaOption> option = ext::dynamic_pointer_cast<VanillaOption>(*optIt);
+        for (const auto& optIt : optionList) {
+            ext::shared_ptr<VanillaOption> option = ext::dynamic_pointer_cast<VanillaOption>(optIt);
             QL_REQUIRE(option, "instrument must be option");
             QL_REQUIRE(option->exercise()->type() == Exercise::European,
                 "not an European Option");
@@ -107,9 +107,7 @@ namespace QuantLib {
 
             // Calculate n large enough for maximum strike, and round up to a power of 2
             Real maxStrike = 0.0;
-            for (auto it = payIt->second.begin(); it != payIt->second.end(); ++it) {
-                ext::shared_ptr<StrikedTypePayoff> payoff = *it;
-
+            for (const auto& payoff : payIt->second) {
                 if (payoff->strike() > maxStrike)
                     maxStrike = payoff->strike();
             }
@@ -161,10 +159,9 @@ namespace QuantLib {
                 strikes[i] = std::exp(k_u);
             }
 
-            for (auto it = payIt->second.begin(); it != payIt->second.end(); ++it) {
-                ext::shared_ptr<StrikedTypePayoff> payoff = *it;
-
-                Real callPrice = LinearInterpolation(strikes.begin(), strikes.end(), prices.begin())(payoff->strike());
+            for (const auto& payoff : payIt->second) {
+                Real callPrice = LinearInterpolation(strikes.begin(), strikes.end(),
+                                                     prices.begin())(payoff->strike());
                 switch (payoff->optionType())
                 {
                 case Option::Call:
diff --git a/ql/experimental/volatility/abcdatmvolcurve.cpp b/ql/experimental/volatility/abcdatmvolcurve.cpp
index c6618850362..ea8af4606c1 100644
--- a/ql/experimental/volatility/abcdatmvolcurve.cpp
+++ b/ql/experimental/volatility/abcdatmvolcurve.cpp
@@ -76,8 +76,8 @@ namespace QuantLib {
 
     void AbcdAtmVolCurve::registerWithMarketData()
     {
-        for (Size i=0; i<volHandles_.size(); ++i)
-            registerWith(volHandles_[i]);
+        for (auto& volHandle : volHandles_)
+            registerWith(volHandle);
     }
 
     void AbcdAtmVolCurve::interpolate()
diff --git a/ql/experimental/volatility/extendedblackvariancecurve.cpp b/ql/experimental/volatility/extendedblackvariancecurve.cpp
index 834a434f307..2ea5146b412 100644
--- a/ql/experimental/volatility/extendedblackvariancecurve.cpp
+++ b/ql/experimental/volatility/extendedblackvariancecurve.cpp
@@ -50,8 +50,8 @@ namespace QuantLib {
         setVariances();
         setInterpolation<Linear>();
 
-        for (Size j=0; j<volatilities_.size(); ++j)
-            registerWith(volatilities_[j]);
+        for (auto& volatilitie : volatilities_)
+            registerWith(volatilitie);
     }
 
     void ExtendedBlackVarianceCurve::setVariances() {
diff --git a/ql/experimental/volatility/extendedblackvariancesurface.cpp b/ql/experimental/volatility/extendedblackvariancesurface.cpp
index 0c850e1ea1e..89d3876585c 100644
--- a/ql/experimental/volatility/extendedblackvariancesurface.cpp
+++ b/ql/experimental/volatility/extendedblackvariancesurface.cpp
@@ -58,8 +58,8 @@ namespace QuantLib {
 
         setInterpolation<Bilinear>();
 
-        for (Size j = 0; j < volatilities_.size(); j++)
-            registerWith(volatilities_[j]);
+        for (const auto& volatilitie : volatilities_)
+            registerWith(volatilitie);
     }
 
     void ExtendedBlackVarianceSurface::setVariances() {
diff --git a/ql/experimental/volatility/noarbsabrinterpolatedsmilesection.cpp b/ql/experimental/volatility/noarbsabrinterpolatedsmilesection.cpp
index 890691ccd56..0e76262ef7c 100644
--- a/ql/experimental/volatility/noarbsabrinterpolatedsmilesection.cpp
+++ b/ql/experimental/volatility/noarbsabrinterpolatedsmilesection.cpp
@@ -53,8 +53,8 @@ namespace QuantLib {
 
         LazyObject::registerWith(forward_);
         LazyObject::registerWith(atmVolatility_);
-        for (Size i = 0; i < volHandles_.size(); ++i)
-            LazyObject::registerWith(volHandles_[i]);
+        for (auto& volHandle : volHandles_)
+            LazyObject::registerWith(volHandle);
     }
 
     NoArbSabrInterpolatedSmileSection::NoArbSabrInterpolatedSmileSection(
diff --git a/ql/experimental/volatility/sviinterpolatedsmilesection.cpp b/ql/experimental/volatility/sviinterpolatedsmilesection.cpp
index 7c5f61e3026..231314156ca 100644
--- a/ql/experimental/volatility/sviinterpolatedsmilesection.cpp
+++ b/ql/experimental/volatility/sviinterpolatedsmilesection.cpp
@@ -55,8 +55,8 @@ namespace QuantLib {
 
         LazyObject::registerWith(forward_);
         LazyObject::registerWith(atmVolatility_);
-        for (Size i = 0; i < volHandles_.size(); ++i)
-            LazyObject::registerWith(volHandles_[i]);
+        for (auto& volHandle : volHandles_)
+            LazyObject::registerWith(volHandle);
     }
 
     SviInterpolatedSmileSection::SviInterpolatedSmileSection(
diff --git a/ql/experimental/volatility/volcube.cpp b/ql/experimental/volatility/volcube.cpp
index 663338a1433..56536666460 100644
--- a/ql/experimental/volatility/volcube.cpp
+++ b/ql/experimental/volatility/volcube.cpp
@@ -30,15 +30,13 @@ namespace QuantLib {
         QL_REQUIRE(surfaces_.size()>1, "at least 2 surfaces are needed");
 
         Date refDate = surfaces_[0]->referenceDate();
-        for (Size i=0; i<surfaces_.size(); ++i) {
-            QL_REQUIRE(surfaces_[i]->referenceDate() == refDate,
-                       "different reference dates");
+        for (auto& surface : surfaces_) {
+            QL_REQUIRE(surface->referenceDate() == refDate, "different reference dates");
             //curves_.push_back(surfaces_[i]);
         }
 
-        for (Size i=0; i<curves_.size(); ++i) {
-            QL_REQUIRE(curves_[i]->referenceDate() == refDate,
-                       "different reference dates");
+        for (auto& curve : curves_) {
+            QL_REQUIRE(curve->referenceDate() == refDate, "different reference dates");
         }
 
         // sort increasing index tenor
diff --git a/ql/experimental/volatility/zabrinterpolatedsmilesection.hpp b/ql/experimental/volatility/zabrinterpolatedsmilesection.hpp
index 24b65b825bf..fcfbbfae2bb 100644
--- a/ql/experimental/volatility/zabrinterpolatedsmilesection.hpp
+++ b/ql/experimental/volatility/zabrinterpolatedsmilesection.hpp
@@ -240,8 +240,8 @@ ZabrInterpolatedSmileSection<Evaluation>::ZabrInterpolatedSmileSection(
 
     LazyObject::registerWith(forward_);
     LazyObject::registerWith(atmVolatility_);
-    for (Size i = 0; i < volHandles_.size(); ++i)
-        LazyObject::registerWith(volHandles_[i]);
+    for (auto& volHandle : volHandles_)
+        LazyObject::registerWith(volHandle);
 }
 
 template <typename Evaluation>
diff --git a/ql/experimental/volatility/zabrsmilesection.hpp b/ql/experimental/volatility/zabrsmilesection.hpp
index f17efbbb026..6fc27bf7aca 100644
--- a/ql/experimental/volatility/zabrsmilesection.hpp
+++ b/ql/experimental/volatility/zabrsmilesection.hpp
@@ -176,8 +176,8 @@ void ZabrSmileSection<Evaluation>::init(const std::vector<Real> &moneyness,
     strikes_.clear(); // should not be necessary, anyway
     Real lastF = 0.0;
     bool firstStrike = true;
-    for (Size i = 0; i < tmp.size(); i++) {
-        Real f = tmp[i] * forward_;
+    for (double i : tmp) {
+        Real f = i * forward_;
         if (f > 0.0) {
             if (!firstStrike) {
                 for (Size j = 1; j <= fdRefinement_; ++j) {
diff --git a/ql/instruments/bmaswap.cpp b/ql/instruments/bmaswap.cpp
index 0eefc8aa15c..95727bc8f16 100644
--- a/ql/instruments/bmaswap.cpp
+++ b/ql/instruments/bmaswap.cpp
@@ -56,8 +56,8 @@ namespace QuantLib {
             .withPaymentAdjustment(bmaSchedule.businessDayConvention());
 
         for (Size j=0; j<2; ++j) {
-            for (auto i = legs_[j].begin(); i != legs_[j].end(); ++i)
-                registerWith(*i);
+            for (auto& i : legs_[j])
+                registerWith(i);
         }
 
         switch (type_) {
diff --git a/ql/instruments/bond.cpp b/ql/instruments/bond.cpp
index 9d431ff1864..19ca3d28df0 100644
--- a/ql/instruments/bond.cpp
+++ b/ql/instruments/bond.cpp
@@ -54,9 +54,8 @@ namespace QuantLib {
         }
 
         registerWith(Settings::instance().evaluationDate());
-        for (Leg::const_iterator c = cashflows_.begin(); c != cashflows_.end();
-             ++c)
-            registerWith(*c);
+        for (const auto& cashflow : cashflows_)
+            registerWith(cashflow);
     }
 
     Bond::Bond(Natural settlementDays,
@@ -96,9 +95,8 @@ namespace QuantLib {
         }
 
         registerWith(Settings::instance().evaluationDate());
-        for (Leg::const_iterator c = cashflows_.begin(); c != cashflows_.end();
-             ++c)
-            registerWith(*c);
+        for (const auto& cashflow : cashflows_)
+            registerWith(cashflow);
     }
 
     bool Bond::isExpired() const {
@@ -355,9 +353,8 @@ namespace QuantLib {
     }
 
     void Bond::deepUpdate() {
-        for (Size k = 0; k < cashflows_.size(); ++k) {
-            ext::shared_ptr<LazyObject> f =
-                ext::dynamic_pointer_cast<LazyObject>(cashflows_[k]);
+        for (auto& cashflow : cashflows_) {
+            ext::shared_ptr<LazyObject> f = ext::dynamic_pointer_cast<LazyObject>(cashflow);
             if (f != nullptr)
                 f->update();
         }
@@ -370,9 +367,8 @@ namespace QuantLib {
 
         Date lastPaymentDate = Date();
         notionalSchedule_.push_back(Date());
-        for (Size i=0; i<cashflows_.size(); ++i) {
-            ext::shared_ptr<Coupon> coupon =
-                ext::dynamic_pointer_cast<Coupon>(cashflows_[i]);
+        for (auto& cashflow : cashflows_) {
+            ext::shared_ptr<Coupon> coupon = ext::dynamic_pointer_cast<Coupon>(cashflow);
             if (!coupon)
                 continue;
 
diff --git a/ql/instruments/capfloor.cpp b/ql/instruments/capfloor.cpp
index 32f7484b27a..c9f549fc910 100644
--- a/ql/instruments/capfloor.cpp
+++ b/ql/instruments/capfloor.cpp
@@ -268,10 +268,8 @@ namespace QuantLib {
     }
 
     void CapFloor::deepUpdate() {
-        for (Size i = 0; i < floatingLeg_.size(); ++i) {
-            ext::shared_ptr<LazyObject> f =
-                ext::dynamic_pointer_cast<LazyObject>(
-                    floatingLeg_[i]);
+        for (auto& i : floatingLeg_) {
+            ext::shared_ptr<LazyObject> f = ext::dynamic_pointer_cast<LazyObject>(i);
             if (f != nullptr)
                 f->update();
         }
diff --git a/ql/instruments/compositeinstrument.cpp b/ql/instruments/compositeinstrument.cpp
index 43dbee0c0cb..b64402f7098 100644
--- a/ql/instruments/compositeinstrument.cpp
+++ b/ql/instruments/compositeinstrument.cpp
@@ -43,8 +43,8 @@ namespace QuantLib {
     }
 
     bool CompositeInstrument::isExpired() const {
-        for (auto i = components_.begin(); i != components_.end(); ++i) {
-            if (!i->first->isExpired())
+        for (const auto& component : components_) {
+            if (!component.first->isExpired())
                 return false;
         }
         return true;
@@ -52,8 +52,8 @@ namespace QuantLib {
 
     void CompositeInstrument::performCalculations() const {
         NPV_ = 0.0;
-        for (auto i = components_.begin(); i != components_.end(); ++i) {
-            NPV_ += i->second * i->first->NPV();
+        for (const auto& component : components_) {
+            NPV_ += component.second * component.first->NPV();
         }
     }
 
diff --git a/ql/instruments/fixedratebondforward.cpp b/ql/instruments/fixedratebondforward.cpp
index 2e040297ec3..79d45ad053e 100644
--- a/ql/instruments/fixedratebondforward.cpp
+++ b/ql/instruments/fixedratebondforward.cpp
@@ -71,11 +71,10 @@ namespace QuantLib {
           2. considers as income: all coupons paid between settlementDate()
           and contract delivery/maturity date
         */
-        for (Size i = 0; i < cf.size(); ++i) {
-            if (!cf[i]->hasOccurred(settlement, false)) {
-                if (cf[i]->hasOccurred(maturityDate_, false)) {
-                    income += cf[i]->amount() *
-                              incomeDiscountCurve->discount(cf[i]->date()) ;
+        for (auto& i : cf) {
+            if (!i->hasOccurred(settlement, false)) {
+                if (i->hasOccurred(maturityDate_, false)) {
+                    income += i->amount() * incomeDiscountCurve->discount(i->date());
                 } else {
                     break;
                 }
diff --git a/ql/instruments/floatfloatswap.cpp b/ql/instruments/floatfloatswap.cpp
index 812aa5376ce..b3afb165c6b 100644
--- a/ql/instruments/floatfloatswap.cpp
+++ b/ql/instruments/floatfloatswap.cpp
@@ -217,12 +217,12 @@ namespace QuantLib {
         // if the gearing is zero then the ibor / cms leg will be set up with
         // fixed coupons which makes trouble here in this context. We therefore
         // use a dirty trick and enforce the gearing to be non zero.
-        for (Size i = 0; i < gearing1_.size(); i++)
-            if (close(gearing1_[i], 0.0))
-                gearing1_[i] = QL_EPSILON;
-        for (Size i = 0; i < gearing2_.size(); i++)
-            if (close(gearing2_[i], 0.0))
-                gearing2_[i] = QL_EPSILON;
+        for (double& i : gearing1_)
+            if (close(i, 0.0))
+                i = QL_EPSILON;
+        for (double& i : gearing2_)
+            if (close(i, 0.0))
+                i = QL_EPSILON;
 
         ext::shared_ptr<IborIndex> ibor1 =
             ext::dynamic_pointer_cast<IborIndex>(index1_);
diff --git a/ql/instruments/nonstandardswap.cpp b/ql/instruments/nonstandardswap.cpp
index 128488fca1a..d3c1dd4e316 100644
--- a/ql/instruments/nonstandardswap.cpp
+++ b/ql/instruments/nonstandardswap.cpp
@@ -148,9 +148,9 @@ namespace QuantLib {
         // if the gearing is zero then the ibor leg will be set up with fixed
         // coupons which makes trouble here in this context. We therefore use
         // a dirty trick and enforce the gearing to be non zero.
-        for (Size i = 0; i < gearing_.size(); ++i) {
-            if (close(gearing_[i], 0.0))
-                gearing_[i] = QL_EPSILON;
+        for (double& i : gearing_) {
+            if (close(i, 0.0))
+                i = QL_EPSILON;
         }
 
         legs_[0] = FixedRateLeg(fixedSchedule_)
diff --git a/ql/instruments/overnightindexedswap.cpp b/ql/instruments/overnightindexedswap.cpp
index 52c209572b5..9f5fb761e93 100644
--- a/ql/instruments/overnightindexedswap.cpp
+++ b/ql/instruments/overnightindexedswap.cpp
@@ -90,8 +90,8 @@ namespace QuantLib {
             .withAveragingMethod(averagingMethod_);
 
         for (Size j=0; j<2; ++j) {
-            for (auto i = legs_[j].begin(); i != legs_[j].end(); ++i)
-                registerWith(*i);
+            for (auto& i : legs_[j])
+                registerWith(i);
         }
 
         switch (type_) {
diff --git a/ql/instruments/swap.cpp b/ql/instruments/swap.cpp
index 3fcfe07927e..0732315ee09 100644
--- a/ql/instruments/swap.cpp
+++ b/ql/instruments/swap.cpp
@@ -36,10 +36,10 @@ namespace QuantLib {
         legs_[1] = secondLeg;
         payer_[0] = -1.0;
         payer_[1] =  1.0;
-        for (auto i = legs_[0].begin(); i != legs_[0].end(); ++i)
-            registerWith(*i);
-        for (auto i = legs_[1].begin(); i != legs_[1].end(); ++i)
-            registerWith(*i);
+        for (auto& i : legs_[0])
+            registerWith(i);
+        for (auto& i : legs_[1])
+            registerWith(i);
     }
 
     Swap::Swap(const std::vector<Leg>& legs,
@@ -53,8 +53,8 @@ namespace QuantLib {
                    ") and legs (" << legs_.size() << ")");
         for (Size j=0; j<legs_.size(); ++j) {
             if (payer[j]) payer_[j]=-1.0;
-            for (auto i = legs_[j].begin(); i != legs_[j].end(); ++i)
-                registerWith(*i);
+            for (auto& i : legs_[j])
+                registerWith(i);
         }
     }
 
@@ -66,9 +66,9 @@ namespace QuantLib {
 
 
     bool Swap::isExpired() const {
-        for (Size j=0; j<legs_.size(); ++j) {
-            Leg::const_iterator i; 
-            for (i = legs_[j].begin(); i!= legs_[j].end(); ++i)
+        for (const auto& leg : legs_) {
+            Leg::const_iterator i;
+            for (i = leg.begin(); i != leg.end(); ++i)
                 if (!(*i)->hasOccurred())
                     return false;
         }
@@ -158,11 +158,9 @@ namespace QuantLib {
     }
 
     void Swap::deepUpdate() {
-        for (Size j = 0; j < legs_.size(); ++j) {
-            for (Size k = 0; k < legs_[j].size(); ++k) {
-                ext::shared_ptr<LazyObject> f =
-                    ext::dynamic_pointer_cast<LazyObject>(
-                        legs_[j][k]);
+        for (auto& leg : legs_) {
+            for (auto& k : leg) {
+                ext::shared_ptr<LazyObject> f = ext::dynamic_pointer_cast<LazyObject>(k);
                 if (f != nullptr)
                     f->update();
             }
diff --git a/ql/instruments/zerocouponinflationswap.cpp b/ql/instruments/zerocouponinflationswap.cpp
index e7106c60783..2f7b029dcfa 100644
--- a/ql/instruments/zerocouponinflationswap.cpp
+++ b/ql/instruments/zerocouponinflationswap.cpp
@@ -95,8 +95,8 @@ namespace QuantLib {
             new IndexedCashFlow(nominal,infIndex,baseDate_,obsDate_,infPayDate,growthOnly)));
 
         for (Size j=0; j<2; ++j) {
-            for (auto i = legs_[j].begin(); i != legs_[j].end(); ++i)
-                registerWith(*i);
+            for (auto& i : legs_[j])
+                registerWith(i);
         }
 
         switch (type_) {
diff --git a/ql/math/interpolations/kernelinterpolation.hpp b/ql/math/interpolations/kernelinterpolation.hpp
index cb0fe814254..9b73bf23995 100644
--- a/ql/math/interpolations/kernelinterpolation.hpp
+++ b/ql/math/interpolations/kernelinterpolation.hpp
@@ -116,9 +116,8 @@ namespace QuantLib {
 
                 Array diffVec=Abs(M_*alphaVec_ - yVec_);
 
-                for (Size i=0; i<diffVec.size(); ++i) {
-                    QL_REQUIRE(diffVec[i] < invPrec_,
-                               "Inversion failed in 1d kernel interpolation");
+                for (double i : diffVec) {
+                    QL_REQUIRE(i < invPrec_, "Inversion failed in 1d kernel interpolation");
                 }
             }
 
diff --git a/ql/math/interpolations/kernelinterpolation2d.hpp b/ql/math/interpolations/kernelinterpolation2d.hpp
index ad6de885553..544649735f5 100644
--- a/ql/math/interpolations/kernelinterpolation2d.hpp
+++ b/ql/math/interpolations/kernelinterpolation2d.hpp
@@ -166,9 +166,8 @@ namespace QuantLib {
                 // I've chosen not to check determinant(M_)!=0 before solving
 
                 Array diffVec=Abs(M_*alphaVec_ - yVec_);
-                for (Size i=0; i<diffVec.size(); ++i) {
-                    QL_REQUIRE(diffVec[i]<invPrec_,
-                               "inversion failed in 2d kernel interpolation");
+                for (double i : diffVec) {
+                    QL_REQUIRE(i < invPrec_, "inversion failed in 2d kernel interpolation");
                 }
             }
 
diff --git a/ql/math/matrixutilities/basisincompleteordered.cpp b/ql/math/matrixutilities/basisincompleteordered.cpp
index 5e799fb31b2..cf1cde7459b 100644
--- a/ql/math/matrixutilities/basisincompleteordered.cpp
+++ b/ql/math/matrixutilities/basisincompleteordered.cpp
@@ -36,13 +36,12 @@ namespace QuantLib {
         if (currentBasis_.size()==euclideanDimension_)
             return false;
 
-        for (Size j=0; j<currentBasis_.size(); ++j) {
-            Real innerProd = std::inner_product(newVector_.begin(),
-                newVector_.end(),
-                currentBasis_[j].begin(), 0.0);
+        for (auto& currentBasi : currentBasis_) {
+            Real innerProd =
+                std::inner_product(newVector_.begin(), newVector_.end(), currentBasi.begin(), 0.0);
 
             for (Size k=0; k<euclideanDimension_; ++k)
-                newVector_[k] -=innerProd*currentBasis_[j][k];
+                newVector_[k] -= innerProd * currentBasi[k];
         }
 
         Real norm = std::sqrt(std::inner_product(newVector_.begin(),
diff --git a/ql/math/matrixutilities/sparseilupreconditioner.cpp b/ql/math/matrixutilities/sparseilupreconditioner.cpp
index cdc5bee3eb5..be18e02bbcc 100644
--- a/ql/math/matrixutilities/sparseilupreconditioner.cpp
+++ b/ql/math/matrixutilities/sparseilupreconditioner.cpp
@@ -123,9 +123,8 @@ namespace QuantLib {
             }
             std::vector<Integer> leviiNonZeroEntries;
             leviiNonZeroEntries.reserve(levii.size());
-            for (Size i=0; i<levii.size(); ++i) {
-                const Integer entry = levii[i];
-                if(entry > QL_EPSILON || entry < -1.0*QL_EPSILON) {
+            for (int entry : levii) {
+                if (entry > QL_EPSILON || entry < -1.0 * QL_EPSILON) {
                     leviiNonZeroEntries.push_back(entry);
                 }
             }
diff --git a/ql/math/matrixutilities/svd.cpp b/ql/math/matrixutilities/svd.cpp
index a03502de79c..3af50a5c7d5 100644
--- a/ql/math/matrixutilities/svd.cpp
+++ b/ql/math/matrixutilities/svd.cpp
@@ -517,8 +517,8 @@ namespace QuantLib {
         Real eps = QL_EPSILON;
         Real tol = m_*s_[0]*eps;
         Size r = 0;
-        for (Size i = 0; i < s_.size(); i++) {
-            if (s_[i] > tol) {
+        for (double i : s_) {
+            if (i > tol) {
                 r++;
             }
         }
diff --git a/ql/math/optimization/constraint.hpp b/ql/math/optimization/constraint.hpp
index 4dffea42d87..25de78fa86e 100644
--- a/ql/math/optimization/constraint.hpp
+++ b/ql/math/optimization/constraint.hpp
@@ -93,8 +93,8 @@ namespace QuantLib {
         class Impl : public Constraint::Impl {
           public:
             bool test(const Array& params) const override {
-                for (Size i=0; i<params.size(); ++i) {
-                    if (params[i] <= 0.0)
+                for (double param : params) {
+                    if (param <= 0.0)
                         return false;
                 }
                 return true;
@@ -121,8 +121,8 @@ namespace QuantLib {
             Impl(Real low, Real high)
             : low_(low), high_(high) {}
             bool test(const Array& params) const override {
-                for (Size i=0; i<params.size(); i++) {
-                    if ((params[i] < low_) || (params[i] > high_))
+                for (double param : params) {
+                    if ((param < low_) || (param > high_))
                         return false;
                 }
                 return true;
diff --git a/ql/math/optimization/differentialevolution.cpp b/ql/math/optimization/differentialevolution.cpp
index 92c3dce62c2..0ea39f41954 100644
--- a/ql/math/optimization/differentialevolution.cpp
+++ b/ql/math/optimization/differentialevolution.cpp
@@ -140,8 +140,8 @@ namespace QuantLib {
               Array jitter(population[0].values.size(), 0.0);
 
               for (Size popIter = 0; popIter < population.size(); popIter++) {
-                  for (Size jitterIter = 0; jitterIter < jitter.size(); jitterIter++) {
-                      jitter[jitterIter] = rng_.nextReal();
+                  for (double& jitterIter : jitter) {
+                      jitterIter = rng_.nextReal();
                   }
                   population[popIter].values = bestMemberEver_.values
                       + (shuffledPop1[popIter].values - population[popIter].values)
@@ -176,9 +176,9 @@ namespace QuantLib {
               randomize(population.begin(), population.end(), rng_);
               mirrorPopulation = shuffledPop1;
               Array FWeight = Array(population.front().values.size(), 0.0);
-              for (Size fwIter = 0; fwIter < FWeight.size(); fwIter++)
-                  FWeight[fwIter] = (1.0 - configuration().stepsizeWeight)
-                      * rng_.nextReal() + configuration().stepsizeWeight;
+              for (double& fwIter : FWeight)
+                  fwIter = (1.0 - configuration().stepsizeWeight) * rng_.nextReal() +
+                           configuration().stepsizeWeight;
               for (Size popIter = 0; popIter < population.size(); popIter++) {
                   population[popIter].values = population[popIter].values
                       + FWeight * (shuffledPop1[popIter].values - shuffledPop2[popIter].values);
@@ -363,17 +363,17 @@ namespace QuantLib {
          // [=tau1] A Comparative Study on Numerical Benchmark
          // Problems." page 649 for reference
         Real sizeWeightChangeProb = 0.1;
-        for (Size coIter = 0;coIter < currGenSizeWeights_.size(); coIter++){
+        for (double& currGenSizeWeight : currGenSizeWeights_) {
             if (rng_.nextReal() < sizeWeightChangeProb)
-                currGenSizeWeights_[coIter] = sizeWeightLowerBound + rng_.nextReal() * sizeWeightUpperBound;
+                currGenSizeWeight = sizeWeightLowerBound + rng_.nextReal() * sizeWeightUpperBound;
         }
     }
 
     void DifferentialEvolution::adaptCrossover() const {
         Real crossoverChangeProb = 0.1; // [=tau2]
-        for (Size coIter = 0;coIter < currGenCrossover_.size(); coIter++){
+        for (double& coIter : currGenCrossover_) {
             if (rng_.nextReal() < crossoverChangeProb)
-                currGenCrossover_[coIter] = rng_.nextReal();
+                coIter = rng_.nextReal();
         }
     }
 
diff --git a/ql/math/optimization/projection.cpp b/ql/math/optimization/projection.cpp
index fb3a871145c..d1bbb823d06 100644
--- a/ql/math/optimization/projection.cpp
+++ b/ql/math/optimization/projection.cpp
@@ -34,8 +34,8 @@ namespace QuantLib {
 
         QL_REQUIRE(fixedParameters_.size() == fixParameters_.size(),
                    "fixedParameters_.size()!=parametersFreedoms_.size()");
-        for (Size i = 0; i < fixParameters_.size(); i++)
-            if (!fixParameters_[i])
+        for (auto&& fixParameter : fixParameters_)
+            if (!fixParameter)
                 numberOfFreeParameters_++;
         QL_REQUIRE(numberOfFreeParameters_ > 0, "numberOfFreeParameters==0");
     }
diff --git a/ql/math/optimization/simplex.cpp b/ql/math/optimization/simplex.cpp
index 12fa94e9898..76fa997ffc1 100644
--- a/ql/math/optimization/simplex.cpp
+++ b/ql/math/optimization/simplex.cpp
@@ -43,12 +43,12 @@ namespace QuantLib {
     // Computes the size of the simplex
         Real computeSimplexSize (const std::vector<Array>& vertices) {
             Array center(vertices.front().size(),0);
-            for (Size i=0; i<vertices.size(); ++i)
-                center += vertices[i];
+            for (const auto& vertice : vertices)
+                center += vertice;
             center *=1/Real(vertices.size());
             Real result = 0;
-            for (Size i=0; i<vertices.size(); ++i) {
-                Array temp = vertices[i] - center;
+            for (const auto& vertice : vertices) {
+                Array temp = vertice - center;
                 result += Norm2(temp);
             }
             return result/Real(vertices.size());
diff --git a/ql/math/optimization/simulatedannealing.hpp b/ql/math/optimization/simulatedannealing.hpp
index 24d7883135c..2b9e2d76c27 100644
--- a/ql/math/optimization/simulatedannealing.hpp
+++ b/ql/math/optimization/simulatedannealing.hpp
@@ -96,12 +96,12 @@ namespace QuantLib {
     Real SimulatedAnnealing<RNG>::simplexSize() { // this is taken from
                                                   // simplex.cpp
         Array center(vertices_.front().size(), 0);
-        for (Size i = 0; i < vertices_.size(); ++i)
-            center += vertices_[i];
+        for (auto& vertice : vertices_)
+            center += vertice;
         center *= 1 / Real(vertices_.size());
         Real result = 0;
-        for (Size i = 0; i < vertices_.size(); ++i) {
-            Array temp = vertices_[i] - center;
+        for (auto& vertice : vertices_) {
+            Array temp = vertice - center;
             result += Norm2(temp);
         }
         return result / Real(vertices_.size());
diff --git a/ql/math/sampledcurve.hpp b/ql/math/sampledcurve.hpp
index 940589b9a02..3e40dfe5458 100644
--- a/ql/math/sampledcurve.hpp
+++ b/ql/math/sampledcurve.hpp
@@ -122,9 +122,8 @@ namespace QuantLib {
             Array newValues = new_grid;
             std::transform(newValues.begin(), newValues.end(),
                            newValues.begin(), func);
-            for (Array::iterator j = newValues.begin();
-                 j != newValues.end(); ++j) {
-                *j = priceSpline(*j, true);
+            for (double& newValue : newValues) {
+                newValue = priceSpline(newValue, true);
             }
             values_.swap(newValues);
             grid_ = new_grid;
diff --git a/ql/math/statistics/histogram.cpp b/ql/math/statistics/histogram.cpp
index 16463f8ddb9..f101a1c4003 100644
--- a/ql/math/statistics/histogram.cpp
+++ b/ql/math/statistics/histogram.cpp
@@ -157,11 +157,10 @@ namespace QuantLib {
         counts_.resize(bins_);
         std::fill(counts_.begin(), counts_.end(), 0);
 
-        for (std::vector<Real>::const_iterator p = data_.begin();
-             p != data_.end(); ++p) {
+        for (double p : data_) {
             bool processed = false;
             for (Size i=0; i<breaks_.size(); ++i) {
-                if (*p < breaks_[i]) {
+                if (p < breaks_[i]) {
                     ++counts_[i];
                     processed = true;
                     break;
diff --git a/ql/methods/finitedifferences/meshers/concentrating1dmesher.cpp b/ql/methods/finitedifferences/meshers/concentrating1dmesher.cpp
index 90ab9249248..c0fe365f8ee 100644
--- a/ql/methods/finitedifferences/meshers/concentrating1dmesher.cpp
+++ b/ql/methods/finitedifferences/meshers/concentrating1dmesher.cpp
@@ -157,9 +157,9 @@ namespace QuantLib {
         QL_REQUIRE(end > start, "end must be larger than start");
 
         std::vector<Real> points, betas;
-        for (auto iter = cPoints.begin(); iter != cPoints.end(); ++iter) {
-            points.push_back(ext::get<0>(*iter));
-            betas.push_back(square<Real>()(ext::get<1>(*iter)*(end-start)));
+        for (const auto& cPoint : cPoints) {
+            points.push_back(ext::get<0>(cPoint));
+            betas.push_back(square<Real>()(ext::get<1>(cPoint) * (end - start)));
         }
 
         // get scaling factor a so that y(1) = end
diff --git a/ql/methods/finitedifferences/meshers/fdmblackscholesmesher.cpp b/ql/methods/finitedifferences/meshers/fdmblackscholesmesher.cpp
index 407d278c14a..0176e7cf79e 100644
--- a/ql/methods/finitedifferences/meshers/fdmblackscholesmesher.cpp
+++ b/ql/methods/finitedifferences/meshers/fdmblackscholesmesher.cpp
@@ -49,14 +49,10 @@ namespace QuantLib {
         QL_REQUIRE(S > 0.0, "negative or null underlying given");
 
         std::vector<std::pair<Time, Real> > intermediateSteps;
-        for (Size i=0; i < dividendSchedule.size(); ++i) {
-            const Time t = process->time(dividendSchedule[i]->date());
+        for (const auto& i : dividendSchedule) {
+            const Time t = process->time(i->date());
             if (t <= maturity && t >= 0.0)
-                intermediateSteps.push_back(
-                    std::make_pair(
-                        process->time(dividendSchedule[i]->date()),
-                        dividendSchedule[i]->amount()
-                    ) );
+                intermediateSteps.push_back(std::make_pair(process->time(i->date()), i->amount()));
         }
 
         const Size intermediateTimeSteps = std::max<Size>(2, Size(24.0*maturity));
@@ -81,9 +77,9 @@ namespace QuantLib {
         Real fwd = S + spotAdjustment;
         Real mi = fwd, ma = fwd;
 
-        for (Size i=0; i < intermediateSteps.size(); ++i) {
-            const Time divTime = intermediateSteps[i].first;
-            const Real divAmount = intermediateSteps[i].second;
+        for (auto& intermediateStep : intermediateSteps) {
+            const Time divTime = intermediateStep.first;
+            const Real divAmount = intermediateStep.second;
 
             fwd = fwd / rTS->discount(divTime) * rTS->discount(lastDivTime)
                       * qTS->discount(divTime) / qTS->discount(lastDivTime);
diff --git a/ql/methods/finitedifferences/schemes/boundaryconditionschemehelper.hpp b/ql/methods/finitedifferences/schemes/boundaryconditionschemehelper.hpp
index 7e4cc561cc3..6d0c7abcad3 100644
--- a/ql/methods/finitedifferences/schemes/boundaryconditionschemehelper.hpp
+++ b/ql/methods/finitedifferences/schemes/boundaryconditionschemehelper.hpp
@@ -38,24 +38,24 @@ namespace QuantLib {
         : bcSet_(std::move(bcSet)) {}
 
         void applyBeforeApplying(operator_type& op) const {
-            for (Size i=0; i < bcSet_.size(); ++i)
-                bcSet_[i]->applyBeforeApplying(op);
+            for (const auto& i : bcSet_)
+                i->applyBeforeApplying(op);
         }
         void applyBeforeSolving(operator_type& op, array_type& a) const {
-            for (Size i=0; i < bcSet_.size(); ++i)
-                bcSet_[i]->applyBeforeSolving(op, a);
+            for (const auto& i : bcSet_)
+                i->applyBeforeSolving(op, a);
         }
         void applyAfterApplying(array_type& a) const {
-            for (Size i=0; i < bcSet_.size(); ++i)
-                bcSet_[i]->applyAfterApplying(a);
+            for (const auto& i : bcSet_)
+                i->applyAfterApplying(a);
         }
         void applyAfterSolving(array_type& a) const {
-            for (Size i=0; i < bcSet_.size(); ++i)
-                bcSet_[i]->applyAfterSolving(a);
+            for (const auto& i : bcSet_)
+                i->applyAfterSolving(a);
         }
         void setTime(Time t) const {
-            for (Size i=0; i < bcSet_.size(); ++i)
-                bcSet_[i]->setTime(t);
+            for (const auto& i : bcSet_)
+                i->setTime(t);
         }
 
       private:
diff --git a/ql/methods/finitedifferences/stepconditions/fdmbermudanstepcondition.cpp b/ql/methods/finitedifferences/stepconditions/fdmbermudanstepcondition.cpp
index a6abcd6d9fa..4006fae75e2 100644
--- a/ql/methods/finitedifferences/stepconditions/fdmbermudanstepcondition.cpp
+++ b/ql/methods/finitedifferences/stepconditions/fdmbermudanstepcondition.cpp
@@ -33,9 +33,8 @@ namespace QuantLib {
     : mesher_(std::move(mesher)), calculator_(std::move(calculator)) {
 
         exerciseTimes_.reserve(exerciseDates.size());
-        for (auto iter = exerciseDates.begin(); iter != exerciseDates.end(); ++iter) {
-            exerciseTimes_.push_back(
-                             dayCounter.yearFraction(referenceDate, *iter));
+        for (auto exerciseDate : exerciseDates) {
+            exerciseTimes_.push_back(dayCounter.yearFraction(referenceDate, exerciseDate));
         }
     }
 
diff --git a/ql/methods/finitedifferences/stepconditions/fdmstepconditioncomposite.cpp b/ql/methods/finitedifferences/stepconditions/fdmstepconditioncomposite.cpp
index 59514b82b71..0854acb679e 100644
--- a/ql/methods/finitedifferences/stepconditions/fdmstepconditioncomposite.cpp
+++ b/ql/methods/finitedifferences/stepconditions/fdmstepconditioncomposite.cpp
@@ -38,8 +38,8 @@ namespace QuantLib {
     : conditions_(std::move(conditions)) {
 
         std::set<Real> allStoppingTimes;
-        for (auto iter = stoppingTimes.begin(); iter != stoppingTimes.end(); ++iter) {
-            allStoppingTimes.insert(iter->begin(), iter->end());
+        for (const auto& stoppingTime : stoppingTimes) {
+            allStoppingTimes.insert(stoppingTime.begin(), stoppingTime.end());
         }
         stoppingTimes_ = std::vector<Time>(allStoppingTimes.begin(),
                                            allStoppingTimes.end());
@@ -55,8 +55,8 @@ namespace QuantLib {
     }
 
     void FdmStepConditionComposite::applyTo(Array& a, Time t) const {
-        for (auto iter = conditions_.begin(); iter != conditions_.end(); ++iter) {
-            (*iter)->applyTo(a, t);
+        for (const auto& condition : conditions_) {
+            condition->applyTo(a, t);
         }
     }
     
diff --git a/ql/methods/finitedifferences/utilities/fdmaffinemodelswapinnervalue.hpp b/ql/methods/finitedifferences/utilities/fdmaffinemodelswapinnervalue.hpp
index 81c838083a8..a250a3495f3 100644
--- a/ql/methods/finitedifferences/utilities/fdmaffinemodelswapinnervalue.hpp
+++ b/ql/methods/finitedifferences/utilities/fdmaffinemodelswapinnervalue.hpp
@@ -124,11 +124,11 @@ namespace QuantLib {
 
         Real npv = 0.0;
         for (Size j = 0; j < 2; j++) {
-            for (auto i = swap_->leg(j).begin(); i != swap_->leg(j).end(); ++i) {
-                npv += ext::dynamic_pointer_cast<Coupon>(*i)
-                                    ->accrualStartDate() >= iterExerciseDate
-                            ? (*i)->amount() * disTs_->discount((*i)->date())
-                            : 0.0;
+            for (const auto& i : swap_->leg(j)) {
+                npv +=
+                    ext::dynamic_pointer_cast<Coupon>(i)->accrualStartDate() >= iterExerciseDate ?
+                        i->amount() * disTs_->discount(i->date()) :
+                        0.0;
             }
             if (j == 0)
                 npv *= -1.0;
diff --git a/ql/methods/finitedifferences/utilities/fdmdirichletboundary.cpp b/ql/methods/finitedifferences/utilities/fdmdirichletboundary.cpp
index f8297ff5060..7159c9a8e34 100644
--- a/ql/methods/finitedifferences/utilities/fdmdirichletboundary.cpp
+++ b/ql/methods/finitedifferences/utilities/fdmdirichletboundary.cpp
@@ -52,8 +52,8 @@ namespace QuantLib {
     }
 
     void FdmDirichletBoundary::applyAfterApplying(Array& x) const {
-        for (auto iter = indices_.begin(); iter != indices_.end(); ++iter) {
-            x[*iter] = valueOnBoundary_;
+        for (unsigned long indice : indices_) {
+            x[indice] = valueOnBoundary_;
         }
     }
     
diff --git a/ql/methods/finitedifferences/utilities/fdmdividendhandler.cpp b/ql/methods/finitedifferences/utilities/fdmdividendhandler.cpp
index fccdb203927..94e82002d73 100644
--- a/ql/methods/finitedifferences/utilities/fdmdividendhandler.cpp
+++ b/ql/methods/finitedifferences/utilities/fdmdividendhandler.cpp
@@ -40,10 +40,10 @@ namespace QuantLib {
         dividends_.reserve(schedule.size());
         dividendDates_.reserve(schedule.size());
         dividendTimes_.reserve(schedule.size());
-        for (auto iter = schedule.begin(); iter != schedule.end(); ++iter) {
-            dividends_.push_back((*iter)->amount());
-            dividendDates_.push_back((*iter)->date());
-            dividendTimes_.push_back(dayCounter.yearFraction(referenceDate, (*iter)->date()));
+        for (const auto& iter : schedule) {
+            dividends_.push_back(iter->amount());
+            dividendDates_.push_back(iter->date());
+            dividendTimes_.push_back(dayCounter.yearFraction(referenceDate, iter->date()));
         }
 
          Array tmp = mesher_->locations(equityDirection);
diff --git a/ql/methods/finitedifferences/utilities/fdmshoutloginnervaluecalculator.cpp b/ql/methods/finitedifferences/utilities/fdmshoutloginnervaluecalculator.cpp
index 48a32af9a1c..2d9c29a32b4 100644
--- a/ql/methods/finitedifferences/utilities/fdmshoutloginnervaluecalculator.cpp
+++ b/ql/methods/finitedifferences/utilities/fdmshoutloginnervaluecalculator.cpp
@@ -22,24 +22,22 @@
 */
 
 #include <ql/instruments/payoffs.hpp>
-#include <ql/pricingengines/blackformula.hpp>
-#include <ql/processes/blackscholesprocess.hpp>
 #include <ql/methods/finitedifferences/meshers/fdmmesher.hpp>
 #include <ql/methods/finitedifferences/utilities/fdmshoutloginnervaluecalculator.hpp>
+#include <ql/pricingengines/blackformula.hpp>
+#include <ql/processes/blackscholesprocess.hpp>
+#include <utility>
 
 namespace QuantLib {
 
     FdmShoutLogInnerValueCalculator::FdmShoutLogInnerValueCalculator(
-        const ext::shared_ptr<GeneralizedBlackScholesProcess>& process,
+        ext::shared_ptr<GeneralizedBlackScholesProcess> process,
         Time maturity,
-        const ext::shared_ptr<PlainVanillaPayoff>& payoff,
-        const ext::shared_ptr<FdmMesher>& mesher,
+        ext::shared_ptr<PlainVanillaPayoff> payoff,
+        ext::shared_ptr<FdmMesher> mesher,
         Size direction)
-    : process_(process),
-      maturity_(maturity),
-      payoff_(payoff),
-      mesher_(mesher),
-      direction_(direction) { }
+    : process_(std::move(process)), maturity_(maturity), payoff_(std::move(payoff)),
+      mesher_(std::move(mesher)), direction_(direction) {}
 
 
     Real FdmShoutLogInnerValueCalculator::innerValue(
diff --git a/ql/methods/finitedifferences/utilities/fdmshoutloginnervaluecalculator.hpp b/ql/methods/finitedifferences/utilities/fdmshoutloginnervaluecalculator.hpp
index 3f8679dc8af..a4b68961607 100644
--- a/ql/methods/finitedifferences/utilities/fdmshoutloginnervaluecalculator.hpp
+++ b/ql/methods/finitedifferences/utilities/fdmshoutloginnervaluecalculator.hpp
@@ -33,12 +33,11 @@ namespace QuantLib {
 
     class FdmShoutLogInnerValueCalculator: public FdmInnerValueCalculator {
       public:
-        FdmShoutLogInnerValueCalculator(
-            const ext::shared_ptr<GeneralizedBlackScholesProcess>& process,
-            Time maturity,
-            const ext::shared_ptr<PlainVanillaPayoff>& payoff,
-            const ext::shared_ptr<FdmMesher>& mesher,
-            Size direction);
+        FdmShoutLogInnerValueCalculator(ext::shared_ptr<GeneralizedBlackScholesProcess> process,
+                                        Time maturity,
+                                        ext::shared_ptr<PlainVanillaPayoff> payoff,
+                                        ext::shared_ptr<FdmMesher> mesher,
+                                        Size direction);
 
         Real innerValue(const FdmLinearOpIterator& iter, Time t) override;
         Real avgInnerValue(const FdmLinearOpIterator& iter, Time t) override;
diff --git a/ql/methods/montecarlo/genericlsregression.cpp b/ql/methods/montecarlo/genericlsregression.cpp
index 9ccefaa43c5..025640f3da6 100644
--- a/ql/methods/montecarlo/genericlsregression.cpp
+++ b/ql/methods/montecarlo/genericlsregression.cpp
@@ -101,8 +101,8 @@ namespace QuantLib {
         // over all paths
         Statistics estimate;
         std::vector<NodeData>& estimatedData = simulationData[0];
-        for (Size j=0; j<estimatedData.size(); ++j)
-            estimate.add(estimatedData[j].cumulatedCashFlows);
+        for (auto& j : estimatedData)
+            estimate.add(j.cumulatedCashFlows);
 
         return estimate.mean();
     }
diff --git a/ql/methods/montecarlo/lsmbasissystem.cpp b/ql/methods/montecarlo/lsmbasissystem.cpp
index 07de8580fc5..2710edea6a0 100644
--- a/ql/methods/montecarlo/lsmbasissystem.cpp
+++ b/ql/methods/montecarlo/lsmbasissystem.cpp
@@ -76,10 +76,9 @@ namespace QuantLib {
 
         // check size and order of tuples
         void check_tuples(const VV& v, Size dim, Size order) {
-            for(Size i=0; i<v.size(); ++i) {
-                QL_REQUIRE(dim==v[i].size(), "wrong tuple size");
-                QL_REQUIRE(order == std::accumulate(v[i].begin(), v[i].end(), 0UL),
-                           "wrong tuple order");
+            for (const auto& i : v) {
+                QL_REQUIRE(dim == i.size(), "wrong tuple size");
+                QL_REQUIRE(order == std::accumulate(i.begin(), i.end(), 0UL), "wrong tuple order");
             }
         }
 
@@ -95,8 +94,8 @@ namespace QuantLib {
             std::vector<Size> x;
             for(Size i=0; i<dim; ++i) {
                 // increase i-th value in every tuple by 1
-                for(Size j=0; j<v.size(); ++j) {
-                    x = v[j];
+                for (const auto& j : v) {
+                    x = j;
                     x[i] += 1;
                     tuples.insert(x);
                 }
@@ -158,9 +157,9 @@ namespace QuantLib {
             tuples = next_order_tuples(tuples);
             // now we have all tuples of order i
             // for each tuple add the corresponding term
-            for(Size j=0; j<tuples.size(); ++j) {
+            for (auto& tuple : tuples) {
                 for(Size k=0; k<dim; ++k)
-                    term[k] = pathBasis[tuples[j][k]];
+                    term[k] = pathBasis[tuple[k]];
                 ret.push_back(MultiDimFct(term));
             }
         }
diff --git a/ql/methods/montecarlo/parametricexercise.cpp b/ql/methods/montecarlo/parametricexercise.cpp
index 2a5a77591ec..a960998fabd 100644
--- a/ql/methods/montecarlo/parametricexercise.cpp
+++ b/ql/methods/montecarlo/parametricexercise.cpp
@@ -49,8 +49,8 @@ namespace QuantLib {
         : simulationData_(simulationData), exercise_(exercise),
           exerciseIndex_(exerciseIndex),
           parameters_(exercise.numberOfParameters()[exerciseIndex]) {
-            for (Size i=0; i<simulationData_.size(); ++i) {
-                if (simulationData_[i].isValid)
+            for (const auto& i : simulationData_) {
+                if (i.isValid)
                     return;
             }
             QL_FAIL("no valid paths");
@@ -61,15 +61,13 @@ namespace QuantLib {
                       parameters_.begin());
             Real sum = 0.0;
             Size n = 0;
-            for (Size i=0; i<simulationData_.size(); ++i) {
-                if (simulationData_[i].isValid) {
+            for (const auto& i : simulationData_) {
+                if (i.isValid) {
                     ++n;
-                    if (exercise_.exercise(exerciseIndex_,
-                                           parameters_,
-                                           simulationData_[i].values))
-                        sum += simulationData_[i].exerciseValue;
+                    if (exercise_.exercise(exerciseIndex_, parameters_, i.values))
+                        sum += i.exerciseValue;
                     else
-                        sum += simulationData_[i].cumulatedCashFlows;
+                        sum += i.cumulatedCashFlows;
                 }
             }
             return -sum/n;
@@ -129,8 +127,8 @@ namespace QuantLib {
 
         Real sum = 0.0;
         const std::vector<NodeData>& initialData = simulationData.front();
-        for (Size i=0; i<initialData.size(); ++i)
-            sum += initialData[i].cumulatedCashFlows;
+        for (const auto& i : initialData)
+            sum += i.cumulatedCashFlows;
         return sum/initialData.size();
     }
 
diff --git a/ql/models/marketmodels/accountingengine.cpp b/ql/models/marketmodels/accountingengine.cpp
index 3752898b226..ae15fc93ed4 100644
--- a/ql/models/marketmodels/accountingengine.cpp
+++ b/ql/models/marketmodels/accountingengine.cpp
@@ -43,9 +43,8 @@ namespace QuantLib {
             product_->possibleCashFlowTimes();
         const std::vector<Rate>& rateTimes = product_->evolution().rateTimes();
         discounters_.reserve(cashFlowTimes.size());
-        for (Size j=0; j<cashFlowTimes.size(); ++j)
-            discounters_.push_back(MarketModelDiscounter(cashFlowTimes[j],
-                                                         rateTimes));
+        for (double cashFlowTime : cashFlowTimes)
+            discounters_.push_back(MarketModelDiscounter(cashFlowTime, rateTimes));
     }
 
     Real AccountingEngine::singlePathValues(std::vector<Real>& values) {
diff --git a/ql/models/marketmodels/pathwiseaccountingengine.cpp b/ql/models/marketmodels/pathwiseaccountingengine.cpp
index fd280c323bc..cd3dc8a18de 100644
--- a/ql/models/marketmodels/pathwiseaccountingengine.cpp
+++ b/ql/models/marketmodels/pathwiseaccountingengine.cpp
@@ -66,8 +66,8 @@ namespace QuantLib {
             cashFlowsGenerated_[i].resize(
                 product_->maxNumberOfCashFlowsPerProductPerStep());
 
-            for (Size j=0; j < cashFlowsGenerated_[i].size(); ++j)
-                cashFlowsGenerated_[i][j].amount.resize(numberRates_+1);
+            for (auto& j : cashFlowsGenerated_[i])
+                j.amount.resize(numberRates_ + 1);
 
             numberCashFlowsThisIndex_[i].resize(product_->possibleCashFlowTimes().size());
 
@@ -92,9 +92,8 @@ namespace QuantLib {
         const std::vector<Time>& evolutionTimes = product_->evolution().evolutionTimes();
         discounters_.reserve(cashFlowTimes.size());
 
-        for (Size j=0; j<cashFlowTimes.size(); ++j)
-            discounters_.push_back(MarketModelPathwiseDiscounter(cashFlowTimes[j],
-            rateTimes));
+        for (double cashFlowTime : cashFlowTimes)
+            discounters_.push_back(MarketModelPathwiseDiscounter(cashFlowTime, rateTimes));
 
 
         // need to check that we are in money market measure
@@ -393,8 +392,8 @@ namespace QuantLib {
             cashFlowsGenerated_[i].resize(
                 product_->maxNumberOfCashFlowsPerProductPerStep());
 
-            for (Size j=0; j < cashFlowsGenerated_[i].size(); ++j)
-                cashFlowsGenerated_[i][j].amount.resize(numberRates_+1);
+            for (auto& j : cashFlowsGenerated_[i])
+                j.amount.resize(numberRates_ + 1);
 
             numberCashFlowsThisIndex_[i].resize(product_->possibleCashFlowTimes().size());
 
@@ -419,9 +418,8 @@ namespace QuantLib {
         const std::vector<Time>& evolutionTimes = product_->evolution().evolutionTimes();
         discounters_.reserve(cashFlowTimes.size());
 
-        for (Size j=0; j<cashFlowTimes.size(); ++j)
-            discounters_.push_back(MarketModelPathwiseDiscounter(cashFlowTimes[j],
-            rateTimes));
+        for (double cashFlowTime : cashFlowTimes)
+            discounters_.push_back(MarketModelPathwiseDiscounter(cashFlowTime, rateTimes));
 
 
         // need to check that we are in money market measure
@@ -787,8 +785,8 @@ namespace QuantLib {
             cashFlowsGenerated_[i].resize(
                 product_->maxNumberOfCashFlowsPerProductPerStep());
 
-            for (Size j=0; j < cashFlowsGenerated_[i].size(); ++j)
-                cashFlowsGenerated_[i][j].amount.resize(numberRates_+1);
+            for (auto& j : cashFlowsGenerated_[i])
+                j.amount.resize(numberRates_ + 1);
 
             numberCashFlowsThisIndex_[i].resize(product_->possibleCashFlowTimes().size());
 
@@ -813,9 +811,8 @@ namespace QuantLib {
         const std::vector<Time>& evolutionTimes = product_->evolution().evolutionTimes();
         discounters_.reserve(cashFlowTimes.size());
 
-        for (Size j=0; j<cashFlowTimes.size(); ++j)
-            discounters_.push_back(MarketModelPathwiseDiscounter(cashFlowTimes[j],
-            rateTimes));
+        for (double cashFlowTime : cashFlowTimes)
+            discounters_.push_back(MarketModelPathwiseDiscounter(cashFlowTime, rateTimes));
 
 
         // need to check that we are in money market measure
diff --git a/ql/models/marketmodels/pathwisegreeks/bumpinstrumentjacobian.cpp b/ql/models/marketmodels/pathwisegreeks/bumpinstrumentjacobian.cpp
index ad1a11920e1..a825b42ef7e 100644
--- a/ql/models/marketmodels/pathwisegreeks/bumpinstrumentjacobian.cpp
+++ b/ql/models/marketmodels/pathwisegreeks/bumpinstrumentjacobian.cpp
@@ -168,8 +168,8 @@ namespace QuantLib
         theBumps.resize(numberSteps);
        // recall that the bumps: We do the outermost vector by time step and inner one by which vega.
 
-        for (Size i=0; i < theBumps.size(); ++i)
-            theBumps[i].resize(numberRestrictedBumps);
+        for (auto& theBump : theBumps)
+            theBump.resize(numberRestrictedBumps);
 
         Matrix modelMatrix(numberRates, factors,0.0);
 
diff --git a/ql/models/marketmodels/pathwisegreeks/ratepseudorootjacobian.cpp b/ql/models/marketmodels/pathwisegreeks/ratepseudorootjacobian.cpp
index 1cadd918c2e..f46661a135e 100644
--- a/ql/models/marketmodels/pathwisegreeks/ratepseudorootjacobian.cpp
+++ b/ql/models/marketmodels/pathwisegreeks/ratepseudorootjacobian.cpp
@@ -266,22 +266,22 @@ namespace QuantLib
           Size numberRates = taus_.size();
 
            QL_REQUIRE(B.size() == numberRates, "we need B.size() which is " << B.size() << " to equal numberRates which is "  << numberRates);
-           for (Size j=0; j < B.size(); ++j)
-                      QL_REQUIRE(B[j].columns() == factors_ && B[j].rows() == numberRates , "we need B[j].rows() which is " << B[j].rows() << " to equal numberRates which is "  << numberRates << 
-                      " and B[j].columns() which is " << B[j].columns() << " to be equal to factors which is " << factors_);
+           for (auto& j : B)
+               QL_REQUIRE(j.columns() == factors_ && j.rows() == numberRates,
+                          "we need B[j].rows() which is "
+                              << j.rows() << " to equal numberRates which is " << numberRates
+                              << " and B[j].columns() which is " << j.columns()
+                              << " to be equal to factors which is " << factors_);
 
 
+           for (Size j = aliveIndex_; j < numberRates; ++j)
+               ratios_[j] = (oldRates[j] + displacements_[j]) * discountRatios[j + 1];
 
+           for (Size f = 0; f < factors_; ++f) {
+               e_[aliveIndex_][f] = 0;
 
-        for (Size j=aliveIndex_; j < numberRates; ++j)
-            ratios_[j] = (oldRates[j] + displacements_[j])*discountRatios[j+1];
-
-        for (Size f=0; f < factors_; ++f)
-        {
-            e_[aliveIndex_][f] = 0;
-
-            for (Size j= aliveIndex_+1; j < numberRates; ++j)
-                e_[j][f] = e_[j-1][f] + ratios_[j-1]*pseudoRoot_[j-1][f];
+               for (Size j = aliveIndex_ + 1; j < numberRates; ++j)
+                   e_[j][f] = e_[j - 1][f] + ratios_[j - 1] * pseudoRoot_[j - 1][f];
         }
 
         // nullify B for rates that have already reset
diff --git a/ql/models/marketmodels/pathwisegreeks/vegabumpcluster.cpp b/ql/models/marketmodels/pathwisegreeks/vegabumpcluster.cpp
index 9cfb980449c..f1fd1743911 100644
--- a/ql/models/marketmodels/pathwisegreeks/vegabumpcluster.cpp
+++ b/ql/models/marketmodels/pathwisegreeks/vegabumpcluster.cpp
@@ -131,8 +131,9 @@ namespace QuantLib {
                                            ext::shared_ptr<MarketModel> volStructure)
     : allBumps_(std::move(allBumps)), associatedVolStructure_(std::move(volStructure)),
       checked_(false) {
-        for (Size j=0; j < allBumps_.size(); ++j)
-            QL_REQUIRE(allBumps_[j].isCompatible(associatedVolStructure_),"incompatible bumps passed to VegaBumpCollection");
+        for (auto& allBump : allBumps_)
+            QL_REQUIRE(allBump.isCompatible(associatedVolStructure_),
+                       "incompatible bumps passed to VegaBumpCollection");
     }
 
 
@@ -159,13 +160,11 @@ namespace QuantLib {
         for (Size j=0; j < associatedVolStructure_->numberOfSteps(); ++j)
             v.push_back(modelTwo);
 
-        for (Size k=0; k < allBumps_.size(); ++k)
-        {
-            for (Size f=allBumps_[k].factorBegin(); f <  allBumps_[k].factorEnd(); ++f)
-                for (Size r=allBumps_[k].rateBegin(); r <  allBumps_[k].rateEnd(); ++r)
-                    for (Size s= allBumps_[k].stepBegin(); s <  allBumps_[k].stepEnd(); ++s)
+        for (const auto& allBump : allBumps_) {
+            for (Size f = allBump.factorBegin(); f < allBump.factorEnd(); ++f)
+                for (Size r = allBump.rateBegin(); r < allBump.rateEnd(); ++r)
+                    for (Size s = allBump.stepBegin(); s < allBump.stepEnd(); ++s)
                         v[s][r][f] = true;
-
         }
 
         Size numberFailures =0;
@@ -202,17 +201,14 @@ namespace QuantLib {
 
         Size numberFailures=0;
 
-        for (Size k=0; k < allBumps_.size(); ++k)
-        {
-            for (Size f=allBumps_[k].factorBegin(); f <  allBumps_[k].factorEnd(); ++f)
-                for (Size r=allBumps_[k].rateBegin(); r <  allBumps_[k].rateEnd(); ++r)
-                    for (Size s= allBumps_[k].stepBegin(); s <  allBumps_[k].stepEnd(); ++s)
-                    {
+        for (const auto& allBump : allBumps_) {
+            for (Size f = allBump.factorBegin(); f < allBump.factorEnd(); ++f)
+                for (Size r = allBump.rateBegin(); r < allBump.rateEnd(); ++r)
+                    for (Size s = allBump.stepBegin(); s < allBump.stepEnd(); ++s) {
                         if (v[s][r][f])
                             ++numberFailures;
                         v[s][r][f] = true;
                     }
-
         }
 
         return numberFailures>0;
diff --git a/ql/models/marketmodels/products/compositeproduct.cpp b/ql/models/marketmodels/products/compositeproduct.cpp
index 027825a844b..ab8583273f9 100644
--- a/ql/models/marketmodels/products/compositeproduct.cpp
+++ b/ql/models/marketmodels/products/compositeproduct.cpp
@@ -40,9 +40,9 @@ namespace QuantLib {
     }
 
     void MarketModelComposite::reset() {
-        for (auto i = components_.begin(); i != components_.end(); ++i) {
-            i->product->reset();
-            i->done = false;
+        for (auto& component : components_) {
+            component.product->reset();
+            component.done = false;
         }
         currentIndex_ = 0;
     }
diff --git a/ql/models/marketmodels/products/multiproductcomposite.cpp b/ql/models/marketmodels/products/multiproductcomposite.cpp
index 15ac14a621c..93e15c83c20 100644
--- a/ql/models/marketmodels/products/multiproductcomposite.cpp
+++ b/ql/models/marketmodels/products/multiproductcomposite.cpp
@@ -24,18 +24,16 @@ namespace QuantLib {
 
     Size MultiProductComposite::numberOfProducts() const {
         Size result = 0;
-        for (auto i = components_.begin(); i != components_.end(); ++i)
-            result += i->product->numberOfProducts();
+        for (const auto& component : components_)
+            result += component.product->numberOfProducts();
         return result;
     }
 
 
     Size MultiProductComposite::maxNumberOfCashFlowsPerProductPerStep() const {
         Size result = 0;
-        for (auto i = components_.begin(); i != components_.end(); ++i)
-            result = std::max(result,
-            i->product
-            ->maxNumberOfCashFlowsPerProductPerStep());
+        for (const auto& component : components_)
+            result = std::max(result, component.product->maxNumberOfCashFlowsPerProductPerStep());
         return result;
     }
 
diff --git a/ql/models/marketmodels/products/multistep/multisteppathwisewrapper.cpp b/ql/models/marketmodels/products/multistep/multisteppathwisewrapper.cpp
index 0a1cbd78c7b..8a546683f32 100644
--- a/ql/models/marketmodels/products/multistep/multisteppathwisewrapper.cpp
+++ b/ql/models/marketmodels/products/multistep/multisteppathwisewrapper.cpp
@@ -30,10 +30,9 @@ namespace QuantLib
         numberOfProducts_(innerProduct.numberOfProducts())
     {
 
-        for (Size i=0; i < cashFlowsGenerated_.size(); ++i)
-            for (Size j=0; j < cashFlowsGenerated_[i].size(); ++j)
-                    cashFlowsGenerated_[i][j].amount.resize(1+innerProduct.evolution().numberOfRates());
-        
+        for (auto& i : cashFlowsGenerated_)
+            for (auto& j : i)
+                j.amount.resize(1 + innerProduct.evolution().numberOfRates());
     }
 
         std::vector<Time>  MultiProductPathwiseWrapper::possibleCashFlowTimes() const
diff --git a/ql/models/marketmodels/products/multistep/multistepperiodcapletswaptions.cpp b/ql/models/marketmodels/products/multistep/multistepperiodcapletswaptions.cpp
index 97e4a34e0dc..390ebc4b23a 100644
--- a/ql/models/marketmodels/products/multistep/multistepperiodcapletswaptions.cpp
+++ b/ql/models/marketmodels/products/multistep/multistepperiodcapletswaptions.cpp
@@ -43,8 +43,8 @@ namespace QuantLib {
 
         checkIncreasingTimes(forwardOptionPaymentTimes);
         checkIncreasingTimes(swaptionPaymentTimes);
-        for (Size i=0; i < swaptionPaymentTimes_.size(); ++i)
-            paymentTimes_.push_back(swaptionPaymentTimes_[i]);
+        for (double& swaptionPaymentTime : swaptionPaymentTimes_)
+            paymentTimes_.push_back(swaptionPaymentTime);
         lastIndex_ = rateTimes.size()-1;
         numberFRAs_ = rateTimes.size()-1;
         numberBigFRAs_ = (numberFRAs_-offset_)/period_;
@@ -75,51 +75,51 @@ namespace QuantLib {
                                                                genCashFlows)
     {
 
-     for (Size i=0; i < numberCashFlowsThisStep.size(); ++i)
-        numberCashFlowsThisStep[i]=0UL;
-
-    if (currentIndex_ >=offset_ && (currentIndex_ - offset_) % period_ ==0)
-    {
-        // caplet first
-        Real df = currentState.discountRatio(currentIndex_ + period_, currentIndex_);
-        Time tau = rateTimes_[currentIndex_+period_]- rateTimes_[currentIndex_];
-        Real forward = (1.0/df-1.0)/tau;
-        Real value = (*forwardPayOffs_[productIndex_])(forward);
-        value *= tau*currentState.discountRatio(currentIndex_+period_,currentIndex_);
-
-        if (value >0)
-        {
-            numberCashFlowsThisStep[productIndex_]=1UL;
-            genCashFlows[productIndex_][0].amount = value;
-            genCashFlows[productIndex_][0].timeIndex= productIndex_;
-        }
-
-        // now swaption
-
-        unsigned long numberPeriods = numberBigFRAs_ - productIndex_;
-        Real B = 0.0;
-        double P0 = 1.0; // i.e currentState.discountRatio(currentIndex_,currentIndex_);
-        Real Pn = currentState.discountRatio(currentIndex_ + numberPeriods*period_, currentIndex_);
-        for (unsigned long i=0; i < numberPeriods; ++i)
-        {
-            Time tau = rateTimes_[currentIndex_+(i+1)*period_]- rateTimes_[currentIndex_+i*period_];
-            B+= tau*currentState.discountRatio(currentIndex_+(i+1)*period_,currentIndex_);
-        }
-
-
-        Real swapRate = (P0-Pn)/B;
-
-        Real swaptionValue=  (*swapPayOffs_[productIndex_])(swapRate);
-        swaptionValue *=B;
-
-        if (swaptionValue >0)
-        {
-            numberCashFlowsThisStep[productIndex_+numberBigFRAs_]=1UL;
-            genCashFlows[productIndex_+numberBigFRAs_][0].amount = swaptionValue;
-            genCashFlows[productIndex_+numberBigFRAs_][0].timeIndex=productIndex_+numberBigFRAs_;
-       }
-
-        ++productIndex_;
+        for (Size & i : numberCashFlowsThisStep)
+            i = 0UL;
+
+        if (currentIndex_ >= offset_ && (currentIndex_ - offset_) % period_ == 0) {
+            // caplet first
+            Real df = currentState.discountRatio(currentIndex_ + period_, currentIndex_);
+            Time tau = rateTimes_[currentIndex_ + period_] - rateTimes_[currentIndex_];
+            Real forward = (1.0 / df - 1.0) / tau;
+            Real value = (*forwardPayOffs_[productIndex_])(forward);
+            value *= tau * currentState.discountRatio(currentIndex_ + period_, currentIndex_);
+
+            if (value > 0) {
+                numberCashFlowsThisStep[productIndex_] = 1UL;
+                genCashFlows[productIndex_][0].amount = value;
+                genCashFlows[productIndex_][0].timeIndex = productIndex_;
+            }
+
+            // now swaption
+
+            unsigned long numberPeriods = numberBigFRAs_ - productIndex_;
+            Real B = 0.0;
+            double P0 = 1.0; // i.e currentState.discountRatio(currentIndex_,currentIndex_);
+            Real Pn =
+                currentState.discountRatio(currentIndex_ + numberPeriods * period_, currentIndex_);
+            for (unsigned long i = 0; i < numberPeriods; ++i) {
+                Time tau = rateTimes_[currentIndex_ + (i + 1) * period_] -
+                           rateTimes_[currentIndex_ + i * period_];
+                B += tau *
+                     currentState.discountRatio(currentIndex_ + (i + 1) * period_, currentIndex_);
+            }
+
+
+            Real swapRate = (P0 - Pn) / B;
+
+            Real swaptionValue = (*swapPayOffs_[productIndex_])(swapRate);
+            swaptionValue *= B;
+
+            if (swaptionValue > 0) {
+                numberCashFlowsThisStep[productIndex_ + numberBigFRAs_] = 1UL;
+                genCashFlows[productIndex_ + numberBigFRAs_][0].amount = swaptionValue;
+                genCashFlows[productIndex_ + numberBigFRAs_][0].timeIndex =
+                    productIndex_ + numberBigFRAs_;
+            }
+
+            ++productIndex_;
 
     }
 
diff --git a/ql/models/marketmodels/products/pathwise/pathwiseproductcaplet.cpp b/ql/models/marketmodels/products/pathwise/pathwiseproductcaplet.cpp
index 80fd8bf1962..5d23ae25046 100644
--- a/ql/models/marketmodels/products/pathwise/pathwiseproductcaplet.cpp
+++ b/ql/models/marketmodels/products/pathwise/pathwiseproductcaplet.cpp
@@ -299,13 +299,10 @@ namespace QuantLib {
 
         innerCashFlowSizes_.resize(accruals.size());
         innerCashFlowsGenerated_.resize(accruals.size());
-        for (Size i=0; i <  innerCashFlowsGenerated_.size(); ++i)
-        {
-            innerCashFlowsGenerated_[i].resize(underlyingCaplets_.maxNumberOfCashFlowsPerProductPerStep());
+        for (auto& i : innerCashFlowsGenerated_) {
+            i.resize(underlyingCaplets_.maxNumberOfCashFlowsPerProductPerStep());
             for (Size j=0; j < underlyingCaplets_.maxNumberOfCashFlowsPerProductPerStep(); ++j)
-                innerCashFlowsGenerated_[i][j].amount.resize(accruals.size()+1);
-
-
+                i[j].amount.resize(accruals.size() + 1);
         }
     }
 
diff --git a/ql/models/marketmodels/products/singleproductcomposite.cpp b/ql/models/marketmodels/products/singleproductcomposite.cpp
index b7d407c3a5f..4ec658d66e8 100644
--- a/ql/models/marketmodels/products/singleproductcomposite.cpp
+++ b/ql/models/marketmodels/products/singleproductcomposite.cpp
@@ -29,8 +29,8 @@ namespace QuantLib {
 
     Size SingleProductComposite::maxNumberOfCashFlowsPerProductPerStep() const {
         Size result = 0;
-        for (auto i = components_.begin(); i != components_.end(); ++i)
-            result += i->product->maxNumberOfCashFlowsPerProductPerStep();
+        for (const auto& component : components_)
+            result += component.product->maxNumberOfCashFlowsPerProductPerStep();
         return result;
     }
 
diff --git a/ql/models/marketmodels/proxygreekengine.cpp b/ql/models/marketmodels/proxygreekengine.cpp
index 93a30d0126c..5bc952acffa 100644
--- a/ql/models/marketmodels/proxygreekengine.cpp
+++ b/ql/models/marketmodels/proxygreekengine.cpp
@@ -86,8 +86,8 @@ namespace QuantLib {
         modifiedValues.resize(constrainedEvolvers_.size());
         for (Size i=0; i<modifiedValues.size(); ++i) {
             modifiedValues[i].resize(constrainedEvolvers_[i].size());
-            for (Size j=0; j<modifiedValues[i].size(); ++j)
-                modifiedValues[i][j].resize(N);
+            for (auto& j : modifiedValues[i])
+                j.resize(N);
         }
 
         std::vector<Real> results(N);
diff --git a/ql/models/marketmodels/utilities.cpp b/ql/models/marketmodels/utilities.cpp
index 3d5d510e52a..abc73a9c83a 100644
--- a/ql/models/marketmodels/utilities.cpp
+++ b/ql/models/marketmodels/utilities.cpp
@@ -31,10 +31,8 @@ namespace QuantLib {
                     std::vector<std::valarray<bool> >& isPresent) {
 
         std::vector<Time> allTimes;
-        for (Size i=0; i<times.size(); i++) {
-            allTimes.insert(allTimes.end(),
-                            times[i].begin(),
-                            times[i].end());
+        for (const auto& time : times) {
+            allTimes.insert(allTimes.end(), time.begin(), time.end());
         }
 
         // ...sort and compact the vector mergedTimes...
diff --git a/ql/models/model.cpp b/ql/models/model.cpp
index fab3b567301..0ab18b1b4ea 100644
--- a/ql/models/model.cpp
+++ b/ql/models/model.cpp
@@ -150,8 +150,8 @@ namespace QuantLib {
 
     Disposable<Array> CalibratedModel::params() const {
         Size size=0;
-        for (Size i=0; i<arguments_.size(); ++i)
-            size += arguments_[i].size();
+        for (const auto& argument : arguments_)
+            size += argument.size();
         Array params(size);
         for (Size i=0, k=0; i<arguments_.size(); ++i) {
             for (Size j=0; j<arguments_[i].size(); ++j, ++k)
@@ -162,10 +162,10 @@ namespace QuantLib {
 
     void CalibratedModel::setParams(const Array& params) {
         Array::const_iterator p = params.begin();
-        for (Size i=0; i<arguments_.size(); ++i) {
-            for (Size j=0; j<arguments_[i].size(); ++j, ++p) {
+        for (auto& argument : arguments_) {
+            for (Size j = 0; j < argument.size(); ++j, ++p) {
                 QL_REQUIRE(p!=params.end(),"parameter array too small");
-                arguments_[i].setParam(j, *p);
+                argument.setParam(j, *p);
             }
         }
         QL_REQUIRE(p==params.end(),"parameter array too big!");
diff --git a/ql/models/model.hpp b/ql/models/model.hpp
index 5a223f3a217..1ac3a3b0771 100644
--- a/ql/models/model.hpp
+++ b/ql/models/model.hpp
@@ -190,12 +190,12 @@ namespace QuantLib {
 
             bool test(const Array& params) const override {
                 Size k=0;
-                for (Size i=0; i<arguments_.size(); i++) {
-                    Size size = arguments_[i].size();
+                for (const auto& argument : arguments_) {
+                    Size size = argument.size();
                     Array testParams(size);
                     for (Size j=0; j<size; j++, k++)
                         testParams[j] = params[k];
-                    if (!arguments_[i].testParams(testParams))
+                    if (!argument.testParams(testParams))
                         return false;
                 }
                 return true;
@@ -204,17 +204,16 @@ namespace QuantLib {
             Array upperBound(const Array& params) const override {
                 Size k = 0, k2 = 0;
                 Size totalSize = 0;
-                for (Size i = 0; i < arguments_.size(); i++) {
-                    totalSize += arguments_[i].size();
+                for (const auto& argument : arguments_) {
+                    totalSize += argument.size();
                 }
                 Array result(totalSize);
-                for (Size i = 0; i < arguments_.size(); i++) {
-                    Size size = arguments_[i].size();
+                for (const auto& argument : arguments_) {
+                    Size size = argument.size();
                     Array partialParams(size);
                     for (Size j = 0; j < size; j++, k++)
                         partialParams[j] = params[k];
-                    Array tmpBound =
-                        arguments_[i].constraint().upperBound(partialParams);
+                    Array tmpBound = argument.constraint().upperBound(partialParams);
                     for (Size j = 0; j < size; j++, k2++)
                         result[k2] = tmpBound[j];
                 }
@@ -224,17 +223,16 @@ namespace QuantLib {
             Array lowerBound(const Array& params) const override {
                 Size k = 0, k2 = 0;
                 Size totalSize = 0;
-                for (Size i = 0; i < arguments_.size(); i++) {
-                    totalSize += arguments_[i].size();
+                for (const auto& argument : arguments_) {
+                    totalSize += argument.size();
                 }
                 Array result(totalSize);
-                for (Size i = 0; i < arguments_.size(); i++) {
-                    Size size = arguments_[i].size();
+                for (const auto& argument : arguments_) {
+                    Size size = argument.size();
                     Array partialParams(size);
                     for (Size j = 0; j < size; j++, k++)
                         partialParams[j] = params[k];
-                    Array tmpBound =
-                        arguments_[i].constraint().lowerBound(partialParams);
+                    Array tmpBound = argument.constraint().lowerBound(partialParams);
                     for (Size j = 0; j < size; j++, k2++)
                         result[k2] = tmpBound[j];
                 }
diff --git a/ql/models/shortrate/onefactormodels/gsr.cpp b/ql/models/shortrate/onefactormodels/gsr.cpp
index a67752b3067..15f71aed69a 100644
--- a/ql/models/shortrate/onefactormodels/gsr.cpp
+++ b/ql/models/shortrate/onefactormodels/gsr.cpp
@@ -170,11 +170,11 @@ void Gsr::initialize(Real T) {
     volatilityObserver_ = ext::make_shared<VolatilityObserver>(this);
     reversionObserver_ = ext::make_shared<ReversionObserver>(this);
 
-    for (Size i = 0; i < reversions_.size(); ++i)
-        reversionObserver_->registerWith(reversions_[i]);
+    for (auto& reversion : reversions_)
+        reversionObserver_->registerWith(reversion);
 
-    for (Size i = 0; i < volatilities_.size(); ++i)
-        volatilityObserver_->registerWith(volatilities_[i]);
+    for (auto& volatilitie : volatilities_)
+        volatilityObserver_->registerWith(volatilitie);
 }
 
 Real Gsr::zerobondImpl(const Time T, const Time t, const Real y,
diff --git a/ql/models/shortrate/onefactormodels/markovfunctional.cpp b/ql/models/shortrate/onefactormodels/markovfunctional.cpp
index 0ad391f5337..00d16ff6c3f 100644
--- a/ql/models/shortrate/onefactormodels/markovfunctional.cpp
+++ b/ql/models/shortrate/onefactormodels/markovfunctional.cpp
@@ -118,10 +118,10 @@ namespace QuantLib {
         times_.push_back(0.0);
         modelOutputs_.expiries_.clear();
         modelOutputs_.tenors_.clear();
-        for (auto k = calibrationPoints_.begin(); k != calibrationPoints_.end(); ++k) {
-            times_.push_back(termStructure()->timeFromReference(k->first));
-            modelOutputs_.expiries_.push_back(k->first);
-            modelOutputs_.tenors_.push_back(k->second.tenor_);
+        for (auto& calibrationPoint : calibrationPoints_) {
+            times_.push_back(termStructure()->timeFromReference(calibrationPoint.first));
+            modelOutputs_.expiries_.push_back(calibrationPoint.first);
+            modelOutputs_.tenors_.push_back(calibrationPoint.second.tenor_);
         }
         times_.push_back(numeraireTime_);
         QL_REQUIRE(volatilities_.size() == volsteptimes_.size() + 1,
@@ -154,8 +154,8 @@ namespace QuantLib {
         updateTimes1();
 
         if (capletCalibrated_) {
-            for (std::vector<Date>::const_iterator i = capletExpiries_.begin(); i != capletExpiries_.end(); ++i) {
-                makeCapletCalibrationPoint(*i);
+            for (auto capletExpirie : capletExpiries_) {
+                makeCapletCalibrationPoint(capletExpirie);
             }
         } else {
             std::vector<Date>::const_iterator i;
@@ -381,9 +381,9 @@ namespace QuantLib {
                         "for sabr calibration at least 4 points are needed (is "
                             << k.size() << ")");
                     std::vector<Real> v;
-                    for (Size j = 0; j < k.size(); j++) {
-                        v.push_back(
-                            i->second.rawSmileSection_->volatility(k[j]));
+                    v.reserve(k.size());
+                    for (double j : k) {
+                        v.push_back(i->second.rawSmileSection_->volatility(j));
                     }
 
                     // TODO should we fix beta to avoid numerical instabilities
@@ -650,29 +650,27 @@ namespace QuantLib {
             modelOutputs_.marketRawCallPremium_.clear();
             modelOutputs_.marketRawPutPremium_.clear();
 
-            for (auto i = calibrationPoints_.begin(); i != calibrationPoints_.end(); ++i) {
-                modelOutputs_.atm_.push_back(i->second.atm_);
-                modelOutputs_.annuity_.push_back(i->second.annuity_);
-                ext::shared_ptr<SmileSection> sec = i->second.smileSection_;
-                ext::shared_ptr<SmileSection> rawSec =
-                    i->second.rawSmileSection_;
-                SmileSectionUtils ssutils(
-                    *sec, modelSettings_.smileMoneynessCheckpoints_,
-                    i->second.atm_);
+            for (auto& calibrationPoint : calibrationPoints_) {
+                modelOutputs_.atm_.push_back(calibrationPoint.second.atm_);
+                modelOutputs_.annuity_.push_back(calibrationPoint.second.annuity_);
+                ext::shared_ptr<SmileSection> sec = calibrationPoint.second.smileSection_;
+                ext::shared_ptr<SmileSection> rawSec = calibrationPoint.second.rawSmileSection_;
+                SmileSectionUtils ssutils(*sec, modelSettings_.smileMoneynessCheckpoints_,
+                                          calibrationPoint.second.atm_);
                 Real shift = sec->shift();
                 std::vector<Real> money = ssutils.moneyGrid();
                 std::vector<Real> strikes, marketCall, marketPut, modelCall,
                     modelPut, marketVega, marketRawCall, marketRawPut;
                 for (Size j = 0; j < money.size(); j++) {
-                    strikes.push_back(
-                        sec->volatilityType() == Normal
-                            ? i->second.atm_ + money[j]
-                            : money[j] * (i->second.atm_ + shift) - shift);
+                    strikes.push_back(sec->volatilityType() == Normal ?
+                                          calibrationPoint.second.atm_ + money[j] :
+                                          money[j] * (calibrationPoint.second.atm_ + shift) -
+                                              shift);
                     try {
                         marketRawCall.push_back(rawSec->optionPrice(
-                            strikes[j], Option::Call, i->second.annuity_));
+                            strikes[j], Option::Call, calibrationPoint.second.annuity_));
                         marketRawPut.push_back(rawSec->optionPrice(
-                            strikes[j], Option::Put, i->second.annuity_));
+                            strikes[j], Option::Put, calibrationPoint.second.annuity_));
                     }
                     catch (Error&) {
                         // the smile section might not be able to output an
@@ -680,26 +678,25 @@ namespace QuantLib {
                         marketRawCall.push_back(0.0);
                         marketRawPut.push_back(0.0);
                     }
-                    marketCall.push_back(sec->optionPrice(
-                        strikes[j], Option::Call, i->second.annuity_));
-                    marketPut.push_back(sec->optionPrice(
-                        strikes[j], Option::Put, i->second.annuity_));
+                    marketCall.push_back(sec->optionPrice(strikes[j], Option::Call,
+                                                          calibrationPoint.second.annuity_));
+                    marketPut.push_back(sec->optionPrice(strikes[j], Option::Put,
+                                                         calibrationPoint.second.annuity_));
                     modelCall.push_back(
-                        i->second.isCaplet_
-                            ? capletPriceInternal(Option::Call, i->first, strikes[j],
-                                             Null<Date>(), 0.0, true)
-                            : swaptionPriceInternal(Option::Call, i->first,
-                                               i->second.tenor_, strikes[j],
-                                               Null<Date>(), 0.0, true));
+                        calibrationPoint.second.isCaplet_ ?
+                            capletPriceInternal(Option::Call, calibrationPoint.first, strikes[j],
+                                                Null<Date>(), 0.0, true) :
+                            swaptionPriceInternal(Option::Call, calibrationPoint.first,
+                                                  calibrationPoint.second.tenor_, strikes[j],
+                                                  Null<Date>(), 0.0, true));
                     modelPut.push_back(
-                        i->second.isCaplet_
-                            ? capletPriceInternal(Option::Put, i->first, strikes[j],
-                                             Null<Date>(), 0.0, true)
-                            : swaptionPriceInternal(Option::Put, i->first,
-                                               i->second.tenor_, strikes[j],
-                                               Null<Date>(), 0.0, true));
-                    marketVega.push_back(
-                        sec->vega(strikes[j], i->second.annuity_));
+                        calibrationPoint.second.isCaplet_ ?
+                            capletPriceInternal(Option::Put, calibrationPoint.first, strikes[j],
+                                                Null<Date>(), 0.0, true) :
+                            swaptionPriceInternal(Option::Put, calibrationPoint.first,
+                                                  calibrationPoint.second.tenor_, strikes[j],
+                                                  Null<Date>(), 0.0, true));
+                    marketVega.push_back(sec->vega(strikes[j], calibrationPoint.second.annuity_));
                 }
                 modelOutputs_.smileStrikes_.push_back(strikes);
                 modelOutputs_.marketCallPremium_.push_back(marketCall);
@@ -916,8 +913,8 @@ namespace QuantLib {
             return out; // no trace information was collected so no output
         out << std::endl;
         out << "Messages:" << std::endl;
-        for (auto i = m.messages_.begin(); i != m.messages_.end(); ++i)
-            out << (*i) << std::endl;
+        for (const auto& message : m.messages_)
+            out << message << std::endl;
         out << std::endl << std::setprecision(16);
         out << "Yield termstructure fit:" << std::endl;
         out << "expiry;tenor;atm;annuity;digitalAdj;ytsAdj;marketzerorate;"
diff --git a/ql/patterns/observable.cpp b/ql/patterns/observable.cpp
index f6b24ea1a34..87da71d0b8d 100644
--- a/ql/patterns/observable.cpp
+++ b/ql/patterns/observable.cpp
@@ -34,10 +34,9 @@ namespace QuantLib {
             bool successful = true;
             std::string errMsg;
 
-            for (iterator i=deferredObservers_.begin();
-                i!=deferredObservers_.end(); ++i) {
+            for (auto* deferredObserver : deferredObservers_) {
                 try {
-                    (*i)->update();
+                    deferredObserver->update();
                 } catch (std::exception& e) {
                     successful = false;
                     errMsg = e.what();
@@ -62,9 +61,9 @@ namespace QuantLib {
         } else if (!observers_.empty()) {
             bool successful = true;
             std::string errMsg;
-            for (iterator i=observers_.begin(); i!=observers_.end(); ++i) {
+            for (auto* observer : observers_) {
                 try {
-                    (*i)->update();
+                    observer->update();
                 } catch (std::exception& e) {
                     // quite a dilemma. If we don't catch the exception,
                     // other observers will not receive the notification
diff --git a/ql/patterns/observable.hpp b/ql/patterns/observable.hpp
index 613eb221ce5..4f671975e53 100644
--- a/ql/patterns/observable.hpp
+++ b/ql/patterns/observable.hpp
@@ -188,8 +188,8 @@ namespace QuantLib {
 
     inline Observer::Observer(const Observer& o)
     : observables_(o.observables_) {
-        for (iterator i=observables_.begin(); i!=observables_.end(); ++i)
-            (*i)->registerObserver(this);
+        for (const auto& observable : observables_)
+            observable->registerObserver(this);
     }
 
     inline Observer& Observer::operator=(const Observer& o) {
@@ -203,8 +203,8 @@ namespace QuantLib {
     }
 
     inline Observer::~Observer() {
-        for (iterator i=observables_.begin(); i!=observables_.end(); ++i)
-            (*i)->unregisterObserver(this);
+        for (const auto& observable : observables_)
+            observable->unregisterObserver(this);
     }
 
     inline std::pair<Observer::iterator, bool>
@@ -233,8 +233,8 @@ namespace QuantLib {
     }
 
     inline void Observer::unregisterWithAll() {
-        for (iterator i=observables_.begin(); i!=observables_.end(); ++i)
-            (*i)->unregisterObserver(this);
+        for (const auto& observable : observables_)
+            observable->unregisterObserver(this);
         observables_.clear();
     }
 
diff --git a/ql/prices.cpp b/ql/prices.cpp
index a74bee6a8ae..1b5b9b990e8 100644
--- a/ql/prices.cpp
+++ b/ql/prices.cpp
@@ -134,8 +134,8 @@ namespace QuantLib {
                                            IntervalPrice::Type t)  {
         std::vector<Real> returnval;
         returnval.reserve(ts.size());
-        for (auto i = ts.begin(); i != ts.end(); ++i) {
-            returnval.push_back(i->second.value(t));
+        for (const auto& i : ts) {
+            returnval.push_back(i.second.value(t));
         }
         return returnval;
     }
diff --git a/ql/pricingengines/asian/analytic_discr_geom_av_strike.cpp b/ql/pricingengines/asian/analytic_discr_geom_av_strike.cpp
index 605a0e7fddb..eeb94f84a72 100644
--- a/ql/pricingengines/asian/analytic_discr_geom_av_strike.cpp
+++ b/ql/pricingengines/asian/analytic_discr_geom_av_strike.cpp
@@ -55,10 +55,9 @@ namespace QuantLib {
         DayCounter voldc = process_->blackVolatility()->dayCounter();
 
         std::vector<Time> fixingTimes;
-        for (Size i=0; i<arguments_.fixingDates.size(); i++) {
-            if (arguments_.fixingDates[i]>=arguments_.fixingDates[0]) {
-                Time t = voldc.yearFraction(arguments_.fixingDates[0],
-                    arguments_.fixingDates[i]);
+        for (auto& fixingDate : arguments_.fixingDates) {
+            if (fixingDate >= arguments_.fixingDates[0]) {
+                Time t = voldc.yearFraction(arguments_.fixingDates[0], fixingDate);
                 fixingTimes.push_back(t);
             }
         }
diff --git a/ql/pricingengines/asian/fdblackscholesasianengine.cpp b/ql/pricingengines/asian/fdblackscholesasianengine.cpp
index 3e77bf30dcc..0b01ea4c046 100644
--- a/ql/pricingengines/asian/fdblackscholesasianengine.cpp
+++ b/ql/pricingengines/asian/fdblackscholesasianengine.cpp
@@ -93,8 +93,8 @@ namespace QuantLib {
 
         // 3.1 Arithmetic average step conditions
         std::vector<Time> averageTimes;
-        for (Size i=0; i<arguments_.fixingDates.size(); ++i) {
-            Time t = process_->time(arguments_.fixingDates[i]);
+        for (auto& fixingDate : arguments_.fixingDates) {
+            Time t = process_->time(fixingDate);
             QL_REQUIRE(t >= 0, "Fixing dates must not contain past date");
             averageTimes.push_back(t);
         }
diff --git a/ql/pricingengines/asian/mc_discr_arith_av_price_heston.cpp b/ql/pricingengines/asian/mc_discr_arith_av_price_heston.cpp
index d9b41c50ff5..a201f47562f 100644
--- a/ql/pricingengines/asian/mc_discr_arith_av_price_heston.cpp
+++ b/ql/pricingengines/asian/mc_discr_arith_av_price_heston.cpp
@@ -40,8 +40,8 @@ namespace QuantLib {
         Real sum = runningSum_;
         Size fixings = pastFixings_ + fixingIndices_.size();
 
-        for (Size i=0; i<fixingIndices_.size(); i++) {
-            sum += path[fixingIndices_[i]];
+        for (unsigned long fixingIndice : fixingIndices_) {
+            sum += path[fixingIndice];
         }
 
         Real averagePrice = sum/fixings;
diff --git a/ql/pricingengines/asian/mc_discr_arith_av_price_heston.hpp b/ql/pricingengines/asian/mc_discr_arith_av_price_heston.hpp
index 18f2fce836b..4dac2a98dd3 100644
--- a/ql/pricingengines/asian/mc_discr_arith_av_price_heston.hpp
+++ b/ql/pricingengines/asian/mc_discr_arith_av_price_heston.hpp
@@ -161,8 +161,9 @@ namespace QuantLib {
         TimeGrid timeGrid = this->timeGrid();
         std::vector<Time> fixingTimes = timeGrid.mandatoryTimes();
         std::vector<Size> fixingIndexes;
-        for (Size i=0; i<fixingTimes.size(); i++) {
-            fixingIndexes.push_back(timeGrid.closestIndex(fixingTimes[i]));
+        fixingIndexes.reserve(fixingTimes.size());
+        for (double fixingTime : fixingTimes) {
+            fixingIndexes.push_back(timeGrid.closestIndex(fixingTime));
         }
 
         ext::shared_ptr<PlainVanillaPayoff> payoff =
@@ -199,8 +200,9 @@ namespace QuantLib {
         TimeGrid timeGrid = this->timeGrid();
         std::vector<Time> fixingTimes = timeGrid.mandatoryTimes();
         std::vector<Size> fixingIndexes;
-        for (Size i=0; i<fixingTimes.size(); i++) {
-            fixingIndexes.push_back(timeGrid.closestIndex(fixingTimes[i]));
+        fixingIndexes.reserve(fixingTimes.size());
+        for (double fixingTime : fixingTimes) {
+            fixingIndexes.push_back(timeGrid.closestIndex(fixingTime));
         }
 
         ext::shared_ptr<PlainVanillaPayoff> payoff =
diff --git a/ql/pricingengines/asian/mc_discr_geom_av_price_heston.cpp b/ql/pricingengines/asian/mc_discr_geom_av_price_heston.cpp
index ba26b3e59f0..4f4e35cd6e4 100644
--- a/ql/pricingengines/asian/mc_discr_geom_av_price_heston.cpp
+++ b/ql/pricingengines/asian/mc_discr_geom_av_price_heston.cpp
@@ -45,8 +45,8 @@ namespace QuantLib {
 
         // care must be taken not to overflow product
         Real maxValue = QL_MAX_REAL;
-        for (Size i=0; i<fixingIndices_.size(); i++) {
-            Real price = path[fixingIndices_[i]];
+        for (unsigned long fixingIndice : fixingIndices_) {
+            Real price = path[fixingIndice];
             if (product < maxValue/price) {
                 product *= price;
             } else {
diff --git a/ql/pricingengines/asian/mc_discr_geom_av_price_heston.hpp b/ql/pricingengines/asian/mc_discr_geom_av_price_heston.hpp
index 5c0e94c6170..548b6acec4f 100644
--- a/ql/pricingengines/asian/mc_discr_geom_av_price_heston.hpp
+++ b/ql/pricingengines/asian/mc_discr_geom_av_price_heston.hpp
@@ -143,8 +143,9 @@ namespace QuantLib {
         TimeGrid timeGrid = this->timeGrid();
         std::vector<Time> fixingTimes = timeGrid.mandatoryTimes();
         std::vector<Size> fixingIndexes;
-        for (Size i=0; i<fixingTimes.size(); i++) {
-            fixingIndexes.push_back(timeGrid.closestIndex(fixingTimes[i]));
+        fixingIndexes.reserve(fixingTimes.size());
+        for (double fixingTime : fixingTimes) {
+            fixingIndexes.push_back(timeGrid.closestIndex(fixingTime));
         }
 
         ext::shared_ptr<PlainVanillaPayoff> payoff =
diff --git a/ql/pricingengines/barrier/discretizedbarrieroption.cpp b/ql/pricingengines/barrier/discretizedbarrieroption.cpp
index aa45074a368..3959e8e1adf 100644
--- a/ql/pricingengines/barrier/discretizedbarrieroption.cpp
+++ b/ql/pricingengines/barrier/discretizedbarrieroption.cpp
@@ -71,12 +71,12 @@ namespace QuantLib {
                 stoppingTime = true;
             break;
           case Exercise::Bermudan:
-            for (Size i=0; i<stoppingTimes_.size(); i++) {
-                if (isOnTime(stoppingTimes_[i])) {
-                    stoppingTime = true;
-                    break;
-                }
-            }
+              for (double i : stoppingTimes_) {
+                  if (isOnTime(i)) {
+                      stoppingTime = true;
+                      break;
+                  }
+              }
             break;
           default:
             QL_FAIL("invalid option type");
diff --git a/ql/pricingengines/capfloor/gaussian1dcapfloorengine.cpp b/ql/pricingengines/capfloor/gaussian1dcapfloorengine.cpp
index b5bb98c58e9..b423cc958a0 100644
--- a/ql/pricingengines/capfloor/gaussian1dcapfloorengine.cpp
+++ b/ql/pricingengines/capfloor/gaussian1dcapfloorengine.cpp
@@ -25,10 +25,8 @@ namespace QuantLib {
 
     void Gaussian1dCapFloorEngine::calculate() const {
 
-        for (Size i = 0; i < arguments_.spreads.size(); i++)
-            QL_REQUIRE(arguments_.spreads[i] == 0.0,
-                       "Non zero spreads (" << arguments_.spreads[i]
-                                            << ") are not allowed.");
+        for (double spread : arguments_.spreads)
+            QL_REQUIRE(spread == 0.0, "Non zero spreads (" << spread << ") are not allowed.");
 
         Size optionlets = arguments_.startDates.size();
         std::vector<Real> values(optionlets, 0.0);
diff --git a/ql/pricingengines/credit/isdacdsengine.cpp b/ql/pricingengines/credit/isdacdsengine.cpp
index ec0bf96c196..2db986169f1 100644
--- a/ql/pricingengines/credit/isdacdsengine.cpp
+++ b/ql/pricingengines/credit/isdacdsengine.cpp
@@ -194,9 +194,8 @@ namespace QuantLib {
         // premium leg pricing (npv is always positive at this stage)
 
         Real premiumNpv = 0.0, defaultAccrualNpv = 0.0;
-        for (Size i = 0; i < arguments_.leg.size(); ++i) {
-            ext::shared_ptr<FixedRateCoupon> coupon =
-                ext::dynamic_pointer_cast<FixedRateCoupon>(arguments_.leg[i]);
+        for (auto& i : arguments_.leg) {
+            ext::shared_ptr<FixedRateCoupon> coupon = ext::dynamic_pointer_cast<FixedRateCoupon>(i);
 
             QL_REQUIRE(coupon->dayCounter() == dc ||
                            coupon->dayCounter() == dc1 ||
@@ -205,8 +204,7 @@ namespace QuantLib {
                            << "or Act/360 (" << coupon->dayCounter() << ")");
 
             // premium coupons
-            if (!arguments_.leg[i]->hasOccurred(effectiveProtectionStart,
-                                                includeSettlementDateFlows_)) {
+            if (!i->hasOccurred(effectiveProtectionStart, includeSettlementDateFlows_)) {
                 premiumNpv +=
                     coupon->amount() *
                     discountCurve_->discount(coupon->date()) *
diff --git a/ql/pricingengines/swap/discretizedswap.cpp b/ql/pricingengines/swap/discretizedswap.cpp
index cad546d8fec..fdf82babf5d 100644
--- a/ql/pricingengines/swap/discretizedswap.cpp
+++ b/ql/pricingengines/swap/discretizedswap.cpp
@@ -71,23 +71,19 @@ namespace QuantLib {
 
     std::vector<Time> DiscretizedSwap::mandatoryTimes() const {
         std::vector<Time> times;
-        for (Size i=0; i<fixedResetTimes_.size(); i++) {
-            Time t = fixedResetTimes_[i];
+        for (double t : fixedResetTimes_) {
             if (t >= 0.0)
                 times.push_back(t);
         }
-        for (Size i=0; i<fixedPayTimes_.size(); i++) {
-            Time t = fixedPayTimes_[i];
+        for (double t : fixedPayTimes_) {
             if (t >= 0.0)
                 times.push_back(t);
         }
-        for (Size i=0; i<floatingResetTimes_.size(); i++) {
-            Time t = floatingResetTimes_[i];
+        for (double t : floatingResetTimes_) {
             if (t >= 0.0)
                 times.push_back(t);
         }
-        for (Size i=0; i<floatingPayTimes_.size(); i++) {
-            Time t = floatingPayTimes_[i];
+        for (double t : floatingPayTimes_) {
             if (t >= 0.0)
                 times.push_back(t);
         }
diff --git a/ql/pricingengines/swaption/basketgeneratingengine.hpp b/ql/pricingengines/swaption/basketgeneratingengine.hpp
index 9329387023e..e6ba97ce7ac 100644
--- a/ql/pricingengines/swaption/basketgeneratingengine.hpp
+++ b/ql/pricingengines/swaption/basketgeneratingengine.hpp
@@ -122,19 +122,16 @@ namespace QuantLib {
                      Real y,
                      int type) const {
                 Real npv = 0.0;
-                for (Size i = 0; i < swap->fixedLeg().size(); i++) {
+                for (const auto& i : swap->fixedLeg()) {
                     ext::shared_ptr<FixedRateCoupon> c =
-                        ext::dynamic_pointer_cast<FixedRateCoupon>(
-                            swap->fixedLeg()[i]);
+                        ext::dynamic_pointer_cast<FixedRateCoupon>(i);
                     npv -=
                         fixedRate * c->accrualPeriod() * nominal *
                         mdl_->zerobond(c->date(), expiry_, y,
                                        indexBase_->discountingTermStructure());
                 }
-                for (Size i = 0; i < swap->floatingLeg().size(); i++) {
-                    ext::shared_ptr<IborCoupon> c =
-                        ext::dynamic_pointer_cast<IborCoupon>(
-                            swap->floatingLeg()[i]);
+                for (const auto& i : swap->floatingLeg()) {
+                    ext::shared_ptr<IborCoupon> c = ext::dynamic_pointer_cast<IborCoupon>(i);
                     npv +=
                         mdl_->forwardRate(c->fixingDate(), expiry_, y,
                                           c->iborIndex()) *
@@ -148,8 +145,8 @@ namespace QuantLib {
             Real value(const Array& v) const override {
                 Array vals = values(v);
                 Real res = 0.0;
-                for (Size i = 0; i < vals.size(); i++) {
-                    res += vals[i] * vals[i];
+                for (double val : vals) {
+                    res += val * val;
                 }
                 return std::sqrt(res / vals.size());
             }
diff --git a/ql/pricingengines/swaption/discretizedswaption.cpp b/ql/pricingengines/swaption/discretizedswaption.cpp
index b00435f9b66..9be7d825a98 100644
--- a/ql/pricingengines/swaption/discretizedswaption.cpp
+++ b/ql/pricingengines/swaption/discretizedswaption.cpp
@@ -61,15 +61,13 @@ namespace QuantLib {
                     && arguments_.fixedResetDates[j] < referenceDate)
                     arguments_.fixedPayDates[j] = exerciseDate;
             }
-            for (Size j=0; j<arguments_.fixedResetDates.size(); j++) {
-                if (withinPreviousWeek(exerciseDate,
-                                       arguments_.fixedResetDates[j]))
-                    arguments_.fixedResetDates[j] = exerciseDate;
+            for (auto& fixedResetDate : arguments_.fixedResetDates) {
+                if (withinPreviousWeek(exerciseDate, fixedResetDate))
+                    fixedResetDate = exerciseDate;
             }
-            for (Size j=0; j<arguments_.floatingResetDates.size(); j++) {
-                if (withinPreviousWeek(exerciseDate,
-                                       arguments_.floatingResetDates[j]))
-                    arguments_.floatingResetDates[j] = exerciseDate;
+            for (auto& floatingResetDate : arguments_.floatingResetDates) {
+                if (withinPreviousWeek(exerciseDate, floatingResetDate))
+                    floatingResetDate = exerciseDate;
             }
         }
 
diff --git a/ql/pricingengines/swaption/fdg2swaptionengine.cpp b/ql/pricingengines/swaption/fdg2swaptionengine.cpp
index e130c088c85..64766aacea0 100644
--- a/ql/pricingengines/swaption/fdg2swaptionengine.cpp
+++ b/ql/pricingengines/swaption/fdg2swaptionengine.cpp
@@ -80,11 +80,11 @@ namespace QuantLib {
         const std::vector<Date>& exerciseDates = arguments_.exercise->dates();
         std::map<Time, Date> t2d;
 
-        for (Size i=0; i < exerciseDates.size(); ++i) {
-            const Time t = dc.yearFraction(referenceDate, exerciseDates[i]);
+        for (auto exerciseDate : exerciseDates) {
+            const Time t = dc.yearFraction(referenceDate, exerciseDate);
             QL_REQUIRE(t >= 0, "exercise dates must not contain past date");
 
-            t2d[t] = exerciseDates[i];
+            t2d[t] = exerciseDate;
         }
 
         const Handle<YieldTermStructure> disTs = model_->termStructure();
diff --git a/ql/pricingengines/swaption/fdhullwhiteswaptionengine.cpp b/ql/pricingengines/swaption/fdhullwhiteswaptionengine.cpp
index fd69e6e8ca2..036c861f727 100644
--- a/ql/pricingengines/swaption/fdhullwhiteswaptionengine.cpp
+++ b/ql/pricingengines/swaption/fdhullwhiteswaptionengine.cpp
@@ -74,11 +74,11 @@ namespace QuantLib {
         const std::vector<Date>& exerciseDates = arguments_.exercise->dates();
         std::map<Time, Date> t2d;
 
-        for (Size i=0; i < exerciseDates.size(); ++i) {
-            const Time t = dc.yearFraction(referenceDate, exerciseDates[i]);
+        for (auto exerciseDate : exerciseDates) {
+            const Time t = dc.yearFraction(referenceDate, exerciseDate);
             QL_REQUIRE(t >= 0, "exercise dates must not contain past date");
 
-            t2d[t] = exerciseDates[i];
+            t2d[t] = exerciseDate;
         }
 
         const Handle<YieldTermStructure> disTs = model_->termStructure();
diff --git a/ql/pricingengines/vanilla/discretizedvanillaoption.cpp b/ql/pricingengines/vanilla/discretizedvanillaoption.cpp
index 6153e726f63..3b0c2b4a838 100644
--- a/ql/pricingengines/vanilla/discretizedvanillaoption.cpp
+++ b/ql/pricingengines/vanilla/discretizedvanillaoption.cpp
@@ -58,10 +58,10 @@ namespace QuantLib {
                 applySpecificCondition();
             break;
           case Exercise::Bermudan:
-            for (Size i=0; i<stoppingTimes_.size(); i++) {
-                if (isOnTime(stoppingTimes_[i]))
-                    applySpecificCondition();
-            }
+              for (double stoppingTime : stoppingTimes_) {
+                  if (isOnTime(stoppingTime))
+                      applySpecificCondition();
+              }
             break;
           default:
             QL_FAIL("invalid option type");
diff --git a/ql/pricingengines/vanilla/exponentialfittinghestonengine.cpp b/ql/pricingengines/vanilla/exponentialfittinghestonengine.cpp
index 1997f40d19e..dea1f6b6751 100644
--- a/ql/pricingengines/vanilla/exponentialfittinghestonengine.cpp
+++ b/ql/pricingengines/vanilla/exponentialfittinghestonengine.cpp
@@ -197,8 +197,8 @@ namespace QuantLib {
             const Size n = sizeof(values4)/sizeof(values4[0]);
             moneyness_.reserve(n);
 
-            for (Size i=0; i < n; ++i)
-                moneyness_.push_back(values4[i][0]);
+            for (const auto& i : values4)
+                moneyness_.push_back(i[0]);
         }
     }
 
diff --git a/ql/pricingengines/vanilla/fdblackscholesshoutengine.cpp b/ql/pricingengines/vanilla/fdblackscholesshoutengine.cpp
index fa6bc47f556..60554848719 100644
--- a/ql/pricingengines/vanilla/fdblackscholesshoutengine.cpp
+++ b/ql/pricingengines/vanilla/fdblackscholesshoutengine.cpp
@@ -21,24 +21,24 @@
 */
 
 #include <ql/exercise.hpp>
-#include <ql/processes/blackscholesprocess.hpp>
-#include <ql/methods/finitedifferences/solvers/fdmblackscholessolver.hpp>
-#include <ql/methods/finitedifferences/meshers/fdmmeshercomposite.hpp>
 #include <ql/methods/finitedifferences/meshers/fdmblackscholesmesher.hpp>
+#include <ql/methods/finitedifferences/meshers/fdmmeshercomposite.hpp>
+#include <ql/methods/finitedifferences/solvers/fdmblackscholessolver.hpp>
 #include <ql/methods/finitedifferences/stepconditions/fdmstepconditioncomposite.hpp>
 #include <ql/methods/finitedifferences/utilities/fdmshoutloginnervaluecalculator.hpp>
 #include <ql/pricingengines/vanilla/fdblackscholesshoutengine.hpp>
+#include <ql/processes/blackscholesprocess.hpp>
+#include <utility>
 
 namespace QuantLib {
 
     FdBlackScholesShoutEngine::FdBlackScholesShoutEngine(
-        const ext::shared_ptr<GeneralizedBlackScholesProcess>& process,
-        Size tGrid, Size xGrid, Size dampingSteps,
+        ext::shared_ptr<GeneralizedBlackScholesProcess> process,
+        Size tGrid,
+        Size xGrid,
+        Size dampingSteps,
         const FdmSchemeDesc& schemeDesc)
-    : process_(process),
-      tGrid_(tGrid),
-      xGrid_(xGrid),
-      dampingSteps_(dampingSteps),
+    : process_(std::move(process)), tGrid_(tGrid), xGrid_(xGrid), dampingSteps_(dampingSteps),
       schemeDesc_(schemeDesc) {
 
         registerWith(process_);
diff --git a/ql/pricingengines/vanilla/fdblackscholesshoutengine.hpp b/ql/pricingengines/vanilla/fdblackscholesshoutengine.hpp
index a772aed6888..61ab2a13792 100644
--- a/ql/pricingengines/vanilla/fdblackscholesshoutengine.hpp
+++ b/ql/pricingengines/vanilla/fdblackscholesshoutengine.hpp
@@ -36,8 +36,10 @@ namespace QuantLib {
       public:
         // Constructor
         explicit FdBlackScholesShoutEngine(
-            const ext::shared_ptr<GeneralizedBlackScholesProcess>&,
-            Size tGrid = 100, Size xGrid = 100, Size dampingSteps = 0,
+            ext::shared_ptr<GeneralizedBlackScholesProcess>,
+            Size tGrid = 100,
+            Size xGrid = 100,
+            Size dampingSteps = 0,
             const FdmSchemeDesc& schemeDesc = FdmSchemeDesc::Douglas());
 
         void calculate() const override;
diff --git a/ql/pricingengines/vanilla/fdblackscholesvanillaengine.cpp b/ql/pricingengines/vanilla/fdblackscholesvanillaengine.cpp
index a40a6ef7290..0b4ed6f3af2 100644
--- a/ql/pricingengines/vanilla/fdblackscholesvanillaengine.cpp
+++ b/ql/pricingengines/vanilla/fdblackscholesvanillaengine.cpp
@@ -83,28 +83,25 @@ namespace QuantLib {
             dividendSchedule = arguments_.cashFlow;
             break;
           case Escrowed:
-            for (DividendSchedule::const_iterator
-                    divIter = arguments_.cashFlow.begin();
-                 divIter != arguments_.cashFlow.end(); ++divIter) {
+              for (const auto& divIter : arguments_.cashFlow) {
 
-                const Date divDate = (*divIter)->date();
+                  const Date divDate = divIter->date();
 
-                if (divDate <= exerciseDate && divDate >= settlementDate) {
-                    const Real divAmount = (*divIter)->amount();
+                  if (divDate <= exerciseDate && divDate >= settlementDate) {
+                      const Real divAmount = divIter->amount();
 
-                    if (divAmount != 0.0) {
-                        QL_REQUIRE(arguments_.exercise->type()
-                                        == Exercise::European,
-                             "Escrowed dividend model expects an European option");
+                      if (divAmount != 0.0) {
+                          QL_REQUIRE(arguments_.exercise->type() == Exercise::European,
+                                     "Escrowed dividend model expects an European option");
 
-                        const DiscountFactor discount =
-                            process_->riskFreeRate()->discount(divDate) /
-                            process_->dividendYield()->discount(divDate);
+                          const DiscountFactor discount =
+                              process_->riskFreeRate()->discount(divDate) /
+                              process_->dividendYield()->discount(divDate);
 
-                        spotAdjustment -= divAmount * discount;
-                    }
-                }
-            }
+                          spotAdjustment -= divAmount * discount;
+                      }
+                  }
+              }
 
             QL_REQUIRE(process_->x0() + spotAdjustment > 0.0,
                     "spot minus dividends becomes negative");
diff --git a/ql/pricingengines/vanilla/fdhestonhullwhitevanillaengine.cpp b/ql/pricingengines/vanilla/fdhestonhullwhitevanillaengine.cpp
index 458ce70f6d3..29c3e9d590a 100644
--- a/ql/pricingengines/vanilla/fdhestonhullwhitevanillaengine.cpp
+++ b/ql/pricingengines/vanilla/fdhestonhullwhitevanillaengine.cpp
@@ -54,24 +54,21 @@ namespace QuantLib {
     void FdHestonHullWhiteVanillaEngine::calculate() const {
   
         // 1. cache lookup for precalculated results
-        for (Size i=0; i < cachedArgs2results_.size(); ++i) {
-            if (   cachedArgs2results_[i].first.exercise->type()
-                        == arguments_.exercise->type()
-                && cachedArgs2results_[i].first.exercise->dates()
-                        == arguments_.exercise->dates()) {
+        for (auto& cachedArgs2result : cachedArgs2results_) {
+            if (cachedArgs2result.first.exercise->type() == arguments_.exercise->type() &&
+                cachedArgs2result.first.exercise->dates() == arguments_.exercise->dates()) {
                 ext::shared_ptr<PlainVanillaPayoff> p1 =
                     ext::dynamic_pointer_cast<PlainVanillaPayoff>(
                                                             arguments_.payoff);
                 ext::shared_ptr<PlainVanillaPayoff> p2 =
-                    ext::dynamic_pointer_cast<PlainVanillaPayoff>(
-                                          cachedArgs2results_[i].first.payoff);
+                    ext::dynamic_pointer_cast<PlainVanillaPayoff>(cachedArgs2result.first.payoff);
 
                 if ((p1 != nullptr) && p1->strike() == p2->strike() &&
                     p1->optionType() == p2->optionType()) {
                     QL_REQUIRE(arguments_.cashFlow.empty(),
                                "multiple strikes engine does "
                                "not work with discrete dividends");
-                    results_ = cachedArgs2results_[i].second;
+                    results_ = cachedArgs2result.second;
                     return;
                 }
             }
diff --git a/ql/pricingengines/vanilla/fdhestonvanillaengine.cpp b/ql/pricingengines/vanilla/fdhestonvanillaengine.cpp
index cae7151ab88..9dc9e5ba4e1 100644
--- a/ql/pricingengines/vanilla/fdhestonvanillaengine.cpp
+++ b/ql/pricingengines/vanilla/fdhestonvanillaengine.cpp
@@ -141,24 +141,21 @@ namespace QuantLib {
     void FdHestonVanillaEngine::calculate() const {
 
         // cache lookup for precalculated results
-        for (Size i=0; i < cachedArgs2results_.size(); ++i) {
-            if (   cachedArgs2results_[i].first.exercise->type()
-                        == arguments_.exercise->type()
-                && cachedArgs2results_[i].first.exercise->dates()
-                        == arguments_.exercise->dates()) {
+        for (auto& cachedArgs2result : cachedArgs2results_) {
+            if (cachedArgs2result.first.exercise->type() == arguments_.exercise->type() &&
+                cachedArgs2result.first.exercise->dates() == arguments_.exercise->dates()) {
                 ext::shared_ptr<PlainVanillaPayoff> p1 =
                     ext::dynamic_pointer_cast<PlainVanillaPayoff>(
                                                             arguments_.payoff);
                 ext::shared_ptr<PlainVanillaPayoff> p2 =
-                    ext::dynamic_pointer_cast<PlainVanillaPayoff>(
-                                          cachedArgs2results_[i].first.payoff);
+                    ext::dynamic_pointer_cast<PlainVanillaPayoff>(cachedArgs2result.first.payoff);
 
                 if ((p1 != nullptr) && p1->strike() == p2->strike() &&
                     p1->optionType() == p2->optionType()) {
                     QL_REQUIRE(arguments_.cashFlow.empty(),
                                "multiple strikes engine does "
                                "not work with discrete dividends");
-                    results_ = cachedArgs2results_[i].second;
+                    results_ = cachedArgs2result.second;
                     return;
                 }
             }
diff --git a/ql/pricingengines/vanilla/fdsimplebsswingengine.cpp b/ql/pricingengines/vanilla/fdsimplebsswingengine.cpp
index 70e15dff515..2bc144af1d1 100644
--- a/ql/pricingengines/vanilla/fdsimplebsswingengine.cpp
+++ b/ql/pricingengines/vanilla/fdsimplebsswingengine.cpp
@@ -74,8 +74,8 @@ namespace QuantLib {
         
         // 3.1 Bermudan step conditions
         std::vector<Time> exerciseTimes;
-        for (Size i=0; i<arguments_.exercise->dates().size(); ++i) {
-            Time t = process_->time(arguments_.exercise->dates()[i]);
+        for (auto i : arguments_.exercise->dates()) {
+            Time t = process_->time(i);
             QL_REQUIRE(t >= 0, "exercise dates must not contain past date");
             exerciseTimes.push_back(t);
         }
diff --git a/ql/processes/jointstochasticprocess.cpp b/ql/processes/jointstochasticprocess.cpp
index 2d1fc569968..4d787ec5cbe 100644
--- a/ql/processes/jointstochasticprocess.cpp
+++ b/ql/processes/jointstochasticprocess.cpp
@@ -33,19 +33,19 @@ namespace QuantLib {
         std::vector<ext::shared_ptr<StochasticProcess> > l, Size factors)
     : l_(std::move(l)), size_(0), factors_(factors), modelFactors_(0) {
 
-        for (const_iterator iter=l_.begin(); iter != l_.end(); ++iter) {
-            registerWith(*iter);
+        for (const auto& iter : l_) {
+            registerWith(iter);
         }
 
         vsize_.reserve   (l_.size()+1);
         vfactors_.reserve(l_.size()+1);
 
-        for (const_iterator iter = l_.begin(); iter != l_.end(); ++iter) {
+        for (const auto& iter : l_) {
             vsize_.push_back(size_);
-            size_ += (*iter)->size();
+            size_ += iter->size();
 
             vfactors_.push_back(modelFactors_);
-            modelFactors_ += (*iter)->factors();
+            modelFactors_ += iter->factors();
         }
 
         vsize_.push_back(size_);
diff --git a/ql/processes/stochasticprocessarray.cpp b/ql/processes/stochasticprocessarray.cpp
index 49a0093fa19..d413c897442 100644
--- a/ql/processes/stochasticprocessarray.cpp
+++ b/ql/processes/stochasticprocessarray.cpp
@@ -34,8 +34,8 @@ namespace QuantLib {
         QL_REQUIRE(correlation.rows() == processes.size(),
                    "mismatch between number of processes "
                    "and size of correlation matrix");
-        for (Size i=0; i<processes_.size(); i++)
-            registerWith(processes_[i]);
+        for (auto& processe : processes_)
+            registerWith(processe);
     }
 
     Size StochasticProcessArray::size() const {
diff --git a/ql/termstructures/globalbootstrap.hpp b/ql/termstructures/globalbootstrap.hpp
index d4f6dd6a12c..822c19b40cd 100644
--- a/ql/termstructures/globalbootstrap.hpp
+++ b/ql/termstructures/globalbootstrap.hpp
@@ -163,8 +163,8 @@ template <class Curve> void GlobalBootstrap<Curve>::initialize() const {
 
     // build times vector
     times.clear();
-    for (Size j = 0; j < dates.size(); ++j)
-        times.push_back(ts_->timeFromReference(dates[j]));
+    for (auto& date : dates)
+        times.push_back(ts_->timeFromReference(date));
 
     // determine maxDate
     Date maxDate = firstDate;
diff --git a/ql/termstructures/inflation/interpolatedzeroinflationcurve.hpp b/ql/termstructures/inflation/interpolatedzeroinflationcurve.hpp
index 1b9ebfba469..132c1f7dea6 100644
--- a/ql/termstructures/inflation/interpolatedzeroinflationcurve.hpp
+++ b/ql/termstructures/inflation/interpolatedzeroinflationcurve.hpp
@@ -156,8 +156,8 @@ namespace QuantLib {
         // back to the start of their inflationPeriods
         // otherwise the time calculations will be inconsistent
         if (!indexIsInterpolated_) {
-            for (Size i = 0; i < dates_.size(); i++) {
-                dates_[i] = inflationPeriod(dates_[i], frequency).first;
+            for (auto& date : dates_) {
+                date = inflationPeriod(date, frequency).first;
             }
         }
 
@@ -217,8 +217,8 @@ namespace QuantLib {
         // back to the start of their inflationPeriods
         // otherwise the time calculations will be inconsistent
         if (!indexIsInterpolated_) {
-            for (Size i = 0; i < dates_.size(); i++) {
-                dates_[i] = inflationPeriod(dates_[i], frequency).first;
+            for (auto& date : dates_) {
+                date = inflationPeriod(date, frequency).first;
             }
         }
 
diff --git a/ql/termstructures/volatility/capfloor/capfloortermvolcurve.cpp b/ql/termstructures/volatility/capfloor/capfloortermvolcurve.cpp
index 49ec192f55c..f227a476d8d 100644
--- a/ql/termstructures/volatility/capfloor/capfloortermvolcurve.cpp
+++ b/ql/termstructures/volatility/capfloor/capfloortermvolcurve.cpp
@@ -139,8 +139,8 @@ namespace QuantLib {
 
     void CapFloorTermVolCurve::registerWithMarketData()
     {
-        for (Size i=0; i<volHandles_.size(); ++i)
-            registerWith(volHandles_[i]);
+        for (auto& volHandle : volHandles_)
+            registerWith(volHandle);
     }
 
     void CapFloorTermVolCurve::interpolate()
diff --git a/ql/termstructures/volatility/equityfx/andreasenhugevolatilityinterpl.cpp b/ql/termstructures/volatility/equityfx/andreasenhugevolatilityinterpl.cpp
index 993444e3395..d5fd1f19604 100644
--- a/ql/termstructures/volatility/equityfx/andreasenhugevolatilityinterpl.cpp
+++ b/ql/termstructures/volatility/equityfx/andreasenhugevolatilityinterpl.cpp
@@ -240,10 +240,9 @@ namespace QuantLib {
         std::set<Date> expiries;
 
         calibrationSet_.reserve(calibrationSet.size());
-        for (Size i=0; i < calibrationSet.size(); ++i) {
+        for (const auto& i : calibrationSet) {
 
-            const ext::shared_ptr<Exercise> exercise =
-                calibrationSet[i].first->exercise();
+            const ext::shared_ptr<Exercise> exercise = i.first->exercise();
 
             QL_REQUIRE(exercise->type() == Exercise::European,
                     "European option required");
@@ -252,8 +251,7 @@ namespace QuantLib {
             expiries.insert(expiry);
 
             const ext::shared_ptr<PlainVanillaPayoff> payoff =
-                ext::dynamic_pointer_cast<PlainVanillaPayoff>(
-                    calibrationSet[i].first->payoff());
+                ext::dynamic_pointer_cast<PlainVanillaPayoff>(i.first->payoff());
 
             QL_REQUIRE(payoff, "plain vanilla payoff required");
 
@@ -261,12 +259,9 @@ namespace QuantLib {
             strikes.insert(strike);
 
             calibrationSet_.push_back(
-                std::make_pair(
-                    ext::make_shared<VanillaOption>(payoff, exercise),
-                    calibrationSet[i].second)
-            );
+                std::make_pair(ext::make_shared<VanillaOption>(payoff, exercise), i.second));
 
-            registerWith(calibrationSet[i].second);
+            registerWith(i.second);
         }
 
         strikes_.assign(strikes.begin(), strikes.end());
diff --git a/ql/termstructures/volatility/equityfx/fixedlocalvolsurface.cpp b/ql/termstructures/volatility/equityfx/fixedlocalvolsurface.cpp
index 756918b884d..4c2ad19aede 100644
--- a/ql/termstructures/volatility/equityfx/fixedlocalvolsurface.cpp
+++ b/ql/termstructures/volatility/equityfx/fixedlocalvolsurface.cpp
@@ -108,8 +108,8 @@ namespace QuantLib {
     void FixedLocalVolSurface::checkSurface() {
         QL_REQUIRE(times_.size()==localVolMatrix_->columns(),
                    "mismatch between date vector and vol matrix colums");
-        for (Size i=0; i < strikes_.size(); ++i) {
-            QL_REQUIRE(strikes_[i]->size() == localVolMatrix_->rows(),
+        for (const auto& strike : strikes_) {
+            QL_REQUIRE(strike->size() == localVolMatrix_->rows(),
                        "mismatch between money-strike vector and "
                        "vol matrix rows");
         }
@@ -119,10 +119,9 @@ namespace QuantLib {
                        "dates must be sorted unique!");
         }
 
-        for (Size i=0; i < strikes_.size(); ++i)
-            for (Size j=1; j<strikes_[i]->size(); j++) {
-                QL_REQUIRE((*strikes_[i])[j]>=(*strikes_[i])[j-1],
-                           "strikes must be sorted");
+        for (const auto& strike : strikes_)
+            for (Size j = 1; j < strike->size(); j++) {
+                QL_REQUIRE((*strike)[j] >= (*strike)[j - 1], "strikes must be sorted");
             }
     }
 
diff --git a/ql/termstructures/volatility/interpolatedsmilesection.hpp b/ql/termstructures/volatility/interpolatedsmilesection.hpp
index eaf98a66b79..63eb804a8d8 100644
--- a/ql/termstructures/volatility/interpolatedsmilesection.hpp
+++ b/ql/termstructures/volatility/interpolatedsmilesection.hpp
@@ -106,8 +106,8 @@ namespace QuantLib {
     : SmileSection(timeToExpiry, dc, type, shift),
       exerciseTimeSquareRoot_(std::sqrt(exerciseTime())), strikes_(std::move(strikes)),
       stdDevHandles_(stdDevHandles), atmLevel_(std::move(atmLevel)), vols_(stdDevHandles.size()) {
-        for (Size i=0; i<stdDevHandles_.size(); ++i)
-            LazyObject::registerWith(stdDevHandles_[i]);
+        for (auto& stdDevHandle : stdDevHandles_)
+            LazyObject::registerWith(stdDevHandle);
         LazyObject::registerWith(atmLevel_);
         // check strikes!!!!!!!!!!!!!!!!!!!!
         interpolation_ = interpolator.interpolate(strikes_.begin(),
@@ -155,8 +155,8 @@ namespace QuantLib {
     : SmileSection(d, dc, referenceDate, type, shift),
       exerciseTimeSquareRoot_(std::sqrt(exerciseTime())), strikes_(std::move(strikes)),
       stdDevHandles_(stdDevHandles), atmLevel_(std::move(atmLevel)), vols_(stdDevHandles.size()) {
-        for (Size i=0; i<stdDevHandles_.size(); ++i)
-            LazyObject::registerWith(stdDevHandles_[i]);
+        for (auto& stdDevHandle : stdDevHandles_)
+            LazyObject::registerWith(stdDevHandle);
         LazyObject::registerWith(atmLevel_);
         // check strikes!!!!!!!!!!!!!!!!!!!!
         interpolation_ = interpolator.interpolate(strikes_.begin(),
diff --git a/ql/termstructures/volatility/kahalesmilesection.cpp b/ql/termstructures/volatility/kahalesmilesection.cpp
index c25a5ce6ebf..7ef26c1fc95 100644
--- a/ql/termstructures/volatility/kahalesmilesection.cpp
+++ b/ql/termstructures/volatility/kahalesmilesection.cpp
@@ -53,8 +53,8 @@ namespace QuantLib {
         // for shifted smile sections we shift the forward and the strikes
         // and do as if we were in a lognormal setting
 
-        for(Size i=0;i<k_.size();++i) {
-            k_[i] += shift();
+        for (double& i : k_) {
+            i += shift();
         }
 
         f_ += shift();
diff --git a/ql/termstructures/volatility/optionlet/strippedoptionletadapter.cpp b/ql/termstructures/volatility/optionlet/strippedoptionletadapter.cpp
index c1637b0d6d1..7832ae90a14 100644
--- a/ql/termstructures/volatility/optionlet/strippedoptionletadapter.cpp
+++ b/ql/termstructures/volatility/optionlet/strippedoptionletadapter.cpp
@@ -47,9 +47,9 @@ namespace QuantLib {
             optionletStripper_->optionletStrikes(
                 0); // strikes are the same for all times ?!
         std::vector< Real > stddevs;
-        for (Size i = 0; i < optionletStrikes.size(); i++) {
-            stddevs.push_back(volatilityImpl(t, optionletStrikes[i]) *
-                              std::sqrt(t));
+        stddevs.reserve(optionletStrikes.size());
+        for (double optionletStrike : optionletStrikes) {
+            stddevs.push_back(volatilityImpl(t, optionletStrike) * std::sqrt(t));
         }
         // Extrapolation may be a problem with splines, but since minStrike()
         // and maxStrike() are set, we assume that no one will use stddevs for
diff --git a/ql/termstructures/volatility/sabrinterpolatedsmilesection.cpp b/ql/termstructures/volatility/sabrinterpolatedsmilesection.cpp
index bd75778c83a..e569b25b047 100644
--- a/ql/termstructures/volatility/sabrinterpolatedsmilesection.cpp
+++ b/ql/termstructures/volatility/sabrinterpolatedsmilesection.cpp
@@ -56,8 +56,8 @@ namespace QuantLib {
 
         LazyObject::registerWith(forward_);
         LazyObject::registerWith(atmVolatility_);
-        for (Size i = 0; i < volHandles_.size(); ++i)
-            LazyObject::registerWith(volHandles_[i]);
+        for (auto& volHandle : volHandles_)
+            LazyObject::registerWith(volHandle);
     }
 
     SabrInterpolatedSmileSection::SabrInterpolatedSmileSection(
diff --git a/ql/termstructures/volatility/smilesectionutils.cpp b/ql/termstructures/volatility/smilesectionutils.cpp
index 55a8bd6eef0..0bc2e892a60 100644
--- a/ql/termstructures/volatility/smilesectionutils.cpp
+++ b/ql/termstructures/volatility/smilesectionutils.cpp
@@ -81,15 +81,12 @@ namespace QuantLib {
         }
 
         bool minStrikeAdded = false, maxStrikeAdded = false;
-        for (Size i = 0; i < tmp.size(); i++) {
-            Real k = section.volatilityType() == Normal
-                         ? f_ + tmp[i]
-                         : tmp[i] * (f_ + shift) - shift;
-            if ((section.volatilityType() == ShiftedLognormal &&
-                 tmp[i] <= QL_EPSILON) ||
+        for (double& i : tmp) {
+            Real k = section.volatilityType() == Normal ? f_ + i : i * (f_ + shift) - shift;
+            if ((section.volatilityType() == ShiftedLognormal && i <= QL_EPSILON) ||
                 (k >= section.minStrike() && k <= section.maxStrike())) {
                 if (!minStrikeAdded || !close(k, section.minStrike())) {
-                    m_.push_back(tmp[i]);
+                    m_.push_back(i);
                     k_.push_back(k);
                 }
                 if (close(k, section.maxStrike()))
diff --git a/ql/termstructures/volatility/swaption/cmsmarketcalibration.cpp b/ql/termstructures/volatility/swaption/cmsmarketcalibration.cpp
index 4953b5ee7fc..62aa55bfb67 100644
--- a/ql/termstructures/volatility/swaption/cmsmarketcalibration.cpp
+++ b/ql/termstructures/volatility/swaption/cmsmarketcalibration.cpp
@@ -203,8 +203,8 @@ namespace {
         for (Size i = 0; i < nSwapTenors; ++i) {
             std::vector<Real> beta(x.begin() + (i * nSwapLengths),
                                    x.begin() + ((i + 1) * nSwapLengths));
-            for (Size j = 0; j < beta.size(); ++j)
-                beta[j] = CmsMarketCalibration::betaTransformDirect(beta[j]);
+            for (double& j : beta)
+                j = CmsMarketCalibration::betaTransformDirect(j);
             volCubeBySabr->recalibration(swapLengths, beta, swapTenors[i]);
         }
         Real meanReversion =
@@ -230,8 +230,8 @@ namespace {
         for (Size i = 0; i < nSwapTenors; ++i) {
             std::vector<Real> beta(x.begin() + (i * nSwapLengths),
                                    x.begin() + ((i + 1) * nSwapLengths));
-            for (Size j = 0; j < beta.size(); ++j)
-                beta[j] = CmsMarketCalibration::betaTransformDirect(beta[j]);
+            for (double& j : beta)
+                j = CmsMarketCalibration::betaTransformDirect(j);
             volCubeBySabr->recalibration(swapLengths, beta, swapTenors[i]);
         }
         cmsMarket_->reprice(volCube_, fixedMeanReversion_ == Null<Real>() ?
diff --git a/ql/termstructures/volatility/swaption/swaptionvolcube1.hpp b/ql/termstructures/volatility/swaption/swaptionvolcube1.hpp
index 2b399e215da..54979451ae2 100644
--- a/ql/termstructures/volatility/swaption/swaptionvolcube1.hpp
+++ b/ql/termstructures/volatility/swaption/swaptionvolcube1.hpp
@@ -635,13 +635,12 @@ namespace QuantLib {
         std::vector<Time> swapLengths(sparseParameters_.swapLengths());
         sparseSmiles_.clear();
 
-        for (Size j=0; j<optionTimes.size(); j++) {
+        for (double& optionTime : optionTimes) {
             std::vector<ext::shared_ptr<SmileSection> > tmp;
             Size n = swapLengths.size();
             tmp.reserve(n);
             for (Size k=0; k<n; ++k) {
-                tmp.push_back(smileSection(optionTimes[j], swapLengths[k],
-                                           sparseParameters_));
+                tmp.push_back(smileSection(optionTime, swapLengths[k], sparseParameters_));
             }
             sparseSmiles_.push_back(tmp);
         }
diff --git a/ql/termstructures/yield/fittedbonddiscountcurve.cpp b/ql/termstructures/yield/fittedbonddiscountcurve.cpp
index 3bbf781987d..27cb6f451c2 100644
--- a/ql/termstructures/yield/fittedbonddiscountcurve.cpp
+++ b/ql/termstructures/yield/fittedbonddiscountcurve.cpp
@@ -137,8 +137,8 @@ namespace QuantLib {
         Size n = curve_->bondHelpers_.size();
         costFunction_ = ext::make_shared<FittingCost>(this);
 
-        for (Size i=0; i<curve_->bondHelpers_.size(); ++i) {
-            curve_->bondHelpers_[i]->setTermStructure(curve_);
+        for (auto& bondHelper : curve_->bondHelpers_) {
+            bondHelper->setTermStructure(curve_);
         }
 
         if (calculateWeights_) {
@@ -242,8 +242,8 @@ namespace QuantLib {
                                                        const Array& x) const {
         Real squaredError = 0.0;
         Array vals = values(x);
-        for (Size i = 0; i<vals.size(); ++i) {
-            squaredError += vals[i];
+        for (double val : vals) {
+            squaredError += val;
         }
         return squaredError;
     }
diff --git a/ql/termstructures/yield/fittedbonddiscountcurve.hpp b/ql/termstructures/yield/fittedbonddiscountcurve.hpp
index c4cc29caca2..b1dcc1492b4 100644
--- a/ql/termstructures/yield/fittedbonddiscountcurve.hpp
+++ b/ql/termstructures/yield/fittedbonddiscountcurve.hpp
@@ -283,8 +283,8 @@ namespace QuantLib {
     }
 
     inline void FittedBondDiscountCurve::setup() {
-        for (Size i=0; i<bondHelpers_.size(); ++i)
-            registerWith(bondHelpers_[i]);
+        for (auto& bondHelper : bondHelpers_)
+            registerWith(bondHelper);
     }
 
     inline DiscountFactor FittedBondDiscountCurve::discountImpl(Time t) const {
diff --git a/ql/termstructures/yield/piecewisezerospreadedtermstructure.hpp b/ql/termstructures/yield/piecewisezerospreadedtermstructure.hpp
index 440d7952063..5413cf1edf9 100644
--- a/ql/termstructures/yield/piecewisezerospreadedtermstructure.hpp
+++ b/ql/termstructures/yield/piecewisezerospreadedtermstructure.hpp
@@ -107,8 +107,8 @@ namespace QuantLib {
         QL_REQUIRE(spreads_.size() == dates_.size(),
                    "spread and date vector have different sizes");
         registerWith(originalCurve_);
-        for (Size i = 0; i < spreads_.size(); i++)
-            registerWith(spreads_[i]);
+        for (auto& spread : spreads_)
+            registerWith(spread);
         if (!originalCurve_.empty())
             updateInterpolation();
     }
diff --git a/ql/time/calendars/saudiarabia.cpp b/ql/time/calendars/saudiarabia.cpp
index 3ad28d0a190..59d805163da 100644
--- a/ql/time/calendars/saudiarabia.cpp
+++ b/ql/time/calendars/saudiarabia.cpp
@@ -80,8 +80,8 @@ namespace QuantLib {
                                       (Date(20, July, 2021))
                                       (Date(10, July, 2022));
 
-            for (auto p = EidAlAdha.begin(); p != EidAlAdha.end(); ++p) {
-                if (d >= *p -1 && d <= *p + 4) {
+            for (auto& p : EidAlAdha) {
+                if (d >= p - 1 && d <= p + 4) {
                     return true;
                 }
             }
@@ -122,8 +122,8 @@ namespace QuantLib {
                                       (Date(26, Feb, 2028))
                                       (Date(14, Feb, 2029));
 
-            for (auto p = EidAlFitr.begin(); p != EidAlFitr.end(); ++p) {
-                if (d >= *p -1 && d <= *p + 4) {
+            for (auto& p : EidAlFitr) {
+                if (d >= p - 1 && d <= p + 4) {
                     return true;
                 }
             }
diff --git a/test-suite/americanoption.cpp b/test-suite/americanoption.cpp
index 304b23a3f35..ef501df1802 100644
--- a/test-suite/americanoption.cpp
+++ b/test-suite/americanoption.cpp
@@ -139,18 +139,17 @@ void AmericanOptionTest::testBaroneAdesiWhaleyValues() {
 
     Real tolerance = 3.0e-3;
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(new
-            PlainVanillaPayoff(values[i].type, values[i].strike));
-        Date exDate = today + timeToDays(values[i].t);
+        ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(value.type, value.strike));
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise(
                                          new AmericanExercise(today, exDate));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess(new
             BlackScholesMertonProcess(Handle<Quote>(spot),
@@ -165,14 +164,12 @@ void AmericanOptionTest::testBaroneAdesiWhaleyValues() {
         option.setPricingEngine(engine);
 
         Real calculated = option.NPV();
-        Real error = std::fabs(calculated-values[i].result);
+        Real error = std::fabs(calculated - value.result);
         if (error > tolerance) {
-            REPORT_FAILURE("value", payoff, exercise, values[i].s, values[i].q,
-                           values[i].r, today, values[i].v, values[i].result,
-                           calculated, error, tolerance);
+            REPORT_FAILURE("value", payoff, exercise, value.s, value.q, value.r, today, value.v,
+                           value.result, calculated, error, tolerance);
         }
     }
-
 }
 
 
@@ -212,18 +209,17 @@ void AmericanOptionTest::testBjerksundStenslandValues() {
 
     Real tolerance = 5.0e-5;
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(new
-            PlainVanillaPayoff(values[i].type, values[i].strike));
-        Date exDate = today + timeToDays(values[i].t);
+        ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(value.type, value.strike));
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise(
                                          new AmericanExercise(today, exDate));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess(new
             BlackScholesMertonProcess(Handle<Quote>(spot),
@@ -238,14 +234,12 @@ void AmericanOptionTest::testBjerksundStenslandValues() {
         option.setPricingEngine(engine);
 
         Real calculated = option.NPV();
-        Real error = std::fabs(calculated-values[i].result);
+        Real error = std::fabs(calculated - value.result);
         if (error > tolerance) {
-            REPORT_FAILURE("value", payoff, exercise, values[i].s, values[i].q,
-                           values[i].r, today, values[i].v, values[i].result,
-                           calculated, error, tolerance);
+            REPORT_FAILURE("value", payoff, exercise, value.s, value.q, value.r, today, value.v,
+                           value.result, calculated, error, tolerance);
         }
     }
-
 }
 
 namespace {
@@ -342,18 +336,18 @@ void AmericanOptionTest::testJuValues() {
 
     Real tolerance = 1.0e-3;
 
-    for (Size i=0; i<LENGTH(juValues); i++) {
+    for (auto& juValue : juValues) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(new
-            PlainVanillaPayoff(juValues[i].type, juValues[i].strike));
-        Date exDate = today + timeToDays(juValues[i].t);
+        ext::shared_ptr<StrikedTypePayoff> payoff(
+            new PlainVanillaPayoff(juValue.type, juValue.strike));
+        Date exDate = today + timeToDays(juValue.t);
         ext::shared_ptr<Exercise> exercise(
                                          new AmericanExercise(today, exDate));
 
-        spot ->setValue(juValues[i].s);
-        qRate->setValue(juValues[i].q);
-        rRate->setValue(juValues[i].r);
-        vol  ->setValue(juValues[i].v);
+        spot->setValue(juValue.s);
+        qRate->setValue(juValue.q);
+        rRate->setValue(juValue.r);
+        vol->setValue(juValue.v);
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess(new
             BlackScholesMertonProcess(Handle<Quote>(spot),
@@ -368,12 +362,10 @@ void AmericanOptionTest::testJuValues() {
         option.setPricingEngine(engine);
 
         Real calculated = option.NPV();
-        Real error = std::fabs(calculated-juValues[i].result);
+        Real error = std::fabs(calculated - juValue.result);
         if (error > tolerance) {
-            REPORT_FAILURE("value", payoff, exercise, juValues[i].s,
-                           juValues[i].q, juValues[i].r, today,
-                           juValues[i].v, juValues[i].result,
-                           calculated, error, tolerance);
+            REPORT_FAILURE("value", payoff, exercise, juValue.s, juValue.q, juValue.r, today,
+                           juValue.v, juValue.result, calculated, error, tolerance);
         }
     }
 }
@@ -396,19 +388,19 @@ void AmericanOptionTest::testFdValues() {
 
     Real tolerance = 8.0e-2;
 
-    for (Size i=0; i<LENGTH(juValues); i++) {
+    for (auto& juValue : juValues) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(new
-            PlainVanillaPayoff(juValues[i].type, juValues[i].strike));
+        ext::shared_ptr<StrikedTypePayoff> payoff(
+            new PlainVanillaPayoff(juValue.type, juValue.strike));
 
-        Date exDate = today + timeToDays(juValues[i].t);
+        Date exDate = today + timeToDays(juValue.t);
         ext::shared_ptr<Exercise> exercise(
                                          new AmericanExercise(today, exDate));
 
-        spot ->setValue(juValues[i].s);
-        qRate->setValue(juValues[i].q);
-        rRate->setValue(juValues[i].r);
-        vol  ->setValue(juValues[i].v);
+        spot->setValue(juValue.s);
+        qRate->setValue(juValue.q);
+        rRate->setValue(juValue.r);
+        vol->setValue(juValue.v);
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess =
             ext::make_shared<BlackScholesMertonProcess>(Handle<Quote>(spot),
@@ -423,12 +415,10 @@ void AmericanOptionTest::testFdValues() {
         option.setPricingEngine(engine);
 
         Real calculated = option.NPV();
-        Real error = std::fabs(calculated-juValues[i].result);
+        Real error = std::fabs(calculated - juValue.result);
         if (error > tolerance) {
-            REPORT_FAILURE("value", payoff, exercise, juValues[i].s,
-                           juValues[i].q, juValues[i].r, today,
-                           juValues[i].v, juValues[i].result,
-                           calculated, error, tolerance);
+            REPORT_FAILURE("value", payoff, exercise, juValue.s, juValue.q, juValue.r, today,
+                           juValue.v, juValue.result, calculated, error, tolerance);
         }
     }
 }
@@ -468,88 +458,77 @@ namespace {
 
         ext::shared_ptr<StrikedTypePayoff> payoff;
 
-        for (Size i=0; i<LENGTH(types); i++) {
-          for (Size j=0; j<LENGTH(strikes); j++) {
-            for (Size k=0; k<LENGTH(years); k++) {
-                Date exDate = today + years[k]*Years;
-                ext::shared_ptr<Exercise> exercise(
-                                         new AmericanExercise(today, exDate));
-                ext::shared_ptr<StrikedTypePayoff> payoff(
-                                new PlainVanillaPayoff(types[i], strikes[j]));
-                ext::shared_ptr<BlackScholesMertonProcess> stochProcess(
-                            new BlackScholesMertonProcess(Handle<Quote>(spot),
-                                                          qTS, rTS, volTS));
-
-                ext::shared_ptr<PricingEngine> engine(
-                     new Engine(stochProcess, 50));
-
-                VanillaOption option(payoff, exercise);
-                option.setPricingEngine(engine);
-
-                for (Size l=0; l<LENGTH(underlyings); l++) {
-                  for (Size m=0; m<LENGTH(qRates); m++) {
-                    for (Size n=0; n<LENGTH(rRates); n++) {
-                      for (Size p=0; p<LENGTH(vols); p++) {
-                        Real u = underlyings[l];
-                        Rate q = qRates[m],
-                             r = rRates[n];
-                        Volatility v = vols[p];
-                        spot->setValue(u);
-                        qRate->setValue(q);
-                        rRate->setValue(r);
-                        vol->setValue(v);
-                        //FLOATING_POINT_EXCEPTION
-                        Real value = option.NPV();
-                        calculated["delta"]  = option.delta();
-                        calculated["gamma"]  = option.gamma();
-                        //calculated["theta"]  = option.theta();
-
-                        if (value > spot->value()*1.0e-5) {
-                            // perturb spot and get delta and gamma
-                            Real du = u*1.0e-4;
-                            spot->setValue(u+du);
-                            Real value_p = option.NPV(),
-                                 delta_p = option.delta();
-                            spot->setValue(u-du);
-                            Real value_m = option.NPV(),
-                                 delta_m = option.delta();
-                            spot->setValue(u);
-                            expected["delta"] = (value_p - value_m)/(2*du);
-                            expected["gamma"] = (delta_p - delta_m)/(2*du);
-
-                            /*
-                            // perturb date and get theta
-                            Time dT = dc.yearFraction(today-1, today+1);
-                            Settings::instance().setEvaluationDate(today-1);
-                            value_m = option.NPV();
-                            Settings::instance().setEvaluationDate(today+1);
-                            value_p = option.NPV();
-                            Settings::instance().setEvaluationDate(today);
-                            expected["theta"] = (value_p - value_m)/dT;
-                            */
-
-                            // compare
-                            std::map<std::string,Real>::iterator it;
-                            for (it = calculated.begin();
-                                 it != calculated.end(); ++it) {
-                                std::string greek = it->first;
-                                Real expct = expected  [greek],
-                                    calcl = calculated[greek],
-                                    tol   = tolerance [greek];
-                                Real error = relativeError(expct,calcl,u);
-                                if (error>tol) {
-                                    REPORT_FAILURE(greek, payoff, exercise,
-                                                   u, q, r, today, v,
-                                                   expct, calcl, error, tol);
+        for (auto& type : types) {
+            for (double strike : strikes) {
+                for (int year : years) {
+                    Date exDate = today + year * Years;
+                    ext::shared_ptr<Exercise> exercise(new AmericanExercise(today, exDate));
+                    ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(type, strike));
+                    ext::shared_ptr<BlackScholesMertonProcess> stochProcess(
+                        new BlackScholesMertonProcess(Handle<Quote>(spot), qTS, rTS, volTS));
+
+                    ext::shared_ptr<PricingEngine> engine(new Engine(stochProcess, 50));
+
+                    VanillaOption option(payoff, exercise);
+                    option.setPricingEngine(engine);
+
+                    for (double u : underlyings) {
+                        for (double m : qRates) {
+                            for (double n : rRates) {
+                                for (double v : vols) {
+                                    Rate q = m, r = n;
+                                    spot->setValue(u);
+                                    qRate->setValue(q);
+                                    rRate->setValue(r);
+                                    vol->setValue(v);
+                                    // FLOATING_POINT_EXCEPTION
+                                    Real value = option.NPV();
+                                    calculated["delta"] = option.delta();
+                                    calculated["gamma"] = option.gamma();
+                                    // calculated["theta"]  = option.theta();
+
+                                    if (value > spot->value() * 1.0e-5) {
+                                        // perturb spot and get delta and gamma
+                                        Real du = u * 1.0e-4;
+                                        spot->setValue(u + du);
+                                        Real value_p = option.NPV(), delta_p = option.delta();
+                                        spot->setValue(u - du);
+                                        Real value_m = option.NPV(), delta_m = option.delta();
+                                        spot->setValue(u);
+                                        expected["delta"] = (value_p - value_m) / (2 * du);
+                                        expected["gamma"] = (delta_p - delta_m) / (2 * du);
+
+                                        /*
+                                        // perturb date and get theta
+                                        Time dT = dc.yearFraction(today-1, today+1);
+                                        Settings::instance().setEvaluationDate(today-1);
+                                        value_m = option.NPV();
+                                        Settings::instance().setEvaluationDate(today+1);
+                                        value_p = option.NPV();
+                                        Settings::instance().setEvaluationDate(today);
+                                        expected["theta"] = (value_p - value_m)/dT;
+                                        */
+
+                                        // compare
+                                        std::map<std::string, Real>::iterator it;
+                                        for (it = calculated.begin(); it != calculated.end();
+                                             ++it) {
+                                            std::string greek = it->first;
+                                            Real expct = expected[greek], calcl = calculated[greek],
+                                                 tol = tolerance[greek];
+                                            Real error = relativeError(expct, calcl, u);
+                                            if (error > tol) {
+                                                REPORT_FAILURE(greek, payoff, exercise, u, q, r,
+                                                               today, v, expct, calcl, error, tol);
+                                            }
+                                        }
+                                    }
                                 }
                             }
                         }
-                      }
                     }
-                  }
                 }
             }
-          }
         }
     }
 
diff --git a/test-suite/andreasenhugevolatilityinterpl.cpp b/test-suite/andreasenhugevolatilityinterpl.cpp
index 9565c675feb..bed896a4763 100644
--- a/test-suite/andreasenhugevolatilityinterpl.cpp
+++ b/test-suite/andreasenhugevolatilityinterpl.cpp
@@ -289,12 +289,9 @@ namespace andreasen_huge_volatility_interpl_test {
 
         AndreasenHugeVolatilityInterpl::CalibrationSet calibrationSet;
 
-        for (Size i=0; i < LENGTH(strikes); ++i) {
-            const Real strike = strikes[i];
-
-            for (Size j=0; j < LENGTH(maturityMonths); ++j) {
-                const Date maturityDate = today +
-                    Period(maturityMonths[j], Months);
+        for (double strike : strikes) {
+            for (unsigned long maturityMonth : maturityMonths) {
+                const Date maturityDate = today + Period(maturityMonth, Months);
                 const Time t = dc.yearFraction(today, maturityDate);
 
                 const Real fwd = spot->value()*qTS->discount(t)/rTS->discount(t);
@@ -498,9 +495,8 @@ void AndreasenHugeVolatilityInterplTest::testTimeDependentInterestRates() {
             AnalyticHestonEngine::AndersenPiterbarg,
             AnalyticHestonEngine::Integration::discreteTrapezoid(128)));
 
-    for (Size i=0; i < calibrationSet.size(); ++i) {
-        const ext::shared_ptr<VanillaOption> option =
-            calibrationSet[i].first;
+    for (auto& i : calibrationSet) {
+        const ext::shared_ptr<VanillaOption> option = i.first;
 
         const ext::shared_ptr<PlainVanillaPayoff> payoff =
             ext::dynamic_pointer_cast<PlainVanillaPayoff>(option->payoff());
@@ -520,7 +516,7 @@ void AndreasenHugeVolatilityInterplTest::testTimeDependentInterestRates() {
             optionType, strike, fwd, npv,
             discount, 0.0, Null<Real>(), 1.0, 1e-12)/std::sqrt(t);
 
-        calibrationSet[i].second = ext::make_shared<SimpleQuote>(impliedVol);
+        i.second = ext::make_shared<SimpleQuote>(impliedVol);
     }
 
     CalibrationData irData = { spot, rTS, qTS, calibrationSet };
@@ -573,13 +569,11 @@ void AndreasenHugeVolatilityInterplTest::testSingleOptionCalibration() {
         AndreasenHugeVolatilityInterpl::CallPut
     };
 
-    for (Size i=0; i < LENGTH(interpl); ++i)
-        for (Size j=0; j < LENGTH(calibrationType); ++j) {
-            const ext::shared_ptr<AndreasenHugeVolatilityInterpl>
-                andreasenHugeVolInterplation(
-                    ext::make_shared<AndreasenHugeVolatilityInterpl>(
-                        calibrationSet, spot, rTS, qTS,
-                        interpl[i], calibrationType[j], 50));
+    for (auto i : interpl)
+        for (auto j : calibrationType) {
+            const ext::shared_ptr<AndreasenHugeVolatilityInterpl> andreasenHugeVolInterplation(
+                ext::make_shared<AndreasenHugeVolatilityInterpl>(calibrationSet, spot, rTS, qTS, i,
+                                                                 j, 50));
 
             const ext::shared_ptr<AndreasenHugeVolatilityAdapter>
                 volatilityAdapter =
@@ -609,13 +603,12 @@ void AndreasenHugeVolatilityInterplTest::testArbitrageFree() {
 
     CalibrationData data[] = { BorovkovaExampleData(), arbitrageData() };;
 
-    for (Size i=0; i < LENGTH(data); ++i) {
-        const Handle<Quote>& spot = data[i].spot;
-        const AndreasenHugeVolatilityInterpl::CalibrationSet& calibrationSet =
-            data[i].calibrationSet;
+    for (auto& i : data) {
+        const Handle<Quote>& spot = i.spot;
+        const AndreasenHugeVolatilityInterpl::CalibrationSet& calibrationSet = i.calibrationSet;
 
-        const Handle<YieldTermStructure>& rTS = data[i].rTS;
-        const Handle<YieldTermStructure>& qTS = data[i].qTS;
+        const Handle<YieldTermStructure>& rTS = i.rTS;
+        const Handle<YieldTermStructure>& qTS = i.qTS;
 
         const DayCounter dc = rTS->dayCounter();
         const Date today = rTS->referenceDate();
@@ -723,11 +716,9 @@ void AndreasenHugeVolatilityInterplTest::testBarrierOptionPricing() {
 
     AndreasenHugeVolatilityInterpl::CalibrationSet calibrationSet;
 
-    for (Size i=0; i < LENGTH(strikes); ++i) {
-        const Real strike = strikes[i];
-
-        for (Size j=0; j < LENGTH(maturityMonths); ++j) {
-            const Date maturityDate = today + Period(maturityMonths[j], Months);
+    for (double strike : strikes) {
+        for (unsigned long maturityMonth : maturityMonths) {
+            const Date maturityDate = today + Period(maturityMonth, Months);
             const Time t = dc.yearFraction(today, maturityDate);
 
             const Volatility vol = hestonVol->blackVol(t, strike);
@@ -818,10 +809,8 @@ namespace andreasen_huge_volatility_interpl_test {
 
         const Real strikes[] = { 0.02, 0.025, 0.03, 0.035, 0.04, 0.05, 0.06 };
 
-        for (Size i=0; i < LENGTH(strikes); ++i) {
-            const Real strike = strikes[i];
-            const Volatility vol = sabrVolatility(
-               strike, forward, maturity, alpha, beta, nu, rho);
+        for (double strike : strikes) {
+            const Volatility vol = sabrVolatility(strike, forward, maturity, alpha, beta, nu, rho);
 
             calibrationSet.push_back(std::make_pair(
                 ext::make_shared<VanillaOption>(
@@ -911,19 +900,13 @@ void AndreasenHugeVolatilityInterplTest::testDifferentOptimizers() {
         ext::make_shared<Simplex>(0.2)
     };
 
-    for (Size i=0; i < LENGTH(optimizationMethods); ++i) {
-        const ext::shared_ptr<OptimizationMethod> optimizationMethod =
-            optimizationMethods[i];
-
-        const Real avgError = ext::get<2>(AndreasenHugeVolatilityInterpl(
-            data.calibrationSet,
-            data.spot,
-            data.rTS, data.qTS,
-            AndreasenHugeVolatilityInterpl::CubicSpline,
-            AndreasenHugeVolatilityInterpl::Call,
-            400,
-            Null<Real>(), Null<Real>(),
-            optimizationMethod).calibrationError());
+    for (const auto& optimizationMethod : optimizationMethods) {
+        const Real avgError = ext::get<2>(
+            AndreasenHugeVolatilityInterpl(data.calibrationSet, data.spot, data.rTS, data.qTS,
+                                           AndreasenHugeVolatilityInterpl::CubicSpline,
+                                           AndreasenHugeVolatilityInterpl::Call, 400, Null<Real>(),
+                                           Null<Real>(), optimizationMethod)
+                .calibrationError());
 
         if (boost::math::isnan(avgError) || avgError > 0.0001) {
             BOOST_FAIL("failed to calibrate Andreasen-Huge "
@@ -1039,17 +1022,15 @@ void AndreasenHugeVolatilityInterplTest::testFlatVolCalibration() {
     const ext::shared_ptr<Quote> vol = ext::make_shared<SimpleQuote>(0.18);
 
     AndreasenHugeVolatilityInterpl::CalibrationSet calibrationSet;
-    for (Size i=0; i < LENGTH(expiries); ++i) {
+    for (auto expiry : expiries) {
 
-        const Date expiry = expiries[i];
-        const ext::shared_ptr<Exercise> exercise =
-            ext::make_shared<EuropeanExercise>(expiry);
+        const ext::shared_ptr<Exercise> exercise = ext::make_shared<EuropeanExercise>(expiry);
 
         const Time t = rTS->timeFromReference(expiry);
         const Real fwd = spot->value() / rTS->discount(t) * qTS->discount(t);
 
-        for (Size j=0; j < LENGTH(moneyness); ++j) {
-            const Real strike = fwd * moneyness[j];
+        for (double moneynes : moneyness) {
+            const Real strike = fwd * moneynes;
             const Real mn = std::log(fwd/strike)/std::sqrt(t);
 
             if (std::fabs(mn) < 3.72*vol->value()) {
diff --git a/test-suite/asianoptions.cpp b/test-suite/asianoptions.cpp
index 7b0ee7efa22..9162faaafb0 100644
--- a/test-suite/asianoptions.cpp
+++ b/test-suite/asianoptions.cpp
@@ -209,121 +209,110 @@ void AsianOptionTest::testAnalyticContinuousGeometricAveragePriceGreeks() {
     ext::shared_ptr<BlackScholesMertonProcess> process(
          new BlackScholesMertonProcess(Handle<Quote>(spot), qTS, rTS, volTS));
 
-    for (Size i=0; i<LENGTH(types); i++) {
-      for (Size j=0; j<LENGTH(strikes); j++) {
-        for (Size k=0; k<LENGTH(lengths); k++) {
-
-            ext::shared_ptr<EuropeanExercise> maturity(
-                              new EuropeanExercise(today + lengths[k]*Years));
-
-            ext::shared_ptr<PlainVanillaPayoff> payoff(
-                                new PlainVanillaPayoff(types[i], strikes[j]));
-
-            ext::shared_ptr<PricingEngine> engine(new
-                 AnalyticContinuousGeometricAveragePriceAsianEngine(process));
-
-            ContinuousAveragingAsianOption option(Average::Geometric,
-                                                  payoff, maturity);
-            option.setPricingEngine(engine);
-
-            Size pastFixings = Null<Size>();
-            Real runningAverage = Null<Real>();
-
-            for (Size l=0; l<LENGTH(underlyings); l++) {
-              for (Size m=0; m<LENGTH(qRates); m++) {
-                for (Size n=0; n<LENGTH(rRates); n++) {
-                  for (Size p=0; p<LENGTH(vols); p++) {
-
-                      Real u = underlyings[l];
-                      Rate q = qRates[m],
-                           r = rRates[n];
-                      Volatility v = vols[p];
-                      spot->setValue(u);
-                      qRate->setValue(q);
-                      rRate->setValue(r);
-                      vol->setValue(v);
-
-                      Real value = option.NPV();
-                      calculated["delta"]  = option.delta();
-                      calculated["gamma"]  = option.gamma();
-                      calculated["theta"]  = option.theta();
-                      calculated["rho"]    = option.rho();
-                      calculated["divRho"] = option.dividendRho();
-                      calculated["vega"]   = option.vega();
-
-                      if (value > spot->value()*1.0e-5) {
-                          // perturb spot and get delta and gamma
-                          Real du = u*1.0e-4;
-                          spot->setValue(u+du);
-                          Real value_p = option.NPV(),
-                               delta_p = option.delta();
-                          spot->setValue(u-du);
-                          Real value_m = option.NPV(),
-                               delta_m = option.delta();
-                          spot->setValue(u);
-                          expected["delta"] = (value_p - value_m)/(2*du);
-                          expected["gamma"] = (delta_p - delta_m)/(2*du);
-
-                          // perturb rates and get rho and dividend rho
-                          Spread dr = r*1.0e-4;
-                          rRate->setValue(r+dr);
-                          value_p = option.NPV();
-                          rRate->setValue(r-dr);
-                          value_m = option.NPV();
-                          rRate->setValue(r);
-                          expected["rho"] = (value_p - value_m)/(2*dr);
-
-                          Spread dq = q*1.0e-4;
-                          qRate->setValue(q+dq);
-                          value_p = option.NPV();
-                          qRate->setValue(q-dq);
-                          value_m = option.NPV();
-                          qRate->setValue(q);
-                          expected["divRho"] = (value_p - value_m)/(2*dq);
-
-                          // perturb volatility and get vega
-                          Volatility dv = v*1.0e-4;
-                          vol->setValue(v+dv);
-                          value_p = option.NPV();
-                          vol->setValue(v-dv);
-                          value_m = option.NPV();
-                          vol->setValue(v);
-                          expected["vega"] = (value_p - value_m)/(2*dv);
-
-                          // perturb date and get theta
-                          Time dT = dc.yearFraction(today-1, today+1);
-                          Settings::instance().evaluationDate() = today-1;
-                          value_m = option.NPV();
-                          Settings::instance().evaluationDate() = today+1;
-                          value_p = option.NPV();
-                          Settings::instance().evaluationDate() = today;
-                          expected["theta"] = (value_p - value_m)/dT;
-
-                          // compare
-                          std::map<std::string,Real>::iterator it;
-                          for (it = calculated.begin();
-                               it != calculated.end(); ++it) {
-                              std::string greek = it->first;
-                              Real expct = expected  [greek],
-                                   calcl = calculated[greek],
-                                   tol   = tolerance [greek];
-                              Real error = relativeError(expct,calcl,u);
-                              if (error>tol) {
-                                  REPORT_FAILURE(greek, Average::Geometric,
-                                                 runningAverage, pastFixings,
-                                                 std::vector<Date>(),
-                                                 payoff, maturity,
-                                                 u, q, r, today, v,
-                                                 expct, calcl, tol);
-                              }
-                          }
-                      }
-                  }
+    for (auto& type : types) {
+        for (double strike : strikes) {
+            for (int length : lengths) {
+
+                ext::shared_ptr<EuropeanExercise> maturity(
+                    new EuropeanExercise(today + length * Years));
+
+                ext::shared_ptr<PlainVanillaPayoff> payoff(new PlainVanillaPayoff(type, strike));
+
+                ext::shared_ptr<PricingEngine> engine(
+                    new AnalyticContinuousGeometricAveragePriceAsianEngine(process));
+
+                ContinuousAveragingAsianOption option(Average::Geometric, payoff, maturity);
+                option.setPricingEngine(engine);
+
+                Size pastFixings = Null<Size>();
+                Real runningAverage = Null<Real>();
+
+                for (double u : underlyings) {
+                    for (double m : qRates) {
+                        for (double n : rRates) {
+                            for (double v : vols) {
+
+                                Rate q = m, r = n;
+                                spot->setValue(u);
+                                qRate->setValue(q);
+                                rRate->setValue(r);
+                                vol->setValue(v);
+
+                                Real value = option.NPV();
+                                calculated["delta"] = option.delta();
+                                calculated["gamma"] = option.gamma();
+                                calculated["theta"] = option.theta();
+                                calculated["rho"] = option.rho();
+                                calculated["divRho"] = option.dividendRho();
+                                calculated["vega"] = option.vega();
+
+                                if (value > spot->value() * 1.0e-5) {
+                                    // perturb spot and get delta and gamma
+                                    Real du = u * 1.0e-4;
+                                    spot->setValue(u + du);
+                                    Real value_p = option.NPV(), delta_p = option.delta();
+                                    spot->setValue(u - du);
+                                    Real value_m = option.NPV(), delta_m = option.delta();
+                                    spot->setValue(u);
+                                    expected["delta"] = (value_p - value_m) / (2 * du);
+                                    expected["gamma"] = (delta_p - delta_m) / (2 * du);
+
+                                    // perturb rates and get rho and dividend rho
+                                    Spread dr = r * 1.0e-4;
+                                    rRate->setValue(r + dr);
+                                    value_p = option.NPV();
+                                    rRate->setValue(r - dr);
+                                    value_m = option.NPV();
+                                    rRate->setValue(r);
+                                    expected["rho"] = (value_p - value_m) / (2 * dr);
+
+                                    Spread dq = q * 1.0e-4;
+                                    qRate->setValue(q + dq);
+                                    value_p = option.NPV();
+                                    qRate->setValue(q - dq);
+                                    value_m = option.NPV();
+                                    qRate->setValue(q);
+                                    expected["divRho"] = (value_p - value_m) / (2 * dq);
+
+                                    // perturb volatility and get vega
+                                    Volatility dv = v * 1.0e-4;
+                                    vol->setValue(v + dv);
+                                    value_p = option.NPV();
+                                    vol->setValue(v - dv);
+                                    value_m = option.NPV();
+                                    vol->setValue(v);
+                                    expected["vega"] = (value_p - value_m) / (2 * dv);
+
+                                    // perturb date and get theta
+                                    Time dT = dc.yearFraction(today - 1, today + 1);
+                                    Settings::instance().evaluationDate() = today - 1;
+                                    value_m = option.NPV();
+                                    Settings::instance().evaluationDate() = today + 1;
+                                    value_p = option.NPV();
+                                    Settings::instance().evaluationDate() = today;
+                                    expected["theta"] = (value_p - value_m) / dT;
+
+                                    // compare
+                                    std::map<std::string, Real>::iterator it;
+                                    for (it = calculated.begin(); it != calculated.end(); ++it) {
+                                        std::string greek = it->first;
+                                        Real expct = expected[greek], calcl = calculated[greek],
+                                             tol = tolerance[greek];
+                                        Real error = relativeError(expct, calcl, u);
+                                        if (error > tol) {
+                                            REPORT_FAILURE(greek, Average::Geometric,
+                                                           runningAverage, pastFixings,
+                                                           std::vector<Date>(), payoff, maturity, u,
+                                                           q, r, today, v, expct, calcl, tol);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
                 }
-              }
             }
         }
-      }
     }
 }
 
@@ -699,13 +688,10 @@ void AsianOptionTest::testDiscreteGeometricAveragePriceHestonPastFixings() {
     Option::Type type(Option::Call);
     Average::Type averageType = Average::Geometric;
 
-    for (Size i=0; i<LENGTH(strikes); i++) {
-        for (Size j=0; j<LENGTH(days); j++) {
+    for (double strike : strikes) {
+        for (int day : days) {
             for (Size k=0; k<2; k++) {
-                Real strike = strikes[i];
-                int day = days[j];
-
-                Size futureFixings = int(std::floor(day/30.0));
+                Size futureFixings = int(std::floor(day / 30.0));
                 std::vector<Date> fixingDates(futureFixings);
                 Date expiryDate = today + day*Days;
 
@@ -744,7 +730,6 @@ void AsianOptionTest::testDiscreteGeometricAveragePriceHestonPastFixings() {
             }
         }
     }
-
 }
 
 namespace {
@@ -853,27 +838,25 @@ void AsianOptionTest::testMCDiscreteArithmeticAveragePrice() {
     Average::Type averageType = Average::Arithmetic;
     Real runningSum = 0.0;
     Size pastFixings = 0;
-    for (Size l=0; l<LENGTH(cases4); l++) {
+    for (auto& l : cases4) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(new
-            PlainVanillaPayoff(cases4[l].type, cases4[l].strike));
+        ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(l.type, l.strike));
 
-        Time dt = cases4[l].length/(cases4[l].fixings-1);
-        std::vector<Time> timeIncrements(cases4[l].fixings);
-        std::vector<Date> fixingDates(cases4[l].fixings);
-        timeIncrements[0] = cases4[l].first;
+        Time dt = l.length / (l.fixings - 1);
+        std::vector<Time> timeIncrements(l.fixings);
+        std::vector<Date> fixingDates(l.fixings);
+        timeIncrements[0] = l.first;
         fixingDates[0] = today + timeToDays(timeIncrements[0]);
-        for (Size i=1; i<cases4[l].fixings; i++) {
-            timeIncrements[i] = i*dt + cases4[l].first;
+        for (Size i = 1; i < l.fixings; i++) {
+            timeIncrements[i] = i * dt + l.first;
             fixingDates[i] = today + timeToDays(timeIncrements[i]);
         }
-        ext::shared_ptr<Exercise> exercise(new
-            EuropeanExercise(fixingDates[cases4[l].fixings-1]));
+        ext::shared_ptr<Exercise> exercise(new EuropeanExercise(fixingDates[l.fixings - 1]));
 
-        spot ->setValue(cases4[l].underlying);
-        qRate->setValue(cases4[l].dividendYield);
-        rRate->setValue(cases4[l].riskFreeRate);
-        vol  ->setValue(cases4[l].volatility);
+        spot->setValue(l.underlying);
+        qRate->setValue(l.dividendYield);
+        rRate->setValue(l.riskFreeRate);
+        vol->setValue(l.volatility);
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess(new
             BlackScholesMertonProcess(Handle<Quote>(spot),
@@ -884,8 +867,8 @@ void AsianOptionTest::testMCDiscreteArithmeticAveragePrice() {
 
         ext::shared_ptr<PricingEngine> engine =
             MakeMCDiscreteArithmeticAPEngine<LowDiscrepancy>(stochProcess)
-            .withSamples(2047)
-            .withControlVariate(cases4[l].controlVariate);
+                .withSamples(2047)
+                .withControlVariate(l.controlVariate);
 
         DiscreteAveragingAsianOption option(averageType, runningSum,
                                             pastFixings, fixingDates,
@@ -893,7 +876,7 @@ void AsianOptionTest::testMCDiscreteArithmeticAveragePrice() {
         option.setPricingEngine(engine);
 
         Real calculated = option.NPV();
-        Real expected = cases4[l].result;
+        Real expected = l.result;
         Real tolerance = 2.0e-2;
         if (std::fabs(calculated-expected) > tolerance) {
             REPORT_FAILURE("value", averageType, runningSum, pastFixings,
@@ -902,7 +885,7 @@ void AsianOptionTest::testMCDiscreteArithmeticAveragePrice() {
                         vol->value(), expected, calculated, tolerance);
         }
 
-        if(cases4[l].fixings < 100) {
+        if (l.fixings < 100) {
             engine = ext::shared_ptr<PricingEngine>(
                     new FdBlackScholesAsianEngine(stochProcess, 100, 100, 100));
             option.setPricingEngine(engine);
@@ -915,7 +898,6 @@ void AsianOptionTest::testMCDiscreteArithmeticAveragePrice() {
             }
         }
     }
-
 }
 
 
@@ -955,26 +937,24 @@ void AsianOptionTest::testMCDiscreteArithmeticAveragePriceHeston() {
     Real runningSum = 0.0;
     Size pastFixings = 0;
 
-    for (Size l=0; l<LENGTH(cases); l++) {
+    for (auto& l : cases) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(new
-            PlainVanillaPayoff(cases[l].type, cases[l].strike));
+        ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(l.type, l.strike));
 
-        Time dt = cases[l].length/(cases[l].fixings-1);
-        std::vector<Time> timeIncrements(cases[l].fixings);
-        std::vector<Date> fixingDates(cases[l].fixings);
-        timeIncrements[0] = cases[l].first;
+        Time dt = l.length / (l.fixings - 1);
+        std::vector<Time> timeIncrements(l.fixings);
+        std::vector<Date> fixingDates(l.fixings);
+        timeIncrements[0] = l.first;
         fixingDates[0] = today + Integer(timeIncrements[0]*365.25);
-        for (Size i=1; i<cases[l].fixings; i++) {
-            timeIncrements[i] = i*dt + cases[l].first;
+        for (Size i = 1; i < l.fixings; i++) {
+            timeIncrements[i] = i * dt + l.first;
             fixingDates[i] = today + Integer(timeIncrements[i]*365.25);
         }
-        ext::shared_ptr<Exercise> exercise(new
-            EuropeanExercise(fixingDates[cases[l].fixings-1]));
+        ext::shared_ptr<Exercise> exercise(new EuropeanExercise(fixingDates[l.fixings - 1]));
 
-        spot ->setValue(cases[l].underlying);
-        qRate->setValue(cases[l].dividendYield);
-        rRate->setValue(cases[l].riskFreeRate);
+        spot->setValue(l.underlying);
+        qRate->setValue(l.dividendYield);
+        rRate->setValue(l.riskFreeRate);
 
         ext::shared_ptr<HestonProcess> hestonProcess(new
             HestonProcess(Handle<YieldTermStructure>(rTS),
@@ -993,7 +973,7 @@ void AsianOptionTest::testMCDiscreteArithmeticAveragePriceHeston() {
         option.setPricingEngine(engine);
 
         Real calculated = option.NPV();
-        Real expected = cases[l].result;
+        Real expected = l.result;
         // Bounds given in paper, "22.48 to 22.52"
         Real tolerance = 2.0e-2;
 
@@ -1015,7 +995,7 @@ void AsianOptionTest::testMCDiscreteArithmeticAveragePriceHeston() {
         option.setPricingEngine(engine2);
 
         Real calculatedCV = option.NPV();
-        Real expectedCV = cases[l].result;
+        Real expectedCV = l.result;
         tolerance = 2.50e-2;
 
         if (std::fabs(calculatedCV-expectedCV) > tolerance) {
@@ -1199,27 +1179,25 @@ void AsianOptionTest::testMCDiscreteArithmeticAverageStrike() {
     Average::Type averageType = Average::Arithmetic;
     Real runningSum = 0.0;
     Size pastFixings = 0;
-    for (Size l=0; l<LENGTH(cases5); l++) {
+    for (auto& l : cases5) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(new
-            PlainVanillaPayoff(cases5[l].type, cases5[l].strike));
+        ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(l.type, l.strike));
 
-        Time dt = cases5[l].length/(cases5[l].fixings-1);
-        std::vector<Time> timeIncrements(cases5[l].fixings);
-        std::vector<Date> fixingDates(cases5[l].fixings);
-        timeIncrements[0] = cases5[l].first;
+        Time dt = l.length / (l.fixings - 1);
+        std::vector<Time> timeIncrements(l.fixings);
+        std::vector<Date> fixingDates(l.fixings);
+        timeIncrements[0] = l.first;
         fixingDates[0] = today + timeToDays(timeIncrements[0]);
-        for (Size i=1; i<cases5[l].fixings; i++) {
-            timeIncrements[i] = i*dt + cases5[l].first;
+        for (Size i = 1; i < l.fixings; i++) {
+            timeIncrements[i] = i * dt + l.first;
             fixingDates[i] = today + timeToDays(timeIncrements[i]);
         }
-        ext::shared_ptr<Exercise> exercise(new
-            EuropeanExercise(fixingDates[cases5[l].fixings-1]));
+        ext::shared_ptr<Exercise> exercise(new EuropeanExercise(fixingDates[l.fixings - 1]));
 
-        spot ->setValue(cases5[l].underlying);
-        qRate->setValue(cases5[l].dividendYield);
-        rRate->setValue(cases5[l].riskFreeRate);
-        vol  ->setValue(cases5[l].volatility);
+        spot->setValue(l.underlying);
+        qRate->setValue(l.dividendYield);
+        rRate->setValue(l.riskFreeRate);
+        vol->setValue(l.volatility);
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess(new
             BlackScholesMertonProcess(Handle<Quote>(spot),
@@ -1238,7 +1216,7 @@ void AsianOptionTest::testMCDiscreteArithmeticAverageStrike() {
         option.setPricingEngine(engine);
 
         Real calculated = option.NPV();
-        Real expected = cases5[l].result;
+        Real expected = l.result;
         Real tolerance = 2.0e-2;
         if (std::fabs(calculated-expected) > tolerance) {
             REPORT_FAILURE("value", averageType, runningSum, pastFixings,
@@ -1247,7 +1225,6 @@ void AsianOptionTest::testMCDiscreteArithmeticAverageStrike() {
                            vol->value(), expected, calculated, tolerance);
         }
     }
-
 }
 
 void AsianOptionTest::testAnalyticDiscreteGeometricAveragePriceGreeks() {
@@ -1287,129 +1264,116 @@ void AsianOptionTest::testAnalyticDiscreteGeometricAveragePriceGreeks() {
     ext::shared_ptr<BlackScholesMertonProcess> process(
          new BlackScholesMertonProcess(Handle<Quote>(spot), qTS, rTS, volTS));
 
-    for (Size i=0; i<LENGTH(types); i++) {
-      for (Size j=0; j<LENGTH(strikes); j++) {
-        for (Size k=0; k<LENGTH(lengths); k++) {
-
-            ext::shared_ptr<EuropeanExercise> maturity(
-                              new EuropeanExercise(today + lengths[k]*Years));
-
-            ext::shared_ptr<PlainVanillaPayoff> payoff(
-                                new PlainVanillaPayoff(types[i], strikes[j]));
-
-            Real runningAverage = 120;
-            Size pastFixings = 1;
-
-            std::vector<Date> fixingDates;
-            for (Date d = today + 3*Months;
-                      d <= maturity->lastDate();
-                      d += 3*Months)
-                fixingDates.push_back(d);
-
-
-            ext::shared_ptr<PricingEngine> engine(
-               new AnalyticDiscreteGeometricAveragePriceAsianEngine(process));
-
-            DiscreteAveragingAsianOption option(Average::Geometric,
-                                                runningAverage, pastFixings,
-                                                fixingDates, payoff, maturity);
-            option.setPricingEngine(engine);
-
-            for (Size l=0; l<LENGTH(underlyings); l++) {
-              for (Size m=0; m<LENGTH(qRates); m++) {
-                for (Size n=0; n<LENGTH(rRates); n++) {
-                  for (Size p=0; p<LENGTH(vols); p++) {
-
-                      Real u = underlyings[l];
-                      Rate q = qRates[m],
-                           r = rRates[n];
-                      Volatility v = vols[p];
-                      spot->setValue(u);
-                      qRate->setValue(q);
-                      rRate->setValue(r);
-                      vol->setValue(v);
-
-                      Real value = option.NPV();
-                      calculated["delta"]  = option.delta();
-                      calculated["gamma"]  = option.gamma();
-                      calculated["theta"]  = option.theta();
-                      calculated["rho"]    = option.rho();
-                      calculated["divRho"] = option.dividendRho();
-                      calculated["vega"]   = option.vega();
-
-                      if (value > spot->value()*1.0e-5) {
-                          // perturb spot and get delta and gamma
-                          Real du = u*1.0e-4;
-                          spot->setValue(u+du);
-                          Real value_p = option.NPV(),
-                               delta_p = option.delta();
-                          spot->setValue(u-du);
-                          Real value_m = option.NPV(),
-                               delta_m = option.delta();
-                          spot->setValue(u);
-                          expected["delta"] = (value_p - value_m)/(2*du);
-                          expected["gamma"] = (delta_p - delta_m)/(2*du);
-
-                          // perturb rates and get rho and dividend rho
-                          Spread dr = r*1.0e-4;
-                          rRate->setValue(r+dr);
-                          value_p = option.NPV();
-                          rRate->setValue(r-dr);
-                          value_m = option.NPV();
-                          rRate->setValue(r);
-                          expected["rho"] = (value_p - value_m)/(2*dr);
-
-                          Spread dq = q*1.0e-4;
-                          qRate->setValue(q+dq);
-                          value_p = option.NPV();
-                          qRate->setValue(q-dq);
-                          value_m = option.NPV();
-                          qRate->setValue(q);
-                          expected["divRho"] = (value_p - value_m)/(2*dq);
-
-                          // perturb volatility and get vega
-                          Volatility dv = v*1.0e-4;
-                          vol->setValue(v+dv);
-                          value_p = option.NPV();
-                          vol->setValue(v-dv);
-                          value_m = option.NPV();
-                          vol->setValue(v);
-                          expected["vega"] = (value_p - value_m)/(2*dv);
-
-                          // perturb date and get theta
-                          Time dT = dc.yearFraction(today-1, today+1);
-                          Settings::instance().evaluationDate() = today-1;
-                          value_m = option.NPV();
-                          Settings::instance().evaluationDate() = today+1;
-                          value_p = option.NPV();
-                          Settings::instance().evaluationDate() = today;
-                          expected["theta"] = (value_p - value_m)/dT;
-
-                          // compare
-                          std::map<std::string,Real>::iterator it;
-                          for (it = calculated.begin();
-                               it != calculated.end(); ++it) {
-                              std::string greek = it->first;
-                              Real expct = expected  [greek],
-                                   calcl = calculated[greek],
-                                   tol   = tolerance [greek];
-                              Real error = relativeError(expct,calcl,u);
-                              if (error>tol) {
-                                  REPORT_FAILURE(greek, Average::Geometric,
-                                                 runningAverage, pastFixings,
-                                                 std::vector<Date>(),
-                                                 payoff, maturity,
-                                                 u, q, r, today, v,
-                                                 expct, calcl, tol);
-                              }
-                          }
-                      }
-                  }
+    for (auto& type : types) {
+        for (double strike : strikes) {
+            for (int length : lengths) {
+
+                ext::shared_ptr<EuropeanExercise> maturity(
+                    new EuropeanExercise(today + length * Years));
+
+                ext::shared_ptr<PlainVanillaPayoff> payoff(new PlainVanillaPayoff(type, strike));
+
+                Real runningAverage = 120;
+                Size pastFixings = 1;
+
+                std::vector<Date> fixingDates;
+                for (Date d = today + 3 * Months; d <= maturity->lastDate(); d += 3 * Months)
+                    fixingDates.push_back(d);
+
+
+                ext::shared_ptr<PricingEngine> engine(
+                    new AnalyticDiscreteGeometricAveragePriceAsianEngine(process));
+
+                DiscreteAveragingAsianOption option(Average::Geometric, runningAverage, pastFixings,
+                                                    fixingDates, payoff, maturity);
+                option.setPricingEngine(engine);
+
+                for (double u : underlyings) {
+                    for (double m : qRates) {
+                        for (double n : rRates) {
+                            for (double v : vols) {
+
+                                Rate q = m, r = n;
+                                spot->setValue(u);
+                                qRate->setValue(q);
+                                rRate->setValue(r);
+                                vol->setValue(v);
+
+                                Real value = option.NPV();
+                                calculated["delta"] = option.delta();
+                                calculated["gamma"] = option.gamma();
+                                calculated["theta"] = option.theta();
+                                calculated["rho"] = option.rho();
+                                calculated["divRho"] = option.dividendRho();
+                                calculated["vega"] = option.vega();
+
+                                if (value > spot->value() * 1.0e-5) {
+                                    // perturb spot and get delta and gamma
+                                    Real du = u * 1.0e-4;
+                                    spot->setValue(u + du);
+                                    Real value_p = option.NPV(), delta_p = option.delta();
+                                    spot->setValue(u - du);
+                                    Real value_m = option.NPV(), delta_m = option.delta();
+                                    spot->setValue(u);
+                                    expected["delta"] = (value_p - value_m) / (2 * du);
+                                    expected["gamma"] = (delta_p - delta_m) / (2 * du);
+
+                                    // perturb rates and get rho and dividend rho
+                                    Spread dr = r * 1.0e-4;
+                                    rRate->setValue(r + dr);
+                                    value_p = option.NPV();
+                                    rRate->setValue(r - dr);
+                                    value_m = option.NPV();
+                                    rRate->setValue(r);
+                                    expected["rho"] = (value_p - value_m) / (2 * dr);
+
+                                    Spread dq = q * 1.0e-4;
+                                    qRate->setValue(q + dq);
+                                    value_p = option.NPV();
+                                    qRate->setValue(q - dq);
+                                    value_m = option.NPV();
+                                    qRate->setValue(q);
+                                    expected["divRho"] = (value_p - value_m) / (2 * dq);
+
+                                    // perturb volatility and get vega
+                                    Volatility dv = v * 1.0e-4;
+                                    vol->setValue(v + dv);
+                                    value_p = option.NPV();
+                                    vol->setValue(v - dv);
+                                    value_m = option.NPV();
+                                    vol->setValue(v);
+                                    expected["vega"] = (value_p - value_m) / (2 * dv);
+
+                                    // perturb date and get theta
+                                    Time dT = dc.yearFraction(today - 1, today + 1);
+                                    Settings::instance().evaluationDate() = today - 1;
+                                    value_m = option.NPV();
+                                    Settings::instance().evaluationDate() = today + 1;
+                                    value_p = option.NPV();
+                                    Settings::instance().evaluationDate() = today;
+                                    expected["theta"] = (value_p - value_m) / dT;
+
+                                    // compare
+                                    std::map<std::string, Real>::iterator it;
+                                    for (it = calculated.begin(); it != calculated.end(); ++it) {
+                                        std::string greek = it->first;
+                                        Real expct = expected[greek], calcl = calculated[greek],
+                                             tol = tolerance[greek];
+                                        Real error = relativeError(expct, calcl, u);
+                                        if (error > tol) {
+                                            REPORT_FAILURE(greek, Average::Geometric,
+                                                           runningAverage, pastFixings,
+                                                           std::vector<Date>(), payoff, maturity, u,
+                                                           q, r, today, v, expct, calcl, tol);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
                 }
-              }
             }
         }
-      }
     }
 }
 
@@ -1736,25 +1700,20 @@ void AsianOptionTest::testLevyEngine() {
     DayCounter dc = Actual360();
     Date today = Settings::instance().evaluationDate();
 
-    for (Size l=0; l<LENGTH(cases); l++) {
+    for (auto& l : cases) {
 
-        ext::shared_ptr<SimpleQuote> spot(new SimpleQuote(cases[l].spot));
-        ext::shared_ptr<YieldTermStructure> qTS =
-            flatRate(today, cases[l].dividendYield, dc);
-        ext::shared_ptr<YieldTermStructure> rTS =
-            flatRate(today, cases[l].riskFreeRate, dc);
-        ext::shared_ptr<BlackVolTermStructure> volTS =
-            flatVol(today, cases[l].volatility, dc);
+        ext::shared_ptr<SimpleQuote> spot(new SimpleQuote(l.spot));
+        ext::shared_ptr<YieldTermStructure> qTS = flatRate(today, l.dividendYield, dc);
+        ext::shared_ptr<YieldTermStructure> rTS = flatRate(today, l.riskFreeRate, dc);
+        ext::shared_ptr<BlackVolTermStructure> volTS = flatVol(today, l.volatility, dc);
 
         Average::Type averageType = Average::Arithmetic;
-        ext::shared_ptr<Quote> average(
-                                    new SimpleQuote(cases[l].currentAverage));
+        ext::shared_ptr<Quote> average(new SimpleQuote(l.currentAverage));
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(
-                      new PlainVanillaPayoff(cases[l].type, cases[l].strike));
+        ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(l.type, l.strike));
 
-        Date startDate = today - cases[l].elapsed;
-        Date maturity = startDate + cases[l].length;
+        Date startDate = today - l.elapsed;
+        Date maturity = startDate + l.length;
 
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(maturity));
 
@@ -1773,23 +1732,19 @@ void AsianOptionTest::testLevyEngine() {
         option.setPricingEngine(engine);
 
         Real calculated = option.NPV();
-        Real expected = cases[l].result;
+        Real expected = l.result;
         Real tolerance = 1.0e-4;
         Real error = std::fabs(expected-calculated);
         if (error > tolerance) {
-            BOOST_ERROR("Asian option with Levy engine:"
-                        << "\n    spot:            " << cases[l].spot
-                        << "\n    current average: " << cases[l].currentAverage
-                        << "\n    strike:          " << cases[l].strike
-                        << "\n    dividend yield:  " << cases[l].dividendYield
-                        << "\n    risk-free rate:  " << cases[l].riskFreeRate
-                        << "\n    volatility:      " << cases[l].volatility
-                        << "\n    reference date:  " << today
-                        << "\n    length:          " << cases[l].length
-                        << "\n    elapsed:         " << cases[l].elapsed
-                        << "\n    expected value:  " << expected
-                        << "\n    calculated:      " << calculated
-                        << "\n    error:           " << error);
+            BOOST_ERROR(
+                "Asian option with Levy engine:"
+                << "\n    spot:            " << l.spot << "\n    current average: "
+                << l.currentAverage << "\n    strike:          " << l.strike
+                << "\n    dividend yield:  " << l.dividendYield << "\n    risk-free rate:  "
+                << l.riskFreeRate << "\n    volatility:      " << l.volatility
+                << "\n    reference date:  " << today << "\n    length:          " << l.length
+                << "\n    elapsed:         " << l.elapsed << "\n    expected value:  " << expected
+                << "\n    calculated:      " << calculated << "\n    error:           " << error);
         }
     }
 }
@@ -1830,22 +1785,18 @@ void AsianOptionTest::testVecerEngine() {
     Size timeSteps = 200;
     Size assetSteps = 200;
 
-    for (Size i=0; i<LENGTH(cases); ++i) {
-        Handle<Quote> u(ext::make_shared<SimpleQuote>(cases[i].spot));
-        Handle<YieldTermStructure> r(flatRate(today,
-                                              cases[i].riskFreeRate,
-                                              dayCounter));
-        Handle<BlackVolTermStructure> sigma(flatVol(today,
-                                                    cases[i].volatility,
-                                                    dayCounter));
+    for (auto& i : cases) {
+        Handle<Quote> u(ext::make_shared<SimpleQuote>(i.spot));
+        Handle<YieldTermStructure> r(flatRate(today, i.riskFreeRate, dayCounter));
+        Handle<BlackVolTermStructure> sigma(flatVol(today, i.volatility, dayCounter));
         ext::shared_ptr<BlackScholesMertonProcess> process =
             ext::make_shared<BlackScholesMertonProcess>(u, q, r, sigma);
 
-        Date maturity = today + cases[i].length*360;
+        Date maturity = today + i.length * 360;
         ext::shared_ptr<Exercise> exercise =
             ext::make_shared<EuropeanExercise>(maturity);
         ext::shared_ptr<StrikedTypePayoff> payoff =
-            ext::make_shared<PlainVanillaPayoff>(type, cases[i].strike);
+            ext::make_shared<PlainVanillaPayoff>(type, i.strike);
         Handle<Quote> average(ext::make_shared<SimpleQuote>(0.0));
 
         ContinuousAveragingAsianOption option(Average::Arithmetic,
@@ -1855,14 +1806,12 @@ void AsianOptionTest::testVecerEngine() {
                 process,average,today,timeSteps,assetSteps,-1.0,1.0));
 
         Real calculated = option.NPV();
-        Real error = std::fabs(calculated - cases[i].result);
-        if (error > cases[i].tolerance)
+        Real error = std::fabs(calculated - i.result);
+        if (error > i.tolerance)
             BOOST_ERROR("Failed to reproduce expected NPV"
-                        << "\n    calculated: " << calculated
-                        << "\n    expected:   " << cases[i].result
-                        << "\n    expected:   " << cases[i].result
-                        << "\n    error:      " << error
-                        << "\n    tolerance:  " << cases[i].tolerance);
+                        << "\n    calculated: " << calculated << "\n    expected:   " << i.result
+                        << "\n    expected:   " << i.result << "\n    error:      " << error
+                        << "\n    tolerance:  " << i.tolerance);
     }
 }
 
diff --git a/test-suite/barrieroption.cpp b/test-suite/barrieroption.cpp
index 14c4f03e9e5..76ac7fb6189 100644
--- a/test-suite/barrieroption.cpp
+++ b/test-suite/barrieroption.cpp
@@ -390,17 +390,16 @@ void BarrierOptionTest::testHaugValues() {
     ext::shared_ptr<SimpleQuote> vol = ext::make_shared<SimpleQuote>(0.0);
     ext::shared_ptr<BlackVolTermStructure> volTS = flatVol(today, vol, dc);
 
-    for (Size i=0; i<LENGTH(values); i++) {
-        Date exDate = today + timeToDays(values[i].t);
+    for (auto& value : values) {
+        Date exDate = today + timeToDays(value.t);
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
         ext::shared_ptr<StrikedTypePayoff> payoff =
-            ext::make_shared<PlainVanillaPayoff>(values[i].type,
-                                                   values[i].strike);
+            ext::make_shared<PlainVanillaPayoff>(value.type, value.strike);
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess =
             ext::make_shared<BlackScholesMertonProcess>(
@@ -410,64 +409,57 @@ void BarrierOptionTest::testHaugValues() {
                                       Handle<BlackVolTermStructure>(volTS));
 
         ext::shared_ptr<Exercise> exercise;
-        if (values[i].exType == Exercise::European)
+        if (value.exType == Exercise::European)
             exercise = ext::make_shared<EuropeanExercise>(exDate);
         else
             exercise = ext::make_shared<AmericanExercise>(exDate);
 
-        BarrierOption barrierOption(
-                values[i].barrierType,
-                values[i].barrier,
-                values[i].rebate,
-                payoff,
-                exercise);
+        BarrierOption barrierOption(value.barrierType, value.barrier, value.rebate, payoff,
+                                    exercise);
 
         ext::shared_ptr<PricingEngine> engine;
         Real calculated;
         Real expected;
         Real error;
-        if (values[i].exType == Exercise::European) {
-           // these engines support only european options
-           engine = ext::make_shared<AnalyticBarrierEngine>(stochProcess);
-
-           barrierOption.setPricingEngine(engine);
-
-           Real calculated = barrierOption.NPV();
-           Real expected = values[i].result;
-           Real error = std::fabs(calculated-expected);
-           if (error>values[i].tol) {
-               REPORT_FAILURE("value", values[i].barrierType, values[i].barrier,
-                              values[i].rebate, payoff, exercise, values[i].s,
-                              values[i].q, values[i].r, today, values[i].v,
-                              expected, calculated, error, values[i].tol);
-           }
-
-           engine = ext::make_shared<FdBlackScholesBarrierEngine>(stochProcess, 200, 400);
-           barrierOption.setPricingEngine(engine);
-
-           calculated = barrierOption.NPV();
-           expected = values[i].result;
-           error = std::fabs(calculated-expected);
-           if (error>5.0e-3) {
-               REPORT_FAILURE("fd value", values[i].barrierType, values[i].barrier,
-                              values[i].rebate, payoff, exercise, values[i].s,
-                              values[i].q, values[i].r, today, values[i].v,
-                              expected, calculated, error, values[i].tol);
-           }
+        if (value.exType == Exercise::European) {
+            // these engines support only european options
+            engine = ext::make_shared<AnalyticBarrierEngine>(stochProcess);
+
+            barrierOption.setPricingEngine(engine);
+
+            Real calculated = barrierOption.NPV();
+            Real expected = value.result;
+            Real error = std::fabs(calculated - expected);
+            if (error > value.tol) {
+                REPORT_FAILURE("value", value.barrierType, value.barrier, value.rebate, payoff,
+                               exercise, value.s, value.q, value.r, today, value.v, expected,
+                               calculated, error, value.tol);
+            }
+
+            engine = ext::make_shared<FdBlackScholesBarrierEngine>(stochProcess, 200, 400);
+            barrierOption.setPricingEngine(engine);
+
+            calculated = barrierOption.NPV();
+            expected = value.result;
+            error = std::fabs(calculated - expected);
+            if (error > 5.0e-3) {
+                REPORT_FAILURE("fd value", value.barrierType, value.barrier, value.rebate, payoff,
+                               exercise, value.s, value.q, value.r, today, value.v, expected,
+                               calculated, error, value.tol);
+            }
         }
 
         engine = ext::make_shared<BinomialBarrierEngine<CoxRossRubinstein,DiscretizedBarrierOption> >(stochProcess, 400);
         barrierOption.setPricingEngine(engine);
 
         calculated = barrierOption.NPV();
-        expected = values[i].result;
+        expected = value.result;
         error = std::fabs(calculated-expected);
         double tol = 1.1e-2;
         if (error>tol) {
-            REPORT_FAILURE("Binomial (Boyle-lau) value", values[i].barrierType, values[i].barrier,
-                           values[i].rebate, payoff, exercise, values[i].s,
-                           values[i].q, values[i].r, today, values[i].v,
-                           expected, calculated, error, tol);
+            REPORT_FAILURE("Binomial (Boyle-lau) value", value.barrierType, value.barrier,
+                           value.rebate, payoff, exercise, value.s, value.q, value.r, today,
+                           value.v, expected, calculated, error, tol);
         }
 
         // Note: here, to test Derman convergence, we force maxTimeSteps to 
@@ -477,14 +469,13 @@ void BarrierOptionTest::testHaugValues() {
         engine = ext::make_shared<BinomialBarrierEngine<CoxRossRubinstein,DiscretizedDermanKaniBarrierOption> >(stochProcess, 400);
         barrierOption.setPricingEngine(engine);
         calculated = barrierOption.NPV();
-        expected = values[i].result;
+        expected = value.result;
         error = std::fabs(calculated-expected);
         tol = 4e-2;
         if (error>tol) {
-            REPORT_FAILURE("Binomial (Derman) value", values[i].barrierType, values[i].barrier,
-                           values[i].rebate, payoff, exercise, values[i].s,
-                           values[i].q, values[i].r, today, values[i].v,
-                           expected, calculated, error, tol);
+            REPORT_FAILURE("Binomial (Derman) value", value.barrierType, value.barrier,
+                           value.rebate, payoff, exercise, value.s, value.q, value.r, today,
+                           value.v, expected, calculated, error, tol);
         }
     }
 }
@@ -539,12 +530,11 @@ void BarrierOptionTest::testBabsiriValues() {
     ext::shared_ptr<Exercise> exercise =
         ext::make_shared<EuropeanExercise>(exDate);
 
-    for (Size i=0; i<LENGTH(values); i++) {
-        volatility->setValue(values[i].volatility);
+    for (auto& value : values) {
+        volatility->setValue(value.volatility);
 
         ext::shared_ptr<StrikedTypePayoff> callPayoff =
-            ext::make_shared<PlainVanillaPayoff>(Option::Call,
-                                                   values[i].strike);
+            ext::make_shared<PlainVanillaPayoff>(Option::Call, value.strike);
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess =
             ext::make_shared<BlackScholesMertonProcess>(
@@ -558,22 +548,16 @@ void BarrierOptionTest::testBabsiriValues() {
             ext::make_shared<AnalyticBarrierEngine>(stochProcess);
 
         // analytic
-        BarrierOption barrierCallOption(
-                values[i].type,
-                values[i].barrier,
-                rebate,
-                callPayoff,
-                exercise);
+        BarrierOption barrierCallOption(value.type, value.barrier, rebate, callPayoff, exercise);
         barrierCallOption.setPricingEngine(engine);
         Real calculated = barrierCallOption.NPV();
-        Real expected = values[i].callValue;
+        Real expected = value.callValue;
         Real error = std::fabs(calculated-expected);
         Real maxErrorAllowed = 1.0e-5;
         if (error>maxErrorAllowed) {
-            REPORT_FAILURE("value", values[i].type, values[i].barrier,
-                           rebate, callPayoff, exercise, underlyingPrice,
-                           q, r, today, values[i].volatility,
-                           expected, calculated, error, maxErrorAllowed);
+            REPORT_FAILURE("value", value.type, value.barrier, rebate, callPayoff, exercise,
+                           underlyingPrice, q, r, today, value.volatility, expected, calculated,
+                           error, maxErrorAllowed);
         }
 
         Real maxMcRelativeErrorAllowed = 2.0e-2;
@@ -590,13 +574,10 @@ void BarrierOptionTest::testBabsiriValues() {
         calculated = barrierCallOption.NPV();
         error = std::fabs(calculated-expected)/expected;
         if (error>maxMcRelativeErrorAllowed) {
-            REPORT_FAILURE("value", values[i].type, values[i].barrier,
-                           rebate, callPayoff, exercise, underlyingPrice,
-                           q, r, today, values[i].volatility,
-                           expected, calculated, error,
-                           maxMcRelativeErrorAllowed);
+            REPORT_FAILURE("value", value.type, value.barrier, rebate, callPayoff, exercise,
+                           underlyingPrice, q, r, today, value.volatility, expected, calculated,
+                           error, maxMcRelativeErrorAllowed);
         }
-
     }
 }
 
@@ -644,12 +625,11 @@ void BarrierOptionTest::testBeagleholeValues() {
     ext::shared_ptr<Exercise> exercise =
         ext::make_shared<EuropeanExercise>(exDate);
 
-    for (Size i=0; i<LENGTH(values); i++) {
-        volatility->setValue(values[i].volatility);
+    for (auto& value : values) {
+        volatility->setValue(value.volatility);
 
         ext::shared_ptr<StrikedTypePayoff> callPayoff =
-            ext::make_shared<PlainVanillaPayoff>(Option::Call,
-                                                   values[i].strike);
+            ext::make_shared<PlainVanillaPayoff>(Option::Call, value.strike);
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess =
             ext::make_shared<BlackScholesMertonProcess>(
@@ -661,22 +641,16 @@ void BarrierOptionTest::testBeagleholeValues() {
         ext::shared_ptr<PricingEngine> engine =
             ext::make_shared<AnalyticBarrierEngine>(stochProcess);
 
-        BarrierOption barrierCallOption(
-                values[i].type,
-                values[i].barrier,
-                rebate,
-                callPayoff,
-                exercise);
+        BarrierOption barrierCallOption(value.type, value.barrier, rebate, callPayoff, exercise);
         barrierCallOption.setPricingEngine(engine);
         Real calculated = barrierCallOption.NPV();
-        Real expected = values[i].callValue;
+        Real expected = value.callValue;
         Real maxErrorAllowed = 1.0e-3;
         Real error = std::fabs(calculated-expected);
         if (error > maxErrorAllowed) {
-            REPORT_FAILURE("value", values[i].type, values[i].barrier,
-                           rebate, callPayoff, exercise, underlyingPrice,
-                           q, r, today, values[i].volatility,
-                           expected, calculated, error, maxErrorAllowed);
+            REPORT_FAILURE("value", value.type, value.barrier, rebate, callPayoff, exercise,
+                           underlyingPrice, q, r, today, value.volatility, expected, calculated,
+                           error, maxErrorAllowed);
         }
 
         Real maxMcRelativeErrorAllowed = 0.01;
@@ -692,11 +666,9 @@ void BarrierOptionTest::testBeagleholeValues() {
         calculated = barrierCallOption.NPV();
         error = std::fabs(calculated-expected)/expected;
         if (error>maxMcRelativeErrorAllowed) {
-            REPORT_FAILURE("value", values[i].type, values[i].barrier,
-                           rebate, callPayoff, exercise, underlyingPrice,
-                           q, r, today, values[i].volatility,
-                           expected, calculated, error,
-                           maxMcRelativeErrorAllowed);
+            REPORT_FAILURE("value", value.type, value.barrier, rebate, callPayoff, exercise,
+                           underlyingPrice, q, r, today, value.volatility, expected, calculated,
+                           error, maxMcRelativeErrorAllowed);
         }
     }
 }
@@ -1102,56 +1074,38 @@ void BarrierOptionTest::testVannaVolgaSimpleBarrierValues() {
     ext::shared_ptr<SimpleQuote> volAtm = ext::make_shared<SimpleQuote>(0.0);
     ext::shared_ptr<SimpleQuote> vol25Call = ext::make_shared<SimpleQuote>(0.0);
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        spot->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol25Put->setValue(values[i].vol25Put);
-        volAtm->setValue(values[i].volAtm);
-        vol25Call->setValue(values[i].vol25Call);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol25Put->setValue(value.vol25Put);
+        volAtm->setValue(value.volAtm);
+        vol25Call->setValue(value.vol25Call);
 
         ext::shared_ptr<StrikedTypePayoff> payoff =
-            ext::make_shared<PlainVanillaPayoff>(values[i].type,
-                                                 values[i].strike);
+            ext::make_shared<PlainVanillaPayoff>(value.type, value.strike);
 
-        Date exDate = today + timeToDays(values[i].t, 365);
+        Date exDate = today + timeToDays(value.t, 365);
         ext::shared_ptr<Exercise> exercise =
             ext::make_shared<EuropeanExercise>(exDate);
 
-        Handle<DeltaVolQuote> volAtmQuote = Handle<DeltaVolQuote>(
-						ext::make_shared<DeltaVolQuote>(
-							Handle<Quote>(volAtm),
-							DeltaVolQuote::Fwd,
-							values[i].t,
-							DeltaVolQuote::AtmDeltaNeutral));
-
-        Handle<DeltaVolQuote> vol25PutQuote(Handle<DeltaVolQuote>(
-						ext::make_shared<DeltaVolQuote>(
-							-0.25,
-							Handle<Quote>(vol25Put),
-							values[i].t,
-							DeltaVolQuote::Fwd
-							)));
-
-        Handle<DeltaVolQuote> vol25CallQuote(Handle<DeltaVolQuote>(
-						ext::make_shared<DeltaVolQuote>(
-							0.25,
-							Handle<Quote>(vol25Call),
-							values[i].t,
-							DeltaVolQuote::Fwd
-							)));
-
-        BarrierOption barrierOption(values[i].barrierType,
-                                    values[i].barrier,
-                                    values[i].rebate,
-                                    payoff,
+        Handle<DeltaVolQuote> volAtmQuote = Handle<DeltaVolQuote>(ext::make_shared<DeltaVolQuote>(
+            Handle<Quote>(volAtm), DeltaVolQuote::Fwd, value.t, DeltaVolQuote::AtmDeltaNeutral));
+
+        Handle<DeltaVolQuote> vol25PutQuote(Handle<DeltaVolQuote>(ext::make_shared<DeltaVolQuote>(
+            -0.25, Handle<Quote>(vol25Put), value.t, DeltaVolQuote::Fwd)));
+
+        Handle<DeltaVolQuote> vol25CallQuote(Handle<DeltaVolQuote>(ext::make_shared<DeltaVolQuote>(
+            0.25, Handle<Quote>(vol25Call), value.t, DeltaVolQuote::Fwd)));
+
+        BarrierOption barrierOption(value.barrierType, value.barrier, value.rebate, payoff,
                                     exercise);
 
         Real bsVanillaPrice =
-            blackFormula(values[i].type, values[i].strike,
-                         spot->value()*qTS->discount(values[i].t)/rTS->discount(values[i].t),
-						 values[i].v * sqrt(values[i].t), rTS->discount(values[i].t));
+            blackFormula(value.type, value.strike,
+                         spot->value() * qTS->discount(value.t) / rTS->discount(value.t),
+                         value.v * sqrt(value.t), rTS->discount(value.t));
         ext::shared_ptr<PricingEngine> vannaVolgaEngine =
             ext::make_shared<VannaVolgaBarrierEngine>(
                             volAtmQuote,
@@ -1165,15 +1119,13 @@ void BarrierOptionTest::testVannaVolgaSimpleBarrierValues() {
         barrierOption.setPricingEngine(vannaVolgaEngine);
 
         Real calculated = barrierOption.NPV();
-        Real expected = values[i].result;
+        Real expected = value.result;
         Real error = std::fabs(calculated-expected);
-        if (error>values[i].tol) {
-            REPORT_FX_FAILURE(
-                "value", values[i].barrierType, values[i].barrier,
-                values[i].rebate, payoff, exercise, values[i].s,
-                values[i].q, values[i].r, today, values[i].vol25Put,
-                values[i].volAtm, values[i].vol25Call, values[i].v,
-                expected, calculated, error, values[i].tol);
+        if (error > value.tol) {
+            REPORT_FX_FAILURE("value", value.barrierType, value.barrier, value.rebate, payoff,
+                              exercise, value.s, value.q, value.r, today, value.vol25Put,
+                              value.volAtm, value.vol25Call, value.v, expected, calculated, error,
+                              value.tol);
         }
     }
 }
@@ -1262,7 +1214,7 @@ void BarrierOptionTest::testDividendBarrierOption() {
 
     const Real relTol = 1e-4;
     for (Size i=0; i < LENGTH(barriers); ++i) {
-        for (Size j=0; j < LENGTH(engines); ++j) {
+        for (const auto& engine : engines) {
             const Real barrier = barriers[i];
             const Barrier::Type barrierType = barrierTypes[i];
 
@@ -1271,7 +1223,7 @@ void BarrierOptionTest::testDividendBarrierOption() {
                 std::vector<Date>(1, divDate),
                 std::vector<Real>(1, divAmount));
 
-            barrierOption.setPricingEngine(engines[j]);
+            barrierOption.setPricingEngine(engine);
 
             const Real calculated = barrierOption.NPV();
 
diff --git a/test-suite/basismodels.cpp b/test-suite/basismodels.cpp
index 9467b1a2508..d160430bbab 100644
--- a/test-suite/basismodels.cpp
+++ b/test-suite/basismodels.cpp
@@ -66,11 +66,12 @@ namespace {
                                       const Real spread = 0.0) {
         Date today = Settings::instance().evaluationDate();
         std::vector<Date> dates;
-        for (Size k = 0; k < terms.size(); ++k)
-            dates.push_back(NullCalendar().advance(today, terms[k], Unadjusted));
+        dates.reserve(terms.size());
+        for (auto term : terms)
+            dates.push_back(NullCalendar().advance(today, term, Unadjusted));
         std::vector<Real> ratesPlusSpread(rates);
-        for (Size k = 0; k < ratesPlusSpread.size(); ++k)
-            ratesPlusSpread[k] += spread;
+        for (double& k : ratesPlusSpread)
+            k += spread;
         ext::shared_ptr<YieldTermStructure> ts =
             ext::shared_ptr<YieldTermStructure>(new InterpolatedZeroCurve<Cubic>(
                 dates, ratesPlusSpread, Actual365Fixed(), NullCalendar()));
@@ -111,8 +112,9 @@ namespace {
     Handle<OptionletVolatilityStructure> getOptionletTS() {
         Date today = Settings::instance().evaluationDate();
         std::vector<Date> dates;
-        for (Size k = 0; k < capletTerms.size(); ++k)
-            dates.push_back(TARGET().advance(today, capletTerms[k], Following));
+        dates.reserve(capletTerms.size());
+        for (auto& capletTerm : capletTerms)
+            dates.push_back(TARGET().advance(today, capletTerm, Following));
         // set up vol data manually
         std::vector<std::vector<Real> > capletVols;
         capletVols.push_back(std::vector<Real>(cplRow01, cplRow01 + 8));
@@ -127,11 +129,11 @@ namespace {
         capletVols.push_back(std::vector<Real>(cplRow10, cplRow10 + 8));
         // create quotes
         std::vector<std::vector<Handle<Quote> > > capletVolQuotes;
-        for (Size i = 0; i < capletVols.size(); ++i) {
+        for (auto& capletVol : capletVols) {
             std::vector<Handle<Quote> > row;
-            for (Size j = 0; j < capletVols[i].size(); ++j)
-                row.push_back(RelinkableHandle<Quote>(
-                    ext::shared_ptr<Quote>(new SimpleQuote(capletVols[i][j]))));
+            row.reserve(capletVol.size());
+            for (double j : capletVol)
+                row.push_back(RelinkableHandle<Quote>(ext::shared_ptr<Quote>(new SimpleQuote(j))));
             capletVolQuotes.push_back(row);
         }
         Handle<YieldTermStructure> curve3m = getYTS(terms, proj3mRates);
@@ -162,11 +164,11 @@ namespace {
         swaptionVols.push_back(std::vector<Real>(swtRow04, swtRow04 + 5));
         swaptionVols.push_back(std::vector<Real>(swtRow05, swtRow05 + 5));
         std::vector<std::vector<Handle<Quote> > > swaptionVolQuotes;
-        for (Size i = 0; i < swaptionVols.size(); ++i) {
+        for (auto& swaptionVol : swaptionVols) {
             std::vector<Handle<Quote> > row;
-            for (Size j = 0; j < swaptionVols[i].size(); ++j)
-                row.push_back(RelinkableHandle<Quote>(
-                    ext::shared_ptr<Quote>(new SimpleQuote(swaptionVols[i][j]))));
+            row.reserve(swaptionVol.size());
+            for (double j : swaptionVol)
+                row.push_back(RelinkableHandle<Quote>(ext::shared_ptr<Quote>(new SimpleQuote(j))));
             swaptionVolQuotes.push_back(row);
         }
         ext::shared_ptr<SwaptionVolatilityStructure> tmp(
@@ -288,19 +290,19 @@ void BasismodelsTest::testTenoroptionletvts() {
         // now we can set up the new volTS and calculate volatilities
         ext::shared_ptr<OptionletVolatilityStructure> optionletVTS6m(
             new TenorOptionletVTS(optionletVTS3m, euribor3m, euribor6m, corr));
-        for (Size i = 0; i < capletTerms.size(); ++i) {
-            for (Size j = 0; j < capletStrikes.size(); ++j) {
-                Real vol3m = optionletVTS3m->volatility(capletTerms[i], capletStrikes[j], true);
-                Real vol6m = optionletVTS6m->volatility(capletTerms[i], capletStrikes[j], true);
+        for (auto& capletTerm : capletTerms) {
+            for (double& capletStrike : capletStrikes) {
+                Real vol3m = optionletVTS3m->volatility(capletTerm, capletStrike, true);
+                Real vol6m = optionletVTS6m->volatility(capletTerm, capletStrike, true);
                 Real vol6mShifted =
-                    optionletVTS6m->volatility(capletTerms[i], capletStrikes[j] + spread, true);
+                    optionletVTS6m->volatility(capletTerm, capletStrike + spread, true);
                 // De-correlation yields that larger tenor shifted vols are smaller then shorter
                 // tenor vols
                 if (vol6mShifted - vol3m >
                     0.0001) // we leave 1bp tolerance due to simplified spread calculation
                     BOOST_ERROR("Shifted 6m vol significantly larger then 3m vol at\n"
-                                << "expiry term: " << capletTerms[i]
-                                << ", strike: " << capletStrikes[j] << "\n"
+                                << "expiry term: " << capletTerm << ", strike: " << capletStrike
+                                << "\n"
                                 << "vol3m: " << vol3m << ", vol6m: " << vol6m
                                 << ", vol6mShifted: " << vol6mShifted << "\n");
             }
@@ -324,19 +326,19 @@ void BasismodelsTest::testTenoroptionletvts() {
         ext::shared_ptr<OptionletVolatilityStructure> optionletVTS6m(
             new TenorOptionletVTS(optionletVTS3m, euribor3m, euribor6m, corr));
         for (Size i = 0; i < capletTerms.size(); ++i) {
-            for (Size j = 0; j < capletStrikes.size(); ++j) {
-                Real vol3m = optionletVTS3m->volatility(capletTerms[i], capletStrikes[j], true);
-                Real vol6m = optionletVTS6m->volatility(capletTerms[i], capletStrikes[j], true);
+            for (double& capletStrike : capletStrikes) {
+                Real vol3m = optionletVTS3m->volatility(capletTerms[i], capletStrike, true);
+                Real vol6m = optionletVTS6m->volatility(capletTerms[i], capletStrike, true);
                 Real vol6mShifted =
-                    optionletVTS6m->volatility(capletTerms[i], capletStrikes[j] + spread, true);
+                    optionletVTS6m->volatility(capletTerms[i], capletStrike + spread, true);
                 // for perfect correlation shifted 6m vols should coincide with 3m vols
                 Real tol =
                     (i < 3) ? (0.001) :
                               (0.0001); // 10bp tol for smaller tenors and 1bp tol for larger tenors
                 if (fabs(vol6mShifted - vol3m) > tol)
                     BOOST_ERROR("Shifted 6m vol does not match 3m vol for perfect correlation at\n"
-                                << "expiry term: " << capletTerms[i]
-                                << ", strike: " << capletStrikes[j] << "\n"
+                                << "expiry term: " << capletTerms[i] << ", strike: " << capletStrike
+                                << "\n"
                                 << "vol3m: " << vol3m << ", vol6m: " << vol6m
                                 << ", vol6mShifted: " << vol6mShifted << "\n");
             }
diff --git a/test-suite/basketoption.cpp b/test-suite/basketoption.cpp
index 1a6cd7c8bdd..a1192d8edac 100644
--- a/test-suite/basketoption.cpp
+++ b/test-suite/basketoption.cpp
@@ -279,67 +279,57 @@ void BasketOptionTest::testEuroTwoValues() {
     const Real mcRelativeErrorTolerance = 0.01;
     const Real fdRelativeErrorTolerance = 0.01;
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        ext::shared_ptr<PlainVanillaPayoff> payoff(new
-            PlainVanillaPayoff(values[i].type, values[i].strike));
+        ext::shared_ptr<PlainVanillaPayoff> payoff(
+            new PlainVanillaPayoff(value.type, value.strike));
 
-        Date exDate = today + timeToDays(values[i].t);
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-        spot1 ->setValue(values[i].s1);
-        spot2 ->setValue(values[i].s2);
-        qRate1->setValue(values[i].q1);
-        qRate2->setValue(values[i].q2);
-        rRate ->setValue(values[i].r );
-        vol1  ->setValue(values[i].v1);
-        vol2  ->setValue(values[i].v2);
+        spot1->setValue(value.s1);
+        spot2->setValue(value.s2);
+        qRate1->setValue(value.q1);
+        qRate2->setValue(value.q2);
+        rRate->setValue(value.r);
+        vol1->setValue(value.v1);
+        vol2->setValue(value.v2);
+
 
-        
         ext::shared_ptr<PricingEngine> analyticEngine;
         ext::shared_ptr<GeneralizedBlackScholesProcess> p1, p2;
-        switch(values[i].basketType) {
-          case MaxBasket: 
-          case MinBasket:
-            p1 = ext::shared_ptr<GeneralizedBlackScholesProcess>(
-                new BlackScholesMertonProcess(
-                                        Handle<Quote>(spot1),
-                                        Handle<YieldTermStructure>(qTS1),
-                                        Handle<YieldTermStructure>(rTS),
-                                        Handle<BlackVolTermStructure>(volTS1)));
-            p2 = ext::shared_ptr<GeneralizedBlackScholesProcess>(
-                new BlackScholesMertonProcess(
-                                        Handle<Quote>(spot2),
-                                        Handle<YieldTermStructure>(qTS2),
-                                        Handle<YieldTermStructure>(rTS),
-                                        Handle<BlackVolTermStructure>(volTS2)));
-            analyticEngine=ext::shared_ptr<PricingEngine>(
-                new StulzEngine(p1, p2, values[i].rho));
-            break;
-          case SpreadBasket:
-              p1 = ext::shared_ptr<GeneralizedBlackScholesProcess>(
-                  new BlackProcess(Handle<Quote>(spot1),
-                                   Handle<YieldTermStructure>(rTS),
-                                   Handle<BlackVolTermStructure>(volTS1)));
-              p2 = ext::shared_ptr<GeneralizedBlackScholesProcess>(
-                  new BlackProcess(Handle<Quote>(spot2),
-                                   Handle<YieldTermStructure>(rTS),
-                                   Handle<BlackVolTermStructure>(volTS2)));
-              
-              analyticEngine=ext::shared_ptr<PricingEngine>(
-                  new KirkEngine(ext::dynamic_pointer_cast<BlackProcess>(p1), 
-                                 ext::dynamic_pointer_cast<BlackProcess>(p2), 
-                                 values[i].rho));
-            break;
-          default:
-              QL_FAIL("unknown basket type");
+        switch (value.basketType) {
+            case MaxBasket:
+            case MinBasket:
+                p1 = ext::shared_ptr<GeneralizedBlackScholesProcess>(new BlackScholesMertonProcess(
+                    Handle<Quote>(spot1), Handle<YieldTermStructure>(qTS1),
+                    Handle<YieldTermStructure>(rTS), Handle<BlackVolTermStructure>(volTS1)));
+                p2 = ext::shared_ptr<GeneralizedBlackScholesProcess>(new BlackScholesMertonProcess(
+                    Handle<Quote>(spot2), Handle<YieldTermStructure>(qTS2),
+                    Handle<YieldTermStructure>(rTS), Handle<BlackVolTermStructure>(volTS2)));
+                analyticEngine = ext::shared_ptr<PricingEngine>(new StulzEngine(p1, p2, value.rho));
+                break;
+            case SpreadBasket:
+                p1 = ext::shared_ptr<GeneralizedBlackScholesProcess>(
+                    new BlackProcess(Handle<Quote>(spot1), Handle<YieldTermStructure>(rTS),
+                                     Handle<BlackVolTermStructure>(volTS1)));
+                p2 = ext::shared_ptr<GeneralizedBlackScholesProcess>(
+                    new BlackProcess(Handle<Quote>(spot2), Handle<YieldTermStructure>(rTS),
+                                     Handle<BlackVolTermStructure>(volTS2)));
+
+                analyticEngine = ext::shared_ptr<PricingEngine>(
+                    new KirkEngine(ext::dynamic_pointer_cast<BlackProcess>(p1),
+                                   ext::dynamic_pointer_cast<BlackProcess>(p2), value.rho));
+                break;
+            default:
+                QL_FAIL("unknown basket type");
         }
-        
+
         std::vector<ext::shared_ptr<StochasticProcess1D> > procs;
         procs.push_back(p1);
         procs.push_back(p2);
 
-        Matrix correlationMatrix(2,2, values[i].rho);
+        Matrix correlationMatrix(2, 2, value.rho);
         for (Integer j=0; j < 2; j++) {
             correlationMatrix[j][j] = 1.0;
         }
@@ -354,24 +344,19 @@ void BasketOptionTest::testEuroTwoValues() {
             .withSeed(42);
 
         ext::shared_ptr<PricingEngine> fdEngine(
-                    new Fd2dBlackScholesVanillaEngine(p1, p2, values[i].rho,
-                                                      50, 50, 15));
-        
-        BasketOption basketOption(basketTypeToPayoff(values[i].basketType,
-                                                     payoff),
-                                  exercise);
+            new Fd2dBlackScholesVanillaEngine(p1, p2, value.rho, 50, 50, 15));
+
+        BasketOption basketOption(basketTypeToPayoff(value.basketType, payoff), exercise);
 
         // analytic engine
         basketOption.setPricingEngine(analyticEngine);
         Real calculated = basketOption.NPV();
-        Real expected = values[i].result;
+        Real expected = value.result;
         Real error = std::fabs(calculated-expected);
-        if (error > values[i].tol) {
-            REPORT_FAILURE_2("value", values[i].basketType, payoff, exercise,
-                             values[i].s1, values[i].s2, values[i].q1,
-                             values[i].q2, values[i].r, today, values[i].v1,
-                             values[i].v2, values[i].rho, values[i].result,
-                             calculated, error, values[i].tol);
+        if (error > value.tol) {
+            REPORT_FAILURE_2("value", value.basketType, payoff, exercise, value.s1, value.s2,
+                             value.q1, value.q2, value.r, today, value.v1, value.v2, value.rho,
+                             value.result, calculated, error, value.tol);
         }
 
         // fd engine
@@ -379,27 +364,20 @@ void BasketOptionTest::testEuroTwoValues() {
         calculated = basketOption.NPV();
         Real relError = relativeError(calculated, expected, expected);
         if (relError > mcRelativeErrorTolerance ) {
-            REPORT_FAILURE_2("FD value", values[i].basketType, payoff,
-                             exercise, values[i].s1, values[i].s2,
-                             values[i].q1, values[i].q2, values[i].r,
-                             today, values[i].v1, values[i].v2, values[i].rho,
-                             values[i].result, calculated, relError,
-                             fdRelativeErrorTolerance);
+            REPORT_FAILURE_2("FD value", value.basketType, payoff, exercise, value.s1, value.s2,
+                             value.q1, value.q2, value.r, today, value.v1, value.v2, value.rho,
+                             value.result, calculated, relError, fdRelativeErrorTolerance);
         }
 
         // mc engine
         basketOption.setPricingEngine(mcEngine);
         calculated = basketOption.NPV();
-        relError = relativeError(calculated, expected, values[i].s1);
+        relError = relativeError(calculated, expected, value.s1);
         if (relError > mcRelativeErrorTolerance ) {
-            REPORT_FAILURE_2("MC value", values[i].basketType, payoff,
-                             exercise, values[i].s1, values[i].s2,
-                             values[i].q1, values[i].q2, values[i].r,
-                             today, values[i].v1, values[i].v2, values[i].rho,
-                             values[i].result, calculated, relError,
-                             mcRelativeErrorTolerance);
+            REPORT_FAILURE_2("MC value", value.basketType, payoff, exercise, value.s1, value.s2,
+                             value.q1, value.q2, value.r, today, value.v1, value.v2, value.rho,
+                             value.result, calculated, relError, mcRelativeErrorTolerance);
         }
-
     }
 }
 
@@ -509,23 +487,23 @@ void BasketOptionTest::testBarraquandThreeValues() {
     ext::shared_ptr<SimpleQuote> vol3(new SimpleQuote(0.0));
     ext::shared_ptr<BlackVolTermStructure> volTS3 = flatVol(today, vol3, dc);
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        ext::shared_ptr<PlainVanillaPayoff> payoff(new
-            PlainVanillaPayoff(values[i].type, values[i].strike));
+        ext::shared_ptr<PlainVanillaPayoff> payoff(
+            new PlainVanillaPayoff(value.type, value.strike));
 
-        Date exDate = today + Integer(values[i].t)*30;
+        Date exDate = today + Integer(value.t) * 30;
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
         ext::shared_ptr<Exercise> amExercise(new AmericanExercise(today,
                                                                     exDate));
 
-        spot1 ->setValue(values[i].s1);
-        spot2 ->setValue(values[i].s2);
-        spot3 ->setValue(values[i].s3);
-        rRate ->setValue(values[i].r );
-        vol1  ->setValue(values[i].v1);
-        vol2  ->setValue(values[i].v2);
-        vol3  ->setValue(values[i].v3);
+        spot1->setValue(value.s1);
+        spot2->setValue(value.s2);
+        spot3->setValue(value.s3);
+        rRate->setValue(value.r);
+        vol1->setValue(value.v1);
+        vol2->setValue(value.v2);
+        vol3->setValue(value.v3);
 
         ext::shared_ptr<StochasticProcess1D> stochProcess1(new
             BlackScholesMertonProcess(Handle<Quote>(spot1),
@@ -550,7 +528,7 @@ void BasketOptionTest::testBarraquandThreeValues() {
         procs.push_back(stochProcess2);
         procs.push_back(stochProcess3);
 
-        Matrix correlation(3,3, values[i].rho);
+        Matrix correlation(3, 3, value.rho);
         for (Integer j=0; j < 3; j++) {
             correlation[j][j] = 1.0;
         }
@@ -567,21 +545,17 @@ void BasketOptionTest::testBarraquandThreeValues() {
             .withSamples(8091)
             .withSeed(42);
 
-        BasketOption euroBasketOption(basketTypeToPayoff(values[i].basketType,
-                                                         payoff),
-                                      exercise);
+        BasketOption euroBasketOption(basketTypeToPayoff(value.basketType, payoff), exercise);
         euroBasketOption.setPricingEngine(mcQuasiEngine);
 
-        Real expected = values[i].euroValue;
+        Real expected = value.euroValue;
         Real calculated = euroBasketOption.NPV();
-        Real relError = relativeError(calculated, expected, values[i].s1);
+        Real relError = relativeError(calculated, expected, value.s1);
         Real mcRelativeErrorTolerance = 0.01;
         if (relError > mcRelativeErrorTolerance ) {
-            REPORT_FAILURE_3("MC Quasi value", values[i].basketType, payoff,
-                             exercise, values[i].s1, values[i].s2,
-                             values[i].s3, values[i].r, today, values[i].v1,
-                             values[i].v2, values[i].v3, values[i].rho,
-                             values[i].euroValue, calculated, relError,
+            REPORT_FAILURE_3("MC Quasi value", value.basketType, payoff, exercise, value.s1,
+                             value.s2, value.s3, value.r, today, value.v1, value.v2, value.v3,
+                             value.rho, value.euroValue, calculated, relError,
                              mcRelativeErrorTolerance);
         }
 
@@ -597,24 +571,19 @@ void BasketOptionTest::testBarraquandThreeValues() {
             .withCalibrationSamples(requiredSamples/4)
             .withSeed(seed);
 
-        BasketOption amBasketOption(basketTypeToPayoff(values[i].basketType,
-                                                       payoff),
-                                    amExercise);
+        BasketOption amBasketOption(basketTypeToPayoff(value.basketType, payoff), amExercise);
         amBasketOption.setPricingEngine(mcLSMCEngine);
 
-        expected = values[i].amValue;
+        expected = value.amValue;
         calculated = amBasketOption.NPV();
-        relError = relativeError(calculated, expected, values[i].s1);
+        relError = relativeError(calculated, expected, value.s1);
         Real mcAmericanRelativeErrorTolerance = 0.01;
         if (relError > mcAmericanRelativeErrorTolerance) {
-            REPORT_FAILURE_3("MC LSMC Value", values[i].basketType, payoff,
-                             exercise, values[i].s1, values[i].s2,
-                             values[i].s3, values[i].r, today, values[i].v1,
-                             values[i].v2, values[i].v3, values[i].rho,
-                             values[i].amValue, calculated, relError,
+            REPORT_FAILURE_3("MC LSMC Value", value.basketType, payoff, exercise, value.s1,
+                             value.s2, value.s3, value.r, today, value.v1, value.v2, value.v3,
+                             value.rho, value.amValue, calculated, relError,
                              mcRelativeErrorTolerance);
         }
-
     }
 }
 
@@ -912,18 +881,18 @@ void BasketOptionTest::testOddSamples() {
         .withCalibrationSamples(requiredSamples/4)
         .withSeed(seed);
 
-    for (Size i=0; i<LENGTH(values); i++) {
-        ext::shared_ptr<PlainVanillaPayoff> payoff(new
-            PlainVanillaPayoff(values[i].type, values[i].strike));
+    for (auto& value : values) {
+        ext::shared_ptr<PlainVanillaPayoff> payoff(
+            new PlainVanillaPayoff(value.type, value.strike));
 
-        Date exDate = today + timeToDays(values[i].t);
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise(new AmericanExercise(today,
                                                                   exDate));
 
-        spot1 ->setValue(values[i].s);
-        vol1  ->setValue(values[i].v);
-        rRate ->setValue(values[i].r);
-        qRate ->setValue(values[i].q);
+        spot1->setValue(value.s);
+        vol1->setValue(value.v);
+        rRate->setValue(value.r);
+        qRate->setValue(value.q);
 
         BasketOption basketOption(// process,
                                   basketTypeToPayoff(MaxBasket, payoff),
@@ -931,14 +900,14 @@ void BasketOptionTest::testOddSamples() {
         basketOption.setPricingEngine(mcLSMCEngine);
 
         Real calculated = basketOption.NPV();
-        Real expected = values[i].result;
+        Real expected = value.result;
         // Real errorEstimate = basketOption.errorEstimate();
-        Real relError = relativeError(calculated, expected, values[i].s);
+        Real relError = relativeError(calculated, expected, value.s);
         // Real error = std::fabs(calculated-expected);
 
-        if (relError > values[i].tol) {
-            BOOST_FAIL("expected value: " << values[i].result << "\n"
-                       << "calculated:     " << calculated);
+        if (relError > value.tol) {
+            BOOST_FAIL("expected value: " << value.result << "\n"
+                                          << "calculated:     " << calculated);
         }
     }
 }
diff --git a/test-suite/batesmodel.cpp b/test-suite/batesmodel.cpp
index 80df5621359..fedf4c80693 100644
--- a/test-suite/batesmodel.cpp
+++ b/test-suite/batesmodel.cpp
@@ -47,8 +47,8 @@ namespace bates_model_test {
     Real getCalibrationError(
                std::vector<ext::shared_ptr<BlackCalibrationHelper> > & options) {
         Real sse = 0;
-        for (Size i = 0; i < options.size(); ++i) {
-            const Real diff = options[i]->calibrationError()*100.0;
+        for (auto& option : options) {
+            const Real diff = option->calibrationError() * 100.0;
             sse += diff*diff;
         }
         return sse;
@@ -315,22 +315,16 @@ void BatesModelTest::testAnalyticVsMCPricing() {
                                    new PlainVanillaPayoff(Option::Put, 100));
     ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exerciseDate));
 
-    
-    for (Size i=0; i < LENGTH(hestonModels); ++i) { 
-        Handle<YieldTermStructure> riskFreeTS(flatRate(hestonModels[i].r, 
-                                                       dayCounter));
-        Handle<YieldTermStructure> dividendTS(flatRate(hestonModels[i].q, 
-                                                       dayCounter));
+
+    for (auto& hestonModel : hestonModels) {
+        Handle<YieldTermStructure> riskFreeTS(flatRate(hestonModel.r, dayCounter));
+        Handle<YieldTermStructure> dividendTS(flatRate(hestonModel.q, dayCounter));
         Handle<Quote> s0(ext::shared_ptr<Quote>(new SimpleQuote(100)));
 
         ext::shared_ptr<BatesProcess> batesProcess(new BatesProcess(
-                       riskFreeTS, dividendTS, s0,
-                       hestonModels[i].v0, 
-                       hestonModels[i].kappa, 
-                       hestonModels[i].theta, 
-                       hestonModels[i].sigma, 
-                       hestonModels[i].rho, 2.0, -0.2, 0.1));
-    
+            riskFreeTS, dividendTS, s0, hestonModel.v0, hestonModel.kappa, hestonModel.theta,
+            hestonModel.sigma, hestonModel.rho, 2.0, -0.2, 0.1));
+
         const Real mcTolerance = 0.5;
         ext::shared_ptr<PricingEngine> mcEngine =
                 MakeMCEuropeanHestonEngine<PseudoRandom>(batesProcess)
@@ -361,22 +355,18 @@ void BatesModelTest::testAnalyticVsMCPricing() {
         const Real mcError = std::fabs(calculated - expected);
         if (mcError > 3*mcTolerance) {
             BOOST_FAIL("failed to reproduce Monte-Carlo price for BatesEngine"
-                       << "\n    parameter:  " << hestonModels[i].name
-                       << std::fixed << std::setprecision(8)
-                       << "\n    calculated: " << calculated
-                       << "\n    expected:   " << expected
-                       << "\n    error: "      << mcError
+                       << "\n    parameter:  " << hestonModel.name << std::fixed
+                       << std::setprecision(8) << "\n    calculated: " << calculated
+                       << "\n    expected:   " << expected << "\n    error: " << mcError
                        << "\n    tolerance:  " << mcTolerance);
         }
         const Real fdTolerance = 0.2;
         const Real fdError = std::fabs(fdCalculated - expected);
         if (fdError > fdTolerance) {
             BOOST_FAIL("failed to reproduce PIDE price for BatesEngine"
-                       << "\n    parameter:  " << hestonModels[i].name
-                       << std::fixed << std::setprecision(8)
-                       << "\n    calculated: " << fdCalculated
-                       << "\n    expected:   " << expected
-                       << "\n    error: "      << fdError
+                       << "\n    parameter:  " << hestonModel.name << std::fixed
+                       << std::setprecision(8) << "\n    calculated: " << fdCalculated
+                       << "\n    expected:   " << expected << "\n    error: " << fdError
                        << "\n    tolerance:  " << fdTolerance);
         }
     }
@@ -524,8 +514,8 @@ void BatesModelTest::testDAXCalibration() {
 
     Real tolerance=0.1;
     for (Size i = 0; i < pricingEngines.size(); ++i) {
-        for (Size j = 0; j < options.size(); ++j) {
-            options[j]->setPricingEngine(pricingEngines[i]);
+        for (auto& option : options) {
+            option->setPricingEngine(pricingEngines[i]);
         }
 
         Real calculated = std::fabs(getCalibrationError(options));
diff --git a/test-suite/bermudanswaption.cpp b/test-suite/bermudanswaption.cpp
index 76d640c6998..1ef805a0ba5 100644
--- a/test-suite/bermudanswaption.cpp
+++ b/test-suite/bermudanswaption.cpp
@@ -137,10 +137,9 @@ void BermudanSwaptionTest::testCachedValues() {
                                                      a, sigma));
     std::vector<Date> exerciseDates;
     const Leg& leg = atmSwap->fixedLeg();
-    for (Size i=0; i<leg.size(); i++) {
-        ext::shared_ptr<Coupon> coupon =
-            ext::dynamic_pointer_cast<Coupon>(leg[i]);
-            exerciseDates.push_back(coupon->accrualStartDate());
+    for (const auto& i : leg) {
+        ext::shared_ptr<Coupon> coupon = ext::dynamic_pointer_cast<Coupon>(i);
+        exerciseDates.push_back(coupon->accrualStartDate());
     }
     ext::shared_ptr<Exercise> exercise(new BermudanExercise(exerciseDates));
 
@@ -202,8 +201,8 @@ void BermudanSwaptionTest::testCachedValues() {
                     << "expected:   " << otmValueFdm);
 
 
-    for (Size j=0; j<exerciseDates.size(); j++)
-        exerciseDates[j] = vars.calendar.adjust(exerciseDates[j]-10);
+    for (auto& exerciseDate : exerciseDates)
+        exerciseDate = vars.calendar.adjust(exerciseDate - 10);
     exercise =
         ext::shared_ptr<Exercise>(new BermudanExercise(exerciseDates));
 
@@ -257,9 +256,8 @@ void BermudanSwaptionTest::testCachedG2Values() {
         const ext::shared_ptr<VanillaSwap> swap(vars.makeSwap(s*atmRate));
 
         std::vector<Date> exerciseDates;
-        for (Size i=0; i < swap->fixedLeg().size(); i++) {
-            exerciseDates.push_back(ext::dynamic_pointer_cast<Coupon>(
-                swap->fixedLeg()[i])->accrualStartDate());
+        for (const auto& i : swap->fixedLeg()) {
+            exerciseDates.push_back(ext::dynamic_pointer_cast<Coupon>(i)->accrualStartDate());
         }
         swaptions.push_back(ext::make_shared<Swaption>(swap,
             ext::make_shared<BermudanExercise>(exerciseDates)));
diff --git a/test-suite/binaryoption.cpp b/test-suite/binaryoption.cpp
index f6c89367a6a..582dd73d533 100644
--- a/test-suite/binaryoption.cpp
+++ b/test-suite/binaryoption.cpp
@@ -151,20 +151,20 @@ void BinaryOptionTest::testCashOrNothingHaugValues() {
     ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.25));
     ext::shared_ptr<BlackVolTermStructure> volTS = flatVol(today, vol, dc);
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(new CashOrNothingPayoff(
-            values[i].type, values[i].strike, values[i].cash));
+        ext::shared_ptr<StrikedTypePayoff> payoff(
+            new CashOrNothingPayoff(value.type, value.strike, value.cash));
 
-        Date exDate = today + timeToDays(values[i].t);
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> amExercise(new AmericanExercise(today,
                                                                     exDate,
                                                                     true));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess(new
             BlackScholesMertonProcess(Handle<Quote>(spot),
@@ -174,21 +174,16 @@ void BinaryOptionTest::testCashOrNothingHaugValues() {
         ext::shared_ptr<PricingEngine> engine(
                              new AnalyticBinaryBarrierEngine(stochProcess));
 
-        BarrierOption opt(values[i].barrierType, 
-                          values[i].barrier, 
-                          0,
-                          payoff,
-                          amExercise);
+        BarrierOption opt(value.barrierType, value.barrier, 0, payoff, amExercise);
 
         opt.setPricingEngine(engine);
 
         Real calculated = opt.NPV();
-        Real error = std::fabs(calculated-values[i].result);
-        if (error > values[i].tol) {
-            REPORT_FAILURE("value", payoff, amExercise, values[i].barrierType, 
-                           values[i].barrier, values[i].s,
-                           values[i].q, values[i].r, today, values[i].v,
-                           values[i].result, calculated, error, values[i].tol);
+        Real error = std::fabs(calculated - value.result);
+        if (error > value.tol) {
+            REPORT_FAILURE("value", payoff, amExercise, value.barrierType, value.barrier, value.s,
+                           value.q, value.r, today, value.v, value.result, calculated, error,
+                           value.tol);
         }
     }
 }
@@ -239,18 +234,18 @@ void BinaryOptionTest::testAssetOrNothingHaugValues() {
     ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.25));
     ext::shared_ptr<BlackVolTermStructure> volTS = flatVol(today, vol, dc);
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(new AssetOrNothingPayoff(
-            values[i].type, values[i].strike));
+        ext::shared_ptr<StrikedTypePayoff> payoff(
+            new AssetOrNothingPayoff(value.type, value.strike));
 
-        Date exDate = today + timeToDays(values[i].t);
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> amExercise(new AmericanExercise(today, exDate, true));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess(new
             BlackScholesMertonProcess(Handle<Quote>(spot),
@@ -260,21 +255,16 @@ void BinaryOptionTest::testAssetOrNothingHaugValues() {
         ext::shared_ptr<PricingEngine> engine(
                              new AnalyticBinaryBarrierEngine(stochProcess));
 
-        BarrierOption opt(values[i].barrierType, 
-                          values[i].barrier, 
-                          0,
-                          payoff,
-                          amExercise);
+        BarrierOption opt(value.barrierType, value.barrier, 0, payoff, amExercise);
 
         opt.setPricingEngine(engine);
 
         Real calculated = opt.NPV();
-        Real error = std::fabs(calculated-values[i].result);
-        if (error > values[i].tol) {
-            REPORT_FAILURE("value", payoff, amExercise, values[i].barrierType, 
-                           values[i].barrier, values[i].s,
-                           values[i].q, values[i].r, today, values[i].v,
-                           values[i].result, calculated, error, values[i].tol);
+        Real error = std::fabs(calculated - value.result);
+        if (error > value.tol) {
+            REPORT_FAILURE("value", payoff, amExercise, value.barrierType, value.barrier, value.s,
+                           value.q, value.r, today, value.v, value.result, calculated, error,
+                           value.tol);
         }
     }
 }
diff --git a/test-suite/blackdeltacalculator.cpp b/test-suite/blackdeltacalculator.cpp
index f3067229cbf..b2f3731db4d 100644
--- a/test-suite/blackdeltacalculator.cpp
+++ b/test-suite/blackdeltacalculator.cpp
@@ -228,25 +228,24 @@ void BlackDeltaCalculatorTest::testDeltaPriceConsistency() {
 
     Real tolerance=1.0e-10;
 
-    for(Size i=0; i<LENGTH(values);++i){
+    for (auto& value : values) {
 
-        payoff = ext::shared_ptr<StrikedTypePayoff>(
-                    new PlainVanillaPayoff(values[i].type, values[i].strike));
-        exDate = today + timeToDays(values[i].t);
+        payoff =
+            ext::shared_ptr<StrikedTypePayoff>(new PlainVanillaPayoff(value.type, value.strike));
+        exDate = today + timeToDays(value.t);
         exercise = ext::shared_ptr<Exercise>(new EuropeanExercise(exDate));
 
-        spotQuote   ->setValue(values[i].s);
-        volQuote    ->setValue(values[i].v);
-        rQuote      ->setValue(values[i].r);
-        qQuote      ->setValue(values[i].q);
+        spotQuote->setValue(value.s);
+        volQuote->setValue(value.v);
+        rQuote->setValue(value.r);
+        qQuote->setValue(value.q);
 
         discDom =rTS->discount(exDate);
         discFor =qTS->discount(exDate);
         implVol =sqrt(volTS->blackVariance(exDate,0.0));
 
-        BlackDeltaCalculator myCalc(values[i].type, DeltaVolQuote::PaSpot,
-                                    spotQuote->value(),
-                                    discDom, discFor, implVol);
+        BlackDeltaCalculator myCalc(value.type, DeltaVolQuote::PaSpot, spotQuote->value(), discDom,
+                                    discFor, implVol);
 
         stochProcess=ext::make_shared<BlackScholesMertonProcess> (spotHandle,
                                       Handle<YieldTermStructure>(qTS),
@@ -259,7 +258,7 @@ void BlackDeltaCalculatorTest::testDeltaPriceConsistency() {
         EuropeanOption option(payoff, exercise);
         option.setPricingEngine(engine);
 
-        calculatedVal=myCalc.deltaFromStrike(values[i].strike);
+        calculatedVal = myCalc.deltaFromStrike(value.strike);
 
         Real delta = 0.0;
         if (implVol > 0.0) {
@@ -286,7 +285,7 @@ void BlackDeltaCalculatorTest::testDeltaPriceConsistency() {
 
         myCalc.setDeltaType(DeltaVolQuote::PaFwd);
 
-        calculatedVal=myCalc.deltaFromStrike(values[i].strike);
+        calculatedVal = myCalc.deltaFromStrike(value.strike);
         expectedVal=expectedVal/discFor; // Premium adjusted Fwd Delta is PA spot without discount
         error=std::fabs(expectedVal-calculatedVal);
 
@@ -301,7 +300,7 @@ void BlackDeltaCalculatorTest::testDeltaPriceConsistency() {
         // Test consistency with BlackScholes Calculator for Spot Delta
         myCalc.setDeltaType(DeltaVolQuote::Spot);
 
-        calculatedVal=myCalc.deltaFromStrike(values[i].strike);
+        calculatedVal = myCalc.deltaFromStrike(value.strike);
         expectedVal=delta;
         error=std::fabs(calculatedVal-expectedVal);
 
@@ -417,17 +416,17 @@ void BlackDeltaCalculatorTest::testPutCallParity(){
 
     Real tolerance=1.0e-10;
 
-    for(Size i=0; i<LENGTH(values);++i){
+    for (auto& value : values) {
 
-        payoff = ext::shared_ptr<StrikedTypePayoff>(new
-                            PlainVanillaPayoff(Option::Call, values[i].strike));
-        exDate = today + timeToDays(values[i].t);
+        payoff =
+            ext::shared_ptr<StrikedTypePayoff>(new PlainVanillaPayoff(Option::Call, value.strike));
+        exDate = today + timeToDays(value.t);
         exercise = ext::shared_ptr<Exercise>(new EuropeanExercise(exDate));
 
-        spotQuote->setValue(values[i].s);
-        volQuote->setValue(values[i].v);
-        rQuote->setValue(values[i].r);
-        qQuote->setValue(values[i].q);
+        spotQuote->setValue(value.s);
+        volQuote->setValue(value.v);
+        rQuote->setValue(value.r);
+        qQuote->setValue(value.q);
         discDom=rTS->discount(exDate);
         discFor=qTS->discount(exDate);
         implVol=sqrt(volTS->blackVariance(exDate,0.0));
@@ -437,9 +436,11 @@ void BlackDeltaCalculatorTest::testPutCallParity(){
                                     spotQuote->value(),
                                     discDom, discFor, implVol);
 
-        deltaCall=myCalc.deltaFromStrike(values[i].strike);;
+        deltaCall = myCalc.deltaFromStrike(value.strike);
+        ;
         myCalc.setOptionType(Option::Put);
-        deltaPut=myCalc.deltaFromStrike(values[i].strike);;
+        deltaPut = myCalc.deltaFromStrike(value.strike);
+        ;
         myCalc.setOptionType(Option::Call);
 
         expectedDiff=discFor;
@@ -455,9 +456,11 @@ void BlackDeltaCalculatorTest::testPutCallParity(){
         }
         myCalc.setDeltaType(DeltaVolQuote::Fwd);
 
-        deltaCall=myCalc.deltaFromStrike(values[i].strike);;
+        deltaCall = myCalc.deltaFromStrike(value.strike);
+        ;
         myCalc.setOptionType(Option::Put);
-        deltaPut=myCalc.deltaFromStrike(values[i].strike);;
+        deltaPut = myCalc.deltaFromStrike(value.strike);
+        ;
         myCalc.setOptionType(Option::Call);
 
         expectedDiff=1.0;
@@ -474,12 +477,14 @@ void BlackDeltaCalculatorTest::testPutCallParity(){
 
         myCalc.setDeltaType(DeltaVolQuote::PaSpot);
 
-        deltaCall=myCalc.deltaFromStrike(values[i].strike);;
+        deltaCall = myCalc.deltaFromStrike(value.strike);
+        ;
         myCalc.setOptionType(Option::Put);
-        deltaPut=myCalc.deltaFromStrike(values[i].strike);;
+        deltaPut = myCalc.deltaFromStrike(value.strike);
+        ;
         myCalc.setOptionType(Option::Call);
 
-        expectedDiff=discFor*values[i].strike/forward;
+        expectedDiff = discFor * value.strike / forward;
         calculatedDiff=deltaCall-deltaPut;
         error=std::fabs(expectedDiff-calculatedDiff);
 
@@ -494,12 +499,14 @@ void BlackDeltaCalculatorTest::testPutCallParity(){
 
         myCalc.setDeltaType(DeltaVolQuote::PaFwd);
 
-        deltaCall=myCalc.deltaFromStrike(values[i].strike);;
+        deltaCall = myCalc.deltaFromStrike(value.strike);
+        ;
         myCalc.setOptionType(Option::Put);
-        deltaPut=myCalc.deltaFromStrike(values[i].strike);;
+        deltaPut = myCalc.deltaFromStrike(value.strike);
+        ;
         myCalc.setOptionType(Option::Call);
 
-        expectedDiff = values[i].strike/forward;
+        expectedDiff = value.strike / forward;
         calculatedDiff=deltaCall-deltaPut;
         error=std::fabs(expectedDiff-calculatedDiff);
 
diff --git a/test-suite/blackformula.cpp b/test-suite/blackformula.cpp
index 61b8aac7a38..86a19f54917 100644
--- a/test-suite/blackformula.cpp
+++ b/test-suite/blackformula.cpp
@@ -44,10 +44,10 @@ void BlackFormulaTest::testBachelierImpliedVol(){
     Real discount = 0.95;
 
     Real d[] = {-3.0, -2.0, -1.0, -0.5, 0.0, 0.5, 1.0, 2.0, 3.0};
-    for(Size i=0;i<LENGTH(d);++i){
+    for (double i : d) {
 
 
-        Real strike = forward - d[i] * bpvol * std::sqrt(tte);
+        Real strike = forward - i * bpvol * std::sqrt(tte);
 
         Real callPrem = bachelierBlackFormula(optionType, strike, forward, stdDev, discount);
 
@@ -74,43 +74,31 @@ void BlackFormulaTest::testChambersImpliedVol() {
 
     Real tol = 5.0E-4;
 
-    for (Size i1 = 0; i1 < LENGTH(types); ++i1) {
-        for (Size i2 = 0; i2 < LENGTH(displacements); ++i2) {
-            for (Size i3 = 0; i3 < LENGTH(forwards); ++i3) {
-                for (Size i4 = 0; i4 < LENGTH(strikes); ++i4) {
-                    for (Size i5 = 0; i5 < LENGTH(stdDevs); ++i5) {
-                        for (Size i6 = 0; i6 < LENGTH(discounts); ++i6) {
-                            if (forwards[i3] + displacements[i2] > 0.0 &&
-                                strikes[i4] + displacements[i2] > 0.0) {
-                                Real premium = blackFormula(
-                                    types[i1], strikes[i4], forwards[i3],
-                                    stdDevs[i5], discounts[i6],
-                                    displacements[i2]);
-                                Real atmPremium = blackFormula(
-                                    types[i1], forwards[i3], forwards[i3],
-                                    stdDevs[i5], discounts[i6],
-                                    displacements[i2]);
-                                Real iStdDev =
-                                    blackFormulaImpliedStdDevChambers(
-                                        types[i1], strikes[i4], forwards[i3],
-                                        premium, atmPremium, discounts[i6],
-                                        displacements[i2]);
-                                Real moneyness = (strikes[i4] + displacements[i2]) /
-                                             (forwards[i3] + displacements[i2]);
+    for (auto& type : types) {
+        for (double& displacement : displacements) {
+            for (double& forward : forwards) {
+                for (double& strike : strikes) {
+                    for (double& stdDev : stdDevs) {
+                        for (double& discount : discounts) {
+                            if (forward + displacement > 0.0 && strike + displacement > 0.0) {
+                                Real premium = blackFormula(type, strike, forward, stdDev, discount,
+                                                            displacement);
+                                Real atmPremium = blackFormula(type, forward, forward, stdDev,
+                                                               discount, displacement);
+                                Real iStdDev = blackFormulaImpliedStdDevChambers(
+                                    type, strike, forward, premium, atmPremium, discount,
+                                    displacement);
+                                Real moneyness = (strike + displacement) / (forward + displacement);
                                 if(moneyness > 1.0) moneyness = 1.0 / moneyness;
-                                Real error = (iStdDev - stdDevs[i5]) / stdDevs[i5] * moneyness;
+                                Real error = (iStdDev - stdDev) / stdDev * moneyness;
                                 if(error > tol)
-                                    BOOST_ERROR(
-                                        "Failed to verify Chambers-Nawalkha "
-                                        "approximation for "
-                                        << types[i1]
-                                        << " displacement=" << displacements[i2]
-                                        << " forward=" << forwards[i3]
-                                        << " strike=" << strikes[i4]
-                                        << " discount=" << discounts[i6]
-                                        << " stddev=" << stdDevs[i5]
-                                        << " result=" << iStdDev
-                                        << " exceeds maximum error tolerance");
+                                    BOOST_ERROR("Failed to verify Chambers-Nawalkha "
+                                                "approximation for "
+                                                << type << " displacement=" << displacement
+                                                << " forward=" << forward << " strike=" << strike
+                                                << " discount=" << discount << " stddev=" << stdDev
+                                                << " result=" << iStdDev
+                                                << " exceeds maximum error tolerance");
                             }
                         }
                     }
@@ -140,11 +128,8 @@ void BlackFormulaTest::testRadoicicStefanicaImpliedVol() {
 
     const Real tol = 0.02;
 
-    for (Size i=0; i < LENGTH(strikes); ++i) {
-        const Real strike = strikes[i];
-        for (Size j=0; j < LENGTH(types); ++j) {
-            const Option::Type type = types[j];
-
+    for (double strike : strikes) {
+        for (auto type : types) {
             const ext::shared_ptr<PlainVanillaPayoff> payoff(
                 ext::make_shared<PlainVanillaPayoff>(type, strike));
 
@@ -241,20 +226,14 @@ void BlackFormulaTest::testImpliedVolAdaptiveSuccessiveOverRelaxation() {
 
     const Real tol = 1e-8;
 
-    for (Size i=0; i < LENGTH(strikes); ++i) {
-        const Real strike = strikes[i];
-
-        for (Size j=0; j < LENGTH(types); ++j) {
-            const Option::Type type = types[j];
-
+    for (double strike : strikes) {
+        for (auto type : types) {
             const ext::shared_ptr<PlainVanillaPayoff> payoff(
                 ext::make_shared<PlainVanillaPayoff>(type, strike));
 
-            for (Size k=0; k < LENGTH(displacements); ++k) {
+            for (double displacement : displacements) {
 
-                const Real displacement = displacements[k];
-                const Real marketValue = blackFormula(
-                    payoff, forward, stdDev, df, displacement);
+                const Real marketValue = blackFormula(payoff, forward, stdDev, df, displacement);
 
                 const Real impliedStdDev = blackFormulaImpliedStdDevLiRS(
                     payoff, forward, marketValue, df, displacement,
@@ -291,10 +270,9 @@ void assertBlackFormulaForwardDerivative(
     Real epsilon = 1.e-10;
     std::string type = optionType == Option::Call ? "Call" : "Put";
 
-    for (auto it = strikes.begin(); it != strikes.end(); ++it) {
-        Real strike = *it;
-        Real delta = blackFormulaForwardDerivative(
-            optionType, strike, forward, stdDev, discount, displacement);
+    for (double strike : strikes) {
+        Real delta = blackFormulaForwardDerivative(optionType, strike, forward, stdDev, discount,
+                                                   displacement);
         Real bumpedDelta = blackFormulaForwardDerivative(
             optionType, strike, forward + bump, stdDev, discount, displacement);
 
@@ -383,10 +361,9 @@ void assertBachelierBlackFormulaForwardDerivative(
     Real epsilon = 1.e-10;
     std::string type = optionType == Option::Call ? "Call" : "Put";
 
-    for (auto it = strikes.begin(); it != strikes.end(); ++it) {
-        Real strike = *it;
-        Real delta = bachelierBlackFormulaForwardDerivative(
-            optionType, strike, forward, stdDev, discount);
+    for (double strike : strikes) {
+        Real delta =
+            bachelierBlackFormulaForwardDerivative(optionType, strike, forward, stdDev, discount);
         Real bumpedDelta = bachelierBlackFormulaForwardDerivative(
             optionType, strike, forward + bump, stdDev, discount);
 
diff --git a/test-suite/bonds.cpp b/test-suite/bonds.cpp
index d9601171954..e7adf0f83a8 100644
--- a/test-suite/bonds.cpp
+++ b/test-suite/bonds.cpp
@@ -114,102 +114,79 @@ void BondTest::testYield() {
     Rate yields[] = { 0.03, 0.04, 0.05, 0.06, 0.07 };
     Compounding compounding[] = { Compounded, Continuous };
 
-    for (Size i=0; i<LENGTH(issueMonths); i++) {
-      for (Size j=0; j<LENGTH(lengths); j++) {
-        for (Size k=0; k<LENGTH(coupons); k++) {
-          for (Size l=0; l<LENGTH(frequencies); l++) {
-            for (Size n=0; n<LENGTH(compounding); n++) {
-
-              Date dated = vars.calendar.advance(vars.today,
-                                                 issueMonths[i], Months);
-              Date issue = dated;
-              Date maturity = vars.calendar.advance(issue,
-                                                    lengths[j], Years);
-
-              Schedule sch(dated, maturity,
-                           Period(frequencies[l]), vars.calendar,
-                           accrualConvention, accrualConvention,
-                           DateGeneration::Backward, false);
-
-              FixedRateBond bond(settlementDays, vars.faceAmount, sch,
-                                 std::vector<Rate>(1, coupons[k]),
-                                 bondDayCount, paymentConvention,
-                                 redemption, issue);
-
-              for (Size m=0; m<LENGTH(yields); m++) {
-
-                Real price = BondFunctions::cleanPrice(bond, yields[m],
-                                                       bondDayCount,
-                                                       compounding[n],
-                                                       frequencies[l]);
-
-                Rate calculated = BondFunctions::yield(bond, price,
-                                                       bondDayCount, compounding[n],
-                                                       frequencies[l],
-                                                       Date(),
-                                                       tolerance, maxEvaluations,
-                                                       0.05, Bond::Price::Clean);
-
-                if (std::fabs(yields[m]-calculated) > tolerance) {
-                  // the difference might not matter
-                  Real price2 = BondFunctions::cleanPrice(bond, calculated,
-                                                          bondDayCount,
-                                                          compounding[n],
-                                                          frequencies[l]);
-                  if (std::fabs(price-price2)/price > tolerance) {
-                      BOOST_ERROR("\nyield recalculation failed:"
-                          "\n    issue:     " << issue <<
-                          "\n    maturity:  " << maturity <<
-                          "\n    coupon:    " << io::rate(coupons[k]) <<
-                          "\n    frequency: " << frequencies[l] <<
-                          "\n    yield:   " << io::rate(yields[m]) <<
-                          (compounding[n] == Compounded ?
-                                " compounded" : " continuous") <<
-                          std::setprecision(7) <<
-                          "\n    clean price:   " << price <<
-                          "\n    yield': " << io::rate(calculated) <<
-                          "\n    clean price': " << price2);
-                  }
+    for (int issueMonth : issueMonths) {
+        for (int length : lengths) {
+            for (double& coupon : coupons) {
+                for (auto& frequencie : frequencies) {
+                    for (auto& n : compounding) {
+
+                        Date dated = vars.calendar.advance(vars.today, issueMonth, Months);
+                        Date issue = dated;
+                        Date maturity = vars.calendar.advance(issue, length, Years);
+
+                        Schedule sch(dated, maturity, Period(frequencie), vars.calendar,
+                                     accrualConvention, accrualConvention, DateGeneration::Backward,
+                                     false);
+
+                        FixedRateBond bond(settlementDays, vars.faceAmount, sch,
+                                           std::vector<Rate>(1, coupon), bondDayCount,
+                                           paymentConvention, redemption, issue);
+
+                        for (double m : yields) {
+
+                            Real price =
+                                BondFunctions::cleanPrice(bond, m, bondDayCount, n, frequencie);
+
+                            Rate calculated = BondFunctions::yield(
+                                bond, price, bondDayCount, n, frequencie, Date(), tolerance,
+                                maxEvaluations, 0.05, Bond::Price::Clean);
+
+                            if (std::fabs(m - calculated) > tolerance) {
+                                // the difference might not matter
+                                Real price2 = BondFunctions::cleanPrice(
+                                    bond, calculated, bondDayCount, n, frequencie);
+                                if (std::fabs(price - price2) / price > tolerance) {
+                                    BOOST_ERROR("\nyield recalculation failed:"
+                                                "\n    issue:     "
+                                                << issue << "\n    maturity:  " << maturity
+                                                << "\n    coupon:    " << io::rate(coupon)
+                                                << "\n    frequency: " << frequencie
+                                                << "\n    yield:   " << io::rate(m)
+                                                << (n == Compounded ? " compounded" : " continuous")
+                                                << std::setprecision(7) << "\n    clean price:   "
+                                                << price << "\n    yield': " << io::rate(calculated)
+                                                << "\n    clean price': " << price2);
+                                }
+                            }
+
+                            price = BondFunctions::dirtyPrice(bond, m, bondDayCount, n, frequencie);
+
+                            calculated = BondFunctions::yield(
+                                bond, price, bondDayCount, n, frequencie, Date(), tolerance,
+                                maxEvaluations, 0.05, Bond::Price::Dirty);
+
+                            if (std::fabs(m - calculated) > tolerance) {
+                                // the difference might not matter
+                                Real price2 = BondFunctions::dirtyPrice(
+                                    bond, calculated, bondDayCount, n, frequencie);
+                                if (std::fabs(price - price2) / price > tolerance) {
+                                    BOOST_ERROR("\nyield recalculation failed:"
+                                                "\n    issue:     "
+                                                << issue << "\n    maturity:  " << maturity
+                                                << "\n    coupon:    " << io::rate(coupon)
+                                                << "\n    frequency: " << frequencie
+                                                << "\n    yield:   " << io::rate(m)
+                                                << (n == Compounded ? " compounded" : " continuous")
+                                                << std::setprecision(7) << "\n    dirty price:   "
+                                                << price << "\n    yield': " << io::rate(calculated)
+                                                << "\n    dirty price': " << price2);
+                                }
+                            }
+                        }
+                    }
                 }
-
-                price = BondFunctions::dirtyPrice(bond, yields[m],
-                                                  bondDayCount,
-                                                  compounding[n],
-                                                  frequencies[l]);
-
-                calculated = BondFunctions::yield(bond, price,
-                                                  bondDayCount, compounding[n],
-                                                  frequencies[l],
-                                                  Date(),
-                                                  tolerance, maxEvaluations,
-                                                  0.05, Bond::Price::Dirty);
-
-                if (std::fabs(yields[m]-calculated) > tolerance) {
-                  // the difference might not matter
-                  Real price2 = BondFunctions::dirtyPrice(bond, calculated,
-                                                          bondDayCount,
-                                                          compounding[n],
-                                                          frequencies[l]);
-                  if (std::fabs(price-price2)/price > tolerance) {
-                      BOOST_ERROR("\nyield recalculation failed:"
-                          "\n    issue:     " << issue <<
-                          "\n    maturity:  " << maturity <<
-                          "\n    coupon:    " << io::rate(coupons[k]) <<
-                          "\n    frequency: " << frequencies[l] <<
-                          "\n    yield:   " << io::rate(yields[m]) <<
-                          (compounding[n] == Compounded ?
-                                " compounded" : " continuous") <<
-                          std::setprecision(7) <<
-                          "\n    dirty price:   " << price <<
-                          "\n    yield': " << io::rate(calculated) <<
-                          "\n    dirty price': " << price2);
-                  }
-                }
-              }
             }
-          }
         }
-      }
     }
 }
 
@@ -235,48 +212,41 @@ void BondTest::testAtmRate() {
     Handle<YieldTermStructure> disc(flatRate(vars.today,0.03,Actual360()));
     ext::shared_ptr<PricingEngine> bondEngine(new DiscountingBondEngine(disc));
 
-    for (Size i=0; i<LENGTH(issueMonths); i++) {
-      for (Size j=0; j<LENGTH(lengths); j++) {
-        for (Size k=0; k<LENGTH(coupons); k++) {
-          for (Size l=0; l<LENGTH(frequencies); l++) {
-            Date dated = vars.calendar.advance(vars.today,
-                                               issueMonths[i], Months);
-            Date issue = dated;
-            Date maturity = vars.calendar.advance(issue,
-                                                  lengths[j], Years);
-
-            Schedule sch(dated, maturity,
-                         Period(frequencies[l]), vars.calendar,
-                         accrualConvention, accrualConvention,
-                         DateGeneration::Backward, false);
-
-            FixedRateBond bond(settlementDays, vars.faceAmount, sch,
-                             std::vector<Rate>(1, coupons[k]),
-                             bondDayCount, paymentConvention,
-                             redemption, issue);
-
-            bond.setPricingEngine(bondEngine);
-            Real price = bond.cleanPrice();
-            Rate calculated = BondFunctions::atmRate(bond,
-                                                     **disc,
-                                                     bond.settlementDate(),
-                                                     price);
-
-            if (std::fabs(coupons[k]-calculated) > tolerance) {
-                BOOST_ERROR("\natm rate recalculation failed:"
-                      "\n today:           " << vars.today <<
-                      "\n settlement date: " << bond.settlementDate() <<
-                      "\n issue:           " << issue <<
-                      "\n maturity:        " << maturity <<
-                      "\n coupon:          " << io::rate(coupons[k]) <<
-                      "\n frequency:       " << frequencies[l] <<
-                      "\n clean price:     " << price <<
-                      "\n dirty price:     " << price + bond.accruedAmount() <<
-                      "\n atm rate:        " << io::rate(calculated));
+    for (int issueMonth : issueMonths) {
+        for (int length : lengths) {
+            for (double& coupon : coupons) {
+                for (auto& frequencie : frequencies) {
+                    Date dated = vars.calendar.advance(vars.today, issueMonth, Months);
+                    Date issue = dated;
+                    Date maturity = vars.calendar.advance(issue, length, Years);
+
+                    Schedule sch(dated, maturity, Period(frequencie), vars.calendar,
+                                 accrualConvention, accrualConvention, DateGeneration::Backward,
+                                 false);
+
+                    FixedRateBond bond(settlementDays, vars.faceAmount, sch,
+                                       std::vector<Rate>(1, coupon), bondDayCount,
+                                       paymentConvention, redemption, issue);
+
+                    bond.setPricingEngine(bondEngine);
+                    Real price = bond.cleanPrice();
+                    Rate calculated =
+                        BondFunctions::atmRate(bond, **disc, bond.settlementDate(), price);
+
+                    if (std::fabs(coupon - calculated) > tolerance) {
+                        BOOST_ERROR("\natm rate recalculation failed:"
+                                    "\n today:           "
+                                    << vars.today << "\n settlement date: " << bond.settlementDate()
+                                    << "\n issue:           " << issue << "\n maturity:        "
+                                    << maturity << "\n coupon:          " << io::rate(coupon)
+                                    << "\n frequency:       " << frequencie
+                                    << "\n clean price:     " << price
+                                    << "\n dirty price:     " << price + bond.accruedAmount()
+                                    << "\n atm rate:        " << io::rate(calculated));
+                    }
+                }
             }
-          }
         }
-      }
     }
 }
 
@@ -307,71 +277,55 @@ void BondTest::testZspread() {
     Spread spreads[] = { -0.01, -0.005, 0.0, 0.005, 0.01 };
     Compounding compounding[] = { Compounded, Continuous };
 
-    for (Size i=0; i<LENGTH(issueMonths); i++) {
-      for (Size j=0; j<LENGTH(lengths); j++) {
-        for (Size k=0; k<LENGTH(coupons); k++) {
-          for (Size l=0; l<LENGTH(frequencies); l++) {
-            for (Size n=0; n<LENGTH(compounding); n++) {
-
-              Date dated = vars.calendar.advance(vars.today,
-                                                 issueMonths[i], Months);
-              Date issue = dated;
-              Date maturity = vars.calendar.advance(issue,
-                                                    lengths[j], Years);
-
-              Schedule sch(dated, maturity,
-                           Period(frequencies[l]), vars.calendar,
-                           accrualConvention, accrualConvention,
-                           DateGeneration::Backward, false);
-
-              FixedRateBond bond(settlementDays, vars.faceAmount, sch,
-                                 std::vector<Rate>(1, coupons[k]),
-                                 bondDayCount, paymentConvention,
-                                 redemption, issue);
-
-              for (Size m=0; m<LENGTH(spreads); m++) {
-
-                Real price = BondFunctions::cleanPrice(bond, *discountCurve,
-                                                   spreads[m],
-                                                   bondDayCount,
-                                                   compounding[n],
-                                                   frequencies[l]);
-                Spread calculated = BondFunctions::zSpread(bond, price,
-                                                           *discountCurve,
-                                                           bondDayCount,
-                                                           compounding[n],
-                                                           frequencies[l],
-                                                           Date(),
-                                                           tolerance,
-                                                           maxEvaluations);
-
-                if (std::fabs(spreads[m]-calculated) > tolerance) {
-                  // the difference might not matter
-                  Real price2 = BondFunctions::cleanPrice(bond, *discountCurve,
-                                                      calculated,
-                                                      bondDayCount,
-                                                      compounding[n],
-                                                      frequencies[l]);
-                  if (std::fabs(price-price2)/price > tolerance) {
-                      BOOST_ERROR("\nZ-spread recalculation failed:"
-                          "\n    issue:     " << issue <<
-                          "\n    maturity:  " << maturity <<
-                          "\n    coupon:    " << io::rate(coupons[k]) <<
-                          "\n    frequency: " << frequencies[l] <<
-                          "\n    Z-spread:  " << io::rate(spreads[m]) <<
-                          (compounding[n] == Compounded ?
-                                " compounded" : " continuous") <<
-                          std::setprecision(7) <<
-                          "\n    price:     " << price <<
-                          "\n    Z-spread': " << io::rate(calculated) <<
-                          "\n    price':    " << price2);
-                  }
+    for (int issueMonth : issueMonths) {
+        for (int length : lengths) {
+            for (double& coupon : coupons) {
+                for (auto& frequencie : frequencies) {
+                    for (auto& n : compounding) {
+
+                        Date dated = vars.calendar.advance(vars.today, issueMonth, Months);
+                        Date issue = dated;
+                        Date maturity = vars.calendar.advance(issue, length, Years);
+
+                        Schedule sch(dated, maturity, Period(frequencie), vars.calendar,
+                                     accrualConvention, accrualConvention, DateGeneration::Backward,
+                                     false);
+
+                        FixedRateBond bond(settlementDays, vars.faceAmount, sch,
+                                           std::vector<Rate>(1, coupon), bondDayCount,
+                                           paymentConvention, redemption, issue);
+
+                        for (double spread : spreads) {
+
+                            Real price = BondFunctions::cleanPrice(bond, *discountCurve, spread,
+                                                                   bondDayCount, n, frequencie);
+                            Spread calculated = BondFunctions::zSpread(
+                                bond, price, *discountCurve, bondDayCount, n, frequencie, Date(),
+                                tolerance, maxEvaluations);
+
+                            if (std::fabs(spread - calculated) > tolerance) {
+                                // the difference might not matter
+                                Real price2 = BondFunctions::cleanPrice(
+                                    bond, *discountCurve, calculated, bondDayCount, n, frequencie);
+                                if (std::fabs(price - price2) / price > tolerance) {
+                                    BOOST_ERROR("\nZ-spread recalculation failed:"
+                                                "\n    issue:     "
+                                                << issue << "\n    maturity:  " << maturity
+                                                << "\n    coupon:    " << io::rate(coupon)
+                                                << "\n    frequency: " << frequencie
+                                                << "\n    Z-spread:  " << io::rate(spread)
+                                                << (n == Compounded ? " compounded" : " continuous")
+                                                << std::setprecision(7)
+                                                << "\n    price:     " << price
+                                                << "\n    Z-spread': " << io::rate(calculated)
+                                                << "\n    price':    " << price2);
+                                }
+                            }
+                        }
+                    }
                 }
-              }
             }
-          }
         }
-      }
     }
 }
 
@@ -399,73 +353,61 @@ void BondTest::testTheoretical() {
 
     Rate yields[] = { 0.03, 0.04, 0.05, 0.06, 0.07 };
 
-    for (Size j=0; j<LENGTH(lengths); j++) {
-      for (Size k=0; k<LENGTH(coupons); k++) {
-        for (Size l=0; l<LENGTH(frequencies); l++) {
-
-            Date dated = vars.today;
-            Date issue = dated;
-            Date maturity = vars.calendar.advance(issue, lengths[j], Years);
-
-            ext::shared_ptr<SimpleQuote> rate(new SimpleQuote(0.0));
-            Handle<YieldTermStructure> discountCurve(flatRate(vars.today,
-                                                              rate,
-                                                              bondDayCount));
-
-            Schedule sch(dated, maturity,
-                         Period(frequencies[l]), vars.calendar,
-                         accrualConvention, accrualConvention,
-                         DateGeneration::Backward, false);
-
-            FixedRateBond bond(settlementDays, vars.faceAmount, sch,
-                               std::vector<Rate>(1, coupons[k]),
-                               bondDayCount, paymentConvention,
-                               redemption, issue);
-
-            ext::shared_ptr<PricingEngine> bondEngine(
-                                    new DiscountingBondEngine(discountCurve));
-            bond.setPricingEngine(bondEngine);
-
-            for (Size m=0; m<LENGTH(yields); m++) {
-
-                rate->setValue(yields[m]);
-
-                Real price = BondFunctions::cleanPrice(bond, yields[m],
-                                                 bondDayCount, Continuous,
-                                                 frequencies[l]);
-                Real calculatedPrice = bond.cleanPrice();
-
-                if (std::fabs(price-calculatedPrice) > tolerance) {
-                    BOOST_ERROR("price calculation failed:" <<
-                        "\n    issue:     " << issue <<
-                        "\n    maturity:  " << maturity <<
-                        "\n    coupon:    " << io::rate(coupons[k]) <<
-                        "\n    frequency: " << frequencies[l] <<
-                        "\n    yield:  " << io::rate(yields[m]) <<
-                        std::setprecision(7) <<
-                        "\n    expected:    " << price <<
-                        "\n    calculated': " << calculatedPrice <<
-                        "\n    error':      " << price-calculatedPrice);
-                }
-
-                Rate calculatedYield = BondFunctions::yield(bond, calculatedPrice,
-                    bondDayCount, Continuous, frequencies[l],
-                    bond.settlementDate(),
-                    tolerance, maxEvaluations);
-                if (std::fabs(yields[m]-calculatedYield) > tolerance) {
-                    BOOST_ERROR("yield calculation failed:" <<
-                        "\n    issue:     " << issue <<
-                        "\n    maturity:  " << maturity <<
-                        "\n    coupon:    " << io::rate(coupons[k]) <<
-                        "\n    frequency: " << frequencies[l] <<
-                        "\n    yield:  " << io::rate(yields[m]) <<
-                        std::setprecision(7) <<
-                        "\n    price:  " << price <<
-                        "\n    yield': " << io::rate(calculatedYield));
+    for (unsigned long length : lengths) {
+        for (double& coupon : coupons) {
+            for (auto& frequencie : frequencies) {
+
+                Date dated = vars.today;
+                Date issue = dated;
+                Date maturity = vars.calendar.advance(issue, length, Years);
+
+                ext::shared_ptr<SimpleQuote> rate(new SimpleQuote(0.0));
+                Handle<YieldTermStructure> discountCurve(flatRate(vars.today, rate, bondDayCount));
+
+                Schedule sch(dated, maturity, Period(frequencie), vars.calendar, accrualConvention,
+                             accrualConvention, DateGeneration::Backward, false);
+
+                FixedRateBond bond(settlementDays, vars.faceAmount, sch,
+                                   std::vector<Rate>(1, coupon), bondDayCount, paymentConvention,
+                                   redemption, issue);
+
+                ext::shared_ptr<PricingEngine> bondEngine(new DiscountingBondEngine(discountCurve));
+                bond.setPricingEngine(bondEngine);
+
+                for (double m : yields) {
+
+                    rate->setValue(m);
+
+                    Real price =
+                        BondFunctions::cleanPrice(bond, m, bondDayCount, Continuous, frequencie);
+                    Real calculatedPrice = bond.cleanPrice();
+
+                    if (std::fabs(price - calculatedPrice) > tolerance) {
+                        BOOST_ERROR("price calculation failed:"
+                                    << "\n    issue:     " << issue << "\n    maturity:  "
+                                    << maturity << "\n    coupon:    " << io::rate(coupon)
+                                    << "\n    frequency: " << frequencie
+                                    << "\n    yield:  " << io::rate(m) << std::setprecision(7)
+                                    << "\n    expected:    " << price
+                                    << "\n    calculated': " << calculatedPrice
+                                    << "\n    error':      " << price - calculatedPrice);
+                    }
+
+                    Rate calculatedYield = BondFunctions::yield(
+                        bond, calculatedPrice, bondDayCount, Continuous, frequencie,
+                        bond.settlementDate(), tolerance, maxEvaluations);
+                    if (std::fabs(m - calculatedYield) > tolerance) {
+                        BOOST_ERROR("yield calculation failed:"
+                                    << "\n    issue:     " << issue << "\n    maturity:  "
+                                    << maturity << "\n    coupon:    " << io::rate(coupon)
+                                    << "\n    frequency: " << frequencie
+                                    << "\n    yield:  " << io::rate(m) << std::setprecision(7)
+                                    << "\n    price:  " << price
+                                    << "\n    yield': " << io::rate(calculatedYield));
+                    }
                 }
             }
         }
-      }
     }
 }
 
@@ -1273,39 +1215,28 @@ void BondTest::testExCouponGilt() {
           5.8901860, 43.7239438 }
     };
 
-    for (Size i=0; i<LENGTH(cases); ++i) {
-        Real accrued = bond.accruedAmount(cases[i].settlementDate);
-        ASSERT_CLOSE("accrued amount", cases[i].settlementDate,
-                     accrued, cases[i].accruedAmount, 1e-6);
-        
-        Real npv = cases[i].testPrice + accrued;
-        ASSERT_CLOSE("NPV", cases[i].settlementDate,
-                     npv, cases[i].NPV, 1e-6);
-
-        Rate yield = CashFlows::yield(leg, npv, dc, comp, freq,
-                                      false, cases[i].settlementDate);
-        ASSERT_CLOSE("yield", cases[i].settlementDate,
-                     yield, cases[i].yield, 1e-6);
-
-        Time duration = CashFlows::duration(leg, yield, dc, comp, freq,
-                                            Duration::Modified, false,
-                                            cases[i].settlementDate);
-        ASSERT_CLOSE("duration", cases[i].settlementDate,
-                     duration, cases[i].duration, 1e-6);
-
-        Real convexity = CashFlows::convexity(leg, yield, dc, comp, freq,
-                                              false, cases[i].settlementDate);
-        ASSERT_CLOSE("convexity", cases[i].settlementDate,
-                     convexity, cases[i].convexity, 1e-6);
-
-        Real calcnpv = CashFlows::npv(leg, yield, dc, comp, freq,
-                                      false, cases[i].settlementDate);
-        ASSERT_CLOSE("NPV from yield", cases[i].settlementDate,
-                     calcnpv, cases[i].NPV, 1e-6);
-        
+    for (auto& i : cases) {
+        Real accrued = bond.accruedAmount(i.settlementDate);
+        ASSERT_CLOSE("accrued amount", i.settlementDate, accrued, i.accruedAmount, 1e-6);
+
+        Real npv = i.testPrice + accrued;
+        ASSERT_CLOSE("NPV", i.settlementDate, npv, i.NPV, 1e-6);
+
+        Rate yield = CashFlows::yield(leg, npv, dc, comp, freq, false, i.settlementDate);
+        ASSERT_CLOSE("yield", i.settlementDate, yield, i.yield, 1e-6);
+
+        Time duration = CashFlows::duration(leg, yield, dc, comp, freq, Duration::Modified, false,
+                                            i.settlementDate);
+        ASSERT_CLOSE("duration", i.settlementDate, duration, i.duration, 1e-6);
+
+        Real convexity = CashFlows::convexity(leg, yield, dc, comp, freq, false, i.settlementDate);
+        ASSERT_CLOSE("convexity", i.settlementDate, convexity, i.convexity, 1e-6);
+
+        Real calcnpv = CashFlows::npv(leg, yield, dc, comp, freq, false, i.settlementDate);
+        ASSERT_CLOSE("NPV from yield", i.settlementDate, calcnpv, i.NPV, 1e-6);
+
         Real calcprice = calcnpv - accrued;
-        ASSERT_CLOSE("price from yield", cases[i].settlementDate,
-                     calcprice, cases[i].testPrice, 1e-6);
+        ASSERT_CLOSE("price from yield", i.settlementDate, calcprice, i.testPrice, 1e-6);
     }
 }
 
@@ -1413,39 +1344,28 @@ void BondTest::testExCouponAustralianBond() {
           2.31732, 6.68407 }
     };
 
-    for (Size i=0; i<LENGTH(cases); ++i) {
-        Real accrued = bond.accruedAmount(cases[i].settlementDate);
-        ASSERT_CLOSE("accrued amount", cases[i].settlementDate,
-                     accrued, cases[i].accruedAmount, 1e-3);
-        
-        Real npv = cases[i].testPrice + accrued;
-        ASSERT_CLOSE("NPV", cases[i].settlementDate,
-                     npv, cases[i].NPV, 1e-3);
-
-        Rate yield = CashFlows::yield(leg, npv, dc, comp, freq,
-                                      false, cases[i].settlementDate);
-        ASSERT_CLOSE("yield", cases[i].settlementDate,
-                     yield, cases[i].yield, 1e-5);
-
-        Time duration = CashFlows::duration(leg, yield, dc, comp, freq,
-                                            Duration::Modified, false,
-                                            cases[i].settlementDate);
-        ASSERT_CLOSE("duration", cases[i].settlementDate,
-                     duration, cases[i].duration, 1e-5);
-
-        Real convexity = CashFlows::convexity(leg, yield, dc, comp, freq,
-                                              false, cases[i].settlementDate);
-        ASSERT_CLOSE("convexity", cases[i].settlementDate,
-                     convexity, cases[i].convexity, 1e-4);
-
-        Real calcnpv = CashFlows::npv(leg, yield, dc, comp, freq,
-                                      false, cases[i].settlementDate);
-        ASSERT_CLOSE("NPV from yield", cases[i].settlementDate,
-                     calcnpv, cases[i].NPV, 1e-3);
-        
+    for (auto& i : cases) {
+        Real accrued = bond.accruedAmount(i.settlementDate);
+        ASSERT_CLOSE("accrued amount", i.settlementDate, accrued, i.accruedAmount, 1e-3);
+
+        Real npv = i.testPrice + accrued;
+        ASSERT_CLOSE("NPV", i.settlementDate, npv, i.NPV, 1e-3);
+
+        Rate yield = CashFlows::yield(leg, npv, dc, comp, freq, false, i.settlementDate);
+        ASSERT_CLOSE("yield", i.settlementDate, yield, i.yield, 1e-5);
+
+        Time duration = CashFlows::duration(leg, yield, dc, comp, freq, Duration::Modified, false,
+                                            i.settlementDate);
+        ASSERT_CLOSE("duration", i.settlementDate, duration, i.duration, 1e-5);
+
+        Real convexity = CashFlows::convexity(leg, yield, dc, comp, freq, false, i.settlementDate);
+        ASSERT_CLOSE("convexity", i.settlementDate, convexity, i.convexity, 1e-4);
+
+        Real calcnpv = CashFlows::npv(leg, yield, dc, comp, freq, false, i.settlementDate);
+        ASSERT_CLOSE("NPV from yield", i.settlementDate, calcnpv, i.NPV, 1e-3);
+
         Real calcprice = calcnpv - accrued;
-        ASSERT_CLOSE("price from yield", cases[i].settlementDate,
-                     calcprice, cases[i].testPrice, 1e-3);
+        ASSERT_CLOSE("price from yield", i.settlementDate, calcprice, i.testPrice, 1e-3);
     }
 }
 
diff --git a/test-suite/callablebonds.cpp b/test-suite/callablebonds.cpp
index 7f72d1257c2..ed98e649792 100644
--- a/test-suite/callablebonds.cpp
+++ b/test-suite/callablebonds.cpp
@@ -247,18 +247,16 @@ void CallableBondTest::testConsistency() {
 
     CallabilitySchedule callabilities;
     std::vector<Date> callabilityDates = vars.evenYears();
-    for (Size i=0; i<callabilityDates.size(); ++i) {
+    for (auto& callabilityDate : callabilityDates) {
         callabilities.push_back(ext::make_shared<Callability>(
-                         Bond::Price(110.0, Bond::Price::Clean),
-                         Callability::Call, callabilityDates[i]));
+            Bond::Price(110.0, Bond::Price::Clean), Callability::Call, callabilityDate));
     }
 
     CallabilitySchedule puttabilities;
     std::vector<Date> puttabilityDates = vars.oddYears();
-    for (Size i=0; i<puttabilityDates.size(); ++i) {
-        puttabilities.push_back(ext::make_shared<Callability>(
-                         Bond::Price(90.0, Bond::Price::Clean),
-                         Callability::Put, puttabilityDates[i]));
+    for (auto& puttabilityDate : puttabilityDates) {
+        puttabilities.push_back(ext::make_shared<Callability>(Bond::Price(90.0, Bond::Price::Clean),
+                                                              Callability::Put, puttabilityDate));
     }
 
     Size timeSteps = 240;
@@ -324,16 +322,14 @@ void CallableBondTest::testObservability() {
     CallabilitySchedule callabilities;
 
     std::vector<Date> callabilityDates = vars.evenYears();
-    for (Size i=0; i<callabilityDates.size(); ++i) {
+    for (auto& callabilityDate : callabilityDates) {
         callabilities.push_back(ext::make_shared<Callability>(
-                         Bond::Price(110.0, Bond::Price::Clean),
-                         Callability::Call, callabilityDates[i]));
+            Bond::Price(110.0, Bond::Price::Clean), Callability::Call, callabilityDate));
     }
     std::vector<Date> puttabilityDates = vars.oddYears();
-    for (Size i=0; i<puttabilityDates.size(); ++i) {
-        callabilities.push_back(ext::make_shared<Callability>(
-                         Bond::Price(90.0, Bond::Price::Clean),
-                         Callability::Put, puttabilityDates[i]));
+    for (auto& puttabilityDate : puttabilityDates) {
+        callabilities.push_back(ext::make_shared<Callability>(Bond::Price(90.0, Bond::Price::Clean),
+                                                              Callability::Put, puttabilityDate));
     }
 
     CallableZeroCouponBond bond(3, 100.0, vars.calendar,
@@ -434,16 +430,14 @@ void CallableBondTest::testDegenerate() {
     // out-of-the-money callability
 
     std::vector<Date> callabilityDates = vars.evenYears();
-    for (Size i=0; i<callabilityDates.size(); ++i) {
+    for (auto& callabilityDate : callabilityDates) {
         callabilities.push_back(ext::make_shared<Callability>(
-                         Bond::Price(10000.0, Bond::Price::Clean),
-                         Callability::Call, callabilityDates[i]));
+            Bond::Price(10000.0, Bond::Price::Clean), Callability::Call, callabilityDate));
     }
     std::vector<Date> puttabilityDates = vars.oddYears();
-    for (Size i=0; i<puttabilityDates.size(); ++i) {
-        callabilities.push_back(ext::make_shared<Callability>(
-                         Bond::Price(0.0, Bond::Price::Clean),
-                         Callability::Put, puttabilityDates[i]));
+    for (auto& puttabilityDate : puttabilityDates) {
+        callabilities.push_back(ext::make_shared<Callability>(Bond::Price(0.0, Bond::Price::Clean),
+                                                              Callability::Put, puttabilityDate));
     }
 
     bond1 = CallableZeroCouponBond(3, 100.0, vars.calendar,
@@ -504,20 +498,16 @@ void CallableBondTest::testCached() {
     CallabilitySchedule all_exercises;
 
     std::vector<Date> callabilityDates = vars.evenYears();
-    for (Size i=0; i<callabilityDates.size(); ++i) {
-        ext::shared_ptr<Callability> exercise =
-            ext::make_shared<Callability>(
-                         Bond::Price(110.0, Bond::Price::Clean),
-                         Callability::Call, callabilityDates[i]);
+    for (auto& callabilityDate : callabilityDates) {
+        ext::shared_ptr<Callability> exercise = ext::make_shared<Callability>(
+            Bond::Price(110.0, Bond::Price::Clean), Callability::Call, callabilityDate);
         callabilities.push_back(exercise);
         all_exercises.push_back(exercise);
     }
     std::vector<Date> puttabilityDates = vars.oddYears();
-    for (Size i=0; i<puttabilityDates.size(); ++i) {
-        ext::shared_ptr<Callability> exercise =
-            ext::make_shared<Callability>(
-                         Bond::Price(100.0, Bond::Price::Clean),
-                         Callability::Put, puttabilityDates[i]);
+    for (auto& puttabilityDate : puttabilityDates) {
+        ext::shared_ptr<Callability> exercise = ext::make_shared<Callability>(
+            Bond::Price(100.0, Bond::Price::Clean), Callability::Put, puttabilityDate);
         puttabilities.push_back(exercise);
         all_exercises.push_back(exercise);
     }
diff --git a/test-suite/capfloor.cpp b/test-suite/capfloor.cpp
index 7c92464a4f7..e0606105ece 100644
--- a/test-suite/capfloor.cpp
+++ b/test-suite/capfloor.cpp
@@ -168,20 +168,17 @@ void CapFloorTest::testVega() {
     static const Real shift = 1e-8;
     static const Real tolerance = 0.005;
 
-    for (Size i=0; i<LENGTH(lengths); i++) {
+    for (int length : lengths) {
         for (Size j=0; j<LENGTH(vols); j++) {
-            for (Size k=0; k<LENGTH(strikes); k++) {
-                for (Size h=0; h<LENGTH(types); h++) {
-                    Leg leg = vars.makeLeg(startDate, lengths[i]);
+            for (double strike : strikes) {
+                for (auto& type : types) {
+                    Leg leg = vars.makeLeg(startDate, length);
                     ext::shared_ptr<CapFloor> capFloor =
-                        vars.makeCapFloor(types[h],leg,
-                                          strikes[k],vols[j]);
+                        vars.makeCapFloor(type, leg, strike, vols[j]);
                     ext::shared_ptr<CapFloor> shiftedCapFloor2 =
-                        vars.makeCapFloor(types[h],leg,
-                                          strikes[k],vols[j]+shift);
-                     ext::shared_ptr<CapFloor> shiftedCapFloor1 =
-                        vars.makeCapFloor(types[h],leg,
-                                          strikes[k],vols[j]-shift);
+                        vars.makeCapFloor(type, leg, strike, vols[j] + shift);
+                    ext::shared_ptr<CapFloor> shiftedCapFloor1 =
+                        vars.makeCapFloor(type, leg, strike, vols[j] - shift);
                     Real value1 = shiftedCapFloor1->NPV();
                     Real value2 = shiftedCapFloor2->NPV();
                     Real numericalVega = (value2 - value1) / (2*shift);
@@ -191,16 +188,14 @@ void CapFloorTest::testVega() {
                             std::fabs(numericalVega - analyticalVega);
                         discrepancy /= numericalVega;
                         if (discrepancy > tolerance)
-                            BOOST_FAIL(
-                                "failed to compute cap/floor vega:" <<
-                                "\n   lengths:     " << lengths[j]*Years <<
-                                "\n   strike:      " << io::rate(strikes[k]) <<
-                                //"\n   types:       " << types[h] <<
-                                std::fixed << std::setprecision(12) <<
-                                "\n   calculated:  " << analyticalVega <<
-                                "\n   expected:    " << numericalVega <<
-                                "\n   discrepancy: " << io::rate(discrepancy) <<
-                                "\n   tolerance:   " << io::rate(tolerance));
+                            BOOST_FAIL("failed to compute cap/floor vega:"
+                                       << "\n   lengths:     " << lengths[j] * Years
+                                       << "\n   strike:      " << io::rate(strike) <<
+                                       //"\n   types:       " << types[h] <<
+                                       std::fixed << std::setprecision(12) << "\n   calculated:  "
+                                       << analyticalVega << "\n   expected:    " << numericalVega
+                                       << "\n   discrepancy: " << io::rate(discrepancy)
+                                       << "\n   tolerance:   " << io::rate(tolerance));
                      }
                 }
             }
@@ -222,49 +217,43 @@ void CapFloorTest::testStrikeDependency() {
 
     Date startDate = vars.termStructure->referenceDate();
 
-    for (Size i=0; i<LENGTH(lengths); i++) {
-        for (Size j=0; j<LENGTH(vols); j++) {
+    for (int& length : lengths) {
+        for (double vol : vols) {
             // store the results for different strikes...
             std::vector<Real> cap_values, floor_values;
-            for (Size k=0; k<LENGTH(strikes); k++) {
-                Leg leg = vars.makeLeg(startDate,lengths[i]);
+            for (double strike : strikes) {
+                Leg leg = vars.makeLeg(startDate, length);
                 ext::shared_ptr<Instrument> cap =
-                    vars.makeCapFloor(CapFloor::Cap,leg,
-                                      strikes[k],vols[j]);
+                    vars.makeCapFloor(CapFloor::Cap, leg, strike, vol);
                 cap_values.push_back(cap->NPV());
                 ext::shared_ptr<Instrument> floor =
-                    vars.makeCapFloor(CapFloor::Floor,leg,
-                                      strikes[k],vols[j]);
+                    vars.makeCapFloor(CapFloor::Floor, leg, strike, vol);
                 floor_values.push_back(floor->NPV());
             }
             // and check that they go the right way
             auto it = std::adjacent_find(cap_values.begin(), cap_values.end(), std::less<Real>());
             if (it != cap_values.end()) {
                 Size n = it - cap_values.begin();
-                BOOST_FAIL(
-                    "NPV is increasing with the strike in a cap: \n"
-                    << std::setprecision(2)
-                    << "    length:     " << lengths[i] << " years\n"
-                    << "    volatility: " << io::volatility(vols[j]) << "\n"
-                    << "    value:      " << cap_values[n]
-                    << " at strike: " << io::rate(strikes[n]) << "\n"
-                    << "    value:      " << cap_values[n+1]
-                    << " at strike: " << io::rate(strikes[n+1]));
+                BOOST_FAIL("NPV is increasing with the strike in a cap: \n"
+                           << std::setprecision(2) << "    length:     " << length << " years\n"
+                           << "    volatility: " << io::volatility(vol) << "\n"
+                           << "    value:      " << cap_values[n]
+                           << " at strike: " << io::rate(strikes[n]) << "\n"
+                           << "    value:      " << cap_values[n + 1]
+                           << " at strike: " << io::rate(strikes[n + 1]));
             }
             // same for floors
             it = std::adjacent_find(floor_values.begin(),floor_values.end(),
                                     std::greater<Real>());
             if (it != floor_values.end()) {
                 Size n = it - floor_values.begin();
-                BOOST_FAIL(
-                    "NPV is decreasing with the strike in a floor: \n"
-                    << std::setprecision(2)
-                    << "    length:     " << lengths[i] << " years\n"
-                    << "    volatility: " << io::volatility(vols[j]) << "\n"
-                    << "    value:      " << floor_values[n]
-                    << " at strike: " << io::rate(strikes[n]) << "\n"
-                    << "    value:      " << floor_values[n+1]
-                    << " at strike: " << io::rate(strikes[n+1]));
+                BOOST_FAIL("NPV is decreasing with the strike in a floor: \n"
+                           << std::setprecision(2) << "    length:     " << length << " years\n"
+                           << "    volatility: " << io::volatility(vol) << "\n"
+                           << "    value:      " << floor_values[n]
+                           << " at strike: " << io::rate(strikes[n]) << "\n"
+                           << "    value:      " << floor_values[n + 1]
+                           << " at strike: " << io::rate(strikes[n + 1]));
             }
         }
     }
@@ -285,104 +274,95 @@ void CapFloorTest::testConsistency() {
 
     Date startDate = vars.termStructure->referenceDate();
 
-    for (Size i=0; i<LENGTH(lengths); i++) {
-      for (Size j=0; j<LENGTH(cap_rates); j++) {
-        for (Size k=0; k<LENGTH(floor_rates); k++) {
-          for (Size l=0; l<LENGTH(vols); l++) {
-
-              Leg leg = vars.makeLeg(startDate,lengths[i]);
-              ext::shared_ptr<CapFloor> cap =
-                  vars.makeCapFloor(CapFloor::Cap,leg,
-                                    cap_rates[j],vols[l]);
-              ext::shared_ptr<CapFloor> floor =
-                  vars.makeCapFloor(CapFloor::Floor,leg,
-                                    floor_rates[k],vols[l]);
-              Collar collar(leg,std::vector<Rate>(1,cap_rates[j]),
-                            std::vector<Rate>(1,floor_rates[k]));
-              collar.setPricingEngine(vars.makeEngine(vols[l]));
-
-              if (std::fabs((cap->NPV()-floor->NPV())-collar.NPV()) > 1e-10) {
-                  BOOST_FAIL(
-                    "inconsistency between cap, floor and collar:\n"
-                    << "    length:       " << lengths[i] << " years\n"
-                    << "    volatility:   " << io::volatility(vols[l]) << "\n"
-                    << "    cap value:    " << cap->NPV()
-                    << " at strike: " << io::rate(cap_rates[j]) << "\n"
-                    << "    floor value:  " << floor->NPV()
-                    << " at strike: " << io::rate(floor_rates[k]) << "\n"
-                    << "    collar value: " << collar.NPV());
-
-
-              // test re-composition by optionlets, N.B. two per year
-              Real capletsNPV = 0.0;
-              std::vector<ext::shared_ptr<CapFloor> > caplets;
-              for (Integer m=0; m<lengths[i]*2; m++) {
-                caplets.push_back(cap->optionlet(m));
-                caplets[m]->setPricingEngine(vars.makeEngine(vols[l]));
-                capletsNPV += caplets[m]->NPV();
-              }
-
-              if (std::fabs(cap->NPV() - capletsNPV) > 1e-10) {
-                BOOST_FAIL(
-                  "sum of caplet NPVs does not equal cap NPV:\n"
-                    << "    length:       " << lengths[i] << " years\n"
-                    << "    volatility:   " << io::volatility(vols[l]) << "\n"
-                    << "    cap value:    " << cap->NPV()
-                    << " at strike: " << io::rate(cap_rates[j]) << "\n"
-                    << "    sum of caplets value:  " << capletsNPV
-                    << " at strike (first): " << io::rate(caplets[0]->capRates()[0]) << "\n"
-                );
-              }
-
-              Real floorletsNPV = 0.0;
-              std::vector<ext::shared_ptr<CapFloor> > floorlets;
-              for (Integer m=0; m<lengths[i]*2; m++) {
-                floorlets.push_back(floor->optionlet(m));
-                floorlets[m]->setPricingEngine(vars.makeEngine(vols[l]));
-                floorletsNPV += floorlets[m]->NPV();
-              }
-
-              if (std::fabs(floor->NPV() - floorletsNPV) > 1e-10) {
-                BOOST_FAIL(
-                  "sum of floorlet NPVs does not equal floor NPV:\n"
-                    << "    length:       " << lengths[i] << " years\n"
-                    << "    volatility:   " << io::volatility(vols[l]) << "\n"
-                    << "    cap value:    " << floor->NPV()
-                    << " at strike: " << io::rate(floor_rates[j]) << "\n"
-                    << "    sum of floorlets value:  " << floorletsNPV
-                    << " at strike (first): " << io::rate(floorlets[0]->floorRates()[0]) << "\n"
-                );
-              }
-
-              Real collarletsNPV = 0.0;
-              std::vector<ext::shared_ptr<CapFloor> > collarlets;
-              for (Integer m=0; m<lengths[i]*2; m++) {
-                collarlets.push_back(collar.optionlet(m));
-                collarlets[m]->setPricingEngine(vars.makeEngine(vols[l]));
-                collarletsNPV += collarlets[m]->NPV();
-              }
-
-              if (std::fabs(collar.NPV() - collarletsNPV) > 1e-10) {
-                BOOST_FAIL(
-                  "sum of collarlet NPVs does not equal floor NPV:\n"
-                    << "    length:       " << lengths[i] << " years\n"
-                    << "    volatility:   " << io::volatility(vols[l]) << "\n"
-                    << "    cap value:    " << collar.NPV()
-                    << " at strike floor: " << io::rate(floor_rates[j])
-                    << " at strike cap: " << io::rate(cap_rates[j]) << "\n"
-                    << "    sum of collarlets value:  " << collarletsNPV
-                    << " at strike floor (first): " << io::rate(collarlets[0]->floorRates()[0])
-                    << " at strike cap (first): " << io::rate(collarlets[0]->capRates()[0]) << "\n"
-                );
-              }
-
-
-
-
-              }
-          }
+    for (int& length : lengths) {
+        for (Size j = 0; j < LENGTH(cap_rates); j++) {
+            for (double& floor_rate : floor_rates) {
+                for (double vol : vols) {
+
+                    Leg leg = vars.makeLeg(startDate, length);
+                    ext::shared_ptr<CapFloor> cap =
+                        vars.makeCapFloor(CapFloor::Cap, leg, cap_rates[j], vol);
+                    ext::shared_ptr<CapFloor> floor =
+                        vars.makeCapFloor(CapFloor::Floor, leg, floor_rate, vol);
+                    Collar collar(leg, std::vector<Rate>(1, cap_rates[j]),
+                                  std::vector<Rate>(1, floor_rate));
+                    collar.setPricingEngine(vars.makeEngine(vol));
+
+                    if (std::fabs((cap->NPV() - floor->NPV()) - collar.NPV()) > 1e-10) {
+                        BOOST_FAIL("inconsistency between cap, floor and collar:\n"
+                                   << "    length:       " << length << " years\n"
+                                   << "    volatility:   " << io::volatility(vol) << "\n"
+                                   << "    cap value:    " << cap->NPV()
+                                   << " at strike: " << io::rate(cap_rates[j]) << "\n"
+                                   << "    floor value:  " << floor->NPV()
+                                   << " at strike: " << io::rate(floor_rate) << "\n"
+                                   << "    collar value: " << collar.NPV());
+
+
+                        // test re-composition by optionlets, N.B. two per year
+                        Real capletsNPV = 0.0;
+                        std::vector<ext::shared_ptr<CapFloor> > caplets;
+                        for (Integer m = 0; m < length * 2; m++) {
+                            caplets.push_back(cap->optionlet(m));
+                            caplets[m]->setPricingEngine(vars.makeEngine(vol));
+                            capletsNPV += caplets[m]->NPV();
+                        }
+
+                        if (std::fabs(cap->NPV() - capletsNPV) > 1e-10) {
+                            BOOST_FAIL("sum of caplet NPVs does not equal cap NPV:\n"
+                                       << "    length:       " << length << " years\n"
+                                       << "    volatility:   " << io::volatility(vol) << "\n"
+                                       << "    cap value:    " << cap->NPV()
+                                       << " at strike: " << io::rate(cap_rates[j]) << "\n"
+                                       << "    sum of caplets value:  " << capletsNPV
+                                       << " at strike (first): "
+                                       << io::rate(caplets[0]->capRates()[0]) << "\n");
+                        }
+
+                        Real floorletsNPV = 0.0;
+                        std::vector<ext::shared_ptr<CapFloor> > floorlets;
+                        for (Integer m = 0; m < length * 2; m++) {
+                            floorlets.push_back(floor->optionlet(m));
+                            floorlets[m]->setPricingEngine(vars.makeEngine(vol));
+                            floorletsNPV += floorlets[m]->NPV();
+                        }
+
+                        if (std::fabs(floor->NPV() - floorletsNPV) > 1e-10) {
+                            BOOST_FAIL("sum of floorlet NPVs does not equal floor NPV:\n"
+                                       << "    length:       " << length << " years\n"
+                                       << "    volatility:   " << io::volatility(vol) << "\n"
+                                       << "    cap value:    " << floor->NPV()
+                                       << " at strike: " << io::rate(floor_rates[j]) << "\n"
+                                       << "    sum of floorlets value:  " << floorletsNPV
+                                       << " at strike (first): "
+                                       << io::rate(floorlets[0]->floorRates()[0]) << "\n");
+                        }
+
+                        Real collarletsNPV = 0.0;
+                        std::vector<ext::shared_ptr<CapFloor> > collarlets;
+                        for (Integer m = 0; m < length * 2; m++) {
+                            collarlets.push_back(collar.optionlet(m));
+                            collarlets[m]->setPricingEngine(vars.makeEngine(vol));
+                            collarletsNPV += collarlets[m]->NPV();
+                        }
+
+                        if (std::fabs(collar.NPV() - collarletsNPV) > 1e-10) {
+                            BOOST_FAIL("sum of collarlet NPVs does not equal floor NPV:\n"
+                                       << "    length:       " << length << " years\n"
+                                       << "    volatility:   " << io::volatility(vol) << "\n"
+                                       << "    cap value:    " << collar.NPV()
+                                       << " at strike floor: " << io::rate(floor_rates[j])
+                                       << " at strike cap: " << io::rate(cap_rates[j]) << "\n"
+                                       << "    sum of collarlets value:  " << collarletsNPV
+                                       << " at strike floor (first): "
+                                       << io::rate(collarlets[0]->floorRates()[0])
+                                       << " at strike cap (first): "
+                                       << io::rate(collarlets[0]->capRates()[0]) << "\n");
+                        }
+                    }
+                }
+            }
         }
-      }
     }
 }
 
@@ -400,42 +380,35 @@ void CapFloorTest::testParity() {
 
     Date startDate = vars.termStructure->referenceDate();
 
-    for (Size i=0; i<LENGTH(lengths); i++) {
-      for (Size j=0; j<LENGTH(strikes); j++) {
-        for (Size k=0; k<LENGTH(vols); k++) {
-
-            Leg leg = vars.makeLeg(startDate,lengths[i]);
-            ext::shared_ptr<Instrument> cap =
-                vars.makeCapFloor(CapFloor::Cap,leg,
-                                  strikes[j],vols[k]);
-            ext::shared_ptr<Instrument> floor =
-                vars.makeCapFloor(CapFloor::Floor,leg,
-                                  strikes[j],vols[k]);
-            Date maturity = vars.calendar.advance(startDate,lengths[i],Years,
-                                              vars.convention);
-            Schedule schedule(startDate,maturity,
-                              Period(vars.frequency),vars.calendar,
-                              vars.convention,vars.convention,
-                              DateGeneration::Forward,false);
-            VanillaSwap swap(VanillaSwap::Payer, vars.nominals[0],
-                             schedule, strikes[j], vars.index->dayCounter(),
-                             schedule, vars.index, 0.0,
-                             vars.index->dayCounter());
-            swap.setPricingEngine(ext::shared_ptr<PricingEngine>(
-                              new DiscountingSwapEngine(vars.termStructure)));
-            // FLOATING_POINT_EXCEPTION
-            if (std::fabs((cap->NPV()-floor->NPV()) - swap.NPV()) > 1.0e-10) {
-                BOOST_FAIL(
-                    "put/call parity violated:\n"
-                    << "    length:      " << lengths[i] << " years\n"
-                    << "    volatility:  " << io::volatility(vols[k]) << "\n"
-                    << "    strike:      " << io::rate(strikes[j]) << "\n"
-                    << "    cap value:   " << cap->NPV() << "\n"
-                    << "    floor value: " << floor->NPV() << "\n"
-                    << "    swap value:  " << swap.NPV());
+    for (int& length : lengths) {
+        for (double strike : strikes) {
+            for (double vol : vols) {
+
+                Leg leg = vars.makeLeg(startDate, length);
+                ext::shared_ptr<Instrument> cap =
+                    vars.makeCapFloor(CapFloor::Cap, leg, strike, vol);
+                ext::shared_ptr<Instrument> floor =
+                    vars.makeCapFloor(CapFloor::Floor, leg, strike, vol);
+                Date maturity = vars.calendar.advance(startDate, length, Years, vars.convention);
+                Schedule schedule(startDate, maturity, Period(vars.frequency), vars.calendar,
+                                  vars.convention, vars.convention, DateGeneration::Forward, false);
+                VanillaSwap swap(VanillaSwap::Payer, vars.nominals[0], schedule, strike,
+                                 vars.index->dayCounter(), schedule, vars.index, 0.0,
+                                 vars.index->dayCounter());
+                swap.setPricingEngine(
+                    ext::shared_ptr<PricingEngine>(new DiscountingSwapEngine(vars.termStructure)));
+                // FLOATING_POINT_EXCEPTION
+                if (std::fabs((cap->NPV() - floor->NPV()) - swap.NPV()) > 1.0e-10) {
+                    BOOST_FAIL("put/call parity violated:\n"
+                               << "    length:      " << length << " years\n"
+                               << "    volatility:  " << io::volatility(vol) << "\n"
+                               << "    strike:      " << io::rate(strike) << "\n"
+                               << "    cap value:   " << cap->NPV() << "\n"
+                               << "    floor value: " << floor->NPV() << "\n"
+                               << "    swap value:  " << swap.NPV());
+                }
             }
         }
-      }
     }
 }
 
@@ -453,34 +426,30 @@ void CapFloorTest::testATMRate() {
 
     Date startDate = vars.termStructure->referenceDate();
 
-    for (Size i=0; i<LENGTH(lengths); i++) {
-        Leg leg = vars.makeLeg(startDate,lengths[i]);
-        Date maturity = vars.calendar.advance(startDate,lengths[i],Years,
-                                  vars.convention);
+    for (int& length : lengths) {
+        Leg leg = vars.makeLeg(startDate, length);
+        Date maturity = vars.calendar.advance(startDate, length, Years, vars.convention);
         Schedule schedule(startDate,maturity,
                           Period(vars.frequency),vars.calendar,
                           vars.convention,vars.convention,
                           DateGeneration::Forward,false);
 
-        for (Size j=0; j<LENGTH(strikes); j++) {
-            for (Size k=0; k<LENGTH(vols); k++) {
-                ext::shared_ptr<CapFloor> cap =
-                    vars.makeCapFloor(CapFloor::Cap, leg, strikes[j],vols[k]);
+        for (double strike : strikes) {
+            for (double vol : vols) {
+                ext::shared_ptr<CapFloor> cap = vars.makeCapFloor(CapFloor::Cap, leg, strike, vol);
                 ext::shared_ptr<CapFloor> floor =
-                    vars.makeCapFloor(CapFloor::Floor, leg, strikes[j],vols[k]);
+                    vars.makeCapFloor(CapFloor::Floor, leg, strike, vol);
                 Rate capATMRate = cap->atmRate(**vars.termStructure);
                 Rate floorATMRate = floor->atmRate(**vars.termStructure);
                 if (!checkAbsError(floorATMRate, capATMRate, 1.0e-10))
-                    BOOST_FAIL(
-                      "Cap ATM Rate and floor ATM Rate should be equal :\n"
-                      << "   length:        " << lengths[i] << " years\n"
-                      << "   volatility:    " << io::volatility(vols[k]) << "\n"
-                      << "   strike:        " << io::rate(strikes[j]) << "\n"
-                      << "   cap ATM rate:  " << capATMRate << "\n"
-                      << "   floor ATM rate:" << floorATMRate << "\n"
-                      << "   relative Error:"
-                      << relativeError(capATMRate, floorATMRate,
-                                       capATMRate)*100 << "%" );
+                    BOOST_FAIL("Cap ATM Rate and floor ATM Rate should be equal :\n"
+                               << "   length:        " << length << " years\n"
+                               << "   volatility:    " << io::volatility(vol) << "\n"
+                               << "   strike:        " << io::rate(strike) << "\n"
+                               << "   cap ATM rate:  " << capATMRate << "\n"
+                               << "   floor ATM rate:" << floorATMRate << "\n"
+                               << "   relative Error:"
+                               << relativeError(capATMRate, floorATMRate, capATMRate) * 100 << "%");
                 VanillaSwap swap(VanillaSwap::Payer, vars.nominals[0],
                                  schedule, floorATMRate,
                                  vars.index->dayCounter(),
@@ -490,15 +459,14 @@ void CapFloorTest::testATMRate() {
                               new DiscountingSwapEngine(vars.termStructure)));
                 Real swapNPV = swap.NPV();
                 if (!checkAbsError(swapNPV, 0, 1.0e-10))
-                    BOOST_FAIL(
-                      "the NPV of a Swap struck at ATM rate "
-                      "should be equal to 0:\n"
-                      << "   length:        " << lengths[i] << " years\n"
-                      << "   volatility:    " << io::volatility(vols[k]) << "\n"
-                      << "   ATM rate:      " << io::rate(floorATMRate) << "\n"
-                      << "   swap NPV:      " << swapNPV);
+                    BOOST_FAIL("the NPV of a Swap struck at ATM rate "
+                               "should be equal to 0:\n"
+                               << "   length:        " << length << " years\n"
+                               << "   volatility:    " << io::volatility(vol) << "\n"
+                               << "   ATM rate:      " << io::rate(floorATMRate) << "\n"
+                               << "   swap NPV:      " << swapNPV);
+            }
         }
-      }
     }
 }
 
@@ -522,22 +490,18 @@ void CapFloorTest::testImpliedVolatility() {
     Rate rRates[] = { 0.02, 0.03, 0.04, 0.05, 0.06, 0.07 };
     Volatility vols[] = { 0.01, 0.05, 0.10, 0.20, 0.30, 0.70, 0.90 };
 
-    for (Size k=0; k<LENGTH(lengths); k++) {
-        Leg leg = vars.makeLeg(vars.settlement, lengths[k]);
+    for (int& length : lengths) {
+        Leg leg = vars.makeLeg(vars.settlement, length);
 
-        for (Size i=0; i<LENGTH(types); i++) {
-            for (Size j=0; j<LENGTH(strikes); j++) {
+        for (auto& type : types) {
+            for (double strike : strikes) {
 
-                ext::shared_ptr<CapFloor> capfloor =
-                    vars.makeCapFloor(types[i], leg, strikes[j], 0.0);
+                ext::shared_ptr<CapFloor> capfloor = vars.makeCapFloor(type, leg, strike, 0.0);
 
-                for (Size n=0; n<LENGTH(rRates); n++) {
-                    for (Size m=0; m<LENGTH(vols); m++) {
+                for (double r : rRates) {
+                    for (double v : vols) {
 
-                        Rate r = rRates[n];
-                        Volatility v = vols[m];
-                        vars.termStructure.linkTo(flatRate(vars.settlement,r,
-                                                       Actual360()));
+                        vars.termStructure.linkTo(flatRate(vars.settlement, r, Actual360()));
                         capfloor->setPricingEngine(vars.makeEngine(v));
 
                         Real value = capfloor->NPV();
@@ -560,14 +524,13 @@ void CapFloorTest::testImpliedVolatility() {
                                 continue;
                             }
                             // otherwise, report error
-                            BOOST_ERROR("implied vol failure: " <<
-                                        typeToString(types[i]) <<
-                                        "\n  strike:     " << io::rate(strikes[j]) <<
-                                        "\n  risk-free:  " << io::rate(r) <<
-                                        "\n  length:     " << lengths[k] << "Y" <<
-                                        "\n  volatility: " << io::volatility(v) <<
-                                        "\n  price:      " << value <<
-                                        "\n" << e.what());
+                            BOOST_ERROR("implied vol failure: "
+                                        << typeToString(type) << "\n  strike:     "
+                                        << io::rate(strike) << "\n  risk-free:  " << io::rate(r)
+                                        << "\n  length:     " << length << "Y"
+                                        << "\n  volatility: " << io::volatility(v)
+                                        << "\n  price:      " << value << "\n"
+                                        << e.what());
                         }
                         if (std::fabs(implVol-v) > tolerance) {
                             // the difference might not matter
@@ -575,15 +538,15 @@ void CapFloorTest::testImpliedVolatility() {
                                                     vars.makeEngine(implVol));
                             Real value2 = capfloor->NPV();
                             if (std::fabs(value-value2) > tolerance) {
-                            BOOST_FAIL("implied vol failure: " <<
-                                       typeToString(types[i]) <<
-                                       "\n  strike:        " << io::rate(strikes[j]) <<
-                                       "\n  risk-free:     " << io::rate(r) <<
-                                       "\n  length:        " << lengths[k] << "Y" <<
-                                       "\n  volatility:    " << io::volatility(v) <<
-                                       "\n  price:         " << value <<
-                                       "\n  implied vol:   " << io::volatility(implVol) <<
-                                       "\n  implied price: " << value2);
+                                BOOST_FAIL("implied vol failure: "
+                                           << typeToString(type)
+                                           << "\n  strike:        " << io::rate(strike)
+                                           << "\n  risk-free:     " << io::rate(r)
+                                           << "\n  length:        " << length << "Y"
+                                           << "\n  volatility:    " << io::volatility(v)
+                                           << "\n  price:         " << value
+                                           << "\n  implied vol:   " << io::volatility(implVol)
+                                           << "\n  implied price: " << value2);
                             }
                         }
                     }
@@ -685,12 +648,12 @@ void CapFloorTest::testCachedValueFromOptionLets() {
             << "    calculated: " << capletPrices.size() << " caplet prices\n"
             << "    expected:   " << 40);
 
-    for (Size n=0; n<capletPrices.size(); n++){
-        calculatedCapletsNPV += capletPrices[n];
+    for (double capletPrice : capletPrices) {
+        calculatedCapletsNPV += capletPrice;
     }
 
-    for (Size n=0; n<floorletPrices.size(); n++){
-        calculatedFloorletsNPV += floorletPrices[n];
+    for (double floorletPrice : floorletPrices) {
+        calculatedFloorletsNPV += floorletPrice;
     }
 
     if (std::fabs(calculatedCapletsNPV-cachedCapNPV) > 1.0e-11)
diff --git a/test-suite/cashflows.cpp b/test-suite/cashflows.cpp
index acdc04b8120..a7a60cdf0d6 100644
--- a/test-suite/cashflows.cpp
+++ b/test-suite/cashflows.cpp
@@ -281,8 +281,8 @@ void CashFlowsTest::testExCouponDates() {
 
     // no ex-coupon dates
     Leg l1 = FixedRateLeg(schedule).withNotionals(100.0).withCouponRates(0.03, Actual360());
-    for (Size i = 0; i < l1.size(); ++i) {
-        ext::shared_ptr<Coupon> c = ext::dynamic_pointer_cast<Coupon>(l1[i]);
+    for (auto& i : l1) {
+        ext::shared_ptr<Coupon> c = ext::dynamic_pointer_cast<Coupon>(i);
         if (c->exCouponDate() != Date()) {
             BOOST_ERROR("ex-coupon date found (none expected)");
         }
@@ -291,8 +291,8 @@ void CashFlowsTest::testExCouponDates() {
     // same for floating legs
     ext::shared_ptr<IborIndex> index(new Euribor3M);
     Leg l2 = IborLeg(schedule, index).withNotionals(100.0);
-    for (Size i = 0; i < l2.size(); ++i) {
-        ext::shared_ptr<Coupon> c = ext::dynamic_pointer_cast<Coupon>(l2[i]);
+    for (auto& i : l2) {
+        ext::shared_ptr<Coupon> c = ext::dynamic_pointer_cast<Coupon>(i);
         if (c->exCouponDate() != Date()) {
             BOOST_ERROR("ex-coupon date found (none expected)");
         }
@@ -303,8 +303,8 @@ void CashFlowsTest::testExCouponDates() {
                  .withNotionals(100.0)
                  .withCouponRates(0.03, Actual360())
                  .withExCouponPeriod(Period(2, Days), NullCalendar(), Unadjusted, false);
-    for (Size i = 0; i < l5.size(); ++i) {
-        ext::shared_ptr<Coupon> c = ext::dynamic_pointer_cast<Coupon>(l5[i]);
+    for (auto& i : l5) {
+        ext::shared_ptr<Coupon> c = ext::dynamic_pointer_cast<Coupon>(i);
         Date expected = c->accrualEndDate() - 2;
         if (c->exCouponDate() != expected) {
             BOOST_ERROR("ex-coupon date = " << c->exCouponDate() << " (" << expected
@@ -315,8 +315,8 @@ void CashFlowsTest::testExCouponDates() {
     Leg l6 = IborLeg(schedule, index)
                  .withNotionals(100.0)
                  .withExCouponPeriod(Period(2, Days), NullCalendar(), Unadjusted, false);
-    for (Size i = 0; i < l6.size(); ++i) {
-        ext::shared_ptr<Coupon> c = ext::dynamic_pointer_cast<Coupon>(l6[i]);
+    for (auto& i : l6) {
+        ext::shared_ptr<Coupon> c = ext::dynamic_pointer_cast<Coupon>(i);
         Date expected = c->accrualEndDate() - 2;
         if (c->exCouponDate() != expected) {
             BOOST_ERROR("ex-coupon date = " << c->exCouponDate() << " (" << expected
@@ -329,8 +329,8 @@ void CashFlowsTest::testExCouponDates() {
                  .withNotionals(100.0)
                  .withCouponRates(0.03, Actual360())
                  .withExCouponPeriod(Period(2, Days), TARGET(), Preceding, false);
-    for (Size i = 0; i < l7.size(); ++i) {
-        ext::shared_ptr<Coupon> c = ext::dynamic_pointer_cast<Coupon>(l7[i]);
+    for (auto& i : l7) {
+        ext::shared_ptr<Coupon> c = ext::dynamic_pointer_cast<Coupon>(i);
         Date expected = TARGET().advance(c->accrualEndDate(), -2, Days);
         if (c->exCouponDate() != expected) {
             BOOST_ERROR("ex-coupon date = " << c->exCouponDate() << " (" << expected
@@ -341,8 +341,8 @@ void CashFlowsTest::testExCouponDates() {
     Leg l8 = IborLeg(schedule, index)
                  .withNotionals(100.0)
                  .withExCouponPeriod(Period(2, Days), TARGET(), Preceding, false);
-    for (Size i = 0; i < l8.size(); ++i) {
-        ext::shared_ptr<Coupon> c = ext::dynamic_pointer_cast<Coupon>(l8[i]);
+    for (auto& i : l8) {
+        ext::shared_ptr<Coupon> c = ext::dynamic_pointer_cast<Coupon>(i);
         Date expected = TARGET().advance(c->accrualEndDate(), -2, Days);
         if (c->exCouponDate() != expected) {
             BOOST_ERROR("ex-coupon date = " << c->exCouponDate() << " (" << expected
diff --git a/test-suite/catbonds.cpp b/test-suite/catbonds.cpp
index df8df77cf73..36ed15112a5 100644
--- a/test-suite/catbonds.cpp
+++ b/test-suite/catbonds.cpp
@@ -157,7 +157,8 @@ void CatBondTest::testBetaRisk() {
     {
         BOOST_REQUIRE(simulation->nextPath(path));
         Real processValue = 0.0;
-        for(size_t j=0; j<path.size(); ++j) processValue+=path[j].second;
+        for (auto& j : path)
+            processValue += j.second;
         sum+=processValue;
         sumSquares+=processValue*processValue;
         poissonSum+=path.size();
diff --git a/test-suite/cliquetoption.cpp b/test-suite/cliquetoption.cpp
index 5f7b091eb2c..19374afc1e2 100644
--- a/test-suite/cliquetoption.cpp
+++ b/test-suite/cliquetoption.cpp
@@ -141,121 +141,115 @@ namespace {
                             new BlackScholesMertonProcess(Handle<Quote>(spot),
                                                           qTS, rTS, volTS));
 
-        for (Size i=0; i<LENGTH(types); i++) {
-          for (Size j=0; j<LENGTH(moneyness); j++) {
-            for (Size k=0; k<LENGTH(lengths); k++) {
-              for (Size kk=0; kk<LENGTH(frequencies); kk++) {
-
-                ext::shared_ptr<EuropeanExercise> maturity(
-                              new EuropeanExercise(today + lengths[k]*Years));
-
-                ext::shared_ptr<PercentageStrikePayoff> payoff(
-                          new PercentageStrikePayoff(types[i], moneyness[j]));
-
-                std::vector<Date> reset;
-                for (Date d = today + Period(frequencies[kk]);
-                     d < maturity->lastDate();
-                     d += Period(frequencies[kk]))
-                    reset.push_back(d);
-
-                ext::shared_ptr<PricingEngine> engine(new T(process));
-
-                CliquetOption option(payoff, maturity, reset);
-                option.setPricingEngine(engine);
-
-                for (Size l=0; l<LENGTH(underlyings); l++) {
-                  for (Size m=0; m<LENGTH(qRates); m++) {
-                    for (Size n=0; n<LENGTH(rRates); n++) {
-                      for (Size p=0; p<LENGTH(vols); p++) {
-
-                        Real u = underlyings[l];
-                        Rate q = qRates[m],
-                             r = rRates[n];
-                        Volatility v = vols[p];
-                        spot->setValue(u);
-                        qRate->setValue(q);
-                        rRate->setValue(r);
-                        vol->setValue(v);
-
-                        Real value = option.NPV();
-                        calculated["delta"]  = option.delta();
-                        calculated["gamma"]  = option.gamma();
-                        calculated["theta"]  = option.theta();
-                        calculated["rho"]    = option.rho();
-                        calculated["divRho"] = option.dividendRho();
-                        calculated["vega"]   = option.vega();
-
-                        if (value > spot->value()*1.0e-5) {
-                          // perturb spot and get delta and gamma
-                          Real du = u*1.0e-4;
-                          spot->setValue(u+du);
-                          Real value_p = option.NPV(),
-                               delta_p = option.delta();
-                          spot->setValue(u-du);
-                          Real value_m = option.NPV(),
-                               delta_m = option.delta();
-                          spot->setValue(u);
-                          expected["delta"] = (value_p - value_m)/(2*du);
-                          expected["gamma"] = (delta_p - delta_m)/(2*du);
-
-                          // perturb rates and get rho and dividend rho
-                          Spread dr = r*1.0e-4;
-                          rRate->setValue(r+dr);
-                          value_p = option.NPV();
-                          rRate->setValue(r-dr);
-                          value_m = option.NPV();
-                          rRate->setValue(r);
-                          expected["rho"] = (value_p - value_m)/(2*dr);
-
-                          Spread dq = q*1.0e-4;
-                          qRate->setValue(q+dq);
-                          value_p = option.NPV();
-                          qRate->setValue(q-dq);
-                          value_m = option.NPV();
-                          qRate->setValue(q);
-                          expected["divRho"] = (value_p - value_m)/(2*dq);
-
-                          // perturb volatility and get vega
-                          Volatility dv = v*1.0e-4;
-                          vol->setValue(v+dv);
-                          value_p = option.NPV();
-                          vol->setValue(v-dv);
-                          value_m = option.NPV();
-                          vol->setValue(v);
-                          expected["vega"] = (value_p - value_m)/(2*dv);
-
-                          // perturb date and get theta
-                          Time dT = dc.yearFraction(today-1, today+1);
-                          Settings::instance().evaluationDate() = today-1;
-                          value_m = option.NPV();
-                          Settings::instance().evaluationDate() = today+1;
-                          value_p = option.NPV();
-                          Settings::instance().evaluationDate() = today;
-                          expected["theta"] = (value_p - value_m)/dT;
-
-                          // compare
-                          std::map<std::string,Real>::iterator it;
-                          for (it = calculated.begin();
-                               it != calculated.end(); ++it) {
-                              std::string greek = it->first;
-                              Real expct = expected  [greek],
-                                   calcl = calculated[greek],
-                                   tol   = tolerance [greek];
-                              Real error = relativeError(expct,calcl,u);
-                              if (error>tol) {
-                                  REPORT_FAILURE(greek, payoff, maturity,
-                                                 u, q, r, today, v,
-                                                 expct, calcl, error, tol);
-                              }
-                          }
+        for (auto& type : types) {
+            for (double moneynes : moneyness) {
+                for (int length : lengths) {
+                    for (auto& frequencie : frequencies) {
+
+                        ext::shared_ptr<EuropeanExercise> maturity(
+                            new EuropeanExercise(today + length * Years));
+
+                        ext::shared_ptr<PercentageStrikePayoff> payoff(
+                            new PercentageStrikePayoff(type, moneynes));
+
+                        std::vector<Date> reset;
+                        for (Date d = today + Period(frequencie); d < maturity->lastDate();
+                             d += Period(frequencie))
+                            reset.push_back(d);
+
+                        ext::shared_ptr<PricingEngine> engine(new T(process));
+
+                        CliquetOption option(payoff, maturity, reset);
+                        option.setPricingEngine(engine);
+
+                        for (double u : underlyings) {
+                            for (double m : qRates) {
+                                for (double n : rRates) {
+                                    for (double v : vols) {
+
+                                        Rate q = m, r = n;
+                                        spot->setValue(u);
+                                        qRate->setValue(q);
+                                        rRate->setValue(r);
+                                        vol->setValue(v);
+
+                                        Real value = option.NPV();
+                                        calculated["delta"] = option.delta();
+                                        calculated["gamma"] = option.gamma();
+                                        calculated["theta"] = option.theta();
+                                        calculated["rho"] = option.rho();
+                                        calculated["divRho"] = option.dividendRho();
+                                        calculated["vega"] = option.vega();
+
+                                        if (value > spot->value() * 1.0e-5) {
+                                            // perturb spot and get delta and gamma
+                                            Real du = u * 1.0e-4;
+                                            spot->setValue(u + du);
+                                            Real value_p = option.NPV(), delta_p = option.delta();
+                                            spot->setValue(u - du);
+                                            Real value_m = option.NPV(), delta_m = option.delta();
+                                            spot->setValue(u);
+                                            expected["delta"] = (value_p - value_m) / (2 * du);
+                                            expected["gamma"] = (delta_p - delta_m) / (2 * du);
+
+                                            // perturb rates and get rho and dividend rho
+                                            Spread dr = r * 1.0e-4;
+                                            rRate->setValue(r + dr);
+                                            value_p = option.NPV();
+                                            rRate->setValue(r - dr);
+                                            value_m = option.NPV();
+                                            rRate->setValue(r);
+                                            expected["rho"] = (value_p - value_m) / (2 * dr);
+
+                                            Spread dq = q * 1.0e-4;
+                                            qRate->setValue(q + dq);
+                                            value_p = option.NPV();
+                                            qRate->setValue(q - dq);
+                                            value_m = option.NPV();
+                                            qRate->setValue(q);
+                                            expected["divRho"] = (value_p - value_m) / (2 * dq);
+
+                                            // perturb volatility and get vega
+                                            Volatility dv = v * 1.0e-4;
+                                            vol->setValue(v + dv);
+                                            value_p = option.NPV();
+                                            vol->setValue(v - dv);
+                                            value_m = option.NPV();
+                                            vol->setValue(v);
+                                            expected["vega"] = (value_p - value_m) / (2 * dv);
+
+                                            // perturb date and get theta
+                                            Time dT = dc.yearFraction(today - 1, today + 1);
+                                            Settings::instance().evaluationDate() = today - 1;
+                                            value_m = option.NPV();
+                                            Settings::instance().evaluationDate() = today + 1;
+                                            value_p = option.NPV();
+                                            Settings::instance().evaluationDate() = today;
+                                            expected["theta"] = (value_p - value_m) / dT;
+
+                                            // compare
+                                            std::map<std::string, Real>::iterator it;
+                                            for (it = calculated.begin(); it != calculated.end();
+                                                 ++it) {
+                                                std::string greek = it->first;
+                                                Real expct = expected[greek],
+                                                     calcl = calculated[greek],
+                                                     tol = tolerance[greek];
+                                                Real error = relativeError(expct, calcl, u);
+                                                if (error > tol) {
+                                                    REPORT_FAILURE(greek, payoff, maturity, u, q, r,
+                                                                   today, v, expct, calcl, error,
+                                                                   tol);
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
                         }
-                      }
                     }
-                  }
                 }
-              }
             }
-          }
         }
     }
 
@@ -305,68 +299,63 @@ void CliquetOptionTest::testMcPerformance() {
                             new BlackScholesMertonProcess(Handle<Quote>(spot),
                                                           qTS, rTS, volTS));
 
-    for (Size i=0; i<LENGTH(types); i++) {
-      for (Size j=0; j<LENGTH(moneyness); j++) {
-        for (Size k=0; k<LENGTH(lengths); k++) {
-          for (Size kk=0; kk<LENGTH(frequencies); kk++) {
-
-              Period tenor = Period(frequencies[kk]);
-              ext::shared_ptr<EuropeanExercise> maturity(
-                              new EuropeanExercise(today + lengths[k]*tenor));
-
-              ext::shared_ptr<PercentageStrikePayoff> payoff(
-                          new PercentageStrikePayoff(types[i], moneyness[j]));
-
-              std::vector<Date> reset;
-              for (Date d = today + tenor; d < maturity->lastDate(); d += tenor)
-                  reset.push_back(d);
-
-              CliquetOption option(payoff, maturity, reset);
-
-              ext::shared_ptr<PricingEngine> refEngine(
-                                      new AnalyticPerformanceEngine(process));
-
-              ext::shared_ptr<PricingEngine> mcEngine =
-                  MakeMCPerformanceEngine<PseudoRandom>(process)
-                  .withBrownianBridge()
-                  .withAbsoluteTolerance(5.0e-3)
-                  .withSeed(42);
-
-              for (Size l=0; l<LENGTH(underlyings); l++) {
-                for (Size m=0; m<LENGTH(qRates); m++) {
-                  for (Size n=0; n<LENGTH(rRates); n++) {
-                    for (Size p=0; p<LENGTH(vols); p++) {
-
-                      Real u = underlyings[l];
-                      Rate q = qRates[m],
-                           r = rRates[n];
-                      Volatility v = vols[p];
-                      spot->setValue(u);
-                      qRate->setValue(q);
-                      rRate->setValue(r);
-                      vol->setValue(v);
-
-                      option.setPricingEngine(refEngine);
-                      Real refValue = option.NPV();
-
-                      option.setPricingEngine(mcEngine);
-                      Real value = option.NPV();
-
-                      Real error = std::fabs(refValue-value);
-                      Real tolerance = 1.5e-2;
-                      if (error > tolerance) {
-                          REPORT_FAILURE("value", payoff, maturity,
-                                         u, q, r, today, v,
-                                         refValue, value,
-                                         error, tolerance);
-                      }
+    for (auto& type : types) {
+        for (double moneynes : moneyness) {
+            for (int length : lengths) {
+                for (auto& frequencie : frequencies) {
+
+                    Period tenor = Period(frequencie);
+                    ext::shared_ptr<EuropeanExercise> maturity(
+                        new EuropeanExercise(today + length * tenor));
+
+                    ext::shared_ptr<PercentageStrikePayoff> payoff(
+                        new PercentageStrikePayoff(type, moneynes));
+
+                    std::vector<Date> reset;
+                    for (Date d = today + tenor; d < maturity->lastDate(); d += tenor)
+                        reset.push_back(d);
+
+                    CliquetOption option(payoff, maturity, reset);
+
+                    ext::shared_ptr<PricingEngine> refEngine(
+                        new AnalyticPerformanceEngine(process));
+
+                    ext::shared_ptr<PricingEngine> mcEngine =
+                        MakeMCPerformanceEngine<PseudoRandom>(process)
+                            .withBrownianBridge()
+                            .withAbsoluteTolerance(5.0e-3)
+                            .withSeed(42);
+
+                    for (double u : underlyings) {
+                        for (double m : qRates) {
+                            for (double n : rRates) {
+                                for (double v : vols) {
+
+                                    Rate q = m, r = n;
+                                    spot->setValue(u);
+                                    qRate->setValue(q);
+                                    rRate->setValue(r);
+                                    vol->setValue(v);
+
+                                    option.setPricingEngine(refEngine);
+                                    Real refValue = option.NPV();
+
+                                    option.setPricingEngine(mcEngine);
+                                    Real value = option.NPV();
+
+                                    Real error = std::fabs(refValue - value);
+                                    Real tolerance = 1.5e-2;
+                                    if (error > tolerance) {
+                                        REPORT_FAILURE("value", payoff, maturity, u, q, r, today, v,
+                                                       refValue, value, error, tolerance);
+                                    }
+                                }
+                            }
+                        }
                     }
-                  }
                 }
-              }
-          }
+            }
         }
-      }
     }
 }
 
diff --git a/test-suite/cms.cpp b/test-suite/cms.cpp
index d4965d32f57..45b3122401e 100644
--- a/test-suite/cms.cpp
+++ b/test-suite/cms.cpp
@@ -455,10 +455,10 @@ void CmsTest::testParity() {
                                         startDate, endDate,
                                         vars.iborIndex->dayCounter());
 
-        for (Size i=0; i<swaptionVols.size(); ++i) {
+        for (auto& swaptionVol : swaptionVols) {
             for (Size j=0; j<vars.yieldCurveModels.size(); ++j) {
-                vars.numericalPricers[j]->setSwaptionVolatility(swaptionVols[i]);
-                vars.analyticPricers[j]->setSwaptionVolatility(swaptionVols[i]);
+                vars.numericalPricers[j]->setSwaptionVolatility(swaptionVol);
+                vars.analyticPricers[j]->setSwaptionVolatility(swaptionVol);
                 std::vector<ext::shared_ptr<CmsCouponPricer> > pricers(2);
                 pricers[0] = vars.numericalPricers[j];
                 pricers[1] = vars.analyticPricers[j];
diff --git a/test-suite/compoundoption.cpp b/test-suite/compoundoption.cpp
index 781bb2ae0e6..87fe7d08e0f 100644
--- a/test-suite/compoundoption.cpp
+++ b/test-suite/compoundoption.cpp
@@ -127,30 +127,29 @@ void CompoundOptionTest::testPutCallParity(){
                               new BlackConstantVol(todaysDate, NullCalendar(),
                                                    Handle<Quote>(vol), dc));
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
         ext::shared_ptr<StrikedTypePayoff> payoffMotherCall(
-                new PlainVanillaPayoff(Option::Call, values[i].strikeMother));
+            new PlainVanillaPayoff(Option::Call, value.strikeMother));
 
         ext::shared_ptr<StrikedTypePayoff> payoffMotherPut(
-                new PlainVanillaPayoff(Option::Put, values[i].strikeMother));
+            new PlainVanillaPayoff(Option::Put, value.strikeMother));
 
         ext::shared_ptr<StrikedTypePayoff> payoffDaughter(
-                            new PlainVanillaPayoff(values[i].typeDaughter,
-                                                   values[i].strikeDaughter));
+            new PlainVanillaPayoff(value.typeDaughter, value.strikeDaughter));
 
-        Date matDateMom = todaysDate + timeToDays(values[i].tMother);
-        Date matDateDaughter = todaysDate + timeToDays(values[i].tDaughter);
+        Date matDateMom = todaysDate + timeToDays(value.tMother);
+        Date matDateDaughter = todaysDate + timeToDays(value.tDaughter);
 
         ext::shared_ptr<Exercise> exerciseCompound(
                                             new EuropeanExercise(matDateMom));
         ext::shared_ptr<Exercise> exerciseDaughter(
                                        new EuropeanExercise(matDateDaughter));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
         CompoundOption compoundOptionCall(payoffMotherCall,exerciseCompound,
                                           payoffDaughter, exerciseDaughter);
@@ -180,7 +179,7 @@ void CompoundOptionTest::testPutCallParity(){
         vanillaOption.setPricingEngine(engineEuropean);
 
         Real discFact=rTS->discount(matDateMom);
-        Real discStrike=values[i].strikeMother*discFact;
+        Real discStrike = value.strikeMother * discFact;
 
         Real calculated =
             compoundOptionCall.NPV() + discStrike - compoundOptionPut.NPV()
@@ -191,11 +190,9 @@ void CompoundOptionTest::testPutCallParity(){
         Real tolerance=1.0e-8;
 
         if(error>tolerance){
-            REPORT_FAILURE("put call parity", payoffMotherCall, payoffDaughter,
-                           exerciseCompound, exerciseDaughter, values[i].s,
-                           values[i].q, values[i].r, todaysDate,
-                           values[i].v, values[i].delta, calculated,
-                           error, tolerance);
+            REPORT_FAILURE("put call parity", payoffMotherCall, payoffDaughter, exerciseCompound,
+                           exerciseDaughter, value.s, value.q, value.r, todaysDate, value.v,
+                           value.delta, calculated, error, tolerance);
         }
     }
 }
@@ -264,28 +261,26 @@ void CompoundOptionTest::testValues(){
                               new BlackConstantVol(todaysDate, NullCalendar(),
                                                    Handle<Quote>(vol), dc));
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
         ext::shared_ptr<StrikedTypePayoff> payoffMother(
-                    new PlainVanillaPayoff(values[i].typeMother,
-                                           values[i].strikeMother));
+            new PlainVanillaPayoff(value.typeMother, value.strikeMother));
 
         ext::shared_ptr<StrikedTypePayoff> payoffDaughter(
-                    new PlainVanillaPayoff(values[i].typeDaughter,
-                                           values[i].strikeDaughter));
+            new PlainVanillaPayoff(value.typeDaughter, value.strikeDaughter));
 
-        Date matDateMom = todaysDate + timeToDays(values[i].tMother);
-        Date matDateDaughter = todaysDate + timeToDays(values[i].tDaughter);
+        Date matDateMom = todaysDate + timeToDays(value.tMother);
+        Date matDateDaughter = todaysDate + timeToDays(value.tDaughter);
 
         ext::shared_ptr<Exercise> exerciseMother(
                                             new EuropeanExercise(matDateMom));
         ext::shared_ptr<Exercise> exerciseDaughter(
                                        new EuropeanExercise(matDateDaughter));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
         CompoundOption compoundOption(payoffMother,exerciseMother,
                                       payoffDaughter, exerciseDaughter);
@@ -303,62 +298,52 @@ void CompoundOptionTest::testValues(){
         compoundOption.setPricingEngine(engineCompound);
 
         Real calculated = compoundOption.NPV();
-        Real error= std::fabs(calculated-values[i].npv); //-values[i].npv
-        Real tolerance = values[i].tol;
+        Real error = std::fabs(calculated - value.npv); //-values[i].npv
+        Real tolerance = value.tol;
 
         if (error>tolerance) {
-            REPORT_FAILURE("value", payoffMother, payoffDaughter,
-                           exerciseMother, exerciseDaughter, values[i].s,
-                           values[i].q, values[i].r, todaysDate,
-                           values[i].v, values[i].npv, calculated,
+            REPORT_FAILURE("value", payoffMother, payoffDaughter, exerciseMother, exerciseDaughter,
+                           value.s, value.q, value.r, todaysDate, value.v, value.npv, calculated,
                            error, tolerance);
         }
 
         calculated = compoundOption.delta();
-        error= std::fabs(calculated-values[i].delta);
-        tolerance = values[i].tol;
+        error = std::fabs(calculated - value.delta);
+        tolerance = value.tol;
 
         if (error>tolerance) {
-            REPORT_FAILURE("delta", payoffMother, payoffDaughter,
-                           exerciseMother, exerciseDaughter, values[i].s,
-                           values[i].q, values[i].r, todaysDate,
-                           values[i].v, values[i].delta, calculated,
+            REPORT_FAILURE("delta", payoffMother, payoffDaughter, exerciseMother, exerciseDaughter,
+                           value.s, value.q, value.r, todaysDate, value.v, value.delta, calculated,
                            error, tolerance);
         }
 
         calculated = compoundOption.gamma();
-        error= std::fabs(calculated-values[i].gamma);
-        tolerance = values[i].tol;
+        error = std::fabs(calculated - value.gamma);
+        tolerance = value.tol;
 
         if (error>tolerance) {
-            REPORT_FAILURE("gamma", payoffMother, payoffDaughter,
-                           exerciseMother, exerciseDaughter, values[i].s,
-                           values[i].q, values[i].r, todaysDate,
-                           values[i].v, values[i].gamma, calculated,
+            REPORT_FAILURE("gamma", payoffMother, payoffDaughter, exerciseMother, exerciseDaughter,
+                           value.s, value.q, value.r, todaysDate, value.v, value.gamma, calculated,
                            error, tolerance);
         }
 
         calculated = compoundOption.vega();
-        error= std::fabs(calculated-values[i].vega);
-        tolerance = values[i].tol;
+        error = std::fabs(calculated - value.vega);
+        tolerance = value.tol;
 
         if (error>tolerance) {
-            REPORT_FAILURE("vega", payoffMother, payoffDaughter,
-                           exerciseMother, exerciseDaughter, values[i].s,
-                           values[i].q, values[i].r, todaysDate,
-                           values[i].v, values[i].vega, calculated,
+            REPORT_FAILURE("vega", payoffMother, payoffDaughter, exerciseMother, exerciseDaughter,
+                           value.s, value.q, value.r, todaysDate, value.v, value.vega, calculated,
                            error, tolerance);
         }
 
         calculated = compoundOption.theta();
-        error= std::fabs(calculated-values[i].theta);
-        tolerance = values[i].tol;
+        error = std::fabs(calculated - value.theta);
+        tolerance = value.tol;
 
         if (error>tolerance) {
-            REPORT_FAILURE("theta", payoffMother, payoffDaughter,
-                           exerciseMother, exerciseDaughter, values[i].s,
-                           values[i].q, values[i].r, todaysDate,
-                           values[i].v, values[i].theta, calculated,
+            REPORT_FAILURE("theta", payoffMother, payoffDaughter, exerciseMother, exerciseDaughter,
+                           value.s, value.q, value.r, todaysDate, value.v, value.theta, calculated,
                            error, tolerance);
         }
     }
diff --git a/test-suite/creditdefaultswap.cpp b/test-suite/creditdefaultswap.cpp
index 5219d111e5f..39a6e282b66 100644
--- a/test-suite/creditdefaultswap.cpp
+++ b/test-suite/creditdefaultswap.cpp
@@ -677,46 +677,35 @@ void CreditDefaultSwapTest::testIsdaEngine() {
 
     size_t l = 0;
 
-    for(size_t i = 0; i < sizeof(termDates) / sizeof(Date); i++) {
-        for(size_t j = 0; j < 2; j++) {
-            for(size_t k = 0; k < 2; k++) {
-
-            ext::shared_ptr<CreditDefaultSwap> quotedTrade =
-                MakeCreditDefaultSwap(termDates[i], spreads[j])
-                .withNominal(10000000.);
-
-            Rate h = quotedTrade->impliedHazardRate(0.,
-                                                    discountCurve,
-                                                    Actual365Fixed(),
-                                                    recoveries[k],
-                                                    1e-10,
-                                                    CreditDefaultSwap::ISDA);
-
-            probabilityCurve.linkTo(
-                ext::make_shared<FlatHazardRate>(
-                    0, WeekendsOnly(), h, Actual365Fixed())
-                );
-
-            ext::shared_ptr<IsdaCdsEngine> engine = ext::make_shared<IsdaCdsEngine>(
-                probabilityCurve, recoveries[k], discountCurve,
-                boost::none, IsdaCdsEngine::Taylor, IsdaCdsEngine::HalfDayBias,
-                IsdaCdsEngine::Piecewise);
-
-            ext::shared_ptr<CreditDefaultSwap> conventionalTrade =
-                MakeCreditDefaultSwap(termDates[i], 0.01)
-                .withNominal(10000000.)
-                .withPricingEngine(engine);
-
-            BOOST_CHECK_CLOSE(conventionalTrade->notional() * conventionalTrade->fairUpfront(),
-                              markitValues[l],
-                              tolerance);
-
-            l++;
+    for (auto termDate : termDates) {
+        for (double spread : spreads) {
+            for (double& recoverie : recoveries) {
 
+                ext::shared_ptr<CreditDefaultSwap> quotedTrade =
+                    MakeCreditDefaultSwap(termDate, spread).withNominal(10000000.);
+
+                Rate h = quotedTrade->impliedHazardRate(0., discountCurve, Actual365Fixed(),
+                                                        recoverie, 1e-10, CreditDefaultSwap::ISDA);
+
+                probabilityCurve.linkTo(
+                    ext::make_shared<FlatHazardRate>(0, WeekendsOnly(), h, Actual365Fixed()));
+
+                ext::shared_ptr<IsdaCdsEngine> engine = ext::make_shared<IsdaCdsEngine>(
+                    probabilityCurve, recoverie, discountCurve, boost::none, IsdaCdsEngine::Taylor,
+                    IsdaCdsEngine::HalfDayBias, IsdaCdsEngine::Piecewise);
+
+                ext::shared_ptr<CreditDefaultSwap> conventionalTrade =
+                    MakeCreditDefaultSwap(termDate, 0.01)
+                        .withNominal(10000000.)
+                        .withPricingEngine(engine);
+
+                BOOST_CHECK_CLOSE(conventionalTrade->notional() * conventionalTrade->fairUpfront(),
+                                  markitValues[l], tolerance);
+
+                l++;
             }
         }
     }
-
 }
 
 void CreditDefaultSwapTest::testAccrualRebateAmounts() {
diff --git a/test-suite/crosscurrencyratehelpers.cpp b/test-suite/crosscurrencyratehelpers.cpp
index 0189095e810..07e2be13909 100644
--- a/test-suite/crosscurrencyratehelpers.cpp
+++ b/test-suite/crosscurrencyratehelpers.cpp
@@ -80,14 +80,15 @@ namespace crosscurrencyratehelpers_test {
         }
 
         std::vector<ext::shared_ptr<RateHelper> >
-        buildConstantNotionalXccyRateHelpers(std::vector<XccyTestDatum> xccyData,
+        buildConstantNotionalXccyRateHelpers(const std::vector<XccyTestDatum>& xccyData,
                                              const Handle<YieldTermStructure>& collateralHandle,
                                              bool isFxBaseCurrencyCollateralCurrency,
                                              bool isBasisOnFxBaseCurrencyLeg) const {
             std::vector<ext::shared_ptr<RateHelper> > instruments;
-            for (Size i = 0; i < xccyData.size(); i++) {
+            instruments.reserve(xccyData.size());
+            for (const auto& i : xccyData) {
                 instruments.push_back(constantNotionalXccyRateHelper(
-                    xccyData[i], collateralHandle, isFxBaseCurrencyCollateralCurrency,
+                    i, collateralHandle, isFxBaseCurrencyCollateralCurrency,
                     isBasisOnFxBaseCurrencyLeg));
             }
 
diff --git a/test-suite/dates.cpp b/test-suite/dates.cpp
index 45b53756c15..05cc4c22483 100644
--- a/test-suite/dates.cpp
+++ b/test-suite/dates.cpp
@@ -217,12 +217,10 @@ void DateTest::asxDates() {
             << " is not the ASX code matching " << asx);
 
         // check that for every date the 120 ASX codes refer to future dates
-        for (int i = 0; i<120; ++i) {
-            if (ASX::date(ASXcodes[i], counter)<counter)
-                BOOST_FAIL("\n  "
-                << ASX::date(ASXcodes[i], counter)
-                << " is wrong for " << ASXcodes[i]
-                << " at reference date " << counter);
+        for (const auto& ASXcode : ASXcodes) {
+            if (ASX::date(ASXcode, counter) < counter)
+                BOOST_FAIL("\n  " << ASX::date(ASXcode, counter) << " is wrong for " << ASXcode
+                                  << " at reference date " << counter);
         }
 
         counter = counter + 1;
diff --git a/test-suite/digitalcoupon.cpp b/test-suite/digitalcoupon.cpp
index abdda130af9..368d43f9a30 100644
--- a/test-suite/digitalcoupon.cpp
+++ b/test-suite/digitalcoupon.cpp
@@ -95,16 +95,12 @@ void DigitalCouponTest::testAssetOrNothing() {
                         with black formula result */
     ext::shared_ptr<DigitalReplication>
         replication(new DigitalReplication(Replication::Central, gap));
-    for (Size i = 0; i< LENGTH(vols); i++) {
-            Volatility capletVol = vols[i];
-            RelinkableHandle<OptionletVolatilityStructure> vol;
-            vol.linkTo(ext::shared_ptr<OptionletVolatilityStructure>(new
-                ConstantOptionletVolatility(vars.today,
-                                            vars.calendar, Following,
-                                            capletVol, Actual360())));
-        for (Size j=0; j<LENGTH(strikes); j++) {
-            Rate strike = strikes[j];
-            for (Size k=9; k<10; k++) {
+    for (double capletVol : vols) {
+        RelinkableHandle<OptionletVolatilityStructure> vol;
+        vol.linkTo(ext::shared_ptr<OptionletVolatilityStructure>(new ConstantOptionletVolatility(
+            vars.today, vars.calendar, Following, capletVol, Actual360())));
+        for (double strike : strikes) {
+            for (Size k = 9; k < 10; k++) {
                 Date startDate = vars.calendar.advance(vars.settlement,(k+1)*Years);
                 Date endDate = vars.calendar.advance(vars.settlement,(k+2)*Years);
                 Rate nullstrike = Null<Rate>();
@@ -514,16 +510,12 @@ void DigitalCouponTest::testCashOrNothing() {
     ext::shared_ptr<DigitalReplication> replication(new
         DigitalReplication(Replication::Central, gap));
 
-    for (Size i = 0; i< LENGTH(vols); i++) {
-            Volatility capletVol = vols[i];
-            RelinkableHandle<OptionletVolatilityStructure> vol;
-            vol.linkTo(ext::shared_ptr<OptionletVolatilityStructure>(new
-                ConstantOptionletVolatility(vars.today,
-                                            vars.calendar, Following,
-                                            capletVol, Actual360())));
-        for (Size j = 0; j< LENGTH(strikes); j++) {
-            Rate strike = strikes[j];
-            for (Size k = 0; k<10; k++) {
+    for (double capletVol : vols) {
+        RelinkableHandle<OptionletVolatilityStructure> vol;
+        vol.linkTo(ext::shared_ptr<OptionletVolatilityStructure>(new ConstantOptionletVolatility(
+            vars.today, vars.calendar, Following, capletVol, Actual360())));
+        for (double strike : strikes) {
+            for (Size k = 0; k < 10; k++) {
                 Date startDate = vars.calendar.advance(vars.settlement,(k+1)*Years);
                 Date endDate = vars.calendar.advance(vars.settlement,(k+2)*Years);
                 Rate nullstrike = Null<Rate>();
@@ -888,15 +880,13 @@ void DigitalCouponTest::testCallPutParity() {
     ext::shared_ptr<DigitalReplication> replication(new
         DigitalReplication(Replication::Central, gap));
 
-    for (Size i = 0; i< LENGTH(vols); i++) {
-            Volatility capletVolatility = vols[i];
-            RelinkableHandle<OptionletVolatilityStructure> volatility;
-            volatility.linkTo(ext::shared_ptr<OptionletVolatilityStructure>(new
-                ConstantOptionletVolatility(vars.today, vars.calendar, Following,
-                                            capletVolatility, Actual360())));
-        for (Size j = 0; j< LENGTH(strikes); j++) {
-            Rate strike = strikes[j];
-            for (Size k = 0; k<10; k++) {
+    for (double capletVolatility : vols) {
+        RelinkableHandle<OptionletVolatilityStructure> volatility;
+        volatility.linkTo(
+            ext::shared_ptr<OptionletVolatilityStructure>(new ConstantOptionletVolatility(
+                vars.today, vars.calendar, Following, capletVolatility, Actual360())));
+        for (double strike : strikes) {
+            for (Size k = 0; k < 10; k++) {
                 Date startDate = vars.calendar.advance(vars.settlement,(k+1)*Years);
                 Date endDate = vars.calendar.advance(vars.settlement,(k+2)*Years);
                 Rate nullstrike = Null<Rate>();
@@ -997,15 +987,13 @@ void DigitalCouponTest::testReplicationType() {
     ext::shared_ptr<DigitalReplication> superReplication(new
         DigitalReplication(Replication::Super, gap));
 
-    for (Size i = 0; i< LENGTH(vols); i++) {
-        Volatility capletVolatility = vols[i];
+    for (double capletVolatility : vols) {
         RelinkableHandle<OptionletVolatilityStructure> volatility;
         volatility.linkTo(ext::shared_ptr<OptionletVolatilityStructure>(new
         ConstantOptionletVolatility(vars.today, vars.calendar, Following,
                                     capletVolatility, Actual360())));
-        for (Size j = 0; j< LENGTH(strikes); j++) {
-            Rate strike = strikes[j];
-            for (Size k = 0; k<10; k++) {
+        for (double strike : strikes) {
+            for (Size k = 0; k < 10; k++) {
                 Date startDate = vars.calendar.advance(vars.settlement,(k+1)*Years);
                 Date endDate = vars.calendar.advance(vars.settlement,(k+2)*Years);
                 Rate nullstrike = Null<Rate>();
diff --git a/test-suite/digitaloption.cpp b/test-suite/digitaloption.cpp
index b8cbd864532..380ef2569fb 100644
--- a/test-suite/digitaloption.cpp
+++ b/test-suite/digitaloption.cpp
@@ -94,18 +94,18 @@ void DigitalOptionTest::testCashOrNothingEuropeanValues() {
     ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.0));
     ext::shared_ptr<BlackVolTermStructure> volTS = flatVol(today, vol, dc);
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(new CashOrNothingPayoff(
-            values[i].type, values[i].strike, 10.0));
+        ext::shared_ptr<StrikedTypePayoff> payoff(
+            new CashOrNothingPayoff(value.type, value.strike, 10.0));
 
-        Date exDate = today + timeToDays(values[i].t);
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess(new
             BlackScholesMertonProcess(Handle<Quote>(spot),
@@ -119,11 +119,10 @@ void DigitalOptionTest::testCashOrNothingEuropeanValues() {
         opt.setPricingEngine(engine);
 
         Real calculated = opt.NPV();
-        Real error = std::fabs(calculated-values[i].result);
-        if (error > values[i].tol) {
-            REPORT_FAILURE("value", payoff, exercise, values[i].s, values[i].q,
-                           values[i].r, today, values[i].v, values[i].result,
-                           calculated, error, values[i].tol, values[i].knockin);
+        Real error = std::fabs(calculated - value.result);
+        if (error > value.tol) {
+            REPORT_FAILURE("value", payoff, exercise, value.s, value.q, value.r, today, value.v,
+                           value.result, calculated, error, value.tol, value.knockin);
         }
     }
 }
@@ -149,18 +148,18 @@ void DigitalOptionTest::testAssetOrNothingEuropeanValues() {
     ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.0));
     ext::shared_ptr<BlackVolTermStructure> volTS = flatVol(today, vol, dc);
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(new AssetOrNothingPayoff(
-            values[i].type, values[i].strike));
+        ext::shared_ptr<StrikedTypePayoff> payoff(
+            new AssetOrNothingPayoff(value.type, value.strike));
 
-        Date exDate = today + timeToDays(values[i].t);
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess(new
             BlackScholesMertonProcess(Handle<Quote>(spot),
@@ -174,11 +173,10 @@ void DigitalOptionTest::testAssetOrNothingEuropeanValues() {
         opt.setPricingEngine(engine);
 
         Real calculated = opt.NPV();
-        Real error = std::fabs(calculated-values[i].result);
-        if (error > values[i].tol) {
-            REPORT_FAILURE("value", payoff, exercise, values[i].s, values[i].q,
-                           values[i].r, today, values[i].v, values[i].result,
-                           calculated, error, values[i].tol, values[i].knockin);
+        Real error = std::fabs(calculated - value.result);
+        if (error > value.tol) {
+            REPORT_FAILURE("value", payoff, exercise, value.s, value.q, value.r, today, value.v,
+                           value.result, calculated, error, value.tol, value.knockin);
         }
     }
 }
@@ -204,18 +202,17 @@ void DigitalOptionTest::testGapEuropeanValues() {
     ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.0));
     ext::shared_ptr<BlackVolTermStructure> volTS = flatVol(today, vol, dc);
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(new GapPayoff(
-            values[i].type, values[i].strike, 57.00));
+        ext::shared_ptr<StrikedTypePayoff> payoff(new GapPayoff(value.type, value.strike, 57.00));
 
-        Date exDate = today + timeToDays(values[i].t);
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess(new
             BlackScholesMertonProcess(Handle<Quote>(spot),
@@ -229,11 +226,10 @@ void DigitalOptionTest::testGapEuropeanValues() {
         opt.setPricingEngine(engine);
 
         Real calculated = opt.NPV();
-        Real error = std::fabs(calculated-values[i].result);
-        if (error > values[i].tol) {
-            REPORT_FAILURE("value", payoff, exercise, values[i].s, values[i].q,
-                           values[i].r, today, values[i].v, values[i].result,
-                           calculated, error, values[i].tol, values[i].knockin);
+        Real error = std::fabs(calculated - value.result);
+        if (error > value.tol) {
+            REPORT_FAILURE("value", payoff, exercise, value.s, value.q, value.r, today, value.v,
+                           value.result, calculated, error, value.tol, value.knockin);
         }
     }
 }
@@ -271,19 +267,19 @@ void DigitalOptionTest::testCashAtHitOrNothingAmericanValues() {
     ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.0));
     ext::shared_ptr<BlackVolTermStructure> volTS = flatVol(today, vol, dc);
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(new CashOrNothingPayoff(
-            values[i].type, values[i].strike, 15.00));
+        ext::shared_ptr<StrikedTypePayoff> payoff(
+            new CashOrNothingPayoff(value.type, value.strike, 15.00));
 
-        Date exDate = today + timeToDays(values[i].t);
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> amExercise(new AmericanExercise(today,
                                                                     exDate));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess(new
             BlackScholesMertonProcess(Handle<Quote>(spot),
@@ -297,11 +293,10 @@ void DigitalOptionTest::testCashAtHitOrNothingAmericanValues() {
         opt.setPricingEngine(engine);
 
         Real calculated = opt.NPV();
-        Real error = std::fabs(calculated-values[i].result);
-        if (error > values[i].tol) {
-            REPORT_FAILURE("value", payoff, amExercise, values[i].s,
-                           values[i].q, values[i].r, today, values[i].v,
-                           values[i].result, calculated, error, values[i].tol, values[i].knockin);
+        Real error = std::fabs(calculated - value.result);
+        if (error > value.tol) {
+            REPORT_FAILURE("value", payoff, amExercise, value.s, value.q, value.r, today, value.v,
+                           value.result, calculated, error, value.tol, value.knockin);
         }
     }
 }
@@ -337,19 +332,19 @@ void DigitalOptionTest::testAssetAtHitOrNothingAmericanValues() {
     ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.25));
     ext::shared_ptr<BlackVolTermStructure> volTS = flatVol(today, vol, dc);
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(new AssetOrNothingPayoff(
-            values[i].type, values[i].strike));
+        ext::shared_ptr<StrikedTypePayoff> payoff(
+            new AssetOrNothingPayoff(value.type, value.strike));
 
-        Date exDate = today + timeToDays(values[i].t);
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> amExercise(new AmericanExercise(today,
                                                                     exDate));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess(new
             BlackScholesMertonProcess(Handle<Quote>(spot),
@@ -363,11 +358,10 @@ void DigitalOptionTest::testAssetAtHitOrNothingAmericanValues() {
         opt.setPricingEngine(engine);
 
         Real calculated = opt.NPV();
-        Real error = std::fabs(calculated-values[i].result);
-        if (error > values[i].tol) {
-            REPORT_FAILURE("value", payoff, amExercise, values[i].s,
-                           values[i].q, values[i].r, today, values[i].v,
-                           values[i].result, calculated, error, values[i].tol, values[i].knockin);
+        Real error = std::fabs(calculated - value.result);
+        if (error > value.tol) {
+            REPORT_FAILURE("value", payoff, amExercise, value.s, value.q, value.r, today, value.v,
+                           value.result, calculated, error, value.tol, value.knockin);
         }
     }
 }
@@ -402,20 +396,20 @@ void DigitalOptionTest::testCashAtExpiryOrNothingAmericanValues() {
     ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.25));
     ext::shared_ptr<BlackVolTermStructure> volTS = flatVol(today, vol, dc);
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(new CashOrNothingPayoff(
-            values[i].type, values[i].strike, 15.0));
+        ext::shared_ptr<StrikedTypePayoff> payoff(
+            new CashOrNothingPayoff(value.type, value.strike, 15.0));
 
-        Date exDate = today + timeToDays(values[i].t);
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> amExercise(new AmericanExercise(today,
                                                                     exDate,
                                                                     true));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess(new
             BlackScholesMertonProcess(Handle<Quote>(spot),
@@ -423,8 +417,8 @@ void DigitalOptionTest::testCashAtExpiryOrNothingAmericanValues() {
                                       Handle<YieldTermStructure>(rTS),
                                       Handle<BlackVolTermStructure>(volTS)));
         ext::shared_ptr<PricingEngine> engine;
-        if (values[i].knockin)
-           engine.reset(new AnalyticDigitalAmericanEngine(stochProcess));
+        if (value.knockin)
+            engine.reset(new AnalyticDigitalAmericanEngine(stochProcess));
         else
            engine.reset(new AnalyticDigitalAmericanKOEngine(stochProcess));
 
@@ -432,11 +426,10 @@ void DigitalOptionTest::testCashAtExpiryOrNothingAmericanValues() {
         opt.setPricingEngine(engine);
 
         Real calculated = opt.NPV();
-        Real error = std::fabs(calculated-values[i].result);
-        if (error > values[i].tol) {
-            REPORT_FAILURE("value", payoff, amExercise, values[i].s,
-                           values[i].q, values[i].r, today, values[i].v,
-                           values[i].result, calculated, error, values[i].tol, values[i].knockin);
+        Real error = std::fabs(calculated - value.result);
+        if (error > value.tol) {
+            REPORT_FAILURE("value", payoff, amExercise, value.s, value.q, value.r, today, value.v,
+                           value.result, calculated, error, value.tol, value.knockin);
         }
     }
 }
@@ -475,20 +468,20 @@ void DigitalOptionTest::testAssetAtExpiryOrNothingAmericanValues() {
     ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.25));
     ext::shared_ptr<BlackVolTermStructure> volTS = flatVol(today, vol, dc);
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(new AssetOrNothingPayoff(
-            values[i].type, values[i].strike));
+        ext::shared_ptr<StrikedTypePayoff> payoff(
+            new AssetOrNothingPayoff(value.type, value.strike));
 
-        Date exDate = today + timeToDays(values[i].t);
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> amExercise(new AmericanExercise(today,
                                                                     exDate,
                                                                     true));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess(new
             BlackScholesMertonProcess(Handle<Quote>(spot),
@@ -496,8 +489,8 @@ void DigitalOptionTest::testAssetAtExpiryOrNothingAmericanValues() {
                                       Handle<YieldTermStructure>(rTS),
                                       Handle<BlackVolTermStructure>(volTS)));
         ext::shared_ptr<PricingEngine> engine;
-        if (values[i].knockin)
-           engine.reset(new AnalyticDigitalAmericanEngine(stochProcess));
+        if (value.knockin)
+            engine.reset(new AnalyticDigitalAmericanEngine(stochProcess));
         else
            engine.reset(new AnalyticDigitalAmericanKOEngine(stochProcess));
 
@@ -505,11 +498,10 @@ void DigitalOptionTest::testAssetAtExpiryOrNothingAmericanValues() {
         opt.setPricingEngine(engine);
 
         Real calculated = opt.NPV();
-        Real error = std::fabs(calculated-values[i].result);
-        if (error > values[i].tol) {
-            REPORT_FAILURE("value", payoff, amExercise, values[i].s,
-                           values[i].q, values[i].r, today, values[i].v,
-                           values[i].result, calculated, error, values[i].tol, values[i].knockin);
+        Real error = std::fabs(calculated - value.result);
+        if (error > value.tol) {
+            REPORT_FAILURE("value", payoff, amExercise, value.s, value.q, value.r, today, value.v,
+                           value.result, calculated, error, value.tol, value.knockin);
         }
     }
 }
@@ -571,113 +563,103 @@ void DigitalOptionTest::testCashAtHitOrNothingAmericanGreeks() {
 
     bool knockin=true;
     for (Size j=0; j<LENGTH(engines); j++) {
-      for (Size i1=0; i1<LENGTH(types); i1++) {
-        for (Size i6=0; i6<LENGTH(strikes); i6++) {
-          ext::shared_ptr<StrikedTypePayoff> payoff(
-                            new CashOrNothingPayoff(types[i1],
-                                                    strikes[i6], cashPayoff));
-
-          VanillaOption opt(payoff, exercises[j]);
-          opt.setPricingEngine(engines[j]);
-
-          for (Size i2=0; i2<LENGTH(underlyings); i2++) {
-            for (Size i4=0; i4<LENGTH(qRates); i4++) {
-              for (Size i3=0; i3<LENGTH(rRates); i3++) {
-                for (Size i7=0; i7<LENGTH(vols); i7++) {
-                  // test data
-                  Real u = underlyings[i2];
-                  Rate q = qRates[i4];
-                  Rate r = rRates[i3];
-                  Volatility v = vols[i7];
-                  spot->setValue(u);
-                  qRate->setValue(q);
-                  rRate->setValue(r);
-                  vol->setValue(v);
-
-                  // theta, dividend rho and vega are not available for
-                  // digital option with american exercise. Greeks of
-                  // digital options with european payoff are tested
-                  // in the europeanoption.cpp test
-                  Real value = opt.NPV();
-                  calculated["delta"]  = opt.delta();
-                  calculated["gamma"]  = opt.gamma();
-                  // calculated["theta"]  = opt.theta();
-                  calculated["rho"]    = opt.rho();
-                  // calculated["divRho"] = opt.dividendRho();
-                  // calculated["vega"]   = opt.vega();
-
-                  if (value > 1.0e-6) {
-                      // perturb spot and get delta and gamma
-                      Real du = u*1.0e-4;
-                      spot->setValue(u+du);
-                      Real value_p = opt.NPV(),
-                           delta_p = opt.delta();
-                      spot->setValue(u-du);
-                      Real value_m = opt.NPV(),
-                           delta_m = opt.delta();
-                      spot->setValue(u);
-                      expected["delta"] = (value_p - value_m)/(2*du);
-                      expected["gamma"] = (delta_p - delta_m)/(2*du);
-
-                      // perturb rates and get rho and dividend rho
-                      Spread dr = r*1.0e-4;
-                      rRate->setValue(r+dr);
-                      value_p = opt.NPV();
-                      rRate->setValue(r-dr);
-                      value_m = opt.NPV();
-                      rRate->setValue(r);
-                      expected["rho"] = (value_p - value_m)/(2*dr);
-
-                      /*
-                      Spread dq = q*1.0e-4;
-                      qRate->setValue(q+dq);
-                      value_p = opt.NPV();
-                      qRate->setValue(q-dq);
-                      value_m = opt.NPV();
-                      qRate->setValue(q);
-                      expected["divRho"] = (value_p - value_m)/(2*dq);
-
-                      // perturb volatility and get vega
-                      Volatility dv = v*1.0e-4;
-                      vol->setValue(v+dv);
-                      value_p = opt.NPV();
-                      vol->setValue(v-dv);
-                      value_m = opt.NPV();
-                      vol->setValue(v);
-                      expected["vega"] = (value_p - value_m)/(2*dv);
-
-                      // perturb date and get theta
-                      Time dT = dc.yearFraction(today-1, today+1);
-                      Settings::instance().setEvaluationDate(today-1);
-                      value_m = opt.NPV();
-                      Settings::instance().setEvaluationDate(today+1);
-                      value_p = opt.NPV();
-                      Settings::instance().setEvaluationDate(today);
-                      expected["theta"] = (value_p - value_m)/dT;
-                      */
-
-                      // check
-                      std::map<std::string,Real>::iterator it;
-                      for (it = calculated.begin();
-                           it != calculated.end(); ++it) {
-                          std::string greek = it->first;
-                          Real expct = expected  [greek],
-                               calcl = calculated[greek],
-                               tol   = tolerance [greek];
-                          Real error = relativeError(expct,calcl,value);
-                          if (error > tol) {
-                              REPORT_FAILURE(greek, payoff, exercise,
-                                             u, q, r, today, v,
-                                             expct, calcl, error, tol, knockin);
-                          }
-                      }
-                  }
+        for (auto& type : types) {
+            for (double strike : strikes) {
+                ext::shared_ptr<StrikedTypePayoff> payoff(
+                    new CashOrNothingPayoff(type, strike, cashPayoff));
+
+                VanillaOption opt(payoff, exercises[j]);
+                opt.setPricingEngine(engines[j]);
+
+                for (double u : underlyings) {
+                    for (double q : qRates) {
+                        for (double r : rRates) {
+                            for (double v : vols) {
+                                // test data
+                                spot->setValue(u);
+                                qRate->setValue(q);
+                                rRate->setValue(r);
+                                vol->setValue(v);
+
+                                // theta, dividend rho and vega are not available for
+                                // digital option with american exercise. Greeks of
+                                // digital options with european payoff are tested
+                                // in the europeanoption.cpp test
+                                Real value = opt.NPV();
+                                calculated["delta"] = opt.delta();
+                                calculated["gamma"] = opt.gamma();
+                                // calculated["theta"]  = opt.theta();
+                                calculated["rho"] = opt.rho();
+                                // calculated["divRho"] = opt.dividendRho();
+                                // calculated["vega"]   = opt.vega();
+
+                                if (value > 1.0e-6) {
+                                    // perturb spot and get delta and gamma
+                                    Real du = u * 1.0e-4;
+                                    spot->setValue(u + du);
+                                    Real value_p = opt.NPV(), delta_p = opt.delta();
+                                    spot->setValue(u - du);
+                                    Real value_m = opt.NPV(), delta_m = opt.delta();
+                                    spot->setValue(u);
+                                    expected["delta"] = (value_p - value_m) / (2 * du);
+                                    expected["gamma"] = (delta_p - delta_m) / (2 * du);
+
+                                    // perturb rates and get rho and dividend rho
+                                    Spread dr = r * 1.0e-4;
+                                    rRate->setValue(r + dr);
+                                    value_p = opt.NPV();
+                                    rRate->setValue(r - dr);
+                                    value_m = opt.NPV();
+                                    rRate->setValue(r);
+                                    expected["rho"] = (value_p - value_m) / (2 * dr);
+
+                                    /*
+                                    Spread dq = q*1.0e-4;
+                                    qRate->setValue(q+dq);
+                                    value_p = opt.NPV();
+                                    qRate->setValue(q-dq);
+                                    value_m = opt.NPV();
+                                    qRate->setValue(q);
+                                    expected["divRho"] = (value_p - value_m)/(2*dq);
+
+                                    // perturb volatility and get vega
+                                    Volatility dv = v*1.0e-4;
+                                    vol->setValue(v+dv);
+                                    value_p = opt.NPV();
+                                    vol->setValue(v-dv);
+                                    value_m = opt.NPV();
+                                    vol->setValue(v);
+                                    expected["vega"] = (value_p - value_m)/(2*dv);
+
+                                    // perturb date and get theta
+                                    Time dT = dc.yearFraction(today-1, today+1);
+                                    Settings::instance().setEvaluationDate(today-1);
+                                    value_m = opt.NPV();
+                                    Settings::instance().setEvaluationDate(today+1);
+                                    value_p = opt.NPV();
+                                    Settings::instance().setEvaluationDate(today);
+                                    expected["theta"] = (value_p - value_m)/dT;
+                                    */
+
+                                    // check
+                                    std::map<std::string, Real>::iterator it;
+                                    for (it = calculated.begin(); it != calculated.end(); ++it) {
+                                        std::string greek = it->first;
+                                        Real expct = expected[greek], calcl = calculated[greek],
+                                             tol = tolerance[greek];
+                                        Real error = relativeError(expct, calcl, value);
+                                        if (error > tol) {
+                                            REPORT_FAILURE(greek, payoff, exercise, u, q, r, today,
+                                                           v, expct, calcl, error, tol, knockin);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
                 }
-              }
             }
-          }
         }
-      }
     }
 }
 
@@ -710,18 +692,18 @@ void DigitalOptionTest::testMCCashAtHit() {
     Size maxSamples = 1000000;
     BigNatural seed = 1;
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(new CashOrNothingPayoff(
-            values[i].type, values[i].strike, 15.0));
-        Date exDate = today + timeToDays(values[i].t);
+        ext::shared_ptr<StrikedTypePayoff> payoff(
+            new CashOrNothingPayoff(value.type, value.strike, 15.0));
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> amExercise(
                                          new AmericanExercise(today, exDate));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess(new
             BlackScholesMertonProcess(Handle<Quote>(spot),
@@ -742,11 +724,10 @@ void DigitalOptionTest::testMCCashAtHit() {
         opt.setPricingEngine(mcldEngine);
 
         Real calculated = opt.NPV();
-        Real error = std::fabs(calculated-values[i].result);
-        if (error > values[i].tol) {
-            REPORT_FAILURE("value", payoff, amExercise, values[i].s,
-                           values[i].q, values[i].r, today, values[i].v,
-                           values[i].result, calculated, error, values[i].tol, values[i].knockin);
+        Real error = std::fabs(calculated - value.result);
+        if (error > value.tol) {
+            REPORT_FAILURE("value", payoff, amExercise, value.s, value.q, value.r, today, value.v,
+                           value.result, calculated, error, value.tol, value.knockin);
         }
     }
 }
diff --git a/test-suite/distributions.cpp b/test-suite/distributions.cpp
index 8906850555c..4254a02042c 100644
--- a/test-suite/distributions.cpp
+++ b/test-suite/distributions.cpp
@@ -164,19 +164,18 @@ namespace distributions_test {
         const Real x(0.0);
         const Real y(0.0);
 
-        for (Size i=0;i<LENGTH(rho);i++) {
+        for (double i : rho) {
             for (Integer sgn=-1; sgn < 2; sgn+=2) {
-                Bivariate bvn(sgn*rho[i]);
-                Real expected = 0.25 + std::asin(sgn*rho[i]) / (2*M_PI) ;
+                Bivariate bvn(sgn * i);
+                Real expected = 0.25 + std::asin(sgn * i) / (2 * M_PI);
                 Real realised = bvn(x,y);
 
                 if (std::fabs(realised-expected)>=tolerance) {
                     BOOST_ERROR(tag << " bivariate cumulative distribution\n"
-                                << std::scientific
-                                << "    rho: " << sgn*rho[i] << "\n"
-                                << "    expected:  " << expected << "\n"
-                                << "    realised:  " << realised << "\n"
-                                << "    tolerance: " << tolerance);
+                                    << std::scientific << "    rho: " << sgn * i << "\n"
+                                    << "    expected:  " << expected << "\n"
+                                    << "    realised:  " << realised << "\n"
+                                    << "    tolerance: " << tolerance);
                 }
             }
         }
@@ -588,18 +587,15 @@ void DistributionTest::testBivariateCumulativeStudent() {
     };
 
     tolerance = 1.0e-6;
-    for (Size i=0; i < LENGTH(cases); ++i) {
-		BivariateCumulativeStudentDistribution f(cases[i].n,  cases[i].rho);
-        Real calculated = f(cases[i].x, cases[i].y);
-        Real expected = cases[i].result;
+    for (auto& i : cases) {
+        BivariateCumulativeStudentDistribution f(i.n, i.rho);
+        Real calculated = f(i.x, i.y);
+        Real expected = i.result;
         if (std::fabs(calculated - expected) > tolerance)
-            BOOST_ERROR("Failed to reproduce CDF value:" <<
-                        "\n    n:   " << cases[i].n <<
-                        "\n    rho: " << cases[i].rho <<
-                        "\n    x:   " << cases[i].x <<
-                        "\n    y:   " << cases[i].y <<
-                        "\n    calculated: " << calculated <<
-                        "\n    expected:   " << expected);
+            BOOST_ERROR("Failed to reproduce CDF value:"
+                        << "\n    n:   " << i.n << "\n    rho: " << i.rho << "\n    x:   " << i.x
+                        << "\n    y:   " << i.y << "\n    calculated: " << calculated
+                        << "\n    expected:   " << expected);
     }
 }
 
@@ -732,12 +728,8 @@ void DistributionTest::testSankaranApproximation() {
     const Real ncps[] = {1,2,3,1,2,3};
 
     const Real tol = 0.01;
-    for (Size i=0; i < LENGTH(dfs); ++i) {
-        const Real df = dfs[i];
-
-        for (Size j=0; j < LENGTH(ncps); ++j) {
-            Real ncp = ncps[j];
-
+    for (double df : dfs) {
+        for (double ncp : ncps) {
             const NonCentralCumulativeChiSquareDistribution d(df, ncp);
             const NonCentralCumulativeChiSquareSankaranApprox sankaran(df, ncp);
 
diff --git a/test-suite/dividendoption.cpp b/test-suite/dividendoption.cpp
index 4b38c142b1b..8fa20c2611b 100644
--- a/test-suite/dividendoption.cpp
+++ b/test-suite/dividendoption.cpp
@@ -90,70 +90,59 @@ void DividendOptionTest::testEuropeanValues() {
     ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.0));
     Handle<BlackVolTermStructure> volTS(flatVol(vol, dc));
 
-    for (Size i=0; i<LENGTH(types); i++) {
-      for (Size j=0; j<LENGTH(strikes); j++) {
-        for (Size k=0; k<LENGTH(lengths); k++) {
-          Date exDate = today + lengths[k]*Years;
-          ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
-
-          std::vector<Date> dividendDates;
-          std::vector<Real> dividends;
-          for (Date d = today + 3*Months;
-                    d < exercise->lastDate();
-                    d += 6*Months) {
-              dividendDates.push_back(d);
-              dividends.push_back(0.0);
-          }
-
-          ext::shared_ptr<StrikedTypePayoff> payoff(
-                                new PlainVanillaPayoff(types[i], strikes[j]));
-
-          ext::shared_ptr<BlackScholesMertonProcess> stochProcess(
-                            new BlackScholesMertonProcess(Handle<Quote>(spot),
-                                                          qTS, rTS, volTS));
+    for (auto& type : types) {
+        for (double strike : strikes) {
+            for (int length : lengths) {
+                Date exDate = today + length * Years;
+                ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-          ext::shared_ptr<PricingEngine> ref_engine(
-                                    new AnalyticEuropeanEngine(stochProcess));
+                std::vector<Date> dividendDates;
+                std::vector<Real> dividends;
+                for (Date d = today + 3 * Months; d < exercise->lastDate(); d += 6 * Months) {
+                    dividendDates.push_back(d);
+                    dividends.push_back(0.0);
+                }
 
-          ext::shared_ptr<PricingEngine> engine(
-                            new AnalyticDividendEuropeanEngine(stochProcess));
+                ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(type, strike));
+
+                ext::shared_ptr<BlackScholesMertonProcess> stochProcess(
+                    new BlackScholesMertonProcess(Handle<Quote>(spot), qTS, rTS, volTS));
 
-          DividendVanillaOption option(payoff, exercise,
-                                       dividendDates, dividends);
-          option.setPricingEngine(engine);
-
-          VanillaOption ref_option(payoff, exercise);
-          ref_option.setPricingEngine(ref_engine);
-
-          for (Size l=0; l<LENGTH(underlyings); l++) {
-            for (Size m=0; m<LENGTH(qRates); m++) {
-              for (Size n=0; n<LENGTH(rRates); n++) {
-                for (Size p=0; p<LENGTH(vols); p++) {
-                    Real u = underlyings[l];
-                    Rate q = qRates[m],
-                         r = rRates[n];
-                    Volatility v = vols[p];
-                    spot->setValue(u);
-                    qRate->setValue(q);
-                    rRate->setValue(r);
-                    vol->setValue(v);
-
-                    Real calculated = option.NPV();
-                    Real expected = ref_option.NPV();
-                    Real error = std::fabs(calculated-expected);
-                    if (error > tolerance) {
-                        REPORT_FAILURE("value start limit",
-                                       payoff, exercise,
-                                       u, q, r, today, v,
-                                       expected, calculated,
-                                       error, tolerance);
+                ext::shared_ptr<PricingEngine> ref_engine(new AnalyticEuropeanEngine(stochProcess));
+
+                ext::shared_ptr<PricingEngine> engine(
+                    new AnalyticDividendEuropeanEngine(stochProcess));
+
+                DividendVanillaOption option(payoff, exercise, dividendDates, dividends);
+                option.setPricingEngine(engine);
+
+                VanillaOption ref_option(payoff, exercise);
+                ref_option.setPricingEngine(ref_engine);
+
+                for (double u : underlyings) {
+                    for (double m : qRates) {
+                        for (double n : rRates) {
+                            for (double v : vols) {
+                                Rate q = m, r = n;
+                                spot->setValue(u);
+                                qRate->setValue(q);
+                                rRate->setValue(r);
+                                vol->setValue(v);
+
+                                Real calculated = option.NPV();
+                                Real expected = ref_option.NPV();
+                                Real error = std::fabs(calculated - expected);
+                                if (error > tolerance) {
+                                    REPORT_FAILURE("value start limit", payoff, exercise, u, q, r,
+                                                   today, v, expected, calculated, error,
+                                                   tolerance);
+                                }
+                            }
+                        }
                     }
                 }
-              }
             }
-          }
         }
-      }
     }
 }
 
@@ -256,66 +245,57 @@ void DividendOptionTest::testEuropeanStartLimit() {
     ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.0));
     Handle<BlackVolTermStructure> volTS(flatVol(vol, dc));
 
-    for (Size i=0; i<LENGTH(types); i++) {
-      for (Size j=0; j<LENGTH(strikes); j++) {
-        for (Size k=0; k<LENGTH(lengths); k++) {
-          Date exDate = today + lengths[k]*Years;
-          ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
+    for (auto& type : types) {
+        for (double strike : strikes) {
+            for (int length : lengths) {
+                Date exDate = today + length * Years;
+                ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-          std::vector<Date> dividendDates;
-          std::vector<Real> dividends;
-          dividendDates.push_back(today);
-          dividends.push_back(dividendValue);
+                std::vector<Date> dividendDates;
+                std::vector<Real> dividends;
+                dividendDates.push_back(today);
+                dividends.push_back(dividendValue);
 
-          ext::shared_ptr<StrikedTypePayoff> payoff(
-                                new PlainVanillaPayoff(types[i], strikes[j]));
+                ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(type, strike));
 
-          ext::shared_ptr<BlackScholesMertonProcess> stochProcess(
-                            new BlackScholesMertonProcess(Handle<Quote>(spot),
-                                                          qTS, rTS, volTS));
+                ext::shared_ptr<BlackScholesMertonProcess> stochProcess(
+                    new BlackScholesMertonProcess(Handle<Quote>(spot), qTS, rTS, volTS));
 
-          ext::shared_ptr<PricingEngine> engine(
-                            new AnalyticDividendEuropeanEngine(stochProcess));
+                ext::shared_ptr<PricingEngine> engine(
+                    new AnalyticDividendEuropeanEngine(stochProcess));
 
-          ext::shared_ptr<PricingEngine> ref_engine(
-                                    new AnalyticEuropeanEngine(stochProcess));
-
-          DividendVanillaOption option(payoff, exercise,
-                                       dividendDates, dividends);
-          option.setPricingEngine(engine);
-
-          VanillaOption ref_option(payoff, exercise);
-          ref_option.setPricingEngine(ref_engine);
-
-          for (Size l=0; l<LENGTH(underlyings); l++) {
-            for (Size m=0; m<LENGTH(qRates); m++) {
-              for (Size n=0; n<LENGTH(rRates); n++) {
-                for (Size p=0; p<LENGTH(vols); p++) {
-                    Real u = underlyings[l];
-                    Rate q = qRates[m],
-                         r = rRates[n];
-                    Volatility v = vols[p];
-                    spot->setValue(u);
-                    qRate->setValue(q);
-                    rRate->setValue(r);
-                    vol->setValue(v);
-
-                    Real calculated = option.NPV();
-                    spot->setValue(u-dividendValue);
-                    Real expected = ref_option.NPV();
-                    Real error = std::fabs(calculated-expected);
-                    if (error > tolerance) {
-                        REPORT_FAILURE("value", payoff, exercise,
-                                       u, q, r, today, v,
-                                       expected, calculated,
-                                       error, tolerance);
+                ext::shared_ptr<PricingEngine> ref_engine(new AnalyticEuropeanEngine(stochProcess));
+
+                DividendVanillaOption option(payoff, exercise, dividendDates, dividends);
+                option.setPricingEngine(engine);
+
+                VanillaOption ref_option(payoff, exercise);
+                ref_option.setPricingEngine(ref_engine);
+
+                for (double u : underlyings) {
+                    for (double m : qRates) {
+                        for (double n : rRates) {
+                            for (double v : vols) {
+                                Rate q = m, r = n;
+                                spot->setValue(u);
+                                qRate->setValue(q);
+                                rRate->setValue(r);
+                                vol->setValue(v);
+
+                                Real calculated = option.NPV();
+                                spot->setValue(u - dividendValue);
+                                Real expected = ref_option.NPV();
+                                Real error = std::fabs(calculated - expected);
+                                if (error > tolerance) {
+                                    REPORT_FAILURE("value", payoff, exercise, u, q, r, today, v,
+                                                   expected, calculated, error, tolerance);
+                                }
+                            }
+                        }
                     }
                 }
-              }
             }
-          }
         }
-      }
     }
 }
 
@@ -349,71 +329,60 @@ void DividendOptionTest::testEuropeanEndLimit() {
     ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.0));
     Handle<BlackVolTermStructure> volTS(flatVol(vol, dc));
 
-    for (Size i=0; i<LENGTH(types); i++) {
-      for (Size j=0; j<LENGTH(strikes); j++) {
-        for (Size k=0; k<LENGTH(lengths); k++) {
-          Date exDate = today + lengths[k]*Years;
-          ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
+    for (auto& type : types) {
+        for (double strike : strikes) {
+            for (int length : lengths) {
+                Date exDate = today + length * Years;
+                ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-          std::vector<Date> dividendDates;
-          std::vector<Real> dividends;
-          dividendDates.push_back(exercise->lastDate());
-          dividends.push_back(dividendValue);
+                std::vector<Date> dividendDates;
+                std::vector<Real> dividends;
+                dividendDates.push_back(exercise->lastDate());
+                dividends.push_back(dividendValue);
 
-          ext::shared_ptr<StrikedTypePayoff> payoff(
-                                new PlainVanillaPayoff(types[i], strikes[j]));
+                ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(type, strike));
 
 
-          ext::shared_ptr<StrikedTypePayoff> refPayoff(
-                                new PlainVanillaPayoff(types[i],
-                                                       strikes[j] +
-                                                       dividendValue));
+                ext::shared_ptr<StrikedTypePayoff> refPayoff(
+                    new PlainVanillaPayoff(type, strike + dividendValue));
 
-          ext::shared_ptr<BlackScholesMertonProcess> stochProcess(
-                            new BlackScholesMertonProcess(Handle<Quote>(spot),
-                                                          qTS, rTS, volTS));
+                ext::shared_ptr<BlackScholesMertonProcess> stochProcess(
+                    new BlackScholesMertonProcess(Handle<Quote>(spot), qTS, rTS, volTS));
 
-          ext::shared_ptr<PricingEngine> engine(
-                            new AnalyticDividendEuropeanEngine(stochProcess));
+                ext::shared_ptr<PricingEngine> engine(
+                    new AnalyticDividendEuropeanEngine(stochProcess));
+
+                ext::shared_ptr<PricingEngine> ref_engine(new AnalyticEuropeanEngine(stochProcess));
+
+                DividendVanillaOption option(payoff, exercise, dividendDates, dividends);
+                option.setPricingEngine(engine);
 
-          ext::shared_ptr<PricingEngine> ref_engine(
-                                    new AnalyticEuropeanEngine(stochProcess));
-
-          DividendVanillaOption option(payoff, exercise,
-                                       dividendDates, dividends);
-          option.setPricingEngine(engine);
-
-          VanillaOption ref_option(refPayoff, exercise);
-          ref_option.setPricingEngine(ref_engine);
-
-          for (Size l=0; l<LENGTH(underlyings); l++) {
-            for (Size m=0; m<LENGTH(qRates); m++) {
-              for (Size n=0; n<LENGTH(rRates); n++) {
-                for (Size p=0; p<LENGTH(vols); p++) {
-                    Real u = underlyings[l];
-                    Rate q = qRates[m],
-                         r = rRates[n];
-                    Volatility v = vols[p];
-                    spot->setValue(u);
-                    qRate->setValue(q);
-                    rRate->setValue(r);
-                    vol->setValue(v);
-
-                    Real calculated = option.NPV();
-                    Real expected = ref_option.NPV();
-                    Real error = std::fabs(calculated-expected);
-                    if (error > tolerance) {
-                        REPORT_FAILURE("value", payoff, exercise,
-                                       u, q, r, today, v,
-                                       expected, calculated,
-                                       error, tolerance);
+                VanillaOption ref_option(refPayoff, exercise);
+                ref_option.setPricingEngine(ref_engine);
+
+                for (double u : underlyings) {
+                    for (double m : qRates) {
+                        for (double n : rRates) {
+                            for (double v : vols) {
+                                Rate q = m, r = n;
+                                spot->setValue(u);
+                                qRate->setValue(q);
+                                rRate->setValue(r);
+                                vol->setValue(v);
+
+                                Real calculated = option.NPV();
+                                Real expected = ref_option.NPV();
+                                Real error = std::fabs(calculated - expected);
+                                if (error > tolerance) {
+                                    REPORT_FAILURE("value", payoff, exercise, u, q, r, today, v,
+                                                   expected, calculated, error, tolerance);
+                                }
+                            }
+                        }
                     }
                 }
-              }
             }
-          }
         }
-      }
     }
 }
 
@@ -451,117 +420,104 @@ void DividendOptionTest::testEuropeanGreeks() {
     ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.0));
     Handle<BlackVolTermStructure> volTS(flatVol(vol, dc));
 
-    for (Size i=0; i<LENGTH(types); i++) {
-      for (Size j=0; j<LENGTH(strikes); j++) {
-        for (Size k=0; k<LENGTH(lengths); k++) {
-          Date exDate = today + lengths[k]*Years;
-          ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
-
-          std::vector<Date> dividendDates;
-          std::vector<Real> dividends;
-          for (Date d = today + 3*Months;
-                    d < exercise->lastDate();
-                    d += 6*Months) {
-              dividendDates.push_back(d);
-              dividends.push_back(5.0);
-          }
-
-          ext::shared_ptr<StrikedTypePayoff> payoff(
-                                new PlainVanillaPayoff(types[i], strikes[j]));
-
-          ext::shared_ptr<BlackScholesMertonProcess> stochProcess(
-                            new BlackScholesMertonProcess(Handle<Quote>(spot),
-                                                          qTS, rTS, volTS));
+    for (auto& type : types) {
+        for (double strike : strikes) {
+            for (int length : lengths) {
+                Date exDate = today + length * Years;
+                ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-          ext::shared_ptr<PricingEngine> engine(
-                            new AnalyticDividendEuropeanEngine(stochProcess));
+                std::vector<Date> dividendDates;
+                std::vector<Real> dividends;
+                for (Date d = today + 3 * Months; d < exercise->lastDate(); d += 6 * Months) {
+                    dividendDates.push_back(d);
+                    dividends.push_back(5.0);
+                }
+
+                ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(type, strike));
+
+                ext::shared_ptr<BlackScholesMertonProcess> stochProcess(
+                    new BlackScholesMertonProcess(Handle<Quote>(spot), qTS, rTS, volTS));
+
+                ext::shared_ptr<PricingEngine> engine(
+                    new AnalyticDividendEuropeanEngine(stochProcess));
 
-          DividendVanillaOption option(payoff, exercise,
-                                       dividendDates, dividends);
-          option.setPricingEngine(engine);
-
-          for (Size l=0; l<LENGTH(underlyings); l++) {
-            for (Size m=0; m<LENGTH(qRates); m++) {
-              for (Size n=0; n<LENGTH(rRates); n++) {
-                for (Size p=0; p<LENGTH(vols); p++) {
-                    Real u = underlyings[l];
-                    Rate q = qRates[m],
-                         r = rRates[n];
-                    Volatility v = vols[p];
-                    spot->setValue(u);
-                    qRate->setValue(q);
-                    rRate->setValue(r);
-                    vol->setValue(v);
-
-                    Real value = option.NPV();
-                    calculated["delta"]  = option.delta();
-                    calculated["gamma"]  = option.gamma();
-                    calculated["theta"]  = option.theta();
-                    calculated["rho"]    = option.rho();
-                    calculated["vega"]   = option.vega();
-
-                    if (value > spot->value()*1.0e-5) {
-                        // perturb spot and get delta and gamma
-                        Real du = u*1.0e-4;
-                        spot->setValue(u+du);
-                        Real value_p = option.NPV(),
-                             delta_p = option.delta();
-                        spot->setValue(u-du);
-                        Real value_m = option.NPV(),
-                             delta_m = option.delta();
-                        spot->setValue(u);
-                        expected["delta"] = (value_p - value_m)/(2*du);
-                        expected["gamma"] = (delta_p - delta_m)/(2*du);
-
-                        // perturb risk-free rate and get rho
-                        Spread dr = r*1.0e-4;
-                        rRate->setValue(r+dr);
-                        value_p = option.NPV();
-                        rRate->setValue(r-dr);
-                        value_m = option.NPV();
-                        rRate->setValue(r);
-                        expected["rho"] = (value_p - value_m)/(2*dr);
-
-                        // perturb volatility and get vega
-                        Spread dv = v*1.0e-4;
-                        vol->setValue(v+dv);
-                        value_p = option.NPV();
-                        vol->setValue(v-dv);
-                        value_m = option.NPV();
-                        vol->setValue(v);
-                        expected["vega"] = (value_p - value_m)/(2*dv);
-
-                        // perturb date and get theta
-                        Time dT = dc.yearFraction(today-1, today+1);
-                        Settings::instance().evaluationDate() = today-1;
-                        value_m = option.NPV();
-                        Settings::instance().evaluationDate() = today+1;
-                        value_p = option.NPV();
-                        Settings::instance().evaluationDate() = today;
-                        expected["theta"] = (value_p - value_m)/dT;
-
-                        // compare
-                        std::map<std::string,Real>::iterator it;
-                        for (it = calculated.begin();
-                             it != calculated.end(); ++it) {
-                            std::string greek = it->first;
-                            Real expct = expected  [greek],
-                                 calcl = calculated[greek],
-                                 tol   = tolerance [greek];
-                            Real error = relativeError(expct,calcl,u);
-                            if (error>tol) {
-                                REPORT_FAILURE(greek, payoff, exercise,
-                                               u, q, r, today, v,
-                                               expct, calcl, error, tol);
+                DividendVanillaOption option(payoff, exercise, dividendDates, dividends);
+                option.setPricingEngine(engine);
+
+                for (double u : underlyings) {
+                    for (double m : qRates) {
+                        for (double n : rRates) {
+                            for (double v : vols) {
+                                Rate q = m, r = n;
+                                spot->setValue(u);
+                                qRate->setValue(q);
+                                rRate->setValue(r);
+                                vol->setValue(v);
+
+                                Real value = option.NPV();
+                                calculated["delta"] = option.delta();
+                                calculated["gamma"] = option.gamma();
+                                calculated["theta"] = option.theta();
+                                calculated["rho"] = option.rho();
+                                calculated["vega"] = option.vega();
+
+                                if (value > spot->value() * 1.0e-5) {
+                                    // perturb spot and get delta and gamma
+                                    Real du = u * 1.0e-4;
+                                    spot->setValue(u + du);
+                                    Real value_p = option.NPV(), delta_p = option.delta();
+                                    spot->setValue(u - du);
+                                    Real value_m = option.NPV(), delta_m = option.delta();
+                                    spot->setValue(u);
+                                    expected["delta"] = (value_p - value_m) / (2 * du);
+                                    expected["gamma"] = (delta_p - delta_m) / (2 * du);
+
+                                    // perturb risk-free rate and get rho
+                                    Spread dr = r * 1.0e-4;
+                                    rRate->setValue(r + dr);
+                                    value_p = option.NPV();
+                                    rRate->setValue(r - dr);
+                                    value_m = option.NPV();
+                                    rRate->setValue(r);
+                                    expected["rho"] = (value_p - value_m) / (2 * dr);
+
+                                    // perturb volatility and get vega
+                                    Spread dv = v * 1.0e-4;
+                                    vol->setValue(v + dv);
+                                    value_p = option.NPV();
+                                    vol->setValue(v - dv);
+                                    value_m = option.NPV();
+                                    vol->setValue(v);
+                                    expected["vega"] = (value_p - value_m) / (2 * dv);
+
+                                    // perturb date and get theta
+                                    Time dT = dc.yearFraction(today - 1, today + 1);
+                                    Settings::instance().evaluationDate() = today - 1;
+                                    value_m = option.NPV();
+                                    Settings::instance().evaluationDate() = today + 1;
+                                    value_p = option.NPV();
+                                    Settings::instance().evaluationDate() = today;
+                                    expected["theta"] = (value_p - value_m) / dT;
+
+                                    // compare
+                                    std::map<std::string, Real>::iterator it;
+                                    for (it = calculated.begin(); it != calculated.end(); ++it) {
+                                        std::string greek = it->first;
+                                        Real expct = expected[greek], calcl = calculated[greek],
+                                             tol = tolerance[greek];
+                                        Real error = relativeError(expct, calcl, u);
+                                        if (error > tol) {
+                                            REPORT_FAILURE(greek, payoff, exercise, u, q, r, today,
+                                                           v, expct, calcl, error, tol);
+                                        }
+                                    }
+                                }
                             }
                         }
                     }
                 }
-              }
             }
-          }
         }
-      }
     }
 }
 
@@ -597,75 +553,64 @@ void DividendOptionTest::testFdEuropeanValues() {
     ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.0));
     Handle<BlackVolTermStructure> volTS(flatVol(vol, dc));
 
-    for (Size i=0; i<LENGTH(types); i++) {
-      for (Size j=0; j<LENGTH(strikes); j++) {
-        for (Size k=0; k<LENGTH(lengths); k++) {
-          Date exDate = today + lengths[k]*Years;
-          ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
-
-          std::vector<Date> dividendDates;
-          std::vector<Real> dividends;
-          for (Date d = today + 3*Months;
-                    d < exercise->lastDate();
-                    d += 6*Months) {
-              dividendDates.push_back(d);
-              dividends.push_back(5.0);
-          }
-
-          ext::shared_ptr<StrikedTypePayoff> payoff(
-                                new PlainVanillaPayoff(types[i], strikes[j]));
-
-          ext::shared_ptr<BlackScholesMertonProcess> stochProcess(
-                            new BlackScholesMertonProcess(Handle<Quote>(spot),
-                                                          qTS, rTS, volTS));
+    for (auto& type : types) {
+        for (double strike : strikes) {
+            for (int length : lengths) {
+                Date exDate = today + length * Years;
+                ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-          ext::shared_ptr<PricingEngine> engine =
-              MakeFdBlackScholesVanillaEngine(stochProcess)
-              .withTGrid(timeSteps)
-              .withXGrid(gridPoints)
-              .withCashDividendModel(FdBlackScholesVanillaEngine::Escrowed);
+                std::vector<Date> dividendDates;
+                std::vector<Real> dividends;
+                for (Date d = today + 3 * Months; d < exercise->lastDate(); d += 6 * Months) {
+                    dividendDates.push_back(d);
+                    dividends.push_back(5.0);
+                }
 
-          ext::shared_ptr<PricingEngine> ref_engine(
-                            new AnalyticDividendEuropeanEngine(stochProcess));
+                ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(type, strike));
 
-          DividendVanillaOption option(payoff, exercise,
-                                       dividendDates, dividends);
-          option.setPricingEngine(engine);
-
-          DividendVanillaOption ref_option(payoff, exercise,
-                                           dividendDates, dividends);
-          ref_option.setPricingEngine(ref_engine);
-
-          for (Size l=0; l<LENGTH(underlyings); l++) {
-            for (Size m=0; m<LENGTH(qRates); m++) {
-              for (Size n=0; n<LENGTH(rRates); n++) {
-                for (Size p=0; p<LENGTH(vols); p++) {
-                    Real u = underlyings[l];
-                    Rate q = qRates[m],
-                         r = rRates[n];
-                    Volatility v = vols[p];
-                    spot->setValue(u);
-                    qRate->setValue(q);
-                    rRate->setValue(r);
-                    vol->setValue(v);
-                    // FLOATING_POINT_EXCEPTION
-                    Real calculated = option.NPV();
-                    if (calculated > spot->value()*1.0e-5) {
-                        Real expected = ref_option.NPV();
-                        Real error = std::fabs(calculated-expected);
-                        if (error > tolerance) {
-                            REPORT_FAILURE("value", payoff, exercise,
-                                           u, q, r, today, v,
-                                           expected, calculated,
-                                           error, tolerance);
+                ext::shared_ptr<BlackScholesMertonProcess> stochProcess(
+                    new BlackScholesMertonProcess(Handle<Quote>(spot), qTS, rTS, volTS));
+
+                ext::shared_ptr<PricingEngine> engine =
+                    MakeFdBlackScholesVanillaEngine(stochProcess)
+                        .withTGrid(timeSteps)
+                        .withXGrid(gridPoints)
+                        .withCashDividendModel(FdBlackScholesVanillaEngine::Escrowed);
+
+                ext::shared_ptr<PricingEngine> ref_engine(
+                    new AnalyticDividendEuropeanEngine(stochProcess));
+
+                DividendVanillaOption option(payoff, exercise, dividendDates, dividends);
+                option.setPricingEngine(engine);
+
+                DividendVanillaOption ref_option(payoff, exercise, dividendDates, dividends);
+                ref_option.setPricingEngine(ref_engine);
+
+                for (double u : underlyings) {
+                    for (double m : qRates) {
+                        for (double n : rRates) {
+                            for (double v : vols) {
+                                Rate q = m, r = n;
+                                spot->setValue(u);
+                                qRate->setValue(q);
+                                rRate->setValue(r);
+                                vol->setValue(v);
+                                // FLOATING_POINT_EXCEPTION
+                                Real calculated = option.NPV();
+                                if (calculated > spot->value() * 1.0e-5) {
+                                    Real expected = ref_option.NPV();
+                                    Real error = std::fabs(calculated - expected);
+                                    if (error > tolerance) {
+                                        REPORT_FAILURE("value", payoff, exercise, u, q, r, today, v,
+                                                       expected, calculated, error, tolerance);
+                                    }
+                                }
+                            }
                         }
                     }
                 }
-              }
             }
-          }
         }
-      }
     }
 }
 
@@ -698,8 +643,8 @@ namespace {
         ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.0));
         Handle<BlackVolTermStructure> volTS(flatVol(vol, dc));
 
-        for (Size i=0; i<LENGTH(types); i++) {
-            for (Size j=0; j<LENGTH(strikes); j++) {
+        for (auto& type : types) {
+            for (double strike : strikes) {
 
                 std::vector<Date> dividendDates;
                 std::vector<Real> dividends;
@@ -710,8 +655,7 @@ namespace {
                     dividends.push_back(5.0);
                 }
 
-                ext::shared_ptr<StrikedTypePayoff> payoff(
-                                new PlainVanillaPayoff(types[i], strikes[j]));
+                ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(type, strike));
 
                 ext::shared_ptr<BlackScholesMertonProcess> stochProcess(
                             new BlackScholesMertonProcess(Handle<Quote>(spot),
@@ -725,67 +669,59 @@ namespace {
                                              dividendDates, dividends);
                 option.setPricingEngine(engine);
 
-                for (Size l=0; l<LENGTH(underlyings); l++) {
-                  for (Size m=0; m<LENGTH(qRates); m++) {
-                    for (Size n=0; n<LENGTH(rRates); n++) {
-                      for (Size p=0; p<LENGTH(vols); p++) {
-                        Real u = underlyings[l];
-                        Rate q = qRates[m],
-                             r = rRates[n];
-                        Volatility v = vols[p];
-                        spot->setValue(u);
-                        qRate->setValue(q);
-                        rRate->setValue(r);
-                        vol->setValue(v);
-
-                        // FLOATING_POINT_EXCEPTION
-                        Real value = option.NPV();
-                        calculated["delta"]  = option.delta();
-                        calculated["gamma"]  = option.gamma();
-
-                        if (value > spot->value()*1.0e-5) {
-                          // perturb spot and get delta and gamma
-                          Real du = u*1.0e-4;
-                          spot->setValue(u+du);
-                          Real value_p = option.NPV(),
-                               delta_p = option.delta();
-                          spot->setValue(u-du);
-                          Real value_m = option.NPV(),
-                               delta_m = option.delta();
-                          spot->setValue(u);
-                          expected["delta"] = (value_p - value_m)/(2*du);
-                          expected["gamma"] = (delta_p - delta_m)/(2*du);
-
-                          // perturb date and get theta
-                          /*
-                            Time dT = dc.yearFraction(today-1, today+1);
-                            Settings::instance().evaluationDate() = today-1;
-                            value_m = option.NPV();
-                            Settings::instance().evaluationDate() = today+1;
-                            value_p = option.NPV();
-                            Settings::instance().evaluationDate() = today;
-                            expected["theta"] = (value_p - value_m)/dT;
-                          */
-
-                          // compare
-                          std::map<std::string,Real>::iterator it;
-                          for (it = calculated.begin();
-                               it != calculated.end(); ++it) {
-                            std::string greek = it->first;
-                            Real expct = expected  [greek],
-                                 calcl = calculated[greek],
-                                 tol   = tolerance [greek];
-                            Real error = relativeError(expct,calcl,u);
-                            if (error>tol) {
-                                REPORT_FAILURE(greek, payoff, exercise,
-                                               u, q, r, today, v,
-                                               expct, calcl, error, tol);
+                for (double u : underlyings) {
+                    for (double m : qRates) {
+                        for (double n : rRates) {
+                            for (double v : vols) {
+                                Rate q = m, r = n;
+                                spot->setValue(u);
+                                qRate->setValue(q);
+                                rRate->setValue(r);
+                                vol->setValue(v);
+
+                                // FLOATING_POINT_EXCEPTION
+                                Real value = option.NPV();
+                                calculated["delta"] = option.delta();
+                                calculated["gamma"] = option.gamma();
+
+                                if (value > spot->value() * 1.0e-5) {
+                                    // perturb spot and get delta and gamma
+                                    Real du = u * 1.0e-4;
+                                    spot->setValue(u + du);
+                                    Real value_p = option.NPV(), delta_p = option.delta();
+                                    spot->setValue(u - du);
+                                    Real value_m = option.NPV(), delta_m = option.delta();
+                                    spot->setValue(u);
+                                    expected["delta"] = (value_p - value_m) / (2 * du);
+                                    expected["gamma"] = (delta_p - delta_m) / (2 * du);
+
+                                    // perturb date and get theta
+                                    /*
+                                      Time dT = dc.yearFraction(today-1, today+1);
+                                      Settings::instance().evaluationDate() = today-1;
+                                      value_m = option.NPV();
+                                      Settings::instance().evaluationDate() = today+1;
+                                      value_p = option.NPV();
+                                      Settings::instance().evaluationDate() = today;
+                                      expected["theta"] = (value_p - value_m)/dT;
+                                    */
+
+                                    // compare
+                                    std::map<std::string, Real>::iterator it;
+                                    for (it = calculated.begin(); it != calculated.end(); ++it) {
+                                        std::string greek = it->first;
+                                        Real expct = expected[greek], calcl = calculated[greek],
+                                             tol = tolerance[greek];
+                                        Real error = relativeError(expct, calcl, u);
+                                        if (error > tol) {
+                                            REPORT_FAILURE(greek, payoff, exercise, u, q, r, today,
+                                                           v, expct, calcl, error, tol);
+                                        }
+                                    }
+                                }
                             }
-                          }
                         }
-                      }
                     }
-                  }
                 }
             }
         }
@@ -805,8 +741,8 @@ void DividendOptionTest::testFdEuropeanGreeks() {
     Settings::instance().evaluationDate() = today;
     Integer lengths[] = { 1, 2 };
 
-    for (Size i=0; i<LENGTH(lengths); i++) {
-        Date exDate = today + lengths[i]*Years;
+    for (int length : lengths) {
+        Date exDate = today + length * Years;
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
         testFdGreeks(today,exercise,FdBlackScholesVanillaEngine::Spot);
         testFdGreeks(today,exercise,FdBlackScholesVanillaEngine::Escrowed);
@@ -823,8 +759,8 @@ void DividendOptionTest::testFdAmericanGreeks() {
     Settings::instance().evaluationDate() = today;
     Integer lengths[] = { 1, 2 };
 
-    for (Size i=0; i<LENGTH(lengths); i++) {
-        Date exDate = today + lengths[i]*Years;
+    for (int length : lengths) {
+        Date exDate = today + length * Years;
         ext::shared_ptr<Exercise> exercise(new AmericanExercise(today,exDate));
         testFdGreeks(today,exercise,FdBlackScholesVanillaEngine::Spot);
     }
diff --git a/test-suite/doublebarrieroption.cpp b/test-suite/doublebarrieroption.cpp
index c06ce534e84..870ff71b373 100644
--- a/test-suite/doublebarrieroption.cpp
+++ b/test-suite/doublebarrieroption.cpp
@@ -279,17 +279,16 @@ void DoubleBarrierOptionTest::testEuropeanHaugValues() {
     ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.0));
     ext::shared_ptr<BlackVolTermStructure> volTS = flatVol(today, vol, dc);
 
-    for (Size i=0; i<LENGTH(values); i++) {
-        Date exDate = today + timeToDays(values[i].t);
+    for (auto& value : values) {
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q); 
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(new
-            PlainVanillaPayoff(values[i].type, values[i].strike));
+        ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(value.type, value.strike));
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess(new
             BlackScholesMertonProcess(Handle<Quote>(spot),
@@ -297,13 +296,9 @@ void DoubleBarrierOptionTest::testEuropeanHaugValues() {
                                       Handle<YieldTermStructure>(rTS),
                                       Handle<BlackVolTermStructure>(volTS)));
 
-        DoubleBarrierOption opt(
-                values[i].barrierType,
-                values[i].barrierlo,
-                values[i].barrierhi,
-                0,   // no rebate
-                payoff,
-                exercise);
+        DoubleBarrierOption opt(value.barrierType, value.barrierlo, value.barrierhi,
+                                0, // no rebate
+                                payoff, exercise);
 
         // Ikeda/Kunitomo engine
         ext::shared_ptr<PricingEngine> engine(
@@ -311,13 +306,12 @@ void DoubleBarrierOptionTest::testEuropeanHaugValues() {
         opt.setPricingEngine(engine);
 
         Real calculated = opt.NPV();
-        Real expected = values[i].result;
+        Real expected = value.result;
         Real error = std::fabs(calculated-expected);
-        if (error>values[i].tol) {
-            REPORT_FAILURE("Ikeda/Kunitomo value", values[i].barrierType, values[i].barrierlo,
-                           values[i].barrierhi, payoff, exercise, values[i].s,
-                           values[i].q, values[i].r, today, values[i].v,
-                           expected, calculated, error, values[i].tol);
+        if (error > value.tol) {
+            REPORT_FAILURE("Ikeda/Kunitomo value", value.barrierType, value.barrierlo,
+                           value.barrierhi, payoff, exercise, value.s, value.q, value.r, today,
+                           value.v, expected, calculated, error, value.tol);
         }
 
         // Wulin Suo/Yong Wang engine
@@ -326,13 +320,12 @@ void DoubleBarrierOptionTest::testEuropeanHaugValues() {
         opt.setPricingEngine(engine);
 
         calculated = opt.NPV();
-        expected = values[i].result;
+        expected = value.result;
         error = std::fabs(calculated-expected);
-        if (error>values[i].tol) {
-            REPORT_FAILURE("Wulin/Yong value", values[i].barrierType, values[i].barrierlo,
-                           values[i].barrierhi, payoff, exercise, values[i].s,
-                           values[i].q, values[i].r, today, values[i].v,
-                           expected, calculated, error, values[i].tol);
+        if (error > value.tol) {
+            REPORT_FAILURE("Wulin/Yong value", value.barrierType, value.barrierlo, value.barrierhi,
+                           payoff, exercise, value.s, value.q, value.r, today, value.v, expected,
+                           calculated, error, value.tol);
         }
 
         engine = ext::shared_ptr<PricingEngine>(
@@ -341,15 +334,13 @@ void DoubleBarrierOptionTest::testEuropeanHaugValues() {
                                                                  300));
         opt.setPricingEngine(engine);
         calculated = opt.NPV();
-        expected = values[i].result;
+        expected = value.result;
         error = std::fabs(calculated-expected);
         double tol = 0.28;
         if (error>tol) {
-            REPORT_FAILURE("Binomial value", values[i].barrierType, 
-                           values[i].barrierlo, values[i].barrierhi, payoff, 
-                           exercise, values[i].s, values[i].q, values[i].r, 
-                           today, values[i].v, expected, calculated, error, 
-                           tol);
+            REPORT_FAILURE("Binomial value", value.barrierType, value.barrierlo, value.barrierhi,
+                           payoff, exercise, value.s, value.q, value.r, today, value.v, expected,
+                           calculated, error, tol);
         }
 
         engine = ext::shared_ptr<PricingEngine>(
@@ -358,18 +349,16 @@ void DoubleBarrierOptionTest::testEuropeanHaugValues() {
                                                 stochProcess, 300));
         opt.setPricingEngine(engine);
         calculated = opt.NPV();
-        expected = values[i].result;
+        expected = value.result;
         error = std::fabs(calculated-expected);
         tol = 0.033; // error one order of magnitude lower than plain binomial
         if (error>tol) {
-            REPORT_FAILURE("Binomial (Derman) value", values[i].barrierType, 
-                           values[i].barrierlo, values[i].barrierhi, payoff, 
-                           exercise, values[i].s, values[i].q, values[i].r, 
-                           today, values[i].v, expected, calculated, error, 
-                           tol);
+            REPORT_FAILURE("Binomial (Derman) value", value.barrierType, value.barrierlo,
+                           value.barrierhi, payoff, exercise, value.s, value.q, value.r, today,
+                           value.v, expected, calculated, error, tol);
         }
 
-        if (values[i].barrierType == DoubleBarrier::KnockOut) {
+        if (value.barrierType == DoubleBarrier::KnockOut) {
             engine = ext::make_shared<FdHestonDoubleBarrierEngine>(
                 ext::make_shared<HestonModel>(
                     ext::make_shared<HestonProcess>(
@@ -381,16 +370,14 @@ void DoubleBarrierOptionTest::testEuropeanHaugValues() {
 
             opt.setPricingEngine(engine);
             calculated = opt.NPV();
-            expected = values[i].result;
+            expected = value.result;
             error = std::fabs(calculated-expected);
 
             tol = 0.025; // error one order of magnitude lower than plain binomial
             if (error>tol) {
-                REPORT_FAILURE("Heston value", values[i].barrierType,
-                               values[i].barrierlo, values[i].barrierhi, payoff,
-                               exercise, values[i].s, values[i].q, values[i].r,
-                               today, values[i].v, expected, calculated, error,
-                               tol);
+                REPORT_FAILURE("Heston value", value.barrierType, value.barrierlo, value.barrierhi,
+                               payoff, exercise, value.s, value.q, value.r, today, value.v,
+                               expected, calculated, error, tol);
             }
         }
     }
@@ -447,60 +434,46 @@ void DoubleBarrierOptionTest::testVannaVolgaDoubleBarrierValues() {
     ext::shared_ptr<SimpleQuote> volAtm = ext::make_shared<SimpleQuote>(0.0);
     ext::shared_ptr<SimpleQuote> vol25Call = ext::make_shared<SimpleQuote>(0.0);
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
         for (Size j=0; j<=1; j++) {
 
             auto barrierType = static_cast<DoubleBarrier::Type>(j);
 
-            spot->setValue(values[i].s);
-            qRate->setValue(values[i].q);
-            rRate->setValue(values[i].r);
-            vol25Put->setValue(values[i].vol25Put);
-            volAtm->setValue(values[i].volAtm);
-            vol25Call->setValue(values[i].vol25Call);
+            spot->setValue(value.s);
+            qRate->setValue(value.q);
+            rRate->setValue(value.r);
+            vol25Put->setValue(value.vol25Put);
+            volAtm->setValue(value.volAtm);
+            vol25Call->setValue(value.vol25Call);
 
             ext::shared_ptr<StrikedTypePayoff> payoff =
-                ext::make_shared<PlainVanillaPayoff>(values[i].type,
-                                                       values[i].strike);
+                ext::make_shared<PlainVanillaPayoff>(value.type, value.strike);
 
-            Date exDate = today + timeToDays(values[i].t, 365);
+            Date exDate = today + timeToDays(value.t, 365);
             ext::shared_ptr<Exercise> exercise =
                 ext::make_shared<EuropeanExercise>(exDate);
 
             Handle<DeltaVolQuote> volAtmQuote = Handle<DeltaVolQuote>(
-                        ext::make_shared<DeltaVolQuote>(
-                            Handle<Quote>(volAtm),
-                            DeltaVolQuote::Fwd,
-                            values[i].t,
-                            DeltaVolQuote::AtmDeltaNeutral));
-
-                                //always delta neutral atm
-            Handle<DeltaVolQuote> vol25PutQuote(Handle<DeltaVolQuote>(
-                            ext::make_shared<DeltaVolQuote>(
-                                -0.25,
-                                Handle<Quote>(vol25Put),
-                                values[i].t,
-                                DeltaVolQuote::Fwd)));
-
-            Handle<DeltaVolQuote> vol25CallQuote(Handle<DeltaVolQuote>(
-                            ext::make_shared<DeltaVolQuote>(
-                                0.25,
-                                Handle<Quote>(vol25Call),
-                                values[i].t,
-                                DeltaVolQuote::Fwd)));
-
-            DoubleBarrierOption doubleBarrierOption(barrierType,
-                                                    values[i].barrier1,
-                                                    values[i].barrier2,
-                                                    values[i].rebate,
-                                                    payoff,
-                                                    exercise);
+                ext::make_shared<DeltaVolQuote>(Handle<Quote>(volAtm), DeltaVolQuote::Fwd, value.t,
+                                                DeltaVolQuote::AtmDeltaNeutral));
+
+            // always delta neutral atm
+            Handle<DeltaVolQuote> vol25PutQuote(
+                Handle<DeltaVolQuote>(ext::make_shared<DeltaVolQuote>(
+                    -0.25, Handle<Quote>(vol25Put), value.t, DeltaVolQuote::Fwd)));
+
+            Handle<DeltaVolQuote> vol25CallQuote(
+                Handle<DeltaVolQuote>(ext::make_shared<DeltaVolQuote>(
+                    0.25, Handle<Quote>(vol25Call), value.t, DeltaVolQuote::Fwd)));
+
+            DoubleBarrierOption doubleBarrierOption(barrierType, value.barrier1, value.barrier2,
+                                                    value.rebate, payoff, exercise);
 
             Real bsVanillaPrice =
-                blackFormula(values[i].type, values[i].strike,
-                             spot->value()*qTS->discount(values[i].t)/rTS->discount(values[i].t),
-                             values[i].v * sqrt(values[i].t), rTS->discount(values[i].t));
+                blackFormula(value.type, value.strike,
+                             spot->value() * qTS->discount(value.t) / rTS->discount(value.t),
+                             value.v * sqrt(value.t), rTS->discount(value.t));
             ext::shared_ptr<PricingEngine> vannaVolgaEngine =
                 ext::make_shared<VannaVolgaDoubleBarrierEngine<WulinYongDoubleBarrierEngine> >(
                                 volAtmQuote,
@@ -516,20 +489,17 @@ void DoubleBarrierOptionTest::testVannaVolgaDoubleBarrierValues() {
             // Expected result for KO is given in array, for KI is evaluated as vanilla - KO
             Real expected = 0;
             if (barrierType == DoubleBarrier::KnockOut)
-               expected = values[i].result;
+                expected = value.result;
             else if (barrierType == DoubleBarrier::KnockIn)
-               expected = (bsVanillaPrice - values[i].result);
-           
+                expected = (bsVanillaPrice - value.result);
+
             Real calculated = doubleBarrierOption.NPV();
             Real error = std::fabs(calculated-expected);
-            if (error>values[i].tol) {
-                REPORT_FAILURE_VANNAVOLGA(
-                    "value", barrierType,
-                    values[i].barrier1, values[i].barrier2,
-                    values[i].rebate, payoff, exercise, values[i].s,
-                    values[i].q, values[i].r, today, values[i].vol25Put,
-                    values[i].volAtm, values[i].vol25Call, values[i].v,
-                    expected, calculated, error, values[i].tol);
+            if (error > value.tol) {
+                REPORT_FAILURE_VANNAVOLGA("value", barrierType, value.barrier1, value.barrier2,
+                                          value.rebate, payoff, exercise, value.s, value.q, value.r,
+                                          today, value.vol25Put, value.volAtm, value.vol25Call,
+                                          value.v, expected, calculated, error, value.tol);
             }
 
             vannaVolgaEngine =
@@ -548,16 +518,12 @@ void DoubleBarrierOptionTest::testVannaVolgaDoubleBarrierValues() {
             error = std::fabs(calculated-expected);
             Real maxtol = 5.0e-3; // different engines have somewhat different results
             if (error>maxtol) {
-                REPORT_FAILURE_VANNAVOLGA(
-                    "value", barrierType,
-                    values[i].barrier1, values[i].barrier2,
-                    values[i].rebate, payoff, exercise, values[i].s,
-                    values[i].q, values[i].r, today, values[i].vol25Put,
-                    values[i].volAtm, values[i].vol25Call, values[i].v,
-                    expected, calculated, error, values[i].tol);
+                REPORT_FAILURE_VANNAVOLGA("value", barrierType, value.barrier1, value.barrier2,
+                                          value.rebate, payoff, exercise, value.s, value.q, value.r,
+                                          today, value.vol25Put, value.volAtm, value.vol25Call,
+                                          value.v, expected, calculated, error, value.tol);
             }
         }
-
     }
 }
 
diff --git a/test-suite/doublebinaryoption.cpp b/test-suite/doublebinaryoption.cpp
index ee26c050966..4d26ee6fa2f 100644
--- a/test-suite/doublebinaryoption.cpp
+++ b/test-suite/doublebinaryoption.cpp
@@ -183,23 +183,22 @@ void DoubleBinaryOptionTest::testHaugValues() {
     ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.25));
     ext::shared_ptr<BlackVolTermStructure> volTS = flatVol(today, vol, dc);
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(new CashOrNothingPayoff(
-            Option::Call, 0, values[i].cash));
+        ext::shared_ptr<StrikedTypePayoff> payoff(
+            new CashOrNothingPayoff(Option::Call, 0, value.cash));
 
-        Date exDate = today + timeToDays(values[i].t);
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise;
-        if (values[i].barrierType == DoubleBarrier::KIKO ||
-            values[i].barrierType == DoubleBarrier::KOKI)
+        if (value.barrierType == DoubleBarrier::KIKO || value.barrierType == DoubleBarrier::KOKI)
             exercise.reset(new AmericanExercise(today, exDate));
         else
             exercise.reset(new EuropeanExercise(exDate));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess(new
             BlackScholesMertonProcess(Handle<Quote>(spot),
@@ -210,22 +209,17 @@ void DoubleBinaryOptionTest::testHaugValues() {
         // checking with analytic engine
         ext::shared_ptr<PricingEngine> engine(
                              new AnalyticDoubleBarrierBinaryEngine(stochProcess));
-        DoubleBarrierOption opt(values[i].barrierType, 
-                          values[i].barrier_lo, 
-                          values[i].barrier_hi, 
-                          0,
-                          payoff,
-                          exercise);
+        DoubleBarrierOption opt(value.barrierType, value.barrier_lo, value.barrier_hi, 0, payoff,
+                                exercise);
         opt.setPricingEngine(engine);
 
         Real calculated = opt.NPV();
-        Real expected = values[i].result;
+        Real expected = value.result;
         Real error = std::fabs(calculated-expected);
-        if (error > values[i].tol) {
-            REPORT_FAILURE("value", payoff, exercise, values[i].barrierType, 
-                           values[i].barrier_lo, values[i].barrier_hi, values[i].s,
-                           values[i].q, values[i].r, today, values[i].v,
-                           values[i].result, calculated, error, values[i].tol);
+        if (error > value.tol) {
+            REPORT_FAILURE("value", payoff, exercise, value.barrierType, value.barrier_lo,
+                           value.barrier_hi, value.s, value.q, value.r, today, value.v,
+                           value.result, calculated, error, value.tol);
         }
 
         Size steps = 500;
@@ -236,16 +230,14 @@ void DoubleBinaryOptionTest::testHaugValues() {
                                                                  steps));
         opt.setPricingEngine(engine);
         calculated = opt.NPV();
-        expected = values[i].result;
+        expected = value.result;
         error = std::fabs(calculated-expected);
         double tol = 0.22;
         if (error>tol) {
-            REPORT_FAILURE("Binomial value", payoff, exercise, values[i].barrierType, 
-                           values[i].barrier_lo, values[i].barrier_hi, values[i].s,
-                           values[i].q, values[i].r, today, values[i].v,
-                           values[i].result, calculated, error, tol);
+            REPORT_FAILURE("Binomial value", payoff, exercise, value.barrierType, value.barrier_lo,
+                           value.barrier_hi, value.s, value.q, value.r, today, value.v,
+                           value.result, calculated, error, tol);
         }
-
     }
 } 
 
diff --git a/test-suite/europeanoption.cpp b/test-suite/europeanoption.cpp
index d44c91af269..29814dcad59 100644
--- a/test-suite/europeanoption.cpp
+++ b/test-suite/europeanoption.cpp
@@ -261,17 +261,16 @@ void EuropeanOptionTest::testValues() {
     ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.0));
     ext::shared_ptr<BlackVolTermStructure> volTS = flatVol(today, vol, dc);
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(new
-            PlainVanillaPayoff(values[i].type, values[i].strike));
-        Date exDate = today + timeToDays(values[i].t);
+        ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(value.type, value.strike));
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess(new
             BlackScholesMertonProcess(Handle<Quote>(spot),
@@ -285,13 +284,11 @@ void EuropeanOptionTest::testValues() {
         option.setPricingEngine(engine);
 
         Real calculated = option.NPV();
-        Real error = std::fabs(calculated-values[i].result);
-        Real tolerance = values[i].tol;
+        Real error = std::fabs(calculated - value.result);
+        Real tolerance = value.tol;
         if (error>tolerance) {
-            REPORT_FAILURE("value", payoff, exercise, values[i].s,
-                           values[i].q, values[i].r, today,
-                           values[i].v, values[i].result, calculated,
-                           error, tolerance);
+            REPORT_FAILURE("value", payoff, exercise, value.s, value.q, value.r, today, value.v,
+                           value.result, calculated, error, tolerance);
         }
 
         engine = ext::shared_ptr<PricingEngine>(
@@ -299,16 +296,13 @@ void EuropeanOptionTest::testValues() {
         option.setPricingEngine(engine);
 
         calculated = option.NPV();
-        error = std::fabs(calculated-values[i].result);
+        error = std::fabs(calculated - value.result);
         tolerance = 1.0e-3;
         if (error>tolerance) {
-            REPORT_FAILURE("value", payoff, exercise, values[i].s,
-                           values[i].q, values[i].r, today,
-                           values[i].v, values[i].result, calculated,
-                           error, tolerance);
+            REPORT_FAILURE("value", payoff, exercise, value.s, value.q, value.r, today, value.v,
+                           value.result, calculated, error, tolerance);
         }
     }
-
 }
 
 
@@ -642,128 +636,118 @@ void EuropeanOptionTest::testGreeks() {
 
     ext::shared_ptr<StrikedTypePayoff> payoff;
 
-    for (Size i=0; i<LENGTH(types); i++) {
-      for (Size j=0; j<LENGTH(strikes); j++) {
-        for (Size k=0; k<LENGTH(residualTimes); k++) {
-          Date exDate = today + timeToDays(residualTimes[k]);
-          ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
-          for (Size kk=0; kk<4; kk++) {
-              // option to check
-              if (kk==0) {
-                  payoff = ext::shared_ptr<StrikedTypePayoff>(new
-                    PlainVanillaPayoff(types[i], strikes[j]));
-              } else if (kk==1) {
-                  payoff = ext::shared_ptr<StrikedTypePayoff>(new
-                    CashOrNothingPayoff(types[i], strikes[j],
-                    100.0));
-              } else if (kk==2) {
-                  payoff = ext::shared_ptr<StrikedTypePayoff>(new
-                    AssetOrNothingPayoff(types[i], strikes[j]));
-              } else if (kk==3) {
-                  payoff = ext::shared_ptr<StrikedTypePayoff>(new
-                    GapPayoff(types[i], strikes[j], 100.0));
-              }
-
-              ext::shared_ptr<BlackScholesMertonProcess> stochProcess(
-                            new BlackScholesMertonProcess(Handle<Quote>(spot),
-                                                          qTS, rTS, volTS));
-              ext::shared_ptr<PricingEngine> engine(
-                                    new AnalyticEuropeanEngine(stochProcess));
-              EuropeanOption option(payoff, exercise);
-              option.setPricingEngine(engine);
-
-              for (Size l=0; l<LENGTH(underlyings); l++) {
-                for (Size m=0; m<LENGTH(qRates); m++) {
-                  for (Size n=0; n<LENGTH(rRates); n++) {
-                    for (Size p=0; p<LENGTH(vols); p++) {
-                      Real u = underlyings[l];
-                      Rate q = qRates[m],
-                           r = rRates[n];
-                      Volatility v = vols[p];
-                      spot->setValue(u);
-                      qRate->setValue(q);
-                      rRate->setValue(r);
-                      vol->setValue(v);
-
-                      Real value = option.NPV();
-                      calculated["delta"]  = option.delta();
-                      calculated["gamma"]  = option.gamma();
-                      calculated["theta"]  = option.theta();
-                      calculated["rho"]    = option.rho();
-                      calculated["divRho"] = option.dividendRho();
-                      calculated["vega"]   = option.vega();
-
-                      if (value > spot->value()*1.0e-5) {
-                          // perturb spot and get delta and gamma
-                          Real du = u*1.0e-4;
-                          spot->setValue(u+du);
-                          Real value_p = option.NPV(),
-                               delta_p = option.delta();
-                          spot->setValue(u-du);
-                          Real value_m = option.NPV(),
-                               delta_m = option.delta();
-                          spot->setValue(u);
-                          expected["delta"] = (value_p - value_m)/(2*du);
-                          expected["gamma"] = (delta_p - delta_m)/(2*du);
-
-                          // perturb rates and get rho and dividend rho
-                          Spread dr = r*1.0e-4;
-                          rRate->setValue(r+dr);
-                          value_p = option.NPV();
-                          rRate->setValue(r-dr);
-                          value_m = option.NPV();
-                          rRate->setValue(r);
-                          expected["rho"] = (value_p - value_m)/(2*dr);
-
-                          Spread dq = q*1.0e-4;
-                          qRate->setValue(q+dq);
-                          value_p = option.NPV();
-                          qRate->setValue(q-dq);
-                          value_m = option.NPV();
-                          qRate->setValue(q);
-                          expected["divRho"] = (value_p - value_m)/(2*dq);
-
-                          // perturb volatility and get vega
-                          Volatility dv = v*1.0e-4;
-                          vol->setValue(v+dv);
-                          value_p = option.NPV();
-                          vol->setValue(v-dv);
-                          value_m = option.NPV();
-                          vol->setValue(v);
-                          expected["vega"] = (value_p - value_m)/(2*dv);
-
-                          // perturb date and get theta
-                          Time dT = dc.yearFraction(today-1, today+1);
-                          Settings::instance().evaluationDate() = today-1;
-                          value_m = option.NPV();
-                          Settings::instance().evaluationDate() = today+1;
-                          value_p = option.NPV();
-                          Settings::instance().evaluationDate() = today;
-                          expected["theta"] = (value_p - value_m)/dT;
-
-                          // compare
-                          std::map<std::string,Real>::iterator it;
-                          for (it = calculated.begin();
-                               it != calculated.end(); ++it) {
-                              std::string greek = it->first;
-                              Real expct = expected  [greek],
-                                   calcl = calculated[greek],
-                                   tol   = tolerance [greek];
-                              Real error = relativeError(expct,calcl,u);
-                              if (error>tol) {
-                                  REPORT_FAILURE(greek, payoff, exercise,
-                                                 u, q, r, today, v,
-                                                 expct, calcl, error, tol);
-                              }
-                          }
-                      }
+    for (auto& type : types) {
+        for (double strike : strikes) {
+            for (double residualTime : residualTimes) {
+                Date exDate = today + timeToDays(residualTime);
+                ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
+                for (Size kk = 0; kk < 4; kk++) {
+                    // option to check
+                    if (kk == 0) {
+                        payoff = ext::shared_ptr<StrikedTypePayoff>(
+                            new PlainVanillaPayoff(type, strike));
+                    } else if (kk == 1) {
+                        payoff = ext::shared_ptr<StrikedTypePayoff>(
+                            new CashOrNothingPayoff(type, strike, 100.0));
+                    } else if (kk == 2) {
+                        payoff = ext::shared_ptr<StrikedTypePayoff>(
+                            new AssetOrNothingPayoff(type, strike));
+                    } else if (kk == 3) {
+                        payoff =
+                            ext::shared_ptr<StrikedTypePayoff>(new GapPayoff(type, strike, 100.0));
+                    }
+
+                    ext::shared_ptr<BlackScholesMertonProcess> stochProcess(
+                        new BlackScholesMertonProcess(Handle<Quote>(spot), qTS, rTS, volTS));
+                    ext::shared_ptr<PricingEngine> engine(new AnalyticEuropeanEngine(stochProcess));
+                    EuropeanOption option(payoff, exercise);
+                    option.setPricingEngine(engine);
+
+                    for (double u : underlyings) {
+                        for (double m : qRates) {
+                            for (double n : rRates) {
+                                for (double v : vols) {
+                                    Rate q = m, r = n;
+                                    spot->setValue(u);
+                                    qRate->setValue(q);
+                                    rRate->setValue(r);
+                                    vol->setValue(v);
+
+                                    Real value = option.NPV();
+                                    calculated["delta"] = option.delta();
+                                    calculated["gamma"] = option.gamma();
+                                    calculated["theta"] = option.theta();
+                                    calculated["rho"] = option.rho();
+                                    calculated["divRho"] = option.dividendRho();
+                                    calculated["vega"] = option.vega();
+
+                                    if (value > spot->value() * 1.0e-5) {
+                                        // perturb spot and get delta and gamma
+                                        Real du = u * 1.0e-4;
+                                        spot->setValue(u + du);
+                                        Real value_p = option.NPV(), delta_p = option.delta();
+                                        spot->setValue(u - du);
+                                        Real value_m = option.NPV(), delta_m = option.delta();
+                                        spot->setValue(u);
+                                        expected["delta"] = (value_p - value_m) / (2 * du);
+                                        expected["gamma"] = (delta_p - delta_m) / (2 * du);
+
+                                        // perturb rates and get rho and dividend rho
+                                        Spread dr = r * 1.0e-4;
+                                        rRate->setValue(r + dr);
+                                        value_p = option.NPV();
+                                        rRate->setValue(r - dr);
+                                        value_m = option.NPV();
+                                        rRate->setValue(r);
+                                        expected["rho"] = (value_p - value_m) / (2 * dr);
+
+                                        Spread dq = q * 1.0e-4;
+                                        qRate->setValue(q + dq);
+                                        value_p = option.NPV();
+                                        qRate->setValue(q - dq);
+                                        value_m = option.NPV();
+                                        qRate->setValue(q);
+                                        expected["divRho"] = (value_p - value_m) / (2 * dq);
+
+                                        // perturb volatility and get vega
+                                        Volatility dv = v * 1.0e-4;
+                                        vol->setValue(v + dv);
+                                        value_p = option.NPV();
+                                        vol->setValue(v - dv);
+                                        value_m = option.NPV();
+                                        vol->setValue(v);
+                                        expected["vega"] = (value_p - value_m) / (2 * dv);
+
+                                        // perturb date and get theta
+                                        Time dT = dc.yearFraction(today - 1, today + 1);
+                                        Settings::instance().evaluationDate() = today - 1;
+                                        value_m = option.NPV();
+                                        Settings::instance().evaluationDate() = today + 1;
+                                        value_p = option.NPV();
+                                        Settings::instance().evaluationDate() = today;
+                                        expected["theta"] = (value_p - value_m) / dT;
+
+                                        // compare
+                                        std::map<std::string, Real>::iterator it;
+                                        for (it = calculated.begin(); it != calculated.end();
+                                             ++it) {
+                                            std::string greek = it->first;
+                                            Real expct = expected[greek], calcl = calculated[greek],
+                                                 tol = tolerance[greek];
+                                            Real error = relativeError(expct, calcl, u);
+                                            if (error > tol) {
+                                                REPORT_FAILURE(greek, payoff, exercise, u, q, r,
+                                                               today, v, expct, calcl, error, tol);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
                     }
-                  }
                 }
-              }
             }
         }
-      }
     }
 }
 
@@ -800,99 +784,87 @@ void EuropeanOptionTest::testImpliedVol() {
     ext::shared_ptr<SimpleQuote> rRate(new SimpleQuote(0.0));
     ext::shared_ptr<YieldTermStructure> rTS = flatRate(today, rRate, dc);
 
-    for (Size i=0; i<LENGTH(types); i++) {
-      for (Size j=0; j<LENGTH(strikes); j++) {
-        for (Size k=0; k<LENGTH(lengths); k++) {
-          // option to check
-          Date exDate = today + lengths[k];
-          ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
-          ext::shared_ptr<StrikedTypePayoff> payoff(
-                                new PlainVanillaPayoff(types[i], strikes[j]));
-          ext::shared_ptr<VanillaOption> option =
-              makeOption(payoff, exercise, spot, qTS, rTS, volTS,
-                         Analytic, Null<Size>(), Null<Size>());
-
-          ext::shared_ptr<GeneralizedBlackScholesProcess> process =
-              makeProcess(spot, qTS, rTS,volTS);
-
-          for (Size l=0; l<LENGTH(underlyings); l++) {
-            for (Size m=0; m<LENGTH(qRates); m++) {
-              for (Size n=0; n<LENGTH(rRates); n++) {
-                for (Size p=0; p<LENGTH(vols); p++) {
-                  Real u = underlyings[l];
-                  Rate q = qRates[m],
-                       r = rRates[n];
-                  Volatility v = vols[p];
-                  spot->setValue(u);
-                  qRate->setValue(q);
-                  rRate->setValue(r);
-                  vol->setValue(v);
-
-                  Real value = option->NPV();
-                  Volatility implVol = 0.0; // just to remove a warning...
-                  if (value != 0.0) {
-                      // shift guess somehow
-                      vol->setValue(v*0.5);
-                      if (std::fabs(value-option->NPV()) <= 1.0e-12) {
-                          // flat price vs vol --- pointless (and
-                          // numerically unstable) to solve
-                          continue;
-                      }
-                      try {
-                          implVol = option->impliedVolatility(value,
-                                                              process,
-                                                              tolerance,
-                                                              maxEvaluations);
-                      } catch (std::exception& e) {
-                          BOOST_ERROR(
-                              "\nimplied vol calculation failed:" <<
-                              "\n   option:         " << types[i] <<
-                              "\n   strike:         " << strikes[j] <<
-                              "\n   spot value:     " << u <<
-                              "\n   dividend yield: " << io::rate(q) <<
-                              "\n   risk-free rate: " << io::rate(r) <<
-                              "\n   today:          " << today <<
-                              "\n   maturity:       " << exDate <<
-                              "\n   volatility:     " << io::volatility(v) <<
-                              "\n   option value:   " << value <<
-                              "\n" << e.what());
-                      }
-                      if (std::fabs(implVol-v) > tolerance) {
-                          // the difference might not matter
-                          vol->setValue(implVol);
-                          Real value2 = option->NPV();
-                          Real error = relativeError(value,value2,u);
-                          if (error > tolerance) {
-                              BOOST_ERROR(
-                                  types[i] << " option :\n"
-                                  << "    spot value:          " << u << "\n"
-                                  << "    strike:              "
-                                  << strikes[j] << "\n"
-                                  << "    dividend yield:      "
-                                  << io::rate(q) << "\n"
-                                  << "    risk-free rate:      "
-                                  << io::rate(r) << "\n"
-                                  << "    maturity:            "
-                                  << exDate << "\n\n"
-                                  << "    original volatility: "
-                                  << io::volatility(v) << "\n"
-                                  << "    price:               "
-                                  << value << "\n"
-                                  << "    implied volatility:  "
-                                  << io::volatility(implVol)
-                                  << "\n"
-                                  << "    corresponding price: "
-                                  << value2 << "\n"
-                                  << "    error:               " << error);
-                          }
-                      }
-                  }
+    for (auto& type : types) {
+        for (double& strike : strikes) {
+            for (int length : lengths) {
+                // option to check
+                Date exDate = today + length;
+                ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
+                ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(type, strike));
+                ext::shared_ptr<VanillaOption> option = makeOption(
+                    payoff, exercise, spot, qTS, rTS, volTS, Analytic, Null<Size>(), Null<Size>());
+
+                ext::shared_ptr<GeneralizedBlackScholesProcess> process =
+                    makeProcess(spot, qTS, rTS, volTS);
+
+                for (double u : underlyings) {
+                    for (double m : qRates) {
+                        for (double n : rRates) {
+                            for (double v : vols) {
+                                Rate q = m, r = n;
+                                spot->setValue(u);
+                                qRate->setValue(q);
+                                rRate->setValue(r);
+                                vol->setValue(v);
+
+                                Real value = option->NPV();
+                                Volatility implVol = 0.0; // just to remove a warning...
+                                if (value != 0.0) {
+                                    // shift guess somehow
+                                    vol->setValue(v * 0.5);
+                                    if (std::fabs(value - option->NPV()) <= 1.0e-12) {
+                                        // flat price vs vol --- pointless (and
+                                        // numerically unstable) to solve
+                                        continue;
+                                    }
+                                    try {
+                                        implVol = option->impliedVolatility(
+                                            value, process, tolerance, maxEvaluations);
+                                    } catch (std::exception& e) {
+                                        BOOST_ERROR("\nimplied vol calculation failed:"
+                                                    << "\n   option:         " << type
+                                                    << "\n   strike:         " << strike
+                                                    << "\n   spot value:     " << u
+                                                    << "\n   dividend yield: " << io::rate(q)
+                                                    << "\n   risk-free rate: " << io::rate(r)
+                                                    << "\n   today:          " << today
+                                                    << "\n   maturity:       " << exDate
+                                                    << "\n   volatility:     " << io::volatility(v)
+                                                    << "\n   option value:   " << value << "\n"
+                                                    << e.what());
+                                    }
+                                    if (std::fabs(implVol - v) > tolerance) {
+                                        // the difference might not matter
+                                        vol->setValue(implVol);
+                                        Real value2 = option->NPV();
+                                        Real error = relativeError(value, value2, u);
+                                        if (error > tolerance) {
+                                            BOOST_ERROR(
+                                                type
+                                                << " option :\n"
+                                                << "    spot value:          " << u << "\n"
+                                                << "    strike:              " << strike << "\n"
+                                                << "    dividend yield:      " << io::rate(q)
+                                                << "\n"
+                                                << "    risk-free rate:      " << io::rate(r)
+                                                << "\n"
+                                                << "    maturity:            " << exDate << "\n\n"
+                                                << "    original volatility: " << io::volatility(v)
+                                                << "\n"
+                                                << "    price:               " << value << "\n"
+                                                << "    implied volatility:  "
+                                                << io::volatility(implVol) << "\n"
+                                                << "    corresponding price: " << value2 << "\n"
+                                                << "    error:               " << error);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
                 }
-              }
             }
-          }
         }
-      }
     }
 }
 
@@ -1009,71 +981,62 @@ namespace {
         ext::shared_ptr<SimpleQuote> rRate(new SimpleQuote(0.0));
         ext::shared_ptr<YieldTermStructure> rTS = flatRate(today,rRate,dc);
 
-        for (Size i=0; i<LENGTH(types); i++) {
-          for (Size j=0; j<LENGTH(strikes); j++) {
-            for (Size k=0; k<LENGTH(lengths); k++) {
-              Date exDate = today + lengths[k]*360;
-              ext::shared_ptr<Exercise> exercise(
-                                                new EuropeanExercise(exDate));
-              ext::shared_ptr<StrikedTypePayoff> payoff(new
-                                    PlainVanillaPayoff(types[i], strikes[j]));
-              // reference option
-              ext::shared_ptr<VanillaOption> refOption =
-                  makeOption(payoff, exercise, spot, qTS, rTS, volTS,
-                             Analytic, Null<Size>(), Null<Size>());
-              // option to check
-              ext::shared_ptr<VanillaOption> option =
-                  makeOption(payoff, exercise, spot, qTS, rTS, volTS,
-                             engine, binomialSteps, samples);
-
-              for (Size l=0; l<LENGTH(underlyings); l++) {
-                for (Size m=0; m<LENGTH(qRates); m++) {
-                  for (Size n=0; n<LENGTH(rRates); n++) {
-                    for (Size p=0; p<LENGTH(vols); p++) {
-                      Real u = underlyings[l];
-                      Rate q = qRates[m],
-                           r = rRates[n];
-                      Volatility v = vols[p];
-                      spot->setValue(u);
-                      qRate->setValue(q);
-                      rRate->setValue(r);
-                      vol->setValue(v);
-
-                      expected.clear();
-                      calculated.clear();
-
-                      // FLOATING_POINT_EXCEPTION
-                      expected["value"] = refOption->NPV();
-                      calculated["value"] = option->NPV();
-
-                      if (testGreeks && option->NPV() > spot->value()*1.0e-5) {
-                           expected["delta"] = refOption->delta();
-                           expected["gamma"] = refOption->gamma();
-                           expected["theta"] = refOption->theta();
-                           calculated["delta"] = option->delta();
-                           calculated["gamma"] = option->gamma();
-                           calculated["theta"] = option->theta();
-                      }
-                      std::map<std::string,Real>::iterator it;
-                      for (it = calculated.begin();
-                           it != calculated.end(); ++it) {
-                          std::string greek = it->first;
-                          Real expct = expected  [greek],
-                               calcl = calculated[greek],
-                               tol   = tolerance [greek];
-                          Real error = relativeError(expct,calcl,u);
-                          if (error > tol) {
-                              REPORT_FAILURE(greek, payoff, exercise,
-                                             u, q, r, today, v,
-                                             expct, calcl, error, tol);
-                          }
-                      }
+        for (auto& type : types) {
+            for (double strike : strikes) {
+                for (int length : lengths) {
+                    Date exDate = today + length * 360;
+                    ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
+                    ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(type, strike));
+                    // reference option
+                    ext::shared_ptr<VanillaOption> refOption =
+                        makeOption(payoff, exercise, spot, qTS, rTS, volTS, Analytic, Null<Size>(),
+                                   Null<Size>());
+                    // option to check
+                    ext::shared_ptr<VanillaOption> option = makeOption(
+                        payoff, exercise, spot, qTS, rTS, volTS, engine, binomialSteps, samples);
+
+                    for (double u : underlyings) {
+                        for (double m : qRates) {
+                            for (double n : rRates) {
+                                for (double v : vols) {
+                                    Rate q = m, r = n;
+                                    spot->setValue(u);
+                                    qRate->setValue(q);
+                                    rRate->setValue(r);
+                                    vol->setValue(v);
+
+                                    expected.clear();
+                                    calculated.clear();
+
+                                    // FLOATING_POINT_EXCEPTION
+                                    expected["value"] = refOption->NPV();
+                                    calculated["value"] = option->NPV();
+
+                                    if (testGreeks && option->NPV() > spot->value() * 1.0e-5) {
+                                        expected["delta"] = refOption->delta();
+                                        expected["gamma"] = refOption->gamma();
+                                        expected["theta"] = refOption->theta();
+                                        calculated["delta"] = option->delta();
+                                        calculated["gamma"] = option->gamma();
+                                        calculated["theta"] = option->theta();
+                                    }
+                                    std::map<std::string, Real>::iterator it;
+                                    for (it = calculated.begin(); it != calculated.end(); ++it) {
+                                        std::string greek = it->first;
+                                        Real expct = expected[greek], calcl = calculated[greek],
+                                             tol = tolerance[greek];
+                                        Real error = relativeError(expct, calcl, u);
+                                        if (error > tol) {
+                                            REPORT_FAILURE(greek, payoff, exercise, u, q, r, today,
+                                                           v, expct, calcl, error, tol);
+                                        }
+                                    }
+                                }
+                            }
+                        }
                     }
-                  }
                 }
-              }
             }
-          }
         }
     }
 
@@ -1434,19 +1397,17 @@ void EuropeanOptionTest::testLocalVolatility() {
             
             // check local vol pricing
             // delta/gamma are not the same by definition (model implied greeks)
-            for (Size i=0; i < LENGTH(schemeDescs); ++i) {
-                option.setPricingEngine(
-                    ext::make_shared<FdBlackScholesVanillaEngine>(
-                        process, 25, 100, 0, schemeDescs[i].first, true, 0.35));
+            for (const auto& schemeDesc : schemeDescs) {
+                option.setPricingEngine(ext::make_shared<FdBlackScholesVanillaEngine>(
+                    process, 25, 100, 0, schemeDesc.first, true, 0.35));
 
                 calculatedNPV = option.NPV();
                 if (std::fabs(expectedNPV - calculatedNPV) > tol*expectedNPV) {
                     BOOST_FAIL("Failed to reproduce local vol option price for "
-                               << "\n    strike:     " << payoff->strike()
-                               << "\n    maturity:   " << exDate
-                               << "\n    calculated: " << calculatedNPV
+                               << "\n    strike:     " << payoff->strike() << "\n    maturity:   "
+                               << exDate << "\n    calculated: " << calculatedNPV
                                << "\n    expected:   " << expectedNPV
-                               << "\n    scheme:     " << schemeDescs[i].second);
+                               << "\n    scheme:     " << schemeDesc.second);
                 }
             }
         }
@@ -1591,19 +1552,17 @@ void EuropeanOptionTest::testPDESchemes() {
     const Real expected = option.NPV();
 
     const Real tol = 0.006;
-    for (Size i=0; i < nEngines; ++i) {
-        option.setPricingEngine(engines[i].first);
+    for (const auto& engine : engines) {
+        option.setPricingEngine(engine.first);
         const Real calculated = option.NPV();
 
         const Real diff = std::fabs(expected - calculated);
 
         if (diff > tol) {
             BOOST_FAIL("Failed to reproduce European option values with the "
-                    << engines[i].second << " PDE scheme"
-                       << "\n    calculated: " << calculated
-                       << "\n    expected:   " << expected
-                       << "\n    difference: " << diff
-                       << "\n    tolerance:  " << tol);
+                       << engine.second << " PDE scheme"
+                       << "\n    calculated: " << calculated << "\n    expected:   " << expected
+                       << "\n    difference: " << diff << "\n    tolerance:  " << tol);
         }
     }
 
diff --git a/test-suite/extendedtrees.cpp b/test-suite/extendedtrees.cpp
index 9ca26c49da2..e98c7a3a563 100644
--- a/test-suite/extendedtrees.cpp
+++ b/test-suite/extendedtrees.cpp
@@ -171,71 +171,61 @@ namespace {
         ext::shared_ptr<SimpleQuote> rRate(new SimpleQuote(0.0));
         ext::shared_ptr<YieldTermStructure> rTS = flatRate(today,rRate,dc);
 
-        for (Size i=0; i<LENGTH(types); i++) {
-          for (Size j=0; j<LENGTH(strikes); j++) {
-            for (Size k=0; k<LENGTH(lengths); k++) {
-              Date exDate = today + lengths[k]*360;
-              ext::shared_ptr<Exercise> exercise(
-                                                new EuropeanExercise(exDate));
-              ext::shared_ptr<StrikedTypePayoff> payoff(new
-                                    PlainVanillaPayoff(types[i], strikes[j]));
-              // reference option
-              ext::shared_ptr<VanillaOption> refOption =
-                  makeOption(payoff, exercise, spot, qTS, rTS, volTS,
-                             Analytic, Null<Size>());
-              // option to check
-              ext::shared_ptr<VanillaOption> option =
-                  makeOption(payoff, exercise, spot, qTS, rTS, volTS,
-                             engine, binomialSteps);
-
-              for (Size l=0; l<LENGTH(underlyings); l++) {
-                for (Size m=0; m<LENGTH(qRates); m++) {
-                  for (Size n=0; n<LENGTH(rRates); n++) {
-                    for (Size p=0; p<LENGTH(vols); p++) {
-                      Real u = underlyings[l];
-                      Rate q = qRates[m],
-                           r = rRates[n];
-                      Volatility v = vols[p];
-                      spot->setValue(u);
-                      qRate->setValue(q);
-                      rRate->setValue(r);
-                      vol->setValue(v);
-
-                      expected.clear();
-                      calculated.clear();
-
-                      // FLOATING_POINT_EXCEPTION
-                      expected["value"] = refOption->NPV();
-                      calculated["value"] = option->NPV();
-
-                      if (option->NPV() > spot->value()*1.0e-5) {
-                           expected["delta"] = refOption->delta();
-                           expected["gamma"] = refOption->gamma();
-                           expected["theta"] = refOption->theta();
-                           calculated["delta"] = option->delta();
-                           calculated["gamma"] = option->gamma();
-                           calculated["theta"] = option->theta();
-                      }
-                      std::map<std::string,Real>::iterator it;
-                      for (it = calculated.begin();
-                           it != calculated.end(); ++it) {
-                          std::string greek = it->first;
-                          Real expct = expected  [greek],
-                               calcl = calculated[greek],
-                               tol   = tolerance [greek];
-                          Real error = relativeError(expct,calcl,u);
-                          if (error > tol) {
-                              REPORT_FAILURE(greek, payoff, exercise,
-                                             u, q, r, today, v,
-                                             expct, calcl, error, tol);
-                          }
-                      }
+        for (auto& type : types) {
+            for (double strike : strikes) {
+                for (int length : lengths) {
+                    Date exDate = today + length * 360;
+                    ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
+                    ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(type, strike));
+                    // reference option
+                    ext::shared_ptr<VanillaOption> refOption =
+                        makeOption(payoff, exercise, spot, qTS, rTS, volTS, Analytic, Null<Size>());
+                    // option to check
+                    ext::shared_ptr<VanillaOption> option =
+                        makeOption(payoff, exercise, spot, qTS, rTS, volTS, engine, binomialSteps);
+
+                    for (double u : underlyings) {
+                        for (double m : qRates) {
+                            for (double n : rRates) {
+                                for (double v : vols) {
+                                    Rate q = m, r = n;
+                                    spot->setValue(u);
+                                    qRate->setValue(q);
+                                    rRate->setValue(r);
+                                    vol->setValue(v);
+
+                                    expected.clear();
+                                    calculated.clear();
+
+                                    // FLOATING_POINT_EXCEPTION
+                                    expected["value"] = refOption->NPV();
+                                    calculated["value"] = option->NPV();
+
+                                    if (option->NPV() > spot->value() * 1.0e-5) {
+                                        expected["delta"] = refOption->delta();
+                                        expected["gamma"] = refOption->gamma();
+                                        expected["theta"] = refOption->theta();
+                                        calculated["delta"] = option->delta();
+                                        calculated["gamma"] = option->gamma();
+                                        calculated["theta"] = option->theta();
+                                    }
+                                    std::map<std::string, Real>::iterator it;
+                                    for (it = calculated.begin(); it != calculated.end(); ++it) {
+                                        std::string greek = it->first;
+                                        Real expct = expected[greek], calcl = calculated[greek],
+                                             tol = tolerance[greek];
+                                        Real error = relativeError(expct, calcl, u);
+                                        if (error > tol) {
+                                            REPORT_FAILURE(greek, payoff, exercise, u, q, r, today,
+                                                           v, expct, calcl, error, tol);
+                                        }
+                                    }
+                                }
+                            }
+                        }
                     }
-                  }
                 }
-              }
             }
-          }
         }
     }
 
diff --git a/test-suite/fdcev.cpp b/test-suite/fdcev.cpp
index ab7466aeb49..0a096ed4277 100644
--- a/test-suite/fdcev.cpp
+++ b/test-suite/fdcev.cpp
@@ -59,8 +59,7 @@ void FdCevTest::testLocalMartingale() {
     const Real alpha = 1.75;
     const Real betas[] = {-2.4, 0.23, 0.9, 1.1, 1.5};
 
-    for (Size i=0; i < LENGTH(betas); ++i) {
-        const Real beta = betas[i];
+    for (double beta : betas) {
         const CEVRNDCalculator rndCalculator(f0, alpha, beta);
 
         const Real eps = 1e-10;
@@ -146,9 +145,7 @@ void FdCevTest::testFdmCevOp() {
     const ext::shared_ptr<Exercise> exercise =
         ext::make_shared<EuropeanExercise>(maturityDate);
 
-    for (Size i=0; i < LENGTH(optionTypes); ++i) {
-        const Option::Type optionType = optionTypes[i];
-
+    for (auto optionType : optionTypes) {
         const ext::shared_ptr<PlainVanillaPayoff> payoff =
             ext::make_shared<PlainVanillaPayoff>(optionType, strike);
 
@@ -159,9 +156,7 @@ void FdCevTest::testFdmCevOp() {
         const Real alpha = 0.75;
 
         const Real betas[] = { -2.0, -0.5, 0.45, 0.6, 0.9, 1.45 };
-        for (Size j=0; j < LENGTH(betas); ++j) {
-
-            const Real beta = betas[j];
+        for (double beta : betas) {
 
             VanillaOption option(payoff, exercise);
             option.setPricingEngine(ext::make_shared<AnalyticCEVEngine>(
diff --git a/test-suite/fdcir.cpp b/test-suite/fdcir.cpp
index 2bcad912c75..37b2924087d 100644
--- a/test-suite/fdcir.cpp
+++ b/test-suite/fdcir.cpp
@@ -97,9 +97,9 @@ void FdCIRTest::testFdmCIRConvergence() {
     Real expected = 4.275;
     Real tolerance = 0.0003;
 
-    for (Size l=0; l < LENGTH(schemes); ++l) {
-        ext::shared_ptr<PricingEngine> fdcirengine = MakeFdCIRVanillaEngine(cirProcess, bsmProcess, rho)
-            .withFdmSchemeDesc(schemes[l]);
+    for (const auto& scheme : schemes) {
+        ext::shared_ptr<PricingEngine> fdcirengine =
+            MakeFdCIRVanillaEngine(cirProcess, bsmProcess, rho).withFdmSchemeDesc(scheme);
         europeanOption.setPricingEngine(fdcirengine);
         Real calculated = europeanOption.NPV();
         if (std::fabs(expected - calculated) > tolerance) {
@@ -109,7 +109,6 @@ void FdCIRTest::testFdmCIRConvergence() {
                             << "\n    tolerance:  " << tolerance);
         }
     }
-
 }
 
 test_suite* FdCIRTest::suite(SpeedLevel speed) {
diff --git a/test-suite/fdheston.cpp b/test-suite/fdheston.cpp
index 67d07cc16af..33968d10dc4 100644
--- a/test-suite/fdheston.cpp
+++ b/test-suite/fdheston.cpp
@@ -305,22 +305,20 @@ void FdHestonTest::testFdmHestonBarrierVsBlackScholes() {
 
     ext::shared_ptr<PricingEngine> analyticEngine(
                                         new AnalyticBarrierEngine(bsProcess));
-    
-    for (Size i=0; i<LENGTH(values); i++) {
-        Date exDate = todaysDate + timeToDays(values[i].t, 365);
+
+    for (auto& value : values) {
+        Date exDate = todaysDate + timeToDays(value.t, 365);
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-        ext::dynamic_pointer_cast<SimpleQuote>(spot .currentLink())
-                                                    ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        ext::dynamic_pointer_cast<SimpleQuote>(spot.currentLink())->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(new
-                    PlainVanillaPayoff(values[i].type, values[i].strike));
+        ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(value.type, value.strike));
 
-        BarrierOption barrierOption(values[i].barrierType, values[i].barrier,
-                                    values[i].rebate, payoff, exercise);
+        BarrierOption barrierOption(value.barrierType, value.barrier, value.rebate, payoff,
+                                    exercise);
 
         const Real v0 = vol->value()*vol->value();
         ext::shared_ptr<HestonProcess> hestonProcess(
@@ -526,9 +524,9 @@ void FdHestonTest::testFdmHestonBlackScholes() {
 
     Real strikes[]  = { 8, 9, 10, 11, 12 };
     const Real tol = 0.0001;
-    
-    for (Size i=0; i < LENGTH(strikes); ++i) {
-        Handle<Quote> s0(ext::shared_ptr<Quote>(new SimpleQuote(strikes[i])));
+
+    for (double& strike : strikes) {
+        Handle<Quote> s0(ext::shared_ptr<Quote>(new SimpleQuote(strike)));
 
         ext::shared_ptr<GeneralizedBlackScholesProcess> bsProcess(
                        new GeneralizedBlackScholesProcess(s0, qTS, rTS, volTS));
@@ -550,10 +548,8 @@ void FdHestonTest::testFdmHestonBlackScholes() {
         Real calculated = option.NPV();
         if (std::fabs(calculated - expected) > tol) {
             BOOST_ERROR("Failed to reproduce expected npv"
-                        << "\n    strike:     " << strikes[i]
-                        << "\n    calculated: " << calculated
-                        << "\n    expected:   " << expected
-                        << "\n    tolerance:  " << tol); 
+                        << "\n    strike:     " << strike << "\n    calculated: " << calculated
+                        << "\n    expected:   " << expected << "\n    tolerance:  " << tol);
         }
         
         // Explicit scheme
@@ -566,10 +562,8 @@ void FdHestonTest::testFdmHestonBlackScholes() {
         calculated = option.NPV();
         if (std::fabs(calculated - expected) > tol) {
             BOOST_ERROR("Failed to reproduce expected npv"
-                        << "\n    strike:     " << strikes[i]
-                        << "\n    calculated: " << calculated
-                        << "\n    expected:   " << expected
-                        << "\n    tolerance:  " << tol);
+                        << "\n    strike:     " << strike << "\n    calculated: " << calculated
+                        << "\n    expected:   " << expected << "\n    tolerance:  " << tol);
         }
     }
 }
@@ -682,38 +676,27 @@ void FdHestonTest::testFdmHestonConvergence() {
     
     Handle<Quote> s0(ext::shared_ptr<Quote>(new SimpleQuote(75.0)));
 
-    for (Size l=0; l < LENGTH(schemes); ++l) {
-        for (Size i=0; i < LENGTH(values); ++i) {
-            for (Size j=0; j < LENGTH(tn); ++j) {
-                for (Size k=0; k < LENGTH(v0); ++k) {
-                    Handle<YieldTermStructure> rTS(
-                        flatRate(values[i].r, Actual365Fixed()));
-                    Handle<YieldTermStructure> qTS(
-                        flatRate(values[i].q, Actual365Fixed()));
-                
-                    ext::shared_ptr<HestonProcess> hestonProcess(
-                        new HestonProcess(rTS, qTS, s0, 
-                                          v0[k], 
-                                          values[i].kappa, 
-                                          values[i].theta, 
-                                          values[i].sigma, 
-                                          values[i].rho));
-                
-                    Date exerciseDate = todaysDate 
-                        + Period(static_cast<Integer>(values[i].T*365), Days);
+    for (const auto& scheme : schemes) {
+        for (auto& value : values) {
+            for (unsigned long j : tn) {
+                for (double k : v0) {
+                    Handle<YieldTermStructure> rTS(flatRate(value.r, Actual365Fixed()));
+                    Handle<YieldTermStructure> qTS(flatRate(value.q, Actual365Fixed()));
+
+                    ext::shared_ptr<HestonProcess> hestonProcess(new HestonProcess(
+                        rTS, qTS, s0, k, value.kappa, value.theta, value.sigma, value.rho));
+
+                    Date exerciseDate =
+                        todaysDate + Period(static_cast<Integer>(value.T * 365), Days);
                     ext::shared_ptr<Exercise> exercise(
                                           new EuropeanExercise(exerciseDate));
-                
-                    ext::shared_ptr<StrikedTypePayoff> payoff(new
-                               PlainVanillaPayoff(Option::Call, values[i].K));
-            
+
+                    ext::shared_ptr<StrikedTypePayoff> payoff(
+                        new PlainVanillaPayoff(Option::Call, value.K));
+
                     VanillaOption option(payoff, exercise);
-                    ext::shared_ptr<PricingEngine> engine(
-                         new FdHestonVanillaEngine(
-                             ext::make_shared<HestonModel>(
-                                 hestonProcess), 
-                             tn[j], 101, 51, 0,
-                             schemes[l]));
+                    ext::shared_ptr<PricingEngine> engine(new FdHestonVanillaEngine(
+                        ext::make_shared<HestonModel>(hestonProcess), j, 101, 51, 0, scheme));
                     option.setPricingEngine(engine);
                     
                     const Real calculated = option.NPV();
@@ -971,12 +954,9 @@ void FdHestonTest::testSpuriousOscillations() {
         ext::make_tuple(FdmSchemeDesc::TrBDF2(), "TR-BDF2", false)
     };
 
-    for (Size j=0; j < LENGTH(descs); ++j) {
-        const ext::shared_ptr<FdmHestonSolver> solver =
-            ext::make_shared<FdmHestonSolver>(
-                Handle<HestonProcess>(process),
-                hestonEngine->getSolverDesc(1.0),
-                ext::get<0>(descs[j]));
+    for (const auto& desc : descs) {
+        const ext::shared_ptr<FdmHestonSolver> solver = ext::make_shared<FdmHestonSolver>(
+            Handle<HestonProcess>(process), hestonEngine->getSolverDesc(1.0), ext::get<0>(desc));
 
         std::vector<Real> gammas;
         for (Real x=99; x < 101.001; x+=0.1) {
@@ -993,13 +973,11 @@ void FdHestonTest::testSpuriousOscillations() {
         const Real tol = 0.01;
         const bool hasSpuriousOscillations = maximum > tol;
 
-        if (hasSpuriousOscillations != ext::get<2>(descs[j])) {
+        if (hasSpuriousOscillations != ext::get<2>(desc)) {
             BOOST_ERROR("unable to reproduce spurious oscillation behaviour "
-                     << "\n   scheme name          : " << ext::get<1>(descs[j])
-                     << "\n   oscillations observed: "
-                         << hasSpuriousOscillations
-                     << "\n   oscillations expected: " << ext::get<2>(descs[j])
-            );
+                        << "\n   scheme name          : " << ext::get<1>(desc)
+                        << "\n   oscillations observed: " << hasSpuriousOscillations
+                        << "\n   oscillations expected: " << ext::get<2>(desc));
         }
     }
 }
diff --git a/test-suite/fdmlinearop.cpp b/test-suite/fdmlinearop.cpp
index 35e17e20dc6..46519df9049 100644
--- a/test-suite/fdmlinearop.cpp
+++ b/test-suite/fdmlinearop.cpp
@@ -1300,8 +1300,8 @@ void FdmLinearOpTest::testBiCGstab() {
 
     Array b(n*m);
     MersenneTwisterUniformRng rng(1234);
-    for (Size i=0; i < b.size(); ++i) {
-        b[i] = rng.next().value;
+    for (double& i : b) {
+        i = rng.next().value;
     }
 
     const Real tol = 1e-10;
@@ -1340,8 +1340,8 @@ void FdmLinearOpTest::testGMRES() {
     
     Array b(n*m);
     MersenneTwisterUniformRng rng(1234);
-    for (Size i=0; i < b.size(); ++i) {
-        b[i] = rng.next().value;
+    for (double& i : b) {
+        i = rng.next().value;
     }
 
     const Real tol = 1e-10;
@@ -1487,8 +1487,8 @@ void FdmLinearOpTest::testSpareMatrixReference() {
     std::vector<SparseMatrix> v(nMatrices, SparseMatrix(rows, columns));
     std::vector<SparseMatrixReference> refs;
 
-    for (Size i=0; i < v.size(); ++i) {
-        SparseMatrixReference m(v[i]);
+    for (auto& i : v) {
+        SparseMatrixReference m(i);
         for (Size j=0; j < nElements; ++j) {
             const Size row    = Size(rng.next().value*rows);
             const Size column = Size(rng.next().value*columns);
diff --git a/test-suite/fdsabr.cpp b/test-suite/fdsabr.cpp
index af43d012cb1..f9fe2d5677c 100644
--- a/test-suite/fdsabr.cpp
+++ b/test-suite/fdsabr.cpp
@@ -144,13 +144,10 @@ void FdSabrTest::testFdmSabrOp() {
             Handle<Quote>(ext::make_shared<SimpleQuote>(f0)),
             rTS, rTS, Handle<BlackVolTermStructure>(flatVol(0.2, dc)));
 
-    for (Size j=0; j < LENGTH(betas); ++j) {
-
-        const Real beta = betas[j];
+    for (double beta : betas) {
 
         const ext::shared_ptr<PricingEngine> pdeEngine =
-            ext::make_shared<FdSabrVanillaEngine>(
-                f0, alpha, beta, nu, rho, rTS, 100, 400, 100);
+            ext::make_shared<FdSabrVanillaEngine>(f0, alpha, beta, nu, rho, rTS, 100, 400, 100);
 
         optionPut.setPricingEngine(pdeEngine);
         const Real pdePut = optionPut.NPV();
@@ -232,20 +229,14 @@ void FdSabrTest::testFdmSabrCevPricing() {
 
     const Real tol = 5e-5;
 
-    for (Size i=0; i < LENGTH(optionTypes); ++i) {
-        const Option::Type optionType = optionTypes[i];
-
-        for (Size j=0; j < LENGTH(strikes); ++j) {
-            const Real strike = strikes[j];
-
+    for (auto optionType : optionTypes) {
+        for (double strike : strikes) {
             const ext::shared_ptr<PlainVanillaPayoff> payoff =
                 ext::make_shared<PlainVanillaPayoff>(optionType, strike);
 
             VanillaOption option(payoff, exercise);
 
-            for (Size k=0; k < LENGTH(betas); ++k) {
-                const Real beta = betas[k];
-
+            for (double beta : betas) {
                 option.setPricingEngine(ext::make_shared<FdSabrVanillaEngine>(
                     f0, alpha, beta, nu, rho, rTS, 100, 400, 3));
 
@@ -305,14 +296,10 @@ void FdSabrTest::testFdmSabrVsVolApproximation() {
     const Option::Type optionTypes[] = {Option::Put, Option::Call};
 
     const Real tol = 2.5e-3;
-    for (Size i=0; i < LENGTH(optionTypes); ++i) {
-        const Option::Type optionType = optionTypes[i];
-        for (Size j=0; j < LENGTH(strikes); ++j) {
-            const Real strike = strikes[j];
-
-            VanillaOption option(
-                ext::make_shared<PlainVanillaPayoff>(optionType, strike),
-                ext::make_shared<EuropeanExercise>(maturityDate));
+    for (auto optionType : optionTypes) {
+        for (double strike : strikes) {
+            VanillaOption option(ext::make_shared<PlainVanillaPayoff>(optionType, strike),
+                                 ext::make_shared<EuropeanExercise>(maturityDate));
 
             option.setPricingEngine(ext::make_shared<FdSabrVanillaEngine>(
                 f0, alpha, beta, nu, rho, rTS, 25, 100, 50));
diff --git a/test-suite/fittedbonddiscountcurve.cpp b/test-suite/fittedbonddiscountcurve.cpp
index f90e5c38348..e06763d39a9 100644
--- a/test-suite/fittedbonddiscountcurve.cpp
+++ b/test-suite/fittedbonddiscountcurve.cpp
@@ -151,11 +151,11 @@ void FittedBondDiscountCurveTest::testFlatExtrapolation() {
     ext::shared_ptr<PricingEngine> engine2 =
         ext::make_shared<DiscountingBondEngine>(Handle<YieldTermStructure>(curve2));
 
-    for (Size i = 0; i < bonds.size(); ++i) {
-        bonds[i]->setPricingEngine(engine1);
-        modelPrices1.push_back(bonds[i]->cleanPrice());
-        bonds[i]->setPricingEngine(engine2);
-        modelPrices2.push_back(bonds[i]->cleanPrice());
+    for (auto& bond : bonds) {
+        bond->setPricingEngine(engine1);
+        modelPrices1.push_back(bond->cleanPrice());
+        bond->setPricingEngine(engine2);
+        modelPrices2.push_back(bond->cleanPrice());
     }
     BOOST_CHECK_EQUAL(curve1->fitResults().errorCode(), EndCriteria::MaxIterations);
     BOOST_CHECK_EQUAL(curve2->fitResults().errorCode(), EndCriteria::MaxIterations);
diff --git a/test-suite/forwardoption.cpp b/test-suite/forwardoption.cpp
index 9da40b2e5ae..031ea17e76f 100644
--- a/test-suite/forwardoption.cpp
+++ b/test-suite/forwardoption.cpp
@@ -113,35 +113,29 @@ void ForwardOptionTest::testValues() {
     ext::shared_ptr<PricingEngine> engine(
               new ForwardVanillaEngine<AnalyticEuropeanEngine>(stochProcess));
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(
-                                 new PlainVanillaPayoff(values[i].type, 0.0));
-        Date exDate = today + timeToDays(values[i].t);
+        ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(value.type, 0.0));
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
-        Date reset = today + timeToDays(values[i].start);
+        Date reset = today + timeToDays(value.start);
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
-        ForwardVanillaOption option(values[i].moneyness, reset,
-                                    payoff, exercise);
+        ForwardVanillaOption option(value.moneyness, reset, payoff, exercise);
         option.setPricingEngine(engine);
 
         Real calculated = option.NPV();
-        Real error = std::fabs(calculated-values[i].result);
+        Real error = std::fabs(calculated - value.result);
         Real tolerance = 1e-4;
         if (error>tolerance) {
-            REPORT_FAILURE("value", payoff, exercise, values[i].s,
-                           values[i].q, values[i].r, today,
-                           values[i].v, values[i].moneyness, reset,
-                           values[i].result, calculated,
-                           error, tolerance);
+            REPORT_FAILURE("value", payoff, exercise, value.s, value.q, value.r, today, value.v,
+                           value.moneyness, reset, value.result, calculated, error, tolerance);
         }
     }
-
 }
 
 
@@ -180,35 +174,29 @@ void ForwardOptionTest::testPerformanceValues() {
         new ForwardPerformanceVanillaEngine<AnalyticEuropeanEngine>(
                                                                stochProcess));
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(
-                                 new PlainVanillaPayoff(values[i].type, 0.0));
-        Date exDate = today + timeToDays(values[i].t);
+        ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(value.type, 0.0));
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
-        Date reset = today + timeToDays(values[i].start);
+        Date reset = today + timeToDays(value.start);
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
-        ForwardVanillaOption option(values[i].moneyness, reset,
-                                    payoff, exercise);
+        ForwardVanillaOption option(value.moneyness, reset, payoff, exercise);
         option.setPricingEngine(engine);
 
         Real calculated = option.NPV();
-        Real error = std::fabs(calculated-values[i].result);
+        Real error = std::fabs(calculated - value.result);
         Real tolerance = 1e-4;
         if (error>tolerance) {
-            REPORT_FAILURE("value", payoff, exercise, values[i].s,
-                           values[i].q, values[i].r, today,
-                           values[i].v, values[i].moneyness, reset,
-                           values[i].result, calculated,
-                           error, tolerance);
+            REPORT_FAILURE("value", payoff, exercise, value.s, value.q, value.r, today, value.v,
+                           value.moneyness, reset, value.result, calculated, error, tolerance);
         }
     }
-
 }
 
 
@@ -251,118 +239,110 @@ namespace {
         ext::shared_ptr<PricingEngine> engine(
                             new Engine<AnalyticEuropeanEngine>(stochProcess));
 
-        for (Size i=0; i<LENGTH(types); i++) {
-          for (Size j=0; j<LENGTH(moneyness); j++) {
-            for (Size k=0; k<LENGTH(lengths); k++) {
-              for (Size h=0; h<LENGTH(startMonths); h++) {
-
-                Date exDate = today + lengths[k]*Years;
-                ext::shared_ptr<Exercise> exercise(
-                                                new EuropeanExercise(exDate));
-
-                Date reset = today + startMonths[h]*Months;
-
-                ext::shared_ptr<StrikedTypePayoff> payoff(
-                                       new PlainVanillaPayoff(types[i], 0.0));
-
-                ForwardVanillaOption option(moneyness[j], reset,
-                                            payoff, exercise);
-                option.setPricingEngine(engine);
-
-                for (Size l=0; l<LENGTH(underlyings); l++) {
-                  for (Size m=0; m<LENGTH(qRates); m++) {
-                    for (Size n=0; n<LENGTH(rRates); n++) {
-                      for (Size p=0; p<LENGTH(vols); p++) {
-
-                        Real u = underlyings[l];
-                        Rate q = qRates[m],
-                             r = rRates[n];
-                        Volatility v = vols[p];
-                        spot->setValue(u);
-                        qRate->setValue(q);
-                        rRate->setValue(r);
-                        vol->setValue(v);
-
-                        Real value = option.NPV();
-                        calculated["delta"]   = option.delta();
-                        calculated["gamma"]   = option.gamma();
-                        calculated["theta"]   = option.theta();
-                        calculated["rho"]     = option.rho();
-                        calculated["divRho"]  = option.dividendRho();
-                        calculated["vega"]    = option.vega();
-
-                        if (value > spot->value()*1.0e-5) {
-                          // perturb spot and get delta and gamma
-                          Real du = u*1.0e-4;
-                          spot->setValue(u+du);
-                          Real value_p = option.NPV(),
-                               delta_p = option.delta();
-                          spot->setValue(u-du);
-                          Real value_m = option.NPV(),
-                               delta_m = option.delta();
-                          spot->setValue(u);
-                          expected["delta"] = (value_p - value_m)/(2*du);
-                          expected["gamma"] = (delta_p - delta_m)/(2*du);
-
-                          // perturb rates and get rho and dividend rho
-                          Spread dr = r*1.0e-4;
-                          rRate->setValue(r+dr);
-                          value_p = option.NPV();
-                          rRate->setValue(r-dr);
-                          value_m = option.NPV();
-                          rRate->setValue(r);
-                          expected["rho"] = (value_p - value_m)/(2*dr);
-
-                          Spread dq = q*1.0e-4;
-                          qRate->setValue(q+dq);
-                          value_p = option.NPV();
-                          qRate->setValue(q-dq);
-                          value_m = option.NPV();
-                          qRate->setValue(q);
-                          expected["divRho"] = (value_p - value_m)/(2*dq);
-
-                          // perturb volatility and get vega
-                          Volatility dv = v*1.0e-4;
-                          vol->setValue(v+dv);
-                          value_p = option.NPV();
-                          vol->setValue(v-dv);
-                          value_m = option.NPV();
-                          vol->setValue(v);
-                          expected["vega"] = (value_p - value_m)/(2*dv);
-
-                          // perturb date and get theta
-                          Time dT = dc.yearFraction(today-1, today+1);
-                          Settings::instance().evaluationDate() = today-1;
-                          value_m = option.NPV();
-                          Settings::instance().evaluationDate() = today+1;
-                          value_p = option.NPV();
-                          Settings::instance().evaluationDate() = today;
-                          expected["theta"] = (value_p - value_m)/dT;
-
-                          // compare
-                          std::map<std::string,Real>::iterator it;
-                          for (it = calculated.begin();
-                               it != calculated.end(); ++it) {
-                              std::string greek = it->first;
-                              Real expct = expected  [greek],
-                                   calcl = calculated[greek],
-                                   tol   = tolerance [greek];
-                              Real error = relativeError(expct,calcl,u);
-                              if (error>tol) {
-                                  REPORT_FAILURE(greek, payoff, exercise,
-                                                 u, q, r, today, v,
-                                                 moneyness[j], reset,
-                                                 expct, calcl, error, tol);
-                              }
-                          }
+        for (auto& type : types) {
+            for (double& moneynes : moneyness) {
+                for (int length : lengths) {
+                    for (int startMonth : startMonths) {
+
+                        Date exDate = today + length * Years;
+                        ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
+
+                        Date reset = today + startMonth * Months;
+
+                        ext::shared_ptr<StrikedTypePayoff> payoff(
+                            new PlainVanillaPayoff(type, 0.0));
+
+                        ForwardVanillaOption option(moneynes, reset, payoff, exercise);
+                        option.setPricingEngine(engine);
+
+                        for (double u : underlyings) {
+                            for (double m : qRates) {
+                                for (double n : rRates) {
+                                    for (double v : vols) {
+
+                                        Rate q = m, r = n;
+                                        spot->setValue(u);
+                                        qRate->setValue(q);
+                                        rRate->setValue(r);
+                                        vol->setValue(v);
+
+                                        Real value = option.NPV();
+                                        calculated["delta"] = option.delta();
+                                        calculated["gamma"] = option.gamma();
+                                        calculated["theta"] = option.theta();
+                                        calculated["rho"] = option.rho();
+                                        calculated["divRho"] = option.dividendRho();
+                                        calculated["vega"] = option.vega();
+
+                                        if (value > spot->value() * 1.0e-5) {
+                                            // perturb spot and get delta and gamma
+                                            Real du = u * 1.0e-4;
+                                            spot->setValue(u + du);
+                                            Real value_p = option.NPV(), delta_p = option.delta();
+                                            spot->setValue(u - du);
+                                            Real value_m = option.NPV(), delta_m = option.delta();
+                                            spot->setValue(u);
+                                            expected["delta"] = (value_p - value_m) / (2 * du);
+                                            expected["gamma"] = (delta_p - delta_m) / (2 * du);
+
+                                            // perturb rates and get rho and dividend rho
+                                            Spread dr = r * 1.0e-4;
+                                            rRate->setValue(r + dr);
+                                            value_p = option.NPV();
+                                            rRate->setValue(r - dr);
+                                            value_m = option.NPV();
+                                            rRate->setValue(r);
+                                            expected["rho"] = (value_p - value_m) / (2 * dr);
+
+                                            Spread dq = q * 1.0e-4;
+                                            qRate->setValue(q + dq);
+                                            value_p = option.NPV();
+                                            qRate->setValue(q - dq);
+                                            value_m = option.NPV();
+                                            qRate->setValue(q);
+                                            expected["divRho"] = (value_p - value_m) / (2 * dq);
+
+                                            // perturb volatility and get vega
+                                            Volatility dv = v * 1.0e-4;
+                                            vol->setValue(v + dv);
+                                            value_p = option.NPV();
+                                            vol->setValue(v - dv);
+                                            value_m = option.NPV();
+                                            vol->setValue(v);
+                                            expected["vega"] = (value_p - value_m) / (2 * dv);
+
+                                            // perturb date and get theta
+                                            Time dT = dc.yearFraction(today - 1, today + 1);
+                                            Settings::instance().evaluationDate() = today - 1;
+                                            value_m = option.NPV();
+                                            Settings::instance().evaluationDate() = today + 1;
+                                            value_p = option.NPV();
+                                            Settings::instance().evaluationDate() = today;
+                                            expected["theta"] = (value_p - value_m) / dT;
+
+                                            // compare
+                                            std::map<std::string, Real>::iterator it;
+                                            for (it = calculated.begin(); it != calculated.end();
+                                                 ++it) {
+                                                std::string greek = it->first;
+                                                Real expct = expected[greek],
+                                                     calcl = calculated[greek],
+                                                     tol = tolerance[greek];
+                                                Real error = relativeError(expct, calcl, u);
+                                                if (error > tol) {
+                                                    REPORT_FAILURE(greek, payoff, exercise, u, q, r,
+                                                                   today, v, moneynes, reset, expct,
+                                                                   calcl, error, tol);
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
                         }
-                      }
                     }
-                  }
                 }
-              }
             }
-          }
         }
     }
 
@@ -556,22 +536,21 @@ void ForwardOptionTest::testMCPrices() {
 
    Real moneyness[] = { 0.8, 0.9, 1.0, 1.1, 1.2 };
 
-   for (Size j=0; j<LENGTH(moneyness); j++) {
+   for (double& moneynes : moneyness) {
 
-      ForwardVanillaOption option(moneyness[j], reset, payoff, exercise);
+       ForwardVanillaOption option(moneynes, reset, payoff, exercise);
 
-      option.setPricingEngine(analyticEngine);
-      Real analyticPrice = option.NPV();
+       option.setPricingEngine(analyticEngine);
+       Real analyticPrice = option.NPV();
 
-      option.setPricingEngine(mcEngine);
-      Real mcPrice = option.NPV();
+       option.setPricingEngine(mcEngine);
+       Real mcPrice = option.NPV();
 
-      Real error = relativeError(analyticPrice,mcPrice,s);
-      if (error>tolerance) {
-            REPORT_FAILURE("testMCPrices", payoff, exercise, s,
-                           q, r, today, sigma, moneyness[j], reset,
-                           analyticPrice, mcPrice, error, tolerance);
-      }
+       Real error = relativeError(analyticPrice, mcPrice, s);
+       if (error > tolerance) {
+           REPORT_FAILURE("testMCPrices", payoff, exercise, s, q, r, today, sigma, moneynes, reset,
+                          analyticPrice, mcPrice, error, tolerance);
+       }
    }
 }
 
@@ -581,105 +560,100 @@ void ForwardOptionTest::testHestonMCPrices() {
 
    Option::Type optionTypes[] = { Option::Call, Option::Put };
 
-   for (Size j=0; j<2; j++) {
+   for (auto type : optionTypes) {
 
-      Option::Type type = optionTypes[j];
+       Real mcTolerance = 5e-4;
+       Real analyticTolerance = 5e-4;
 
-      Real mcTolerance = 5e-4;
-      Real analyticTolerance = 5e-4;
+       Size timeSteps = 50;
+       Size numberOfSamples = 32768;
+       Size mcSeed = 42;
 
-      Size timeSteps = 50;
-      Size numberOfSamples = 32768;
-      Size mcSeed = 42;
+       Real q = 0.04;
+       Real r = 0.01;
+       Real sigma_bs = 0.245;
+       Real s = 100;
 
-      Real q = 0.04;
-      Real r = 0.01;
-      Real sigma_bs = 0.245;
-      Real s = 100;
+       // Test 1: Set up an equivalent flat Heston and compare to analytical BS pricing
+       Real v0 = sigma_bs * sigma_bs;
+       Real kappa = 1e-8;
+       Real theta = sigma_bs * sigma_bs;
+       Real sigma = 1e-8;
+       Real rho = -0.93;
 
-      // Test 1: Set up an equivalent flat Heston and compare to analytical BS pricing
-      Real v0 = sigma_bs * sigma_bs;
-      Real kappa = 1e-8;
-      Real theta = sigma_bs * sigma_bs;
-      Real sigma = 1e-8;
-      Real rho = -0.93;
+       DayCounter dc = Actual360();
+       SavedSettings backup;
+       Date today = Settings::instance().evaluationDate();
 
-      DayCounter dc = Actual360();
-      SavedSettings backup;
-      Date today = Settings::instance().evaluationDate();
+       Date exDate = today + 1 * Years;
+       ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
+       Date reset = today + 6 * Months;
+       ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(type, 0.0));
 
-      Date exDate = today + 1*Years;
-      ext::shared_ptr<Exercise> exercise(
-                                 new EuropeanExercise(exDate));
-      Date reset = today + 6*Months;
-      ext::shared_ptr<StrikedTypePayoff> payoff(
-                                 new PlainVanillaPayoff(type, 0.0));
-
-      ext::shared_ptr<SimpleQuote> spot(new SimpleQuote(s));
-      ext::shared_ptr<SimpleQuote> qRate(new SimpleQuote(q));
-      Handle<YieldTermStructure> qTS(flatRate(qRate, dc));
-      ext::shared_ptr<SimpleQuote> rRate(new SimpleQuote(r));
-      Handle<YieldTermStructure> rTS(flatRate(rRate, dc));
-      ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(sigma_bs));
-      Handle<BlackVolTermStructure> volTS(flatVol(vol, dc));
+       ext::shared_ptr<SimpleQuote> spot(new SimpleQuote(s));
+       ext::shared_ptr<SimpleQuote> qRate(new SimpleQuote(q));
+       Handle<YieldTermStructure> qTS(flatRate(qRate, dc));
+       ext::shared_ptr<SimpleQuote> rRate(new SimpleQuote(r));
+       Handle<YieldTermStructure> rTS(flatRate(rRate, dc));
+       ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(sigma_bs));
+       Handle<BlackVolTermStructure> volTS(flatVol(vol, dc));
 
-      ext::shared_ptr<BlackScholesMertonProcess> bsProcess(
-         new BlackScholesMertonProcess(Handle<Quote>(spot), qTS, rTS, volTS));
+       ext::shared_ptr<BlackScholesMertonProcess> bsProcess(
+           new BlackScholesMertonProcess(Handle<Quote>(spot), qTS, rTS, volTS));
 
-      ext::shared_ptr<PricingEngine> analyticEngine(
-         new ForwardVanillaEngine<AnalyticEuropeanEngine>(bsProcess));
+       ext::shared_ptr<PricingEngine> analyticEngine(
+           new ForwardVanillaEngine<AnalyticEuropeanEngine>(bsProcess));
 
-      ext::shared_ptr<HestonProcess> hestonProcess(
-         new HestonProcess(rTS, qTS, Handle<Quote>(spot), v0, kappa, theta, sigma, rho));
+       ext::shared_ptr<HestonProcess> hestonProcess(
+           new HestonProcess(rTS, qTS, Handle<Quote>(spot), v0, kappa, theta, sigma, rho));
 
-      ext::shared_ptr<PricingEngine> mcEngine 
-         = MakeMCForwardEuropeanHestonEngine<LowDiscrepancy>(hestonProcess)
+       ext::shared_ptr<PricingEngine> mcEngine =
+           MakeMCForwardEuropeanHestonEngine<LowDiscrepancy>(hestonProcess)
                .withSteps(timeSteps)
                .withSamples(numberOfSamples)
                .withSeed(mcSeed);
 
-      Real moneyness[] = { 0.8, 0.9, 1.0, 1.1, 1.2 };
-
-      for (Size j=0; j<LENGTH(moneyness); j++) {
+       Real moneyness[] = {0.8, 0.9, 1.0, 1.1, 1.2};
 
-         ForwardVanillaOption option(moneyness[j], reset, payoff, exercise);
+       for (double& moneynes : moneyness) {
 
-         option.setPricingEngine(analyticEngine);
-         Real analyticPrice = option.NPV();
+           ForwardVanillaOption option(moneynes, reset, payoff, exercise);
 
-         option.setPricingEngine(mcEngine);
-         Real mcPrice = option.NPV();
+           option.setPricingEngine(analyticEngine);
+           Real analyticPrice = option.NPV();
 
-         Real mcError = relativeError(analyticPrice, mcPrice, s);
-         if (mcError > mcTolerance) {
-               REPORT_FAILURE("testHestonMCForwardStartPrices", payoff, exercise, s,
-                              q, r, today, sigma_bs, moneyness[j], reset,
-                              analyticPrice, mcPrice, mcError, mcTolerance);
-         }
+           option.setPricingEngine(mcEngine);
+           Real mcPrice = option.NPV();
 
-      }
+           Real mcError = relativeError(analyticPrice, mcPrice, s);
+           if (mcError > mcTolerance) {
+               REPORT_FAILURE("testHestonMCForwardStartPrices", payoff, exercise, s, q, r, today,
+                              sigma_bs, moneynes, reset, analyticPrice, mcPrice, mcError,
+                              mcTolerance);
+           }
+       }
 
 
-      // Test 2: Using an arbitrary Heston model, check that prices match semi-analytical
-      // Heston prices when reset date is t=0
-      v0 = sigma_bs * sigma_bs;
-      kappa = 1.0;
-      theta = 0.08;
-      sigma = 0.39;
-      rho = -0.93;
+       // Test 2: Using an arbitrary Heston model, check that prices match semi-analytical
+       // Heston prices when reset date is t=0
+       v0 = sigma_bs * sigma_bs;
+       kappa = 1.0;
+       theta = 0.08;
+       sigma = 0.39;
+       rho = -0.93;
 
-      reset = today;
+       reset = today;
 
-      ext::shared_ptr<HestonProcess> hestonProcessSmile(
-         new HestonProcess(rTS, qTS, Handle<Quote>(spot), v0, kappa, theta, sigma, rho));
+       ext::shared_ptr<HestonProcess> hestonProcessSmile(
+           new HestonProcess(rTS, qTS, Handle<Quote>(spot), v0, kappa, theta, sigma, rho));
 
-      ext::shared_ptr<HestonModel> hestonModel(ext::make_shared<HestonModel>(hestonProcessSmile));
+       ext::shared_ptr<HestonModel> hestonModel(ext::make_shared<HestonModel>(hestonProcessSmile));
 
-      ext::shared_ptr<PricingEngine> analyticHestonEngine(
-         ext::make_shared<AnalyticHestonEngine>(hestonModel, 96));
+       ext::shared_ptr<PricingEngine> analyticHestonEngine(
+           ext::make_shared<AnalyticHestonEngine>(hestonModel, 96));
 
-      ext::shared_ptr<PricingEngine> mcEngineSmile
-         = MakeMCForwardEuropeanHestonEngine<LowDiscrepancy>(hestonProcessSmile)
+       ext::shared_ptr<PricingEngine> mcEngineSmile =
+           MakeMCForwardEuropeanHestonEngine<LowDiscrepancy>(hestonProcessSmile)
                .withSteps(timeSteps)
                .withSamples(numberOfSamples)
                .withSeed(mcSeed);
@@ -687,39 +661,38 @@ void ForwardOptionTest::testHestonMCPrices() {
        ext::shared_ptr<AnalyticHestonForwardEuropeanEngine> analyticForwardHestonEngine(
            new AnalyticHestonForwardEuropeanEngine(hestonProcessSmile));
 
-      for (Size j=0; j<LENGTH(moneyness); j++) {
+       for (double& moneynes : moneyness) {
 
-         Real strike = s * moneyness[j];
-         ext::shared_ptr<StrikedTypePayoff> vanillaPayoff(
-                           new PlainVanillaPayoff(type, strike));
+           Real strike = s * moneynes;
+           ext::shared_ptr<StrikedTypePayoff> vanillaPayoff(new PlainVanillaPayoff(type, strike));
 
-         VanillaOption vanillaOption(vanillaPayoff, exercise);
-         ForwardVanillaOption forwardOption(moneyness[j], reset, payoff, exercise);
+           VanillaOption vanillaOption(vanillaPayoff, exercise);
+           ForwardVanillaOption forwardOption(moneynes, reset, payoff, exercise);
 
-         vanillaOption.setPricingEngine(analyticHestonEngine);
-         Real analyticPrice = vanillaOption.NPV();
+           vanillaOption.setPricingEngine(analyticHestonEngine);
+           Real analyticPrice = vanillaOption.NPV();
 
-         forwardOption.setPricingEngine(mcEngineSmile);
-         Real mcPrice = forwardOption.NPV();
+           forwardOption.setPricingEngine(mcEngineSmile);
+           Real mcPrice = forwardOption.NPV();
 
-         Real mcError = relativeError(analyticPrice, mcPrice, s);
-         if (mcError > mcTolerance) {
-               REPORT_FAILURE("testHestonMCPrices", vanillaPayoff, exercise, s,
-                              q, r, today, sigma_bs, moneyness[j], reset,
-                              analyticPrice, mcPrice, mcError, mcTolerance);
-         }
+           Real mcError = relativeError(analyticPrice, mcPrice, s);
+           if (mcError > mcTolerance) {
+               REPORT_FAILURE("testHestonMCPrices", vanillaPayoff, exercise, s, q, r, today,
+                              sigma_bs, moneynes, reset, analyticPrice, mcPrice, mcError,
+                              mcTolerance);
+           }
 
-         // T=0, testing the Analytic Pricer's T=0 analytical solution
-         forwardOption.setPricingEngine(analyticForwardHestonEngine);
-         Real hestonAnalyticPrice = forwardOption.NPV();
+           // T=0, testing the Analytic Pricer's T=0 analytical solution
+           forwardOption.setPricingEngine(analyticForwardHestonEngine);
+           Real hestonAnalyticPrice = forwardOption.NPV();
 
-         Real analyticError = relativeError(analyticPrice, hestonAnalyticPrice, s);
-         if (analyticError > analyticTolerance) {
-               REPORT_FAILURE("testHestonAnalyticForwardStartPrices", vanillaPayoff, exercise, s,
-                              q, r, today, sigma_bs, moneyness[j], reset,
-                              analyticPrice, hestonAnalyticPrice, analyticError, analyticTolerance);
-         }
-      }
+           Real analyticError = relativeError(analyticPrice, hestonAnalyticPrice, s);
+           if (analyticError > analyticTolerance) {
+               REPORT_FAILURE("testHestonAnalyticForwardStartPrices", vanillaPayoff, exercise, s, q,
+                              r, today, sigma_bs, moneynes, reset, analyticPrice,
+                              hestonAnalyticPrice, analyticError, analyticTolerance);
+           }
+       }
    }
 }
 
@@ -729,54 +702,50 @@ void ForwardOptionTest::testHestonAnalyticalVsMCPrices() {
 
    Option::Type optionTypes[] = { Option::Call, Option::Put };
 
-   for (Size j=0; j<2; j++) {
+   for (auto type : optionTypes) {
 
-      Real tolerance = 1e-4;
-      Option::Type type = optionTypes[j];
+       Real tolerance = 1e-4;
+       Size timeSteps = 50;
+       Size numberOfSamples = 131072;
+       Size mcSeed = 42;
 
-      Size timeSteps = 50;
-      Size numberOfSamples = 131072;
-      Size mcSeed = 42;
+       Real q = 0.03;
+       Real r = 0.005;
+       Real s = 100;
 
-      Real q = 0.03;
-      Real r = 0.005;
-      Real s = 100;
+       Real vol = 0.3;
+       Real v0 = vol * vol;
+       Real kappa = 11.35;
+       Real theta = 0.022;
+       Real sigma = 0.618;
+       Real rho = -0.5;
 
-      Real vol = 0.3;
-      Real v0 = vol*vol;
-      Real kappa = 11.35;
-      Real theta = 0.022;
-      Real sigma = 0.618;
-      Real rho = -0.5;
+       DayCounter dc = Actual360();
+       SavedSettings backup;
+       Date today = Settings::instance().evaluationDate();
 
-      DayCounter dc = Actual360();
-      SavedSettings backup;
-      Date today = Settings::instance().evaluationDate();
+       Date exDate = today + 1 * Years;
+       ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
+       Date reset = today + 6 * Months;
+       ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(type, 0.0));
 
-      Date exDate = today + 1*Years;
-      ext::shared_ptr<Exercise> exercise(
-                                 new EuropeanExercise(exDate));
-      Date reset = today + 6*Months;
-      ext::shared_ptr<StrikedTypePayoff> payoff(
-                                 new PlainVanillaPayoff(type, 0.0));
+       ext::shared_ptr<SimpleQuote> spot(new SimpleQuote(s));
+       ext::shared_ptr<SimpleQuote> qRate(new SimpleQuote(q));
+       Handle<YieldTermStructure> qTS(flatRate(qRate, dc));
+       ext::shared_ptr<SimpleQuote> rRate(new SimpleQuote(r));
+       Handle<YieldTermStructure> rTS(flatRate(rRate, dc));
 
-      ext::shared_ptr<SimpleQuote> spot(new SimpleQuote(s));
-      ext::shared_ptr<SimpleQuote> qRate(new SimpleQuote(q));
-      Handle<YieldTermStructure> qTS(flatRate(qRate, dc));
-      ext::shared_ptr<SimpleQuote> rRate(new SimpleQuote(r));
-      Handle<YieldTermStructure> rTS(flatRate(rRate, dc));
+       ext::shared_ptr<HestonProcess> hestonProcess(
+           new HestonProcess(rTS, qTS, Handle<Quote>(spot), v0, kappa, theta, sigma, rho));
 
-      ext::shared_ptr<HestonProcess> hestonProcess(
-         new HestonProcess(rTS, qTS, Handle<Quote>(spot), v0, kappa, theta, sigma, rho));
-
-      ext::shared_ptr<PricingEngine> mcEngine 
-         = MakeMCForwardEuropeanHestonEngine<PseudoRandom>(hestonProcess)
+       ext::shared_ptr<PricingEngine> mcEngine =
+           MakeMCForwardEuropeanHestonEngine<PseudoRandom>(hestonProcess)
                .withSteps(timeSteps)
                .withSamples(numberOfSamples)
                .withSeed(mcSeed);
 
-      ext::shared_ptr<PricingEngine> mcEngineCv
-         = MakeMCForwardEuropeanHestonEngine<PseudoRandom>(hestonProcess)
+       ext::shared_ptr<PricingEngine> mcEngineCv =
+           MakeMCForwardEuropeanHestonEngine<PseudoRandom>(hestonProcess)
                .withSteps(timeSteps)
                .withSamples(numberOfSamples)
                .withSeed(mcSeed)
@@ -787,32 +756,31 @@ void ForwardOptionTest::testHestonAnalyticalVsMCPrices() {
 
       Real moneyness[] = { 0.8, 0.9, 1.0, 1.1, 1.2 };
 
-      for (Size j=0; j<LENGTH(moneyness); j++) {
+      for (double& moneynes : moneyness) {
 
-         ForwardVanillaOption option(moneyness[j], reset, payoff, exercise);
+          ForwardVanillaOption option(moneynes, reset, payoff, exercise);
 
-         option.setPricingEngine(analyticEngine);
-         Real analyticPrice = option.NPV();
+          option.setPricingEngine(analyticEngine);
+          Real analyticPrice = option.NPV();
 
-         option.setPricingEngine(mcEngine);
-         Real mcPrice = option.NPV();
-         Real error = relativeError(analyticPrice, mcPrice, s);
+          option.setPricingEngine(mcEngine);
+          Real mcPrice = option.NPV();
+          Real error = relativeError(analyticPrice, mcPrice, s);
 
-         if (error > tolerance) {
-               REPORT_FAILURE("testHestonMCVsAnalyticPrices", payoff, exercise, s,
-                              q, r, today, vol, moneyness[j], reset,
-                              analyticPrice, mcPrice, error, tolerance);
-         }
+          if (error > tolerance) {
+              REPORT_FAILURE("testHestonMCVsAnalyticPrices", payoff, exercise, s, q, r, today, vol,
+                             moneynes, reset, analyticPrice, mcPrice, error, tolerance);
+          }
 
-         option.setPricingEngine(mcEngineCv);
-         Real mcPriceCv = option.NPV();
+          option.setPricingEngine(mcEngineCv);
+          Real mcPriceCv = option.NPV();
 
-         Real errorCv = relativeError(analyticPrice, mcPriceCv, s);
-         if (errorCv > tolerance) {
-               REPORT_FAILURE("testHestonMCControlVariateVsAnalyticPrices", payoff, exercise, s,
-                              q, r, today, vol, moneyness[j], reset,
-                              analyticPrice, mcPrice, errorCv, tolerance);
-         }
+          Real errorCv = relativeError(analyticPrice, mcPriceCv, s);
+          if (errorCv > tolerance) {
+              REPORT_FAILURE("testHestonMCControlVariateVsAnalyticPrices", payoff, exercise, s, q,
+                             r, today, vol, moneynes, reset, analyticPrice, mcPrice, errorCv,
+                             tolerance);
+          }
       }
    }
 }
diff --git a/test-suite/functions.cpp b/test-suite/functions.cpp
index 4cc62407581..df28b415ca9 100644
--- a/test-suite/functions.cpp
+++ b/test-suite/functions.cpp
@@ -95,11 +95,11 @@ void FunctionsTest::testGammaValues() {
             {-21.5, 1.318444918321553e-20, 1e6}
     };
 
-    for (Size i=0; i < LENGTH(tasks); ++i) {
-        const Real x = tasks[i][0];
-        const Real expected = tasks[i][1];
+    for (auto& task : tasks) {
+        const Real x = task[0];
+        const Real expected = task[1];
         const Real calculated = GammaFunction().value(x);
-        const Real tol = tasks[i][2] * QL_EPSILON*std::fabs(expected);
+        const Real tol = task[2] * QL_EPSILON * std::fabs(expected);
 
         if (std::fabs(calculated - expected) > tol) {
             BOOST_ERROR("GammaFunction(" << x << ")\n"
@@ -129,11 +129,11 @@ void FunctionsTest::testModifiedBesselFunctions() {
         {-10.0001, 1.1, 13857.7715614282552, 69288858.9474423379}
     };
 
-    for (Size i=0; i < LENGTH(r); ++i) {
-        const Real nu = r[i][0];
-        const Real x  = r[i][1];
-        const Real expected_i = r[i][2];
-        const Real expected_k = r[i][3];
+    for (auto& i : r) {
+        const Real nu = i[0];
+        const Real x = i[1];
+        const Real expected_i = i[2];
+        const Real expected_k = i[3];
         const Real tol_i = 5e4 * QL_EPSILON*std::fabs(expected_i);
         const Real tol_k = 5e4 * QL_EPSILON*std::fabs(expected_k);
 
@@ -193,13 +193,11 @@ void FunctionsTest::testModifiedBesselFunctions() {
                         -4.480795479964915e-05, -3.489034389148745e-08}
     };
 
-    for (Size i=0; i < LENGTH(c); ++i) {
-        const Real nu = c[i][0];
-        const std::complex<Real> z  = std::complex<Real>(c[i][1], c[i][2]);
-        const std::complex<Real> expected_i
-            = std::complex<Real>(c[i][3],c[i][4]);
-        const std::complex<Real> expected_k
-            = std::complex<Real>(c[i][5],c[i][6]);
+    for (auto& i : c) {
+        const Real nu = i[0];
+        const std::complex<Real> z = std::complex<Real>(i[1], i[2]);
+        const std::complex<Real> expected_i = std::complex<Real>(i[3], i[4]);
+        const std::complex<Real> expected_k = std::complex<Real>(i[5], i[6]);
 
         const Real tol_i = 5e4*QL_EPSILON*std::abs(expected_i);
         const Real tol_k = 1e6*QL_EPSILON*std::abs(expected_k);
diff --git a/test-suite/gaussianquadratures.cpp b/test-suite/gaussianquadratures.cpp
index 0cd237cc9be..0e3368b93f7 100644
--- a/test-suite/gaussianquadratures.cpp
+++ b/test-suite/gaussianquadratures.cpp
@@ -129,14 +129,14 @@ namespace gaussian_quadratures_test {
                              Real expected, Real tolerance) {
         const Size order[] = { 6, 7, 12, 20 };
         TabulatedGaussLegendre quad;
-        for (Size i=0; i<LENGTH(order); i++) {
-            quad.order(order[i]);
+        for (unsigned long i : order) {
+            quad.order(i);
             Real realised = quad(f);
             if (std::fabs(realised-expected) > tolerance) {
                 BOOST_ERROR(" integrating " << tag << "\n"
-                            << "    order " << order[i] << "\n"
-                            << "    realised: " << realised << "\n"
-                            << "    expected: " << expected);
+                                            << "    order " << i << "\n"
+                                            << "    realised: " << realised << "\n"
+                                            << "    expected: " << expected);
             }
         }
     }
@@ -306,23 +306,21 @@ void GaussianQuadraturesTest::testMomentBasedGaussianPolynomial() {
 #endif
 
      const Real tol = 1e-12;
-     for (Size k=0; k < ml.size(); ++k) {
+     for (auto& k : ml) {
 
          for (Size i=0; i < 10; ++i) {
-             const Real diffAlpha = std::fabs(ml[k]->alpha(i)-g.alpha(i));
-             const Real diffBeta = std::fabs(ml[k]->beta(i)-g.beta(i));
+             const Real diffAlpha = std::fabs(k->alpha(i) - g.alpha(i));
+             const Real diffBeta = std::fabs(k->beta(i) - g.beta(i));
 
              if (diffAlpha > tol) {
                  BOOST_ERROR("failed to reproduce alpha for Laguerre quadrature"
-                             << "\n    calculated: " << ml[k]->alpha(i)
-                             << "\n    expected  : " << g.alpha(i)
-                             << "\n    diff      : " << diffAlpha);
+                             << "\n    calculated: " << k->alpha(i) << "\n    expected  : "
+                             << g.alpha(i) << "\n    diff      : " << diffAlpha);
              }
              if (i > 0 && diffBeta > tol) {
                  BOOST_ERROR("failed to reproduce beta for Laguerre quadrature"
-                             << "\n    calculated: " << ml[k]->beta(i)
-                             << "\n    expected  : " << g.beta(i)
-                             << "\n    diff      : " << diffBeta);
+                             << "\n    calculated: " << k->beta(i) << "\n    expected  : "
+                             << g.beta(i) << "\n    diff      : " << diffBeta);
              }
          }
      }
diff --git a/test-suite/hestonmodel.cpp b/test-suite/hestonmodel.cpp
index 2103de2cacf..940cb051e1b 100644
--- a/test-suite/hestonmodel.cpp
+++ b/test-suite/hestonmodel.cpp
@@ -172,21 +172,18 @@ void HestonModelTest::testBlackCalibration() {
     Handle<Quote> vol(ext::make_shared<SimpleQuote>(0.1));
     Volatility volatility = vol->value();
 
-    for (Size i = 0; i < optionMaturities.size(); ++i) {
+    for (auto& optionMaturitie : optionMaturities) {
         for (Real moneyness = -1.0; moneyness < 2.0; moneyness += 1.0) {
             // FLOATING_POINT_EXCEPTION
             const Time tau = dayCounter.yearFraction(
-                                 riskFreeTS->referenceDate(),
-                                 calendar.advance(riskFreeTS->referenceDate(),
-                                                  optionMaturities[i]));
-        const Real fwdPrice = s0->value()*dividendTS->discount(tau)
-                            / riskFreeTS->discount(tau);
-        const Real strikePrice = fwdPrice * std::exp(-moneyness * volatility
-                                                     * std::sqrt(tau));
-
-        options.push_back(ext::make_shared<HestonModelHelper>(optionMaturities[i], calendar,
-                                                s0, strikePrice, vol,
-                                                riskFreeTS, dividendTS));
+                riskFreeTS->referenceDate(),
+                calendar.advance(riskFreeTS->referenceDate(), optionMaturitie));
+            const Real fwdPrice =
+                s0->value() * dividendTS->discount(tau) / riskFreeTS->discount(tau);
+            const Real strikePrice = fwdPrice * std::exp(-moneyness * volatility * std::sqrt(tau));
+
+            options.push_back(ext::make_shared<HestonModelHelper>(
+                optionMaturitie, calendar, s0, strikePrice, vol, riskFreeTS, dividendTS));
         }
     }
 
@@ -204,8 +201,8 @@ void HestonModelTest::testBlackCalibration() {
         ext::shared_ptr<PricingEngine> engine(
             ext::make_shared<AnalyticHestonEngine>(model, 96));
 
-        for (Size i = 0; i < options.size(); ++i)
-            ext::dynamic_pointer_cast<BlackCalibrationHelper>(options[i])->setPricingEngine(engine);
+        for (auto& option : options)
+            ext::dynamic_pointer_cast<BlackCalibrationHelper>(option)->setPricingEngine(engine);
 
         LevenbergMarquardt om(1e-8, 1e-8, 1e-8);
         model->calibrate(options, om, EndCriteria(400, 40, 1.0e-8,
@@ -274,10 +271,10 @@ void HestonModelTest::testDAXCalibration() {
     };
 
     const Array params = model->params();
-    for (Size j=0; j < LENGTH(engines); ++j) {
+    for (const auto& engine : engines) {
         model->setParams(params);
-        for (Size i = 0; i < options.size(); ++i)
-            ext::dynamic_pointer_cast<BlackCalibrationHelper>(options[i])->setPricingEngine(engines[j]);
+        for (const auto& option : options)
+            ext::dynamic_pointer_cast<BlackCalibrationHelper>(option)->setPricingEngine(engine);
 
         LevenbergMarquardt om(1e-8, 1e-8, 1e-8);
         model->calibrate(options, om,
@@ -763,18 +760,16 @@ void HestonModelTest::testKahlJaeckelCase() {
     const Real tolerance = 0.2;
     const Real expected = 4.95212;
 
-    for (Size i=0; i < LENGTH(descriptions); ++i) {
-        const ext::shared_ptr<HestonProcess> process(
-            ext::make_shared<HestonProcess>(riskFreeTS, dividendTS, s0, v0,
-                              kappa, theta, sigma, rho,
-                              descriptions[i].discretization));
+    for (const auto& description : descriptions) {
+        const ext::shared_ptr<HestonProcess> process(ext::make_shared<HestonProcess>(
+            riskFreeTS, dividendTS, s0, v0, kappa, theta, sigma, rho, description.discretization));
 
         const ext::shared_ptr<PricingEngine> engine =
             MakeMCEuropeanHestonEngine<PseudoRandom>(process)
-            .withSteps(descriptions[i].nSteps)
-            .withAntitheticVariate()
-            .withAbsoluteTolerance(tolerance)
-            .withSeed(1234);
+                .withSteps(description.nSteps)
+                .withAntitheticVariate()
+                .withAbsoluteTolerance(tolerance)
+                .withSeed(1234);
         option.setPricingEngine(engine);
 
         const Real calculated = option.NPV();
@@ -782,17 +777,15 @@ void HestonModelTest::testKahlJaeckelCase() {
 
         if (std::fabs(calculated - expected) > 2.34*errorEstimate) {
             BOOST_ERROR("Failed to reproduce cached price with MC engine"
-                        << "\n    discretization: " << descriptions[i].name
+                        << "\n    discretization: " << description.name
                         << "\n    expected:       " << expected
-                        << "\n    calculated:     " << calculated
-                        << " +/- " << errorEstimate);
+                        << "\n    calculated:     " << calculated << " +/- " << errorEstimate);
         }
 
         if (errorEstimate > tolerance) {
             BOOST_ERROR("failed to reproduce error estimate with MC engine"
-                        << "\n    discretization: " << descriptions[i].name
-                        << "\n    calculated    : " << errorEstimate
-                        << "\n    expected      :   " << tolerance);
+                        << "\n    discretization: " << description.name << "\n    calculated    : "
+                        << errorEstimate << "\n    expected      :   " << tolerance);
         }
     }
 
@@ -947,16 +940,15 @@ void HestonModelTest::testDifferentIntegrals() {
         Real maxChebyshev2ndDiff= 0.0;
         Real maxLaguerreDiff    = 0.0;
 
-        for (Size i=0; i < LENGTH(maturities); ++i) {
+        for (int maturitie : maturities) {
             ext::shared_ptr<Exercise> exercise(
-                ext::make_shared<EuropeanExercise>(settlementDate
-                                     + Period(maturities[i], Months)));
+                ext::make_shared<EuropeanExercise>(settlementDate + Period(maturitie, Months)));
 
-            for (Size j=0; j < LENGTH(strikes); ++j) {
-                for (Size k=0; k < LENGTH(types); ++k) {
+            for (double strike : strikes) {
+                for (auto type : types) {
 
                     ext::shared_ptr<StrikedTypePayoff> payoff(
-                        ext::make_shared<PlainVanillaPayoff>(types[k], strikes[j]));
+                        ext::make_shared<PlainVanillaPayoff>(type, strike));
 
                     VanillaOption option(payoff, exercise);
 
@@ -987,7 +979,6 @@ void HestonModelTest::testDifferentIntegrals() {
                     maxChebyshev2ndDiff
                         = std::max(maxChebyshev2ndDiff,
                                    std::fabs(lobattoNPV-chebyshev2nd));
-
                 }
             }
         }
@@ -1041,9 +1032,9 @@ void HestonModelTest::testMultipleStrikesEngine() {
     multiStrikeEngine->enableMultipleStrikesCaching(strikes);
 
     Real relTol = 5e-3;
-    for (Size i=0; i < strikes.size(); ++i) {
+    for (double& strike : strikes) {
         ext::shared_ptr<StrikedTypePayoff> payoff(
-            ext::make_shared<PlainVanillaPayoff>(Option::Put, strikes[i]));
+            ext::make_shared<PlainVanillaPayoff>(Option::Put, strike));
 
         VanillaOption aOption(payoff, exercise);
         aOption.setPricingEngine(multiStrikeEngine);
@@ -1218,12 +1209,10 @@ void HestonModelTest::testDAXCalibrationOfTimeDependentModel() {
             AnalyticPTDHestonEngine::AndersenPiterbarg,
             AnalyticPTDHestonEngine::Integration::discreteTrapezoid(72))
     };
-    
-    for (Size j=0; j < LENGTH(engines); ++j) {
-        const ext::shared_ptr<PricingEngine> engine = engines[j];
 
-        for (Size i=0; i < options.size(); ++i)
-            ext::dynamic_pointer_cast<BlackCalibrationHelper>(options[i])->setPricingEngine(engine);
+    for (const auto& engine : engines) {
+        for (const auto& option : options)
+            ext::dynamic_pointer_cast<BlackCalibrationHelper>(option)->setPricingEngine(engine);
 
         LevenbergMarquardt om(1e-8, 1e-8, 1e-8);
         model->calibrate(options, om,
@@ -2072,10 +2061,10 @@ void HestonModelTest::testCharacteristicFct() {
     const AnalyticHestonEngine analyticEngine(model);
 
     const Real tol = 100*QL_EPSILON;
-    for (Size i=0; i < LENGTH(u); ++i) {
-        for (Size j=0; j < LENGTH(t); ++j) {
-            const std::complex<Real> c = cosEngine.chF(u[i], t[j]);
-            const std::complex<Real> a = analyticEngine.chF(u[i], t[j]);
+    for (double i : u) {
+        for (double j : t) {
+            const std::complex<Real> c = cosEngine.chF(i, j);
+            const std::complex<Real> a = analyticEngine.chF(i, j);
 
             const Real error = std::abs(a-c);
             if (error > tol) {
@@ -2187,16 +2176,13 @@ void HestonModelTest::testAndersenPiterbargPricing() {
 
     const Real tol = 1e-7;
 
-    for (Size u=0; u < LENGTH(maturityDates); ++u) {
-        const ext::shared_ptr<Exercise> exercise =
-            ext::make_shared<EuropeanExercise>(maturityDates[u]);
+    for (auto maturityDate : maturityDates) {
+        const ext::shared_ptr<Exercise> exercise = ext::make_shared<EuropeanExercise>(maturityDate);
 
-        for (Size i=0; i < LENGTH(optionTypes); ++i) {
-            for (Size j=0; j < LENGTH(strikes); ++j) {
-                VanillaOption option(
-                    ext::make_shared<PlainVanillaPayoff>(
-                        optionTypes[i], strikes[j]),
-                    exercise);
+        for (auto optionType : optionTypes) {
+            for (double strike : strikes) {
+                VanillaOption option(ext::make_shared<PlainVanillaPayoff>(optionType, strike),
+                                     exercise);
 
                 option.setPricingEngine(analyticEngine);
                 const Real expected = option.NPV();
@@ -2209,12 +2195,12 @@ void HestonModelTest::testAndersenPiterbargPricing() {
 
                     if (error > tol) {
                         BOOST_ERROR(" failed to reproduce prices with Andersen-"
-                                "Piterbarg control variate"
-                                << "\n    algorithm      : " << algos[k]
-                                << "\n    strike         : " << strikes[j]
-                                << "\n    control variate: " << calculated
-                                << "\n    classic engine : " << expected
-                                << "\n    difference:      " << error);
+                                    "Piterbarg control variate"
+                                    << "\n    algorithm      : " << algos[k]
+                                    << "\n    strike         : " << strike
+                                    << "\n    control variate: " << calculated
+                                    << "\n    classic engine : " << expected
+                                    << "\n    difference:      " << error);
                     }
                 }
             }
@@ -2887,8 +2873,8 @@ void HestonModelTest::testSmallSigmaExpansion4ExpFitting() {
     const Real v0s[]    = { 0.025, 0.20 };
     const Integer maturities[] = { 1, 31, 182, 1850 };
 
-    for (Size m=0; m < LENGTH(maturities); ++m) {
-        const Date maturityDate = todaysDate + Period(maturities[m], Days);
+    for (int maturitie : maturities) {
+        const Date maturityDate = todaysDate + Period(maturitie, Days);
         const DiscountFactor df = rTS->discount(maturityDate);
         const Real fwd = spot->value() * qTS->discount(maturityDate)/df;
 
@@ -2899,21 +2885,13 @@ void HestonModelTest::testSmallSigmaExpansion4ExpFitting() {
 
         Option::Type optionType = Option::Call;
 
-        for (Size i=0; i < LENGTH(kappas); ++i) {
-            const Real kappa = kappas[i];
-
-            for (Size j=0; j < LENGTH(thetas); ++j) {
-                const Real theta = thetas[j];
-
-                for (Size l=0; l < LENGTH(v0s); ++l) {
-                    const Real v0 = v0s[l];
-
+        for (double kappa : kappas) {
+            for (double theta : thetas) {
+                for (double v0 : v0s) {
                     const ext::shared_ptr<PricingEngine> engine =
                         ext::make_shared<ExponentialFittingHestonEngine>(
-                            ext::make_shared<HestonModel>(
-                                ext::make_shared<HestonProcess>(
-                                    rTS, qTS, spot, v0,
-                                    kappa, theta, 1e-13, -0.8)));
+                            ext::make_shared<HestonModel>(ext::make_shared<HestonProcess>(
+                                rTS, qTS, spot, v0, kappa, theta, 1e-13, -0.8)));
 
                     const Real stdDev =
                         std::sqrt(((1-std::exp(-kappa*t))*(v0-theta)/(kappa*t) + theta)*t);
@@ -3040,8 +3018,8 @@ void HestonModelTest::testExponentialFitting4StrikesAndMaturities() {
         ext::make_shared<ExponentialFittingHestonEngine>(model);
 
     Size idx = 0;
-    for (Size i=0; i < LENGTH(maturities); ++i) {
-        const Date maturityDate = todaysDate + maturities[i];
+    for (auto maturitie : maturities) {
+        const Date maturityDate = todaysDate + maturitie;
         const Time t = dc.yearFraction(todaysDate, maturityDate);
 
         const ext::shared_ptr<Exercise> exercise =
diff --git a/test-suite/hestonslvmodel.cpp b/test-suite/hestonslvmodel.cpp
index 24e1eca04d7..b00e4363ef3 100644
--- a/test-suite/hestonslvmodel.cpp
+++ b/test-suite/hestonslvmodel.cpp
@@ -226,9 +226,9 @@ void HestonSLVModelTest::testBlackScholesFokkerPlanckFwdEquation() {
 		ext::make_shared<EuropeanExercise>(maturityDate));
     const Real strikes[] = { 50, 80, 100, 130, 150 };
 
-    for (Size i=0; i < LENGTH(strikes); ++i) {
+    for (double strike : strikes) {
         const ext::shared_ptr<StrikedTypePayoff> payoff(
-			ext::make_shared<PlainVanillaPayoff>(Option::Call, strikes[i]));
+            ext::make_shared<PlainVanillaPayoff>(Option::Call, strike));
 
         VanillaOption option(payoff, exercise);
         option.setPricingEngine(engine);
@@ -248,28 +248,22 @@ void HestonSLVModelTest::testBlackScholesFokkerPlanckFwdEquation() {
         if (std::fabs(expected - calcUniform) > tol) {
             BOOST_FAIL("failed to reproduce european option price "
                        << "with an uniform mesher"
-                       << "\n   strike:     " << strikes[i]
-                       << std::fixed << std::setprecision(8)
-                       << "\n   calculated: " << calcUniform
-                       << "\n   expected:   " << expected
+                       << "\n   strike:     " << strike << std::fixed << std::setprecision(8)
+                       << "\n   calculated: " << calcUniform << "\n   expected:   " << expected
                        << "\n   tolerance:  " << tol);
         }
         if (std::fabs(expected - calcConcentrated) > tol) {
             BOOST_FAIL("failed to reproduce european option price "
                        << "with a concentrated mesher"
-                       << "\n   strike:     " << strikes[i]
-                       << std::fixed << std::setprecision(8)
-                       << "\n   calculated: " << calcConcentrated
-                       << "\n   expected:   " << expected
+                       << "\n   strike:     " << strike << std::fixed << std::setprecision(8)
+                       << "\n   calculated: " << calcConcentrated << "\n   expected:   " << expected
                        << "\n   tolerance:  " << tol);
         }
         if (std::fabs(expected - calcShifted) > tol) {
             BOOST_FAIL("failed to reproduce european option price "
                        << "with a shifted mesher"
-                       << "\n   strike:     " << strikes[i]
-                       << std::fixed << std::setprecision(8)
-                       << "\n   calculated: " << calcShifted
-                       << "\n   expected:   " << expected
+                       << "\n   strike:     " << strike << std::fixed << std::setprecision(8)
+                       << "\n   calculated: " << calcShifted << "\n   expected:   " << expected
                        << "\n   tolerance:  " << tol);
         }
     }
@@ -831,11 +825,10 @@ namespace {
         const Real strikes[] = { 50, 80, 90, 100, 110, 120, 150, 200 };
 
         Time t=eT;
-        for (std::vector<Period>::const_iterator iter = maturities.begin();
-                iter != maturities.end(); ++iter) {
+        for (auto maturitie : maturities) {
 
             // calculate step size
-            const Date nextMaturityDate = todaysDate + *iter;
+            const Date nextMaturityDate = todaysDate + maturitie;
             const Time nextMaturityTime
                 = dc.yearFraction(todaysDate, nextMaturityDate);
 
@@ -847,11 +840,10 @@ namespace {
             }
 
             Real avg=0, min=QL_MAX_REAL, max=0;
-            for (Size i=0; i < LENGTH(strikes); ++i) {
-                const Real strike = strikes[i];
+            for (double strike : strikes) {
                 const ext::shared_ptr<StrikedTypePayoff> payoff(
-					ext::make_shared<PlainVanillaPayoff>((strike > s0) ? Option::Call :
-                                                           Option::Put, strike));
+                    ext::make_shared<PlainVanillaPayoff>((strike > s0) ? Option::Call : Option::Put,
+                                                         strike));
 
                 Array pd(p.size());
                 for (FdmLinearOpIterator iter = layout->begin();
@@ -970,8 +962,8 @@ void HestonSLVModelTest::testHestonFokkerPlanckFwdEquation() {
         }
     };
 
-    for (Size i=0; i < LENGTH(testCases); ++i) {
-        hestonFokkerPlanckFwdEquationTest(testCases[i]);
+    for (const auto& testCase : testCases) {
+        hestonFokkerPlanckFwdEquationTest(testCase);
     }
 }
 
@@ -1019,8 +1011,8 @@ namespace {
 
         Integer times[] = { 13, 41, 75, 165, 256, 345, 524, 703 };
         std::vector<Date> dates;
-        for (Size i = 0; i < 8; ++i) {
-            Date date = todaysDate + times[i];
+        for (int time : times) {
+            Date date = todaysDate + time;
             dates.push_back(date);
         }
 
@@ -1443,26 +1435,24 @@ namespace {
         const Real strikes[] = { 50, 75, 80, 90, 100, 110, 125, 150 };
         const Size times[] = { 3, 6, 9, 12, 24, 36, 60 };
 
-        for (Size t=0; t < LENGTH(times); ++t) {
-            const Date expiry = todaysDate +  Period(times[t], Months);
+        for (unsigned long time : times) {
+            const Date expiry = todaysDate + Period(time, Months);
             const ext::shared_ptr<Exercise> exercise(
 				ext::make_shared<EuropeanExercise>(expiry));
 
             const ext::shared_ptr<PricingEngine> slvEngine(
-                (times[t] <= 3) ?
-				ext::make_shared<FdHestonVanillaEngine>(hestonModel.currentLink(),
-                        Size(std::max(101.0, 51*times[t]/12.0)), 401, 101, 0,
-                            FdmSchemeDesc::ModifiedCraigSneyd(), l)
-                : ext::make_shared<FdHestonVanillaEngine>(hestonModel.currentLink(),
-                        Size(std::max(51.0, 51*times[t]/12.0)), 201, 101, 0,
-                            FdmSchemeDesc::ModifiedCraigSneyd(), l));
-
-            for (Size s=0; s < LENGTH(strikes); ++s) {
-                const Real strike = strikes[s];
-
+                (time <= 3) ?
+                    ext::make_shared<FdHestonVanillaEngine>(
+                        hestonModel.currentLink(), Size(std::max(101.0, 51 * time / 12.0)), 401,
+                        101, 0, FdmSchemeDesc::ModifiedCraigSneyd(), l) :
+                    ext::make_shared<FdHestonVanillaEngine>(
+                        hestonModel.currentLink(), Size(std::max(51.0, 51 * time / 12.0)), 201, 101,
+                        0, FdmSchemeDesc::ModifiedCraigSneyd(), l));
+
+            for (double strike : strikes) {
                 const ext::shared_ptr<StrikedTypePayoff> payoff(
-					ext::make_shared<PlainVanillaPayoff>(
-                        (strike > s0) ? Option::Call : Option::Put, strike));
+                    ext::make_shared<PlainVanillaPayoff>((strike > s0) ? Option::Call : Option::Put,
+                                                         strike));
 
                 VanillaOption option(payoff, exercise);
 
@@ -1481,16 +1471,14 @@ namespace {
                 const Real tol = 0.001;//testCase.eps;
                 if (std::fabs((calculated-expected)/vega) > tol) {
                     BOOST_FAIL("failed to reproduce round trip vola "
-                              << "\n   strike         " << strike
-                              << "\n   time           " << times[t]
-                              << "\n   expected NPV   " << expected
-                              << "\n   calculated NPV " << calculated
-                              << "\n   vega           " << vega
-                              << std::fixed << std::setprecision(5)
-                              << "\n   calculated:    " << lv + (calculated-expected)/vega
-                              << "\n   expected:      " << lv
-                              << "\n   diff  (in bp)  " << (calculated-expected)/vega*1e4
-                              << "\n   tolerance:     " << tol);
+                               << "\n   strike         " << strike << "\n   time           " << time
+                               << "\n   expected NPV   " << expected << "\n   calculated NPV "
+                               << calculated << "\n   vega           " << vega << std::fixed
+                               << std::setprecision(5)
+                               << "\n   calculated:    " << lv + (calculated - expected) / vega
+                               << "\n   expected:      " << lv << "\n   diff  (in bp)  "
+                               << (calculated - expected) / vega * 1e4
+                               << "\n   tolerance:     " << tol);
                 }
             }
         }
@@ -1608,17 +1596,15 @@ void HestonSLVModelTest::testLocalVolsvSLVPropDensity() {
     const SquareRootProcessRNDCalculator squareRootRndCalculator(
         v0, kappa, theta, sigma);
 
-    for (auto iter = logEntries.begin(); iter != logEntries.end(); ++iter) {
+    for (const auto& logEntrie : logEntries) {
 
-        const Time t = iter->t;
+        const Time t = logEntrie.t;
         if (t > 0.2) {
-            const Array x(
-                iter->mesher->getFdm1dMeshers().at(0)->locations().begin(),
-                iter->mesher->getFdm1dMeshers().at(0)->locations().end());
-            const std::vector<Real>& z
-                = iter->mesher->getFdm1dMeshers().at(1)->locations();
+            const Array x(logEntrie.mesher->getFdm1dMeshers().at(0)->locations().begin(),
+                          logEntrie.mesher->getFdm1dMeshers().at(0)->locations().end());
+            const std::vector<Real>& z = logEntrie.mesher->getFdm1dMeshers().at(1)->locations();
 
-            const ext::shared_ptr<Array>& prob = iter->prob;
+            const ext::shared_ptr<Array>& prob = logEntrie.prob;
 
             for (Size i=0; i < z.size(); ++i) {
                 const Real pCalc = DiscreteSimpsonIntegral()(
@@ -1689,10 +1675,9 @@ void HestonSLVModelTest::testBarrierPricingViaHestonLocalVol() {
     const ext::shared_ptr<PricingEngine> hestonEngine(
 		ext::make_shared<AnalyticHestonEngine>(hestonModel.currentLink(), 164));
 
-    for (Size i=0; i < LENGTH(strikeValues); ++i) {
-        for (Size j=0; j < LENGTH(maturities); ++j) {
-            const Real strike = strikeValues[i];
-            const Date exerciseDate = todaysDate+maturities[j];
+    for (double strike : strikeValues) {
+        for (auto maturitie : maturities) {
+            const Date exerciseDate = todaysDate + maturitie;
             const Time t = dc.yearFraction(todaysDate, exerciseDate);
 
             const Volatility impliedVol = surf->blackVol(t, strike, true);
@@ -1936,10 +1921,9 @@ void HestonSLVModelTest::testMonteCarloVsFdmPricing() {
             FdmSchemeDesc::ModifiedCraigSneyd(), leverageFct, 0.1);
 
     const Real strikes[] = { s0, 1.1*s0 };
-    for (Size i=0; i < LENGTH(strikes); ++i) {
-        const Real strike = strikes[i];
-        const ext::shared_ptr<StrikedTypePayoff> payoff
-            = ext::make_shared<PlainVanillaPayoff>(Option::Call, strike);
+    for (double strike : strikes) {
+        const ext::shared_ptr<StrikedTypePayoff> payoff =
+            ext::make_shared<PlainVanillaPayoff>(Option::Call, strike);
 
         VanillaOption option(payoff, exercise);
 
@@ -1974,7 +1958,6 @@ void HestonSLVModelTest::testMonteCarloVsFdmPricing() {
                         << "\n Mixing FDM Price : " << priceFDMWithMix
                         << "\n Non Mixing FDM Price : " << priceFDM);
         }
-
     }
 }
 
@@ -2017,9 +2000,7 @@ void HestonSLVModelTest::testMonteCarloCalibration() {
     const Size xGrid = 400;
     const Size nSims[] = { 40000 };
 
-    for (Size m=0; m < LENGTH(nSims); ++m) {
-        const Size nSim = nSims[m];
-
+    for (unsigned long nSim : nSims) {
         const bool sobol = true;
 
         const ext::shared_ptr<LocalVolTermStructure> leverageFct =
@@ -2048,8 +2029,7 @@ void HestonSLVModelTest::testMonteCarloCalibration() {
         Real maxQualityFactor = 0.0;
         Size nValues = 0U;
 
-        for (Size i=0; i < LENGTH(maturities); ++i) {
-            const Date maturity(maturities[i]);
+        for (auto maturity : maturities) {
             const Time maturityTime = dc.yearFraction(todaysDate, maturity);
 
             const ext::shared_ptr<PricingEngine> fdEngine
@@ -2061,11 +2041,10 @@ void HestonSLVModelTest::testMonteCarloCalibration() {
             const ext::shared_ptr<Exercise> exercise
                 = ext::make_shared<EuropeanExercise>(maturity);
 
-            for (Size j=0; j < LENGTH(strikes); ++j) {
-                const Real strike = strikes[j];
-                const ext::shared_ptr<StrikedTypePayoff> payoff
-                    = ext::make_shared<PlainVanillaPayoff>(
-                      strike < s0 ? Option::Put : Option::Call, strike);
+            for (double strike : strikes) {
+                const ext::shared_ptr<StrikedTypePayoff> payoff =
+                    ext::make_shared<PlainVanillaPayoff>(strike < s0 ? Option::Put : Option::Call,
+                                                         strike);
 
                 VanillaOption option(payoff, exercise);
 
diff --git a/test-suite/hybridhestonhullwhiteprocess.cpp b/test-suite/hybridhestonhullwhiteprocess.cpp
index 94364571610..4f3e070d02a 100644
--- a/test-suite/hybridhestonhullwhiteprocess.cpp
+++ b/test-suite/hybridhestonhullwhiteprocess.cpp
@@ -212,19 +212,18 @@ void HybridHestonHullWhiteProcessTest::testCompareBsmHWandHestonHW() {
     const Size maturity[] = { 1, 2, 3, 5, 10, 15, 20, 25, 30 };
     const Option::Type types[] = { Option::Put, Option::Call };
 
-    for (Size i=0; i < LENGTH(types); ++i) {
-        for (Size j=0; j < LENGTH(strike); ++j) {
-            for (Size l=0; l < LENGTH(maturity); ++l) {
-                const Date maturityDate = today + Period(maturity[l], Years);
+    for (auto type : types) {
+        for (double j : strike) {
+            for (unsigned long l : maturity) {
+                const Date maturityDate = today + Period(l, Years);
 
                 ext::shared_ptr<Exercise> exercise(
                                          new EuropeanExercise(maturityDate));
 
-                Real fwd = strike[j] * spot->value()
-                    *qTS->discount(maturityDate)/rTS->discount(maturityDate);
+                Real fwd =
+                    j * spot->value() * qTS->discount(maturityDate) / rTS->discount(maturityDate);
 
-                ext::shared_ptr<StrikedTypePayoff> payoff(new
-                                          PlainVanillaPayoff(types[i], fwd));
+                ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(type, fwd));
 
                 EuropeanOption option(payoff, exercise);
 
@@ -238,16 +237,13 @@ void HybridHestonHullWhiteProcessTest::testCompareBsmHWandHestonHW() {
                     std::fabs(calculated-expected) > tol) {
                     BOOST_ERROR("Failed to reproduce npvs"
                                 << "\n    calculated: " << calculated
-                                << "\n    expected  : " << expected
-                                << "\n    strike    : " << strike[j]
-                                << "\n    maturity  : " << maturity[l]
-                                << "\n    type      : "
-                                << ((types[i] == Option::Put)? "Put" : "Call")
-                                );
+                                << "\n    expected  : " << expected << "\n    strike    : " << j
+                                << "\n    maturity  : " << l << "\n    type      : "
+                                << ((type == Option::Put) ? "Put" : "Call"));
                 }
             }
         }
-   }
+    }
 }
 
 void HybridHestonHullWhiteProcessTest::testZeroBondPricing() {
@@ -413,14 +409,12 @@ void HybridHestonHullWhiteProcessTest::testMcVanillaPricing() {
     const Real corr[] = {-0.9, -0.5, 0.0, 0.5, 0.9 };
     const Real strike[] = { 100 };
 
-    for (Size i=0; i < LENGTH(corr); ++i) {
-        for (Size j=0; j < LENGTH(strike); ++j) {
+    for (double i : corr) {
+        for (double j : strike) {
             ext::shared_ptr<HybridHestonHullWhiteProcess> jointProcess(
-                new HybridHestonHullWhiteProcess(hestonProcess,
-                                                 hwProcess, corr[i]));
+                new HybridHestonHullWhiteProcess(hestonProcess, hwProcess, i));
 
-            ext::shared_ptr<StrikedTypePayoff> payoff(
-                               new PlainVanillaPayoff(Option::Put, strike[j]));
+            ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(Option::Put, j));
             ext::shared_ptr<Exercise> exercise(
                                new EuropeanExercise(maturity));
 
@@ -440,23 +434,19 @@ void HybridHestonHullWhiteProcessTest::testMcVanillaPricing() {
                                       hwProcess->a(), hwProcess->sigma()));
 
             VanillaOption optionBsmHW(payoff, exercise);
-            optionBsmHW.setPricingEngine(
-                ext::shared_ptr<PricingEngine>(
-                           new AnalyticBSMHullWhiteEngine(corr[i], bsmProcess,
-                                                          hwModel)));
+            optionBsmHW.setPricingEngine(ext::shared_ptr<PricingEngine>(
+                new AnalyticBSMHullWhiteEngine(i, bsmProcess, hwModel)));
 
             const Real calculated = optionHestonHW.NPV();
             const Real error      = optionHestonHW.errorEstimate();
             const Real expected   = optionBsmHW.NPV();
 
-            if (  (corr[i] != 0.0 && std::fabs(calculated - expected) > 3*error)
-                ||(corr[i] == 0.0 &&  std::fabs(calculated - expected)> 1e-4)) {
+            if ((i != 0.0 && std::fabs(calculated - expected) > 3 * error) ||
+                (i == 0.0 && std::fabs(calculated - expected) > 1e-4)) {
                 BOOST_ERROR("Failed to reproduce BSM-HW vanilla prices"
-                        << "\n   corr:       " << corr[i]
-                        << "\n   strike:     " << strike[j]
-                        << "\n   calculated: " << calculated
-                        << "\n   error:      " << error
-                        << "\n   expected:   " << expected);
+                            << "\n   corr:       " << i << "\n   strike:     " << j
+                            << "\n   calculated: " << calculated << "\n   error:      " << error
+                            << "\n   expected:   " << expected);
             }
         }
     }
@@ -506,15 +496,13 @@ void HybridHestonHullWhiteProcessTest::testMcPureHestonPricing() {
     const Real corr[] = { -0.45, 0.45, 0.25 };
     const Real strike[] = { 100, 75, 50, 150 };
 
-    for (Size i=0; i < LENGTH(corr); ++i) {
-        for (Size j=0; j < LENGTH(strike); ++j) {
+    for (double i : corr) {
+        for (double j : strike) {
             ext::shared_ptr<HybridHestonHullWhiteProcess> jointProcess(
-                new HybridHestonHullWhiteProcess(
-                        hestonProcess, hwProcess,
-                        corr[i], HybridHestonHullWhiteProcess::Euler));
+                new HybridHestonHullWhiteProcess(hestonProcess, hwProcess, i,
+                                                 HybridHestonHullWhiteProcess::Euler));
 
-            ext::shared_ptr<StrikedTypePayoff> payoff(
-                               new PlainVanillaPayoff(Option::Put, strike[j]));
+            ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(Option::Put, j));
             ext::shared_ptr<Exercise> exercise(
                                new EuropeanExercise(maturity));
 
@@ -542,11 +530,9 @@ void HybridHestonHullWhiteProcessTest::testMcPureHestonPricing() {
             if (   std::fabs(calculated - expected) > 3*error
                 && std::fabs(calculated - expected) > tol) {
                 BOOST_ERROR("Failed to reproduce pure heston vanilla prices"
-                        << "\n   corr:       " << corr[i]
-                        << "\n   strike:     " << strike[j]
-                        << "\n   calculated: " << calculated
-                        << "\n   error:      " << error
-                        << "\n   expected:   " << expected);
+                            << "\n   corr:       " << i << "\n   strike:     " << j
+                            << "\n   calculated: " << calculated << "\n   error:      " << error
+                            << "\n   expected:   " << expected);
             }
         }
     }
@@ -599,15 +585,14 @@ void HybridHestonHullWhiteProcessTest::testAnalyticHestonHullWhitePricing() {
     const Real strike[] = { 80, 120 };
     const Option::Type types[] = { Option::Put, Option::Call };
 
-    for (Size i=0; i < LENGTH(types); ++i) {
-        for (Size j=0; j < LENGTH(strike); ++j) {
+    for (auto type : types) {
+        for (double j : strike) {
             ext::shared_ptr<HybridHestonHullWhiteProcess> jointProcess(
                 new HybridHestonHullWhiteProcess(
                         hestonProcess, hwFwdProcess, 0.0,
                         HybridHestonHullWhiteProcess::Euler));
 
-            ext::shared_ptr<StrikedTypePayoff> payoff(
-                               new PlainVanillaPayoff(types[i], strike[j]));
+            ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(type, j));
             ext::shared_ptr<Exercise> exercise(
                                new EuropeanExercise(maturity));
 
@@ -633,10 +618,8 @@ void HybridHestonHullWhiteProcessTest::testAnalyticHestonHullWhitePricing() {
             if (   std::fabs(calculated - expected) > 3*error
                 && std::fabs(calculated - expected) > tol) {
                 BOOST_ERROR("Failed to reproduce hw heston vanilla prices"
-                        << "\n   strike:     " << strike[j]
-                        << "\n   calculated: " << calculated
-                        << "\n   error:      " << error
-                        << "\n   expected:   " << expected);
+                            << "\n   strike:     " << j << "\n   calculated: " << calculated
+                            << "\n   error:      " << error << "\n   expected:   " << expected);
             }
         }
     }
@@ -809,27 +792,23 @@ void HybridHestonHullWhiteProcessTest::testDiscretizationError() {
     const Real corr[] = {-0.85, 0.5 };
     const Real strike[] = { 50, 100, 125 };
 
-    for (Size i=0; i < LENGTH(corr); ++i) {
-        for (Size j=0; j < LENGTH(strike); ++j) {
-            ext::shared_ptr<StrikedTypePayoff> payoff(
-                               new PlainVanillaPayoff(Option::Put, strike[j]));
+    for (double i : corr) {
+        for (double j : strike) {
+            ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(Option::Put, j));
             ext::shared_ptr<Exercise> exercise(
                                new EuropeanExercise(maturity));
 
             VanillaOption optionBsmHW(payoff, exercise);
             const ext::shared_ptr<HullWhite> hwModel(new HullWhite(
                                rTS, hwProcess->a(), hwProcess->sigma()));
-            optionBsmHW.setPricingEngine(
-                ext::shared_ptr<PricingEngine>(
-                         new AnalyticBSMHullWhiteEngine(corr[i], bsmProcess,
-                                                        hwModel)));
+            optionBsmHW.setPricingEngine(ext::shared_ptr<PricingEngine>(
+                new AnalyticBSMHullWhiteEngine(i, bsmProcess, hwModel)));
 
             Real expected = optionBsmHW.NPV();
 
             VanillaOption optionHestonHW(payoff, exercise);
             ext::shared_ptr<HybridHestonHullWhiteProcess> jointProcess(
-                new HybridHestonHullWhiteProcess(hestonProcess,
-                                                 hwProcess, corr[i]));
+                new HybridHestonHullWhiteProcess(hestonProcess, hwProcess, i));
             optionHestonHW.setPricingEngine(
                     MakeMCHestonHullWhiteEngine<PseudoRandom>(jointProcess)
                     .withSteps(1)
@@ -843,11 +822,9 @@ void HybridHestonHullWhiteProcessTest::testDiscretizationError() {
             if ((   std::fabs(calculated - expected) > 3*error
                  && std::fabs(calculated - expected) > 1e-5)) {
                 BOOST_ERROR("Failed to reproduce discretization error"
-                        << "\n   corr:       " << corr[i]
-                        << "\n   strike:     " << strike[j]
-                        << "\n   calculated: " << calculated
-                        << "\n   error:      " << error
-                        << "\n   expected:   " << expected);
+                            << "\n   corr:       " << i << "\n   strike:     " << j
+                            << "\n   calculated: " << calculated << "\n   error:      " << error
+                            << "\n   expected:   " << expected);
             }
         }
     }
@@ -887,51 +864,44 @@ void HybridHestonHullWhiteProcessTest::testFdmHestonHullWhiteEngine() {
     const Real corr[] = {-0.85, 0.5 };
     const Real strike[] = { 75, 120, 160 };
 
-    for (Size i=0; i < LENGTH(corr); ++i) {
-        for (Size j=0; j < LENGTH(strike); ++j) {
-            ext::shared_ptr<StrikedTypePayoff> payoff(
-                              new PlainVanillaPayoff(Option::Call, strike[j]));
+    for (double i : corr) {
+        for (double j : strike) {
+            ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(Option::Call, j));
             VanillaOption option(payoff, exercise);
 
-            option.setPricingEngine(ext::shared_ptr<PricingEngine>(
-                new FdHestonHullWhiteVanillaEngine(
-                    ext::make_shared<HestonModel>(
-                        hestonProcess),
-                                        hwProcess, corr[i], 50, 200, 10, 15)));
+            option.setPricingEngine(
+                ext::shared_ptr<PricingEngine>(new FdHestonHullWhiteVanillaEngine(
+                    ext::make_shared<HestonModel>(hestonProcess), hwProcess, i, 50, 200, 10, 15)));
             const Real calculated = option.NPV();
             const Real calculatedDelta = option.delta();
             const Real calculatedGamma = option.gamma();
 
             option.setPricingEngine(ext::shared_ptr<PricingEngine>(
-                new AnalyticBSMHullWhiteEngine(corr[i],
-                                               stochProcess, hwModel)));
+                new AnalyticBSMHullWhiteEngine(i, stochProcess, hwModel)));
             const Real expected = option.NPV();
             const Real expectedDelta = option.delta();
             const Real expectedGamma = option.gamma();
 
             const Real npvTol = 0.01;
             if (std::fabs(calculated - expected) > npvTol) {
-                 BOOST_ERROR("Failed to reproduce analytic npv values"
-                         << "\n   corr:       " << corr[i]
-                         << "\n   strike:     " << strike[j]
-                         << "\n   calculated: " << calculated
-                         << "\n   expected:   " << expected);
+                BOOST_ERROR("Failed to reproduce analytic npv values"
+                            << "\n   corr:       " << i << "\n   strike:     " << j
+                            << "\n   calculated: " << calculated
+                            << "\n   expected:   " << expected);
             }
             const Real deltaTol = 0.001;
             if (std::fabs(calculatedDelta - expectedDelta) > deltaTol) {
-                 BOOST_ERROR("Failed to reproduce analytic delta values"
-                         << "\n   corr:       " << corr[i]
-                         << "\n   strike:     " << strike[j]
-                         << "\n   calculated: " << calculated
-                         << "\n   expected:   " << expected);
+                BOOST_ERROR("Failed to reproduce analytic delta values"
+                            << "\n   corr:       " << i << "\n   strike:     " << j
+                            << "\n   calculated: " << calculated
+                            << "\n   expected:   " << expected);
             }
             const Real gammaTol = 0.001;
             if (std::fabs(calculatedGamma - expectedGamma) > gammaTol) {
-                 BOOST_ERROR("Failed to reproduce analytic gamma values"
-                         << "\n   corr:       " << corr[i]
-                         << "\n   strike:     " << strike[j]
-                         << "\n   calculated: " << calculated
-                         << "\n   expected:   " << expected);
+                BOOST_ERROR("Failed to reproduce analytic gamma values"
+                            << "\n   corr:       " << i << "\n   strike:     " << j
+                            << "\n   calculated: " << calculated
+                            << "\n   expected:   " << expected);
             }
         }
     }
@@ -1076,22 +1046,19 @@ void HybridHestonHullWhiteProcessTest::testBsmHullWhitePricing() {
     Real tolWithOutCV[] = { 5e-3, 5e-3, 5e-3, 5e-3, 0.02 };
     for (Size l=0; l < LENGTH(schemes); ++l) {
         SchemeData scheme = schemes[l];
-        for (Size i=0; i < LENGTH(controlVariate); ++i) {
-            for (Size u=0; u < LENGTH(listOfTimeStepsPerYear); ++u) {
-                Size tSteps = Size(maturity*listOfTimeStepsPerYear[u]);
+        for (bool i : controlVariate) {
+            for (unsigned long u : listOfTimeStepsPerYear) {
+                Size tSteps = Size(maturity * u);
 
                 ext::shared_ptr<FdHestonHullWhiteVanillaEngine> fdEngine(
-                    new FdHestonHullWhiteVanillaEngine(
-                                    hestonModel, hwProcess, equityIrCorr,
-                                    tSteps, 400, 2, 10, 0, controlVariate[i],
-                                    scheme.schemeDesc));
+                    new FdHestonHullWhiteVanillaEngine(hestonModel, hwProcess, equityIrCorr, tSteps,
+                                                       400, 2, 10, 0, i, scheme.schemeDesc));
                 fdEngine->enableMultipleStrikesCaching(
                     std::vector<Real>(strikes, strikes + LENGTH(strikes)));
 
                 Real avgPriceDiff = 0.0;
-                for (Size k=0; k < LENGTH(strikes); ++k) {
-                    VanillaOptionData optionData
-                                  = { strikes[k], maturity, Option::Call };
+                for (double& strike : strikes) {
+                    VanillaOptionData optionData = {strike, maturity, Option::Call};
                     ext::shared_ptr<VanillaOption> option
                                         = makeVanillaOption(optionData);
                     option->setPricingEngine(bsmhwEngine);
@@ -1103,15 +1070,14 @@ void HybridHestonHullWhiteProcessTest::testBsmHullWhitePricing() {
                         +=std::fabs(expected-calculated)/LENGTH(strikes); // NOLINT(bugprone-integer-division)
                 }
 
-                if (controlVariate[i] && tolWithCV[l] < avgPriceDiff) {
-                     BOOST_ERROR("Failed to reproduce BSM-Hull-White prices"
-                             << "\n   scheme       : " << scheme.name
-                             << "\n   model        : " << hestonModelData.name
-                             << "\n   CV           : on");
+                if (i && tolWithCV[l] < avgPriceDiff) {
+                    BOOST_ERROR("Failed to reproduce BSM-Hull-White prices"
+                                << "\n   scheme       : " << scheme.name << "\n   model        : "
+                                << hestonModelData.name << "\n   CV           : on");
                 }
 
 
-                if (!controlVariate[i] && tolWithOutCV[l] < avgPriceDiff) {
+                if (!i && tolWithOutCV[l] < avgPriceDiff) {
                     BOOST_ERROR("Failed to reproduce BSM-Hull-White prices"
                             << "\n   scheme       : " << scheme.name
                             << "\n   model        : " << hestonModelData.name
@@ -1137,19 +1103,18 @@ void HybridHestonHullWhiteProcessTest::testSpatialDiscretizatinError() {
     Size listOfTimeStepsPerYear[] = { 40 };
 
     const Real tol[] = { 0.02, 0.02, 0.02, 0.02, 0.05 };
-    for (Size u=0; u < LENGTH(listOfTimeStepsPerYear); ++u) {
+    for (unsigned long u : listOfTimeStepsPerYear) {
         for (Size i=0; i < LENGTH(schemes); ++i) {
-            for (Size j=0; j < LENGTH(hestonModels); ++j) {
+            for (auto& j : hestonModels) {
                 Real avgPriceDiff = 0;
-                ext::shared_ptr<HestonProcess> hestonProcess(
-                                        makeHestonProcess(hestonModels[j]));
+                ext::shared_ptr<HestonProcess> hestonProcess(makeHestonProcess(j));
                 ext::shared_ptr<HestonModel> hestonModel(
                                         new HestonModel(hestonProcess));
 
                 ext::shared_ptr<PricingEngine> analyticEngine(
                                new AnalyticHestonEngine(hestonModel, 172));
 
-                Size tSteps = Size(maturity*listOfTimeStepsPerYear[u]);
+                Size tSteps = Size(maturity * u);
 
                 ext::shared_ptr<FdHestonVanillaEngine> fdEngine(
                     new FdHestonVanillaEngine(
@@ -1158,9 +1123,8 @@ void HybridHestonHullWhiteProcessTest::testSpatialDiscretizatinError() {
                 fdEngine->enableMultipleStrikesCaching(
                     std::vector<Real>(strikes, strikes + LENGTH(strikes)));
 
-                for (Size k=0; k < LENGTH(strikes); ++k) {
-                    VanillaOptionData optionData
-                                  = { strikes[k], maturity, Option::Call };
+                for (double& strike : strikes) {
+                    VanillaOptionData optionData = {strike, maturity, Option::Call};
                     ext::shared_ptr<VanillaOption> option
                                         = makeVanillaOption(optionData);
                     option->setPricingEngine(analyticEngine);
@@ -1174,11 +1138,10 @@ void HybridHestonHullWhiteProcessTest::testSpatialDiscretizatinError() {
                 }
 
                 if (avgPriceDiff > tol[i]) {
-                    BOOST_ERROR("\nFailed to reproduce Heston prices" <<
-                        "\n scheme    : " << schemes[i].name <<
-                        "\n model     : " << hestonModels[j].name <<
-                        "\n error     : " << avgPriceDiff <<
-                        "\n tolerance : " << tol[i]);
+                    BOOST_ERROR("\nFailed to reproduce Heston prices"
+                                << "\n scheme    : " << schemes[i].name
+                                << "\n model     : " << j.name << "\n error     : " << avgPriceDiff
+                                << "\n tolerance : " << tol[i]);
                 }
             }
         }
diff --git a/test-suite/inflation.cpp b/test-suite/inflation.cpp
index 547b892d1a5..82975e9f82b 100644
--- a/test-suite/inflation.cpp
+++ b/test-suite/inflation.cpp
@@ -413,9 +413,8 @@ void InflationTest::testZeroTermStructure() {
     // we are testing UKRPI which is not interpolated
     Date bd = hz->baseDate();
     Real bf = ii->fixing(bd);
-    for (Size i=0; i<testIndex.size();i++) {
-        Date d = testIndex[i];
-        Real z = hz->zeroRate(d, Period(0,Days));
+    for (auto d : testIndex) {
+        Real z = hz->zeroRate(d, Period(0, Days));
         Real t = hz->dayCounter().yearFraction(bd, d);
         if(!ii->interpolated()) // because fixing constant over period
             t = hz->dayCounter().yearFraction(bd,
@@ -548,9 +547,8 @@ void InflationTest::testZeroTermStructure() {
     // we are testing UKRPI which is FAKE interpolated for testing here
     bd = hz->baseDate();
     bf = iiyes->fixing(bd);
-    for (Size i=0; i<testIndex.size();i++) {
-        Date d = testIndex[i];
-        Real z = hz->zeroRate(d, Period(0,Days));
+    for (auto d : testIndex) {
+        Real z = hz->zeroRate(d, Period(0, Days));
         Real t = hz->dayCounter().yearFraction(bd, d);
         Real calc = bf * pow( 1+z, t);
         if (t<=0) calc = iiyes->fixing(d); // still historical
@@ -565,7 +563,6 @@ void InflationTest::testZeroTermStructure() {
     }
 
 
-
     //===========================================================================================
     // Test zero coupon swap
 
diff --git a/test-suite/inflationcapfloor.cpp b/test-suite/inflationcapfloor.cpp
index db862a5990e..f89ac92656a 100644
--- a/test-suite/inflationcapfloor.cpp
+++ b/test-suite/inflationcapfloor.cpp
@@ -290,108 +290,99 @@ void InflationCapFloorTest::testConsistency() {
     Volatility vols[] = { 0.001, 0.005, 0.010, 0.015, 0.020 };
 
     for (Size whichPricer = 0; whichPricer < 3; whichPricer++) {
-    for (Size i=0; i<LENGTH(lengths); i++) {
-        for (Size j=0; j<LENGTH(cap_rates); j++) {
-            for (Size k=0; k<LENGTH(floor_rates); k++) {
-                for (Size l=0; l<LENGTH(vols); l++) {
-
-                    Leg leg = vars.makeYoYLeg(vars.evaluationDate,lengths[i]);
-
-                    ext::shared_ptr<YoYInflationCapFloor> cap
-                    = vars.makeYoYCapFloor(YoYInflationCapFloor::Cap,
-                                           leg, cap_rates[j], vols[l], whichPricer);
-
-                    ext::shared_ptr<YoYInflationCapFloor> floor
-                    = vars.makeYoYCapFloor(YoYInflationCapFloor::Floor,
-                                           leg, floor_rates[k], vols[l], whichPricer);
-
-                    YoYInflationCollar collar(leg,std::vector<Rate>(1,cap_rates[j]),
-                                  std::vector<Rate>(1,floor_rates[k]));
-                    collar.setPricingEngine(vars.makeEngine(vols[l], whichPricer));
-
-                    if (std::fabs((cap->NPV()-floor->NPV())-collar.NPV()) > 1e-6) {
-                        BOOST_FAIL(
-                                   "inconsistency between cap, floor and collar:\n"
-                                   << "    length:       " << lengths[i] << " years\n"
-                                   << "    volatility:   " << io::volatility(vols[l]) << "\n"
-                                   << "    cap value:    " << cap->NPV()
-                                   << " at strike: " << io::rate(cap_rates[j]) << "\n"
-                                   << "    floor value:  " << floor->NPV()
-                                   << " at strike: " << io::rate(floor_rates[k]) << "\n"
-                                   << "    collar value: " << collar.NPV());
-
-
-                        // test re-composition by optionlets, N.B. ONE per year
-                        Real capletsNPV = 0.0;
-                        std::vector<ext::shared_ptr<YoYInflationCapFloor> > caplets;
-                        for (Integer m=0; m<lengths[i]*1; m++) {
-                            caplets.push_back(cap->optionlet(m));
-                            caplets[m]->setPricingEngine(vars.makeEngine(vols[l], whichPricer));
-                            capletsNPV += caplets[m]->NPV();
-                        }
+        for (int& length : lengths) {
+            for (Size j = 0; j < LENGTH(cap_rates); j++) {
+                for (double& floor_rate : floor_rates) {
+                    for (double vol : vols) {
 
-                        if (std::fabs(cap->NPV() - capletsNPV) > 1e-6) {
-                            BOOST_FAIL(
-                                       "sum of caplet NPVs does not equal cap NPV:\n"
-                                       << "    length:       " << lengths[i] << " years\n"
-                                       << "    volatility:   " << io::volatility(vols[l]) << "\n"
-                                       << "    cap value:    " << cap->NPV()
-                                       << " at strike: " << io::rate(cap_rates[j]) << "\n"
-                                       << "    sum of caplets value:  " << capletsNPV
-                                       << " at strike (first): " << io::rate(caplets[0]->capRates()[0]) << "\n"
-                                       );
-                        }
+                        Leg leg = vars.makeYoYLeg(vars.evaluationDate, length);
 
-                        Real floorletsNPV = 0.0;
-                        std::vector<ext::shared_ptr<YoYInflationCapFloor> > floorlets;
-                        for (Integer m=0; m<lengths[i]*1; m++) {
-                            floorlets.push_back(floor->optionlet(m));
-                            floorlets[m]->setPricingEngine(vars.makeEngine(vols[l], whichPricer));
-                            floorletsNPV += floorlets[m]->NPV();
-                        }
+                        ext::shared_ptr<YoYInflationCapFloor> cap = vars.makeYoYCapFloor(
+                            YoYInflationCapFloor::Cap, leg, cap_rates[j], vol, whichPricer);
 
-                        if (std::fabs(floor->NPV() - floorletsNPV) > 1e-6) {
-                            BOOST_FAIL(
-                                       "sum of floorlet NPVs does not equal floor NPV:\n"
-                                       << "    length:       " << lengths[i] << " years\n"
-                                       << "    volatility:   " << io::volatility(vols[l]) << "\n"
-                                       << "    cap value:    " << floor->NPV()
-                                       << " at strike: " << io::rate(floor_rates[j]) << "\n"
-                                       << "    sum of floorlets value:  " << floorletsNPV
-                                       << " at strike (first): " << io::rate(floorlets[0]->floorRates()[0]) << "\n"
-                                       );
-                        }
+                        ext::shared_ptr<YoYInflationCapFloor> floor = vars.makeYoYCapFloor(
+                            YoYInflationCapFloor::Floor, leg, floor_rate, vol, whichPricer);
 
-                        Real collarletsNPV = 0.0;
-                        std::vector<ext::shared_ptr<YoYInflationCapFloor> > collarlets;
-                        for (Integer m=0; m<lengths[i]*1; m++) {
-                            collarlets.push_back(collar.optionlet(m));
-                            collarlets[m]->setPricingEngine(vars.makeEngine(vols[l], whichPricer));
-                            collarletsNPV += collarlets[m]->NPV();
-                        }
+                        YoYInflationCollar collar(leg, std::vector<Rate>(1, cap_rates[j]),
+                                                  std::vector<Rate>(1, floor_rate));
+                        collar.setPricingEngine(vars.makeEngine(vol, whichPricer));
 
-                        if (std::fabs(collar.NPV() - collarletsNPV) > 1e-6) {
-                            BOOST_FAIL(
-                                       "sum of collarlet NPVs does not equal floor NPV:\n"
-                                       << "    length:       " << lengths[i] << " years\n"
-                                       << "    volatility:   " << io::volatility(vols[l]) << "\n"
-                                       << "    cap value:    " << collar.NPV()
-                                       << " at strike floor: " << io::rate(floor_rates[j])
-                                       << " at strike cap: " << io::rate(cap_rates[j]) << "\n"
-                                       << "    sum of collarlets value:  " << collarletsNPV
-                                       << " at strike floor (first): " << io::rate(collarlets[0]->floorRates()[0])
-                                       << " at strike cap (first): " << io::rate(collarlets[0]->capRates()[0]) << "\n"
-                                       );
+                        if (std::fabs((cap->NPV() - floor->NPV()) - collar.NPV()) > 1e-6) {
+                            BOOST_FAIL("inconsistency between cap, floor and collar:\n"
+                                       << "    length:       " << length << " years\n"
+                                       << "    volatility:   " << io::volatility(vol) << "\n"
+                                       << "    cap value:    " << cap->NPV()
+                                       << " at strike: " << io::rate(cap_rates[j]) << "\n"
+                                       << "    floor value:  " << floor->NPV()
+                                       << " at strike: " << io::rate(floor_rate) << "\n"
+                                       << "    collar value: " << collar.NPV());
+
+
+                            // test re-composition by optionlets, N.B. ONE per year
+                            Real capletsNPV = 0.0;
+                            std::vector<ext::shared_ptr<YoYInflationCapFloor> > caplets;
+                            for (Integer m = 0; m < length * 1; m++) {
+                                caplets.push_back(cap->optionlet(m));
+                                caplets[m]->setPricingEngine(vars.makeEngine(vol, whichPricer));
+                                capletsNPV += caplets[m]->NPV();
+                            }
+
+                            if (std::fabs(cap->NPV() - capletsNPV) > 1e-6) {
+                                BOOST_FAIL("sum of caplet NPVs does not equal cap NPV:\n"
+                                           << "    length:       " << length << " years\n"
+                                           << "    volatility:   " << io::volatility(vol) << "\n"
+                                           << "    cap value:    " << cap->NPV()
+                                           << " at strike: " << io::rate(cap_rates[j]) << "\n"
+                                           << "    sum of caplets value:  " << capletsNPV
+                                           << " at strike (first): "
+                                           << io::rate(caplets[0]->capRates()[0]) << "\n");
+                            }
+
+                            Real floorletsNPV = 0.0;
+                            std::vector<ext::shared_ptr<YoYInflationCapFloor> > floorlets;
+                            for (Integer m = 0; m < length * 1; m++) {
+                                floorlets.push_back(floor->optionlet(m));
+                                floorlets[m]->setPricingEngine(vars.makeEngine(vol, whichPricer));
+                                floorletsNPV += floorlets[m]->NPV();
+                            }
+
+                            if (std::fabs(floor->NPV() - floorletsNPV) > 1e-6) {
+                                BOOST_FAIL("sum of floorlet NPVs does not equal floor NPV:\n"
+                                           << "    length:       " << length << " years\n"
+                                           << "    volatility:   " << io::volatility(vol) << "\n"
+                                           << "    cap value:    " << floor->NPV()
+                                           << " at strike: " << io::rate(floor_rates[j]) << "\n"
+                                           << "    sum of floorlets value:  " << floorletsNPV
+                                           << " at strike (first): "
+                                           << io::rate(floorlets[0]->floorRates()[0]) << "\n");
+                            }
+
+                            Real collarletsNPV = 0.0;
+                            std::vector<ext::shared_ptr<YoYInflationCapFloor> > collarlets;
+                            for (Integer m = 0; m < length * 1; m++) {
+                                collarlets.push_back(collar.optionlet(m));
+                                collarlets[m]->setPricingEngine(vars.makeEngine(vol, whichPricer));
+                                collarletsNPV += collarlets[m]->NPV();
+                            }
+
+                            if (std::fabs(collar.NPV() - collarletsNPV) > 1e-6) {
+                                BOOST_FAIL("sum of collarlet NPVs does not equal floor NPV:\n"
+                                           << "    length:       " << length << " years\n"
+                                           << "    volatility:   " << io::volatility(vol) << "\n"
+                                           << "    cap value:    " << collar.NPV()
+                                           << " at strike floor: " << io::rate(floor_rates[j])
+                                           << " at strike cap: " << io::rate(cap_rates[j]) << "\n"
+                                           << "    sum of collarlets value:  " << collarletsNPV
+                                           << " at strike floor (first): "
+                                           << io::rate(collarlets[0]->floorRates()[0])
+                                           << " at strike cap (first): "
+                                           << io::rate(collarlets[0]->capRates()[0]) << "\n");
+                            }
                         }
-
-
-
-
                     }
                 }
             }
         }
-    }
     } // pricer loop
     // remove circular refernce
     vars.hy.linkTo(ext::shared_ptr<YoYInflationTermStructure>());
@@ -421,22 +412,20 @@ void InflationCapFloorTest::testParity() {
 
     // cap-floor-swap parity is model-independent
     for (Size whichPricer = 0; whichPricer < 3; whichPricer++) {
-        for (Size i=0; i<LENGTH(lengths); i++) {
-            for (Size j=0; j<LENGTH(strikes); j++) {
-                for (Size k=0; k<LENGTH(vols); k++) {
+        for (int& length : lengths) {
+            for (double strike : strikes) {
+                for (double vol : vols) {
 
-                    Leg leg = vars.makeYoYLeg(vars.evaluationDate,lengths[i]);
+                    Leg leg = vars.makeYoYLeg(vars.evaluationDate, length);
 
-                    ext::shared_ptr<Instrument> cap
-                    = vars.makeYoYCapFloor(YoYInflationCapFloor::Cap,
-                                       leg, strikes[j], vols[k], whichPricer);
+                    ext::shared_ptr<Instrument> cap = vars.makeYoYCapFloor(
+                        YoYInflationCapFloor::Cap, leg, strike, vol, whichPricer);
 
-                    ext::shared_ptr<Instrument> floor
-                    = vars.makeYoYCapFloor(YoYInflationCapFloor::Floor,
-                                       leg, strikes[j], vols[k], whichPricer);
+                    ext::shared_ptr<Instrument> floor = vars.makeYoYCapFloor(
+                        YoYInflationCapFloor::Floor, leg, strike, vol, whichPricer);
 
                     Date from = vars.nominalTS->referenceDate();
-                    Date to = from+lengths[i]*Years;
+                    Date to = from + length * Years;
                     Schedule yoySchedule = MakeSchedule().from(from).to(to)
                     .withTenor(1*Years)
                     .withCalendar(UnitedKingdom())
@@ -444,17 +433,12 @@ void InflationCapFloorTest::testParity() {
                     .backwards()
                     ;
 
-                    YearOnYearInflationSwap swap(YearOnYearInflationSwap::Payer,
-                                                1000000.0,
-                                                yoySchedule,//fixed schedule, but same as yoy
-                                                strikes[j],
-                                                vars.dc,
-                                                yoySchedule,
-                                                vars.iir,
-                                                vars.observationLag,
-                                                0.0,        //spread on index
-                                                vars.dc,
-                                                UnitedKingdom());
+                    YearOnYearInflationSwap swap(YearOnYearInflationSwap::Payer, 1000000.0,
+                                                 yoySchedule, // fixed schedule, but same as yoy
+                                                 strike, vars.dc, yoySchedule, vars.iir,
+                                                 vars.observationLag,
+                                                 0.0, // spread on index
+                                                 vars.dc, UnitedKingdom());
 
                     Handle<YieldTermStructure> hTS(vars.nominalTS);
                     ext::shared_ptr<PricingEngine> sppe(new DiscountingSwapEngine(hTS));
@@ -464,14 +448,13 @@ void InflationCapFloorTest::testParity() {
 
                     // N.B. nominals are 10e6
                     if (std::fabs((cap->NPV()-floor->NPV()) - swap.NPV()) > 1.0e-6) {
-                        BOOST_FAIL(
-                               "put/call parity violated:\n"
-                               << "    length:      " << lengths[i] << " years\n"
-                               << "    volatility:  " << io::volatility(vols[k]) << "\n"
-                               << "    strike:      " << io::rate(strikes[j]) << "\n"
-                               << "    cap value:   " << cap->NPV() << "\n"
-                               << "    floor value: " << floor->NPV() << "\n"
-                               << "    swap value:  " << swap.NPV());
+                        BOOST_FAIL("put/call parity violated:\n"
+                                   << "    length:      " << length << " years\n"
+                                   << "    volatility:  " << io::volatility(vol) << "\n"
+                                   << "    strike:      " << io::rate(strike) << "\n"
+                                   << "    cap value:   " << cap->NPV() << "\n"
+                                   << "    floor value: " << floor->NPV() << "\n"
+                                   << "    swap value:  " << swap.NPV());
                     }
                 }
             }
diff --git a/test-suite/inflationcapflooredcoupon.cpp b/test-suite/inflationcapflooredcoupon.cpp
index 46c20622adc..1c65c39414b 100644
--- a/test-suite/inflationcapflooredcoupon.cpp
+++ b/test-suite/inflationcapflooredcoupon.cpp
@@ -714,22 +714,20 @@ void InflationCapFlooredCouponTest::testInstrumentEquality() {
     // capped coupon = fwd - cap, and fwd = swap(0)
     // floored coupon = fwd + floor
     for (Size whichPricer = 0; whichPricer < 3; whichPricer++) {
-        for (Size i=0; i<LENGTH(lengths); i++) {
-            for (Size j=0; j<LENGTH(strikes); j++) {
-                for (Size k=0; k<LENGTH(vols); k++) {
+        for (int& length : lengths) {
+            for (double& strike : strikes) {
+                for (double vol : vols) {
 
-                    Leg leg = vars.makeYoYLeg(vars.evaluationDate,lengths[i]);
+                    Leg leg = vars.makeYoYLeg(vars.evaluationDate, length);
 
-                    ext::shared_ptr<Instrument> cap
-                    = vars.makeYoYCapFloor(YoYInflationCapFloor::Cap,
-                                           leg, strikes[j], vols[k], whichPricer);
+                    ext::shared_ptr<Instrument> cap = vars.makeYoYCapFloor(
+                        YoYInflationCapFloor::Cap, leg, strike, vol, whichPricer);
 
-                    ext::shared_ptr<Instrument> floor
-                    = vars.makeYoYCapFloor(YoYInflationCapFloor::Floor,
-                                           leg, strikes[j], vols[k], whichPricer);
+                    ext::shared_ptr<Instrument> floor = vars.makeYoYCapFloor(
+                        YoYInflationCapFloor::Floor, leg, strike, vol, whichPricer);
 
                     Date from = vars.nominalTS->referenceDate();
-                    Date to = from+lengths[i]*Years;
+                    Date to = from + length * Years;
                     Schedule yoySchedule = MakeSchedule().from(from).to(to)
                     .withTenor(1*Years)
                     .withCalendar(UnitedKingdom())
@@ -754,30 +752,27 @@ void InflationCapFlooredCouponTest::testInstrumentEquality() {
                     swap.setPricingEngine(sppe);
                     setCouponPricer(swap.yoyLeg(), ext::make_shared<YoYInflationCouponPricer>(vars.nominalTS));
 
-                    Leg leg2 = vars.makeYoYCapFlooredLeg(whichPricer, from,
-                                                         lengths[i],
-                                                         std::vector<Rate>(lengths[i],strikes[j]),//cap
-                                                         std::vector<Rate>(),//floor
-                                                         vols[k],
-                                                         1.0,   // gearing
-                                                         0.0);// spread
-
-                    Leg leg3 = vars.makeYoYCapFlooredLeg(whichPricer, from,
-                                                         lengths[i],
-                                                         std::vector<Rate>(),// cap
-                                                         std::vector<Rate>(lengths[i],strikes[j]),//floor
-                                                         vols[k],
-                                                         1.0,   // gearing
-                                                         0.0);// spread
+                    Leg leg2 = vars.makeYoYCapFlooredLeg(whichPricer, from, length,
+                                                         std::vector<Rate>(length, strike), // cap
+                                                         std::vector<Rate>(),               // floor
+                                                         vol,
+                                                         1.0,  // gearing
+                                                         0.0); // spread
+
+                    Leg leg3 = vars.makeYoYCapFlooredLeg(whichPricer, from, length,
+                                                         std::vector<Rate>(),               // cap
+                                                         std::vector<Rate>(length, strike), // floor
+                                                         vol,
+                                                         1.0,  // gearing
+                                                         0.0); // spread
 
                     // N.B. nominals are 10e6
                     Real capped = CashFlows::npv(leg2,(**vars.nominalTS),false);
                     if ( fabs(capped - (swap.NPV() - cap->NPV())) > 1.0e-6) {
-                        BOOST_FAIL(
-                                   "capped coupon != swap(0) - cap:\n"
-                                   << "    length:      " << lengths[i] << " years\n"
-                                   << "    volatility:  " << io::volatility(vols[k]) << "\n"
-                                   << "    strike:      " << io::rate(strikes[j]) << "\n"
+                        BOOST_FAIL("capped coupon != swap(0) - cap:\n"
+                                   << "    length:      " << length << " years\n"
+                                   << "    volatility:  " << io::volatility(vol) << "\n"
+                                   << "    strike:      " << io::rate(strike) << "\n"
                                    << "    cap value:   " << cap->NPV() << "\n"
                                    << "    swap value:  " << swap.NPV() << "\n"
                                    << "   capped coupon " << capped);
@@ -787,16 +782,14 @@ void InflationCapFlooredCouponTest::testInstrumentEquality() {
                     // N.B. nominals are 10e6
                     Real floored = CashFlows::npv(leg3,(**vars.nominalTS),false);
                     if ( fabs(floored - (swap.NPV() + floor->NPV())) > 1.0e-6) {
-                        BOOST_FAIL(
-                                   "floored coupon != swap(0) + floor :\n"
-                                   << "    length:      " << lengths[i] << " years\n"
-                                   << "    volatility:  " << io::volatility(vols[k]) << "\n"
-                                   << "    strike:      " << io::rate(strikes[j]) << "\n"
+                        BOOST_FAIL("floored coupon != swap(0) + floor :\n"
+                                   << "    length:      " << length << " years\n"
+                                   << "    volatility:  " << io::volatility(vol) << "\n"
+                                   << "    strike:      " << io::rate(strike) << "\n"
                                    << "    floor value: " << floor->NPV() << "\n"
                                    << "    swap value:  " << swap.NPV() << "\n"
                                    << "  floored coupon " << floored);
                     }
-
                 }
             }
         }
diff --git a/test-suite/inflationcpicapfloor.cpp b/test-suite/inflationcpicapfloor.cpp
index 5efaec2e48e..3f93e580d59 100644
--- a/test-suite/inflationcpicapfloor.cpp
+++ b/test-suite/inflationcpicapfloor.cpp
@@ -208,18 +208,15 @@ namespace inflation_cpi_capfloor_test {
                 { Date( 2, June, 2070), 3.757542 },
                 { Date( 3, June, 2080), 3.651379 }
             };
-            const Size nominalDataLength = 33-1;
 
             std::vector<Date> nomD;
             std::vector<Rate> nomR;
-            for (Size i = 0; i < nominalDataLength; i++) {
-                nomD.push_back(nominalData[i].date);
-                nomR.push_back(nominalData[i].rate/100.0);
+            for (auto& i : nominalData) {
+                nomD.push_back(i.date);
+                nomR.push_back(i.rate / 100.0);
             }
-            ext::shared_ptr<YieldTermStructure>   nominalTS
-            =   ext::make_shared<InterpolatedZeroCurve<Linear>
-            >(nomD,nomR,dcNominal);
-
+            ext::shared_ptr<YieldTermStructure> nominalTS =
+                ext::make_shared<InterpolatedZeroCurve<Linear>>(nomD,nomR,dcNominal);
 
             nominalUK.linkTo(nominalTS);
 
diff --git a/test-suite/inflationcpiswap.cpp b/test-suite/inflationcpiswap.cpp
index 3eb446de2e4..c21619768d6 100644
--- a/test-suite/inflationcpiswap.cpp
+++ b/test-suite/inflationcpiswap.cpp
@@ -187,18 +187,15 @@ namespace inflation_cpi_swap_test {
                 { Date(25, November, 2069), 3.72677 },
                 { Date(27, November, 2079), 3.63082 }
             };
-            const Size nominalDataLength = 30-1;
 
             std::vector<Date> nomD;
             std::vector<Rate> nomR;
-            for (Size i = 0; i < nominalDataLength; i++) {
-                nomD.push_back(nominalData[i].date);
-                nomR.push_back(nominalData[i].rate/100.0);
+            for (auto& i : nominalData) {
+                nomD.push_back(i.date);
+                nomR.push_back(i.rate / 100.0);
             }
             ext::shared_ptr<YieldTermStructure> nominal =
-            ext::make_shared<InterpolatedZeroCurve<Linear>
-            >(nomD,nomR,dcNominal);
-
+                ext::make_shared<InterpolatedZeroCurve<Linear>>(nomD,nomR,dcNominal);
 
             nominalTS.linkTo(nominal);
 
diff --git a/test-suite/inflationvolatility.cpp b/test-suite/inflationvolatility.cpp
index cb4aa37da09..c3af1d03964 100644
--- a/test-suite/inflationvolatility.cpp
+++ b/test-suite/inflationvolatility.cpp
@@ -226,9 +226,12 @@ namespace inflation_volatility_test {
         cStrikesEU.clear();
         fStrikesEU.clear();
         cfMaturitiesEU.clear();
-        for(Size i = 0; i < ncStrikesEU; i++) cStrikesEU.push_back(capStrikesEU[i]);
-        for(Size i = 0; i < nfStrikesEU; i++) fStrikesEU.push_back(floorStrikesEU[i]);
-        for(Size i = 0; i < ncfMaturitiesEU; i++) cfMaturitiesEU.push_back(capMaturitiesEU[i]);
+        for (double& i : capStrikesEU)
+            cStrikesEU.push_back(i);
+        for (double& i : floorStrikesEU)
+            fStrikesEU.push_back(i);
+        for (auto& i : capMaturitiesEU)
+            cfMaturitiesEU.push_back(i);
         ext::shared_ptr<Matrix> tcPriceEU(new Matrix(ncStrikesEU, ncfMaturitiesEU));
         ext::shared_ptr<Matrix> tfPriceEU(new Matrix(nfStrikesEU, ncfMaturitiesEU));
         for(Size i = 0; i < ncStrikesEU; i++) {
diff --git a/test-suite/integrals.cpp b/test-suite/integrals.cpp
index 8bff5ca4c2e..13b1d49e2a1 100644
--- a/test-suite/integrals.cpp
+++ b/test-suite/integrals.cpp
@@ -466,14 +466,14 @@ void IntegralTest::testExponentialIntegral() {
 
     const Real tol = 1e-10;
 
-    for (Size i=0; i < LENGTH(data); ++i) {
-        const Real x = data[i][0];
-        const Real y = (std::abs(data[i][1]) < 1e-12) ? 0.0 : data[i][1];
+    for (const auto& i : data) {
+        const Real x = i[0];
+        const Real y = (std::abs(i[1]) < 1e-12) ? 0.0 : i[1];
         const std::complex<Real> z(x, y);
 
 
         const std::complex<Real> si = Si(z);
-        std::complex<Real> ref(data[i][2], data[i][3]);
+        std::complex<Real> ref(i[2], i[3]);
         Real diff = std::abs(si-ref)/std::abs(ref);
         if (diff > tol
             || (std::abs(ref.real()) < tol && std::abs(si.real()) > tol)
@@ -482,7 +482,7 @@ void IntegralTest::testExponentialIntegral() {
         }
 
         const std::complex<Real> ci = Ci(z);
-        ref = std::complex<Real>(data[i][4], data[i][5]);
+        ref = std::complex<Real>(i[4], i[5]);
         diff = std::min(std::abs(ci-ref), std::abs(ci-ref)/std::abs(ref));
         if (diff > tol
             || (std::abs(ref.real()) < tol && std::abs(ci.real()) > tol)
@@ -491,7 +491,7 @@ void IntegralTest::testExponentialIntegral() {
         }
 
         const std::complex<Real> ei = Ei(z);
-        ref = std::complex<Real>(data[i][6], data[i][7]);
+        ref = std::complex<Real>(i[6], i[7]);
         diff = std::abs(ei-ref)/std::abs(ref);
         if (diff > tol
             || (std::abs(ref.real()) < tol && std::abs(ei.real()) > tol)
@@ -500,7 +500,7 @@ void IntegralTest::testExponentialIntegral() {
         }
 
         const std::complex<Real> e1 = E1(z);
-        ref = std::complex<Real>(data[i][8], data[i][9]);
+        ref = std::complex<Real>(i[8], i[9]);
         diff = std::min(std::abs(e1-ref), std::abs(e1-ref)/std::abs(ref));
         if (std::abs(z) < 10.0)
             if (diff > tol
@@ -542,28 +542,27 @@ void IntegralTest::testRealSiCiIntegrals() {
 
     const Real tol = 1e-12;
 
-    for (Size i=0; i < LENGTH(data); ++i) {
-        Real x = data[i][0];
+    for (const auto& i : data) {
+        Real x = i[0];
         Real si = Si(x);
 
-        Real diff = std::fabs(si - data[i][1]);
+        Real diff = std::fabs(si - i[1]);
         if (diff > tol) {
-            integrals_test::reportSiCiFail("SineIntegral", x, si, data[i][1], diff, tol);
+            integrals_test::reportSiCiFail("SineIntegral", x, si, i[1], diff, tol);
         }
 
         const Real ci = Ci(x);
-        diff = std::fabs(ci - data[i][2]);
+        diff = std::fabs(ci - i[2]);
         if (diff > tol) {
-            integrals_test::reportSiCiFail("CosineIntegral", x, ci, data[i][2], diff, tol);
+            integrals_test::reportSiCiFail("CosineIntegral", x, ci, i[2], diff, tol);
         }
 
-        x = -data[i][0];
+        x = -i[0];
         si = Si(x);
-        diff = std::fabs(si + data[i][1]);
+        diff = std::fabs(si + i[1]);
         if (diff > tol) {
-            integrals_test::reportSiCiFail("SineIntegral", x, si, -data[i][1], diff, tol);
+            integrals_test::reportSiCiFail("SineIntegral", x, si, -i[1], diff, tol);
         }
-
     }
 }
 
diff --git a/test-suite/interestrates.cpp b/test-suite/interestrates.cpp
index 42c5bf7401c..80942f3818e 100644
--- a/test-suite/interestrates.cpp
+++ b/test-suite/interestrates.cpp
@@ -97,11 +97,10 @@ void InterestRateTest::testConversions() {
     DiscountFactor disc;
 
 
-    for (Size i=0; i<LENGTH(cases); i++) {
-        ir = InterestRate(cases[i].r, Actual360(),
-                          cases[i].comp, cases[i].freq);
-        d2 = d1 + timeToDays(cases[i].t);
-        roundingPrecision = Rounding(cases[i].precision);
+    for (auto& i : cases) {
+        ir = InterestRate(i.r, Actual360(), i.comp, i.freq);
+        d2 = d1 + timeToDays(i.t);
+        roundingPrecision = Rounding(i.precision);
 
         // check that the compound factor is the inverse of the discount factor
         compoundf = ir.compoundFactor(d1, d2);
@@ -154,23 +153,17 @@ void InterestRateTest::testConversions() {
 
         // check that the equivalent InterestRate with *different*
         // compounding, and frequency is the *expected* InterestRate
-        ir3 = ir.equivalentRate(ir.dayCounter(),
-                                cases[i].comp2, cases[i].freq2,
-                                d1, d2);
-        expectedIR = InterestRate(cases[i].expected, ir.dayCounter(),
-                                  cases[i].comp2, cases[i].freq2);
+        ir3 = ir.equivalentRate(ir.dayCounter(), i.comp2, i.freq2, d1, d2);
+        expectedIR = InterestRate(i.expected, ir.dayCounter(), i.comp2, i.freq2);
         r3 = roundingPrecision(ir3.rate());
         error = std::fabs(r3-expectedIR.rate());
         if (error>1.0e-17)
-            BOOST_FAIL(std::setprecision(cases[i].precision+1)
+            BOOST_FAIL(std::setprecision(i.precision + 1)
                        << "\n               original interest rate: " << ir
                        << "\n  calculated equivalent interest rate: " << ir3
-                       << "\n            truncated equivalent rate: "
-                       << io::rate(r3)
-                       << "\n    expected equivalent interest rate: "
-                       << expectedIR
-                       << "\n                           rate error: "
-                       << error);
+                       << "\n            truncated equivalent rate: " << io::rate(r3)
+                       << "\n    expected equivalent interest rate: " << expectedIR
+                       << "\n                           rate error: " << error);
         if (ir3.dayCounter()!=expectedIR.dayCounter())
             BOOST_FAIL("\n day counter error"
                        << "\n    original interest rate: " << ir3
@@ -186,16 +179,13 @@ void InterestRateTest::testConversions() {
 
         // check that the equivalent rate with *different*
         // compounding, and frequency is the *expected* rate
-        r3 = ir.equivalentRate(ir.dayCounter(),
-                               cases[i].comp2, cases[i].freq2,
-                               d1, d2);
+        r3 = ir.equivalentRate(ir.dayCounter(), i.comp2, i.freq2, d1, d2);
         r3 = roundingPrecision(r3);
-        error = std::fabs(r3-cases[i].expected);
+        error = std::fabs(r3 - i.expected);
         if (error>1.0e-17)
-            BOOST_FAIL(std::setprecision(cases[i].precision-2)
+            BOOST_FAIL(std::setprecision(i.precision - 2)
                        << "\n  calculated equivalent rate: " << io::rate(r3)
-                       << "\n    expected equivalent rate: "
-                       << io::rate(cases[i].expected)
+                       << "\n    expected equivalent rate: " << io::rate(i.expected)
                        << "\n                       error: " << error);
     }
 }
diff --git a/test-suite/interpolations.cpp b/test-suite/interpolations.cpp
index a39b7439345..ba20261ea1a 100644
--- a/test-suite/interpolations.cpp
+++ b/test-suite/interpolations.cpp
@@ -1304,87 +1304,84 @@ void InterpolationTest::testSabrInterpolation(){
     ext::shared_ptr<EndCriteria> endCriteria(new
                   EndCriteria(100000, 100, 1e-8, 1e-8, 1e-8));
     // Test looping over all possibilities
-    for (Size j=0; j<methods_.size(); ++j) {
-      for (Size i=0; i<LENGTH(vegaWeighted); ++i) {
-        for (Size k_a=0; k_a<LENGTH(isAlphaFixed); ++k_a) {
-          for (Size k_b=0; k_b<LENGTH(isBetaFixed); ++k_b) {
-            for (Size k_n=0; k_n<LENGTH(isNuFixed); ++k_n) {
-              for (Size k_r=0; k_r<LENGTH(isRhoFixed); ++k_r) {
-                  // to meet the tough calibration tolerance we need to lower the default
-                  // error threshold for accepting a calibration (to be more specific, some
-                  // of the new test cases arising from fixing a subset of the model's
-                  // parameters do not calibrate with the desired error using the initial
-                  // guess (i.e. optimization runs into a local minimum) - then a series of
-                  // random start values for optimization is chosen until our tight custom
-                  // error threshold is satisfied.
-                  SABRInterpolation sabrInterpolation(
-                      strikes.begin(), strikes.end(), volatilities.begin(),
-                      expiry, forward, isAlphaFixed[k_a] ? initialAlpha : alphaGuess,
-                      isBetaFixed[k_b] ? initialBeta : betaGuess,
-                      isNuFixed[k_n] ? initialNu : nuGuess,
-                      isRhoFixed[k_r] ? initialRho : rhoGuess, isAlphaFixed[k_a],
-                      isBetaFixed[k_b], isNuFixed[k_n], isRhoFixed[k_r],
-                      vegaWeighted[i], endCriteria, methods_[j], 1E-10);
-                  sabrInterpolation.update();
-
-                // Recover SABR calibration parameters
-                bool failed = false;
-                Real calibratedAlpha = sabrInterpolation.alpha();
-                Real calibratedBeta = sabrInterpolation.beta();
-                Real calibratedNu = sabrInterpolation.nu();
-                Real calibratedRho = sabrInterpolation.rho();
-                Real error;
-
-                // compare results: alpha
-                error = std::fabs(initialAlpha-calibratedAlpha);
-                if (error > calibrationTolerance) {
-                    BOOST_ERROR("\nfailed to calibrate alpha Sabr parameter:" <<
-                                "\n    expected:        " << initialAlpha <<
-                                "\n    calibrated:      " << calibratedAlpha <<
-                                "\n    error:           " << error);
-                    failed = true;
-                }
-                // Beta
-                error = std::fabs(initialBeta-calibratedBeta);
-                if (error > calibrationTolerance) {
-                    BOOST_ERROR("\nfailed to calibrate beta Sabr parameter:" <<
-                                "\n    expected:        " << initialBeta <<
-                                "\n    calibrated:      " << calibratedBeta <<
-                                "\n    error:           " << error);
-                    failed = true;
-                }
-                // Nu
-                error = std::fabs(initialNu-calibratedNu);
-                if (error > calibrationTolerance) {
-                    BOOST_ERROR("\nfailed to calibrate nu Sabr parameter:" <<
-                                "\n    expected:        " << initialNu <<
-                                "\n    calibrated:      " << calibratedNu <<
-                                "\n    error:           " << error);
-                    failed = true;
-                }
-                // Rho
-                error = std::fabs(initialRho-calibratedRho);
-                if (error > calibrationTolerance) {
-                    BOOST_ERROR("\nfailed to calibrate rho Sabr parameter:" <<
-                                "\n    expected:        " << initialRho <<
-                                "\n    calibrated:      " << calibratedRho <<
-                                "\n    error:           " << error);
-                    failed = true;
-                }
+    for (auto& method : methods_) {
+        for (bool i : vegaWeighted) {
+            for (bool k_a : isAlphaFixed) {
+                for (bool k_b : isBetaFixed) {
+                    for (bool k_n : isNuFixed) {
+                        for (bool k_r : isRhoFixed) {
+                            // to meet the tough calibration tolerance we need to lower the default
+                            // error threshold for accepting a calibration (to be more specific,
+                            // some of the new test cases arising from fixing a subset of the
+                            // model's parameters do not calibrate with the desired error using the
+                            // initial guess (i.e. optimization runs into a local minimum) - then a
+                            // series of random start values for optimization is chosen until our
+                            // tight custom error threshold is satisfied.
+                            SABRInterpolation sabrInterpolation(
+                                strikes.begin(), strikes.end(), volatilities.begin(), expiry,
+                                forward, k_a ? initialAlpha : alphaGuess,
+                                k_b ? initialBeta : betaGuess, k_n ? initialNu : nuGuess,
+                                k_r ? initialRho : rhoGuess, k_a, k_b, k_n, k_r, i, endCriteria,
+                                method, 1E-10);
+                            sabrInterpolation.update();
 
-                if (failed)
-                    BOOST_FAIL("\nSabr calibration failure:" <<
-                               "\n    isAlphaFixed:    " << isAlphaFixed[k_a] <<
-                               "\n    isBetaFixed:     " << isBetaFixed[k_b] <<
-                               "\n    isNuFixed:       " << isNuFixed[k_n] <<
-                               "\n    isRhoFixed:      " << isRhoFixed[k_r] <<
-                               "\n    vegaWeighted[i]: " << vegaWeighted[i]);
+                            // Recover SABR calibration parameters
+                            bool failed = false;
+                            Real calibratedAlpha = sabrInterpolation.alpha();
+                            Real calibratedBeta = sabrInterpolation.beta();
+                            Real calibratedNu = sabrInterpolation.nu();
+                            Real calibratedRho = sabrInterpolation.rho();
+                            Real error;
 
-              }
+                            // compare results: alpha
+                            error = std::fabs(initialAlpha - calibratedAlpha);
+                            if (error > calibrationTolerance) {
+                                BOOST_ERROR("\nfailed to calibrate alpha Sabr parameter:"
+                                            << "\n    expected:        " << initialAlpha
+                                            << "\n    calibrated:      " << calibratedAlpha
+                                            << "\n    error:           " << error);
+                                failed = true;
+                            }
+                            // Beta
+                            error = std::fabs(initialBeta - calibratedBeta);
+                            if (error > calibrationTolerance) {
+                                BOOST_ERROR("\nfailed to calibrate beta Sabr parameter:"
+                                            << "\n    expected:        " << initialBeta
+                                            << "\n    calibrated:      " << calibratedBeta
+                                            << "\n    error:           " << error);
+                                failed = true;
+                            }
+                            // Nu
+                            error = std::fabs(initialNu - calibratedNu);
+                            if (error > calibrationTolerance) {
+                                BOOST_ERROR("\nfailed to calibrate nu Sabr parameter:"
+                                            << "\n    expected:        " << initialNu
+                                            << "\n    calibrated:      " << calibratedNu
+                                            << "\n    error:           " << error);
+                                failed = true;
+                            }
+                            // Rho
+                            error = std::fabs(initialRho - calibratedRho);
+                            if (error > calibrationTolerance) {
+                                BOOST_ERROR("\nfailed to calibrate rho Sabr parameter:"
+                                            << "\n    expected:        " << initialRho
+                                            << "\n    calibrated:      " << calibratedRho
+                                            << "\n    error:           " << error);
+                                failed = true;
+                            }
+
+                            if (failed)
+                                BOOST_FAIL("\nSabr calibration failure:"
+                                           << "\n    isAlphaFixed:    " << k_a
+                                           << "\n    isBetaFixed:     " << k_b
+                                           << "\n    isNuFixed:       " << k_n
+                                           << "\n    isRhoFixed:      " << k_r
+                                           << "\n    vegaWeighted[i]: " << i);
+                        }
+                    }
+                }
             }
-          }
         }
-      }
     }
 }
 
@@ -1425,18 +1422,17 @@ void InterpolationTest::testKernelInterpolation() {
 
     // Check that y-values at knots are exactly the feeded y-values,
     // irrespective of kernel parameters
-    for (Size i=0; i<lambdaVec.size(); ++i) {
-        GaussianKernel myKernel(0,lambdaVec[i]);
+    for (double i : lambdaVec) {
+        GaussianKernel myKernel(0, i);
 
-        for (Size j=0; j<yd.size(); ++j) {
+        for (auto currY : yd) {
 
-            std::vector<Real> currY = yd[j];
-            KernelInterpolation f(deltaGrid.begin(), deltaGrid.end(),
-                                  currY.begin(), myKernel
+            KernelInterpolation f(deltaGrid.begin(), deltaGrid.end(), currY.begin(), myKernel
 #ifdef __FAST_MATH__
-                                  ,1e-6
+                                  ,
+                                  1e-6
 #endif
-                                  );
+            );
             f.update();
 
             for (Size dIt=0; dIt< deltaGrid.size(); ++dIt) {
@@ -1743,11 +1739,8 @@ void InterpolationTest::testUnknownRichardsonExtrapolation() {
             std::make_pair(4.0, 1.0), std::make_pair(4.0, 0.5)
     };
 
-    for (Size i=0; i < LENGTH(testCases); ++i) {
-        const std::pair<Real, Real> testCase = testCases[i];
-
-        const RichardsonExtrapolation extrap(
-            GF(testCase.first, testCase.second), stepSize);
+    for (auto testCase : testCases) {
+        const RichardsonExtrapolation extrap(GF(testCase.first, testCase.second), stepSize);
 
         const Real calculated = extrap(4.0, 2.0);
         const Real diff = std::fabs(M_PI - calculated);
@@ -1925,24 +1918,17 @@ void InterpolationTest::testNoArbSabrInterpolation(){
                   EndCriteria(100000, 100, 1e-8, 1e-8, 1e-8));
     // Test looping over all possibilities
     for (Size j=1; j<methods_.size(); ++j) { // skip simplex (gets caught in some cases)
-        for (Size i=0; i<LENGTH(vegaWeighted); ++i) {
-            for (Size k_a=0; k_a<LENGTH(isAlphaFixed); ++k_a) {
+        for (bool i : vegaWeighted) {
+            for (bool k_a : isAlphaFixed) {
                 for (Size k_b=0; k_b<1/*LENGTH(isBetaFixed)*/; ++k_b) { // keep beta fixed (all 4 params free is a problem for this kind of test)
-                    for (Size k_n=0; k_n<LENGTH(isNuFixed); ++k_n) {
-                        for (Size k_r=0; k_r<LENGTH(isRhoFixed); ++k_r) {
+                    for (bool k_n : isNuFixed) {
+                        for (bool k_r : isRhoFixed) {
                             NoArbSabrInterpolation noarbSabrInterpolation(
-                                                                          strikes.begin(), strikes.end(),
-                                                                          volatilities.begin(), expiry, forward,
-                                                                          isAlphaFixed[k_a] ? initialAlpha
-                                                                          : alphaGuess,
-                                                                          isBetaFixed[k_b] ? initialBeta
-                                                                          : betaGuess,
-                                                                          isNuFixed[k_n] ? initialNu : nuGuess,
-                                                                          isRhoFixed[k_r] ? initialRho : rhoGuess,
-                                                                          isAlphaFixed[k_a], isBetaFixed[k_b],
-                                                                          isNuFixed[k_n], isRhoFixed[k_r],
-                                                                          vegaWeighted[i], endCriteria,
-                                                                          methods_[j], 1E-10);
+                                strikes.begin(), strikes.end(), volatilities.begin(), expiry,
+                                forward, k_a ? initialAlpha : alphaGuess,
+                                isBetaFixed[k_b] ? initialBeta : betaGuess,
+                                k_n ? initialNu : nuGuess, k_r ? initialRho : rhoGuess, k_a,
+                                isBetaFixed[k_b], k_n, k_r, i, endCriteria, methods_[j], 1E-10);
                             noarbSabrInterpolation.update();
 
                             // Recover SABR calibration parameters
@@ -1991,12 +1977,12 @@ void InterpolationTest::testNoArbSabrInterpolation(){
                             }
 
                             if (failed)
-                                BOOST_TEST_MESSAGE("\nnoarb-Sabr calibration failure:" <<
-                                           "\n    isAlphaFixed:    " << isAlphaFixed[k_a] <<
-                                           "\n    isBetaFixed:     " << isBetaFixed[k_b] <<
-                                           "\n    isNuFixed:       " << isNuFixed[k_n] <<
-                                           "\n    isRhoFixed:      " << isRhoFixed[k_r] <<
-                                           "\n    vegaWeighted[i]: " << vegaWeighted[i]);
+                                BOOST_TEST_MESSAGE("\nnoarb-Sabr calibration failure:"
+                                                   << "\n    isAlphaFixed:    " << k_a
+                                                   << "\n    isBetaFixed:     " << isBetaFixed[k_b]
+                                                   << "\n    isNuFixed:       " << k_n
+                                                   << "\n    isRhoFixed:      " << k_r
+                                                   << "\n    vegaWeighted[i]: " << i);
                         }
                     }
                 }
@@ -2392,10 +2378,10 @@ void InterpolationTest::testBSplines() {
 
 
     const Real tol = 1e-10;
-    for (Size i=0; i < referenceValues.size(); ++i) {
-        const Natural idx = ext::get<0>(referenceValues[i]);
-        const Real x = ext::get<1>(referenceValues[i]);
-        const Real expected = ext::get<2>(referenceValues[i]);
+    for (auto& referenceValue : referenceValues) {
+        const Natural idx = ext::get<0>(referenceValue);
+        const Real x = ext::get<1>(referenceValue);
+        const Real expected = ext::get<2>(referenceValue);
 
         const Real calculated = bspline(idx, x);
 
@@ -2422,27 +2408,25 @@ void InterpolationTest::testBackwardFlatOnSinglePoint() {
 
     const Real x[] = { -1.0, 1.0, 2.0, 3.0 };
 
-    for (Size i=0; i < LENGTH(x); ++i) {
-        const Real calculated = impl(x[i], true);
+    for (double i : x) {
+        const Real calculated = impl(i, true);
         const Real expected = values[0];
 
         if (!close_enough(calculated, expected)) {
             BOOST_FAIL("failed to reproduce a piecewise constant "
-                    "interpolation on a single point "
-                    << "\n   x         : " << x[i]
-                    << "\n   expected  : " << expected
-                    << "\n   calculated: " << calculated);
+                       "interpolation on a single point "
+                       << "\n   x         : " << i << "\n   expected  : " << expected
+                       << "\n   calculated: " << calculated);
         }
 
-        const Real expectedPrimitive = values[0]*(x[i] - knots[0]);
-        const Real calculatedPrimitive = impl.primitive(x[i], true);
+        const Real expectedPrimitive = values[0] * (i - knots[0]);
+        const Real calculatedPrimitive = impl.primitive(i, true);
 
         if (!close_enough(calculatedPrimitive, expectedPrimitive)) {
             BOOST_FAIL("failed to reproduce primitive on a piecewise constant "
-                    "interpolation for a single point "
-                    << "\n   x         : " << x[i]
-                    << "\n   expected  : " << expectedPrimitive
-                    << "\n   calculated: " << calculatedPrimitive);
+                       "interpolation for a single point "
+                       << "\n   x         : " << i << "\n   expected  : " << expectedPrimitive
+                       << "\n   calculated: " << calculatedPrimitive);
         }
     }
 }
diff --git a/test-suite/jumpdiffusion.cpp b/test-suite/jumpdiffusion.cpp
index d941027fdb5..4a735ec1e4d 100644
--- a/test-suite/jumpdiffusion.cpp
+++ b/test-suite/jumpdiffusion.cpp
@@ -295,37 +295,35 @@ void JumpDiffusionTest::testMerton76() {
     ext::shared_ptr<PricingEngine> engine(
                                        new JumpDiffusionEngine(stochProcess));
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(new
-            PlainVanillaPayoff(values[i].type, values[i].strike));
+        ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(value.type, value.strike));
 
-        Date exDate = today + timeToDays(values[i].t);
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
 
 
-        jumpIntensity->setValue(values[i].jumpIntensity);
+        jumpIntensity->setValue(value.jumpIntensity);
 
         // delta in Haug's notation
-        Real jVol = values[i].v *
-            std::sqrt(values[i].gamma / values[i].jumpIntensity);
+        Real jVol = value.v * std::sqrt(value.gamma / value.jumpIntensity);
         jumpVol->setValue(jVol);
 
         // z in Haug's notation
-        Real diffusionVol = values[i].v * std::sqrt(1.0 - values[i].gamma);
+        Real diffusionVol = value.v * std::sqrt(1.0 - value.gamma);
         vol  ->setValue(diffusionVol);
 
         // Haug is assuming zero meanJump
         Real meanJump = 0.0;
         meanLogJump->setValue(std::log(1.0+meanJump)-0.5*jVol*jVol);
 
-        Volatility totalVol = std::sqrt(values[i].jumpIntensity*jVol*jVol +
-                                      diffusionVol*diffusionVol);
-        Volatility volError = std::fabs(totalVol-values[i].v);
+        Volatility totalVol =
+            std::sqrt(value.jumpIntensity * jVol * jVol + diffusionVol * diffusionVol);
+        Volatility volError = std::fabs(totalVol - value.v);
         QL_REQUIRE(volError<1e-13,
                    volError << " mismatch");
 
@@ -333,16 +331,13 @@ void JumpDiffusionTest::testMerton76() {
         option.setPricingEngine(engine);
 
         Real calculated = option.NPV();
-        Real error = std::fabs(calculated-values[i].result);
-        if (error>values[i].tol) {
-            REPORT_FAILURE_2("value", payoff, exercise,
-                             values[i].s, values[i].q, values[i].r,
-                             today, values[i].v, values[i].jumpIntensity,
-                             values[i].gamma, values[i].result, calculated,
-                             error, values[i].tol);
+        Real error = std::fabs(calculated - value.result);
+        if (error > value.tol) {
+            REPORT_FAILURE_2("value", payoff, exercise, value.s, value.q, value.r, today, value.v,
+                             value.jumpIntensity, value.gamma, value.result, calculated, error,
+                             value.tol);
         }
     }
-
 }
 
 void JumpDiffusionTest::testGreeks() {
@@ -404,126 +399,127 @@ void JumpDiffusionTest::testGreeks() {
     ext::shared_ptr<PricingEngine> engine(
                                  new JumpDiffusionEngine(stochProcess,1e-08));
 
-    for (Size i=0; i<LENGTH(types); i++) {
-      for (Size j=0; j<LENGTH(strikes); j++) {
-      for (Size jj1=0; jj1<LENGTH(jInt); jj1++) {
-        jumpIntensity->setValue(jInt[jj1]);
-      for (Size jj2=0; jj2<LENGTH(mLJ); jj2++) {
-        meanLogJump->setValue(mLJ[jj2]);
-      for (Size jj3=0; jj3<LENGTH(jV); jj3++) {
-        jumpVol->setValue(jV[jj3]);
-        for (Size k=0; k<LENGTH(residualTimes); k++) {
-          Date exDate = today + timeToDays(residualTimes[k]);
-          ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
-          for (Size kk=0; kk<1; kk++) {
-              // option to check
-              if (kk==0) {
-                  payoff = ext::shared_ptr<StrikedTypePayoff>(new
-                    PlainVanillaPayoff(types[i], strikes[j]));
-              } else if (kk==1) {
-                  payoff = ext::shared_ptr<StrikedTypePayoff>(new
-                    CashOrNothingPayoff(types[i], strikes[j],
-                    100.0));
-              }
-              EuropeanOption option(payoff, exercise);
-              option.setPricingEngine(engine);
-
-              for (Size l=0; l<LENGTH(underlyings); l++) {
-                Real u = underlyings[l];
-                for (Size m=0; m<LENGTH(qRates); m++) {
-                  Rate q = qRates[m];
-                  for (Size n=0; n<LENGTH(rRates); n++) {
-                    Rate r = rRates[n];
-                    for (Size p=0; p<LENGTH(vols); p++) {
-                      Volatility v = vols[p];
-                      spot->setValue(u);
-                      qRate->setValue(q);
-                      rRate->setValue(r);
-                      vol->setValue(v);
-
-                      Real value = option.NPV();
-                      calculated["delta"]  = option.delta();
-                      calculated["gamma"]  = option.gamma();
-                      calculated["theta"]  = option.theta();
-                      calculated["rho"]    = option.rho();
-                      calculated["divRho"] = option.dividendRho();
-                      calculated["vega"]   = option.vega();
-
-                      if (value > spot->value()*1.0e-5) {
-                          // perturb spot and get delta and gamma
-                          Real du = u*1.0e-5;
-                          spot->setValue(u+du);
-                          Real value_p = option.NPV(),
-                               delta_p = option.delta();
-                          spot->setValue(u-du);
-                          Real value_m = option.NPV(),
-                               delta_m = option.delta();
-                          spot->setValue(u);
-                          expected["delta"] = (value_p - value_m)/(2*du);
-                          expected["gamma"] = (delta_p - delta_m)/(2*du);
-
-                          // perturb rates and get rho and dividend rho
-                          Spread dr = 1.0e-5;
-                          rRate->setValue(r+dr);
-                          value_p = option.NPV();
-                          rRate->setValue(r-dr);
-                          value_m = option.NPV();
-                          rRate->setValue(r);
-                          expected["rho"] = (value_p - value_m)/(2*dr);
-
-                          Spread dq = 1.0e-5;
-                          qRate->setValue(q+dq);
-                          value_p = option.NPV();
-                          qRate->setValue(q-dq);
-                          value_m = option.NPV();
-                          qRate->setValue(q);
-                          expected["divRho"] = (value_p - value_m)/(2*dq);
-
-                          // perturb volatility and get vega
-                          Volatility dv = v*1.0e-4;
-                          vol->setValue(v+dv);
-                          value_p = option.NPV();
-                          vol->setValue(v-dv);
-                          value_m = option.NPV();
-                          vol->setValue(v);
-                          expected["vega"] = (value_p - value_m)/(2*dv);
-
-                          // get theta from time-shifted options
-                          Time dT = dc.yearFraction(today-1, today+1);
-                          Settings::instance().evaluationDate() = today-1;
-                          value_m = option.NPV();
-                          Settings::instance().evaluationDate() = today+1;
-                          value_p = option.NPV();
-                          Settings::instance().evaluationDate() = today;
-                          expected["theta"] = (value_p - value_m)/dT;
-                          // compare
-                          std::map<std::string,Real>::iterator it;
-                          for (it = expected.begin();
-                               it != expected.end(); ++it) {
-                              std::string greek = it->first;
-                              Real expct = expected  [greek],
-                                   calcl = calculated[greek],
-                                   tol   = tolerance [greek];
-                              Real error = std::fabs(expct-calcl);
-                              if (error>tol) {
-                                  REPORT_FAILURE_1(greek, payoff, exercise,
-                                                   u, q, r, today, v,
-                                                   jInt[jj1], mLJ[jj2],
-                                                   jV[jj3], expct, calcl,
-                                                   error, tol);
-                              }
-                          }
-                      }
-                    }
-                  }
+    for (auto& type : types) {
+        for (double strike : strikes) {
+            for (double& jj1 : jInt) {
+                jumpIntensity->setValue(jj1);
+                for (double& jj2 : mLJ) {
+                    meanLogJump->setValue(jj2);
+                    for (double& jj3 : jV) {
+                        jumpVol->setValue(jj3);
+                        for (double residualTime : residualTimes) {
+                            Date exDate = today + timeToDays(residualTime);
+                            ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
+                            for (Size kk = 0; kk < 1; kk++) {
+                                // option to check
+                                if (kk == 0) {
+                                    payoff = ext::shared_ptr<StrikedTypePayoff>(
+                                        new PlainVanillaPayoff(type, strike));
+                                } else if (kk == 1) {
+                                    payoff = ext::shared_ptr<StrikedTypePayoff>(
+                                        new CashOrNothingPayoff(type, strike, 100.0));
+                                }
+                                EuropeanOption option(payoff, exercise);
+                                option.setPricingEngine(engine);
+
+                                for (double u : underlyings) {
+                                    for (double q : qRates) {
+                                        for (double r : rRates) {
+                                            for (double v : vols) {
+                                                spot->setValue(u);
+                                                qRate->setValue(q);
+                                                rRate->setValue(r);
+                                                vol->setValue(v);
+
+                                                Real value = option.NPV();
+                                                calculated["delta"] = option.delta();
+                                                calculated["gamma"] = option.gamma();
+                                                calculated["theta"] = option.theta();
+                                                calculated["rho"] = option.rho();
+                                                calculated["divRho"] = option.dividendRho();
+                                                calculated["vega"] = option.vega();
+
+                                                if (value > spot->value() * 1.0e-5) {
+                                                    // perturb spot and get delta and gamma
+                                                    Real du = u * 1.0e-5;
+                                                    spot->setValue(u + du);
+                                                    Real value_p = option.NPV(),
+                                                         delta_p = option.delta();
+                                                    spot->setValue(u - du);
+                                                    Real value_m = option.NPV(),
+                                                         delta_m = option.delta();
+                                                    spot->setValue(u);
+                                                    expected["delta"] =
+                                                        (value_p - value_m) / (2 * du);
+                                                    expected["gamma"] =
+                                                        (delta_p - delta_m) / (2 * du);
+
+                                                    // perturb rates and get rho and dividend rho
+                                                    Spread dr = 1.0e-5;
+                                                    rRate->setValue(r + dr);
+                                                    value_p = option.NPV();
+                                                    rRate->setValue(r - dr);
+                                                    value_m = option.NPV();
+                                                    rRate->setValue(r);
+                                                    expected["rho"] =
+                                                        (value_p - value_m) / (2 * dr);
+
+                                                    Spread dq = 1.0e-5;
+                                                    qRate->setValue(q + dq);
+                                                    value_p = option.NPV();
+                                                    qRate->setValue(q - dq);
+                                                    value_m = option.NPV();
+                                                    qRate->setValue(q);
+                                                    expected["divRho"] =
+                                                        (value_p - value_m) / (2 * dq);
+
+                                                    // perturb volatility and get vega
+                                                    Volatility dv = v * 1.0e-4;
+                                                    vol->setValue(v + dv);
+                                                    value_p = option.NPV();
+                                                    vol->setValue(v - dv);
+                                                    value_m = option.NPV();
+                                                    vol->setValue(v);
+                                                    expected["vega"] =
+                                                        (value_p - value_m) / (2 * dv);
+
+                                                    // get theta from time-shifted options
+                                                    Time dT = dc.yearFraction(today - 1, today + 1);
+                                                    Settings::instance().evaluationDate() =
+                                                        today - 1;
+                                                    value_m = option.NPV();
+                                                    Settings::instance().evaluationDate() =
+                                                        today + 1;
+                                                    value_p = option.NPV();
+                                                    Settings::instance().evaluationDate() = today;
+                                                    expected["theta"] = (value_p - value_m) / dT;
+                                                    // compare
+                                                    std::map<std::string, Real>::iterator it;
+                                                    for (it = expected.begin();
+                                                         it != expected.end(); ++it) {
+                                                        std::string greek = it->first;
+                                                        Real expct = expected[greek],
+                                                             calcl = calculated[greek],
+                                                             tol = tolerance[greek];
+                                                        Real error = std::fabs(expct - calcl);
+                                                        if (error > tol) {
+                                                            REPORT_FAILURE_1(
+                                                                greek, payoff, exercise, u, q, r,
+                                                                today, v, jj1, jj2, jj3, expct,
+                                                                calcl, error, tol);
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    } // strike loop
                 }
-              }
             }
         }
-      } // strike loop
-      }
-      }
-      }
     } // type loop
 }
 
diff --git a/test-suite/libormarketmodelprocess.cpp b/test-suite/libormarketmodelprocess.cpp
index adf54d87dd5..d3826e1539c 100644
--- a/test-suite/libormarketmodelprocess.cpp
+++ b/test-suite/libormarketmodelprocess.cpp
@@ -183,9 +183,9 @@ void LiborMarketModelProcessTest::testLambdaBootstrapping() {
     std::vector<Time> tmp = process->fixingTimes();
     TimeGrid grid(tmp.begin(), tmp.end(), 14);
 
-    for (Size t=0; t<grid.size(); ++t) {
-        Matrix diff = (param->integratedCovariance(grid[t])
-        - param->LfmCovarianceParameterization::integratedCovariance(grid[t]));
+    for (double t : grid) {
+        Matrix diff = (param->integratedCovariance(t) -
+                       param->LfmCovarianceParameterization::integratedCovariance(t));
 
         for (Size i=0; i<diff.rows(); ++i) {
             for (Size j=0; j<diff.columns(); ++j) {
diff --git a/test-suite/lookbackoptions.cpp b/test-suite/lookbackoptions.cpp
index 3ce37ecb739..e75605ad372 100644
--- a/test-suite/lookbackoptions.cpp
+++ b/test-suite/lookbackoptions.cpp
@@ -143,17 +143,16 @@ void LookbackOptionTest::testAnalyticContinuousFloatingLookback() {
     ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.0));
     ext::shared_ptr<BlackVolTermStructure> volTS = flatVol(today, vol, dc);
 
-    for (Size i=0; i<LENGTH(values); i++) {
-        Date exDate = today + timeToDays(values[i].t);
+    for (auto& value : values) {
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
-        ext::shared_ptr<FloatingTypePayoff> payoff(
-                                      new FloatingTypePayoff(values[i].type));
+        ext::shared_ptr<FloatingTypePayoff> payoff(new FloatingTypePayoff(value.type));
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess(
                             new BlackScholesMertonProcess(
@@ -165,20 +164,16 @@ void LookbackOptionTest::testAnalyticContinuousFloatingLookback() {
         ext::shared_ptr<PricingEngine> engine(
                   new AnalyticContinuousFloatingLookbackEngine(stochProcess));
 
-        ContinuousFloatingLookbackOption option(values[i].minmax,
-                                                payoff,
-                                                exercise);
+        ContinuousFloatingLookbackOption option(value.minmax, payoff, exercise);
         option.setPricingEngine(engine);
 
         Real calculated = option.NPV();
-        Real expected = values[i].result;
+        Real expected = value.result;
         Real error = std::fabs(calculated-expected);
-        if (error>values[i].tol) {
-            REPORT_FAILURE_FLOATING("value", values[i].minmax, payoff,
-                                    exercise, values[i].s, values[i].q,
-                                    values[i].r, today, values[i].v,
-                                    expected, calculated, error,
-                                    values[i].tol);
+        if (error > value.tol) {
+            REPORT_FAILURE_FLOATING("value", values[i].minmax, payoff, exercise, value.s, value.q,
+                                    value.r, today, value.v, expected, calculated, error,
+                                    value.tol);
         }
     }
 }
@@ -243,17 +238,16 @@ void LookbackOptionTest::testAnalyticContinuousFixedLookback() {
     ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.0));
     ext::shared_ptr<BlackVolTermStructure> volTS = flatVol(today, vol, dc);
 
-    for (Size i=0; i<LENGTH(values); i++) {
-        Date exDate = today + timeToDays(values[i].t);
+    for (auto& value : values) {
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(
-                     new PlainVanillaPayoff(values[i].type, values[i].strike));
+        ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(value.type, value.strike));
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess(
                             new BlackScholesMertonProcess(
@@ -265,19 +259,15 @@ void LookbackOptionTest::testAnalyticContinuousFixedLookback() {
         ext::shared_ptr<PricingEngine> engine(
                      new AnalyticContinuousFixedLookbackEngine(stochProcess));
 
-        ContinuousFixedLookbackOption option(values[i].minmax,
-                                             payoff,
-                                             exercise);
+        ContinuousFixedLookbackOption option(value.minmax, payoff, exercise);
         option.setPricingEngine(engine);
 
         Real calculated = option.NPV();
-        Real expected = values[i].result;
+        Real expected = value.result;
         Real error = std::fabs(calculated-expected);
-        if (error>values[i].tol) {
-            REPORT_FAILURE_FIXED("value", values[i].minmax, payoff, exercise,
-                                 values[i].s, values[i].q, values[i].r, today,
-                                 values[i].v, expected, calculated, error,
-                                 values[i].tol);
+        if (error > value.tol) {
+            REPORT_FAILURE_FIXED("value", values[i].minmax, payoff, exercise, value.s, value.q,
+                                 value.r, today, value.v, expected, calculated, error, value.tol);
         }
     }
 }
@@ -353,17 +343,16 @@ void LookbackOptionTest::testAnalyticContinuousPartialFloatingLookback() {
     ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.0));
     ext::shared_ptr<BlackVolTermStructure> volTS = flatVol(today, vol, dc);
 
-    for (Size i=0; i<LENGTH(values); i++) {
-        Date exDate = today + timeToDays(values[i].t);
+    for (auto& value : values) {
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
-        ext::shared_ptr<FloatingTypePayoff> payoff(
-                                      new FloatingTypePayoff(values[i].type));
+        ext::shared_ptr<FloatingTypePayoff> payoff(new FloatingTypePayoff(value.type));
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess(
                             new BlackScholesMertonProcess(
@@ -375,23 +364,18 @@ void LookbackOptionTest::testAnalyticContinuousPartialFloatingLookback() {
         ext::shared_ptr<PricingEngine> engine(
                   new AnalyticContinuousPartialFloatingLookbackEngine(stochProcess));
 
-        Date lookbackEnd = today + timeToDays(values[i].t1);
-        ContinuousPartialFloatingLookbackOption option(values[i].minmax,
-                                                values[i].l,
-                                                lookbackEnd,
-                                                payoff,
-                                                exercise);
+        Date lookbackEnd = today + timeToDays(value.t1);
+        ContinuousPartialFloatingLookbackOption option(value.minmax, value.l, lookbackEnd, payoff,
+                                                       exercise);
         option.setPricingEngine(engine);
 
         Real calculated = option.NPV();
-        Real expected = values[i].result;
+        Real expected = value.result;
         Real error = std::fabs(calculated-expected);
-        if (error>values[i].tol) {
-            REPORT_FAILURE_FLOATING("value", values[i].minmax, payoff,
-                                    exercise, values[i].s, values[i].q,
-                                    values[i].r, today, values[i].v,
-                                    expected, calculated, error,
-                                    values[i].tol);
+        if (error > value.tol) {
+            REPORT_FAILURE_FLOATING("value", values[i].minmax, payoff, exercise, value.s, value.q,
+                                    value.r, today, value.v, expected, calculated, error,
+                                    value.tol);
         }
     }
 }
@@ -464,17 +448,16 @@ void LookbackOptionTest::testAnalyticContinuousPartialFixedLookback() {
     ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.0));
     ext::shared_ptr<BlackVolTermStructure> volTS = flatVol(today, vol, dc);
 
-    for (Size i=0; i<LENGTH(values); i++) {
-        Date exDate = today + timeToDays(values[i].t);
+    for (auto& value : values) {
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(
-                     new PlainVanillaPayoff(values[i].type, values[i].strike));
+        ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(value.type, value.strike));
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess(
                             new BlackScholesMertonProcess(
@@ -486,20 +469,18 @@ void LookbackOptionTest::testAnalyticContinuousPartialFixedLookback() {
         ext::shared_ptr<PricingEngine> engine(
                      new AnalyticContinuousPartialFixedLookbackEngine(stochProcess));
 
-        Date lookbackStart = today + timeToDays(values[i].t1);
+        Date lookbackStart = today + timeToDays(value.t1);
         ContinuousPartialFixedLookbackOption option(lookbackStart,
                                              payoff,
                                              exercise);
         option.setPricingEngine(engine);
 
         Real calculated = option.NPV();
-        Real expected = values[i].result;
+        Real expected = value.result;
         Real error = std::fabs(calculated-expected);
-        if (error>values[i].tol) {
-            REPORT_FAILURE_FIXED("value", values[i].minmax, payoff, exercise,
-                                 values[i].s, values[i].q, values[i].r, today,
-                                 values[i].v, expected, calculated, error,
-                                 values[i].tol);
+        if (error > value.tol) {
+            REPORT_FAILURE_FIXED("value", values[i].minmax, payoff, exercise, value.s, value.q,
+                                 value.r, today, value.v, expected, calculated, error, value.tol);
         }
     }
 }
@@ -540,10 +521,8 @@ void LookbackOptionTest::testMonteCarloLookback() {
             Handle<BlackVolTermStructure>(volTS)));
 
     Option::Type types[] = { Option::Call, Option::Put };
-    
-    for (Size i=0; i<LENGTH(types); i++) {
-        Option::Type type = types[i];
 
+    for (auto type : types) {
         ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(type, strike));
 
         /**
diff --git a/test-suite/lowdiscrepancysequences.cpp b/test-suite/lowdiscrepancysequences.cpp
index 7a2f8120a56..1bcfab33495 100644
--- a/test-suite/lowdiscrepancysequences.cpp
+++ b/test-suite/lowdiscrepancysequences.cpp
@@ -1057,37 +1057,34 @@ void LowDiscrepancyTest::testSobolSkipping() {
                                                SobolRsg::SobolLevitan,
                                                SobolRsg::SobolLevitanLemieux };
 
-    for (Size i=0; i<LENGTH(integers); i++) {
-      for (Size j=0; j<LENGTH(dimensionality); j++) {
-        for (Size k=0; k<LENGTH(skip); k++) {
-
-            // extract n samples
-            SobolRsg rsg1(dimensionality[j], seed, integers[i]);
-            for (Size l=0; l<skip[k]; l++)
-                rsg1.nextInt32Sequence();
-
-            // skip n samples at once
-            SobolRsg rsg2(dimensionality[j], seed, integers[i]);
-            rsg2.skipTo(skip[k]);
-
-            // compare next 100 samples
-            for (Size m=0; m<100; m++) {
-                std::vector<boost::uint_least32_t> s1 = rsg1.nextInt32Sequence();
-                std::vector<boost::uint_least32_t> s2 = rsg2.nextInt32Sequence();
-                for (Size n=0; n<s1.size(); n++) {
-                    if (s1[n] != s2[n]) {
-                        BOOST_ERROR("Mismatch after skipping:"
-                                    << "\n  size:     " << dimensionality[j]
-                                    << "\n  integers: " << integers[i]
-                                    << "\n  skipped:  " << skip[k]
-                                    << "\n  at index: " << n
-                                    << "\n  expected: " << s1[n]
-                                    << "\n  found:    " << s2[n]);
+    for (auto& integer : integers) {
+        for (Size& j : dimensionality) {
+            for (unsigned long& k : skip) {
+
+                // extract n samples
+                SobolRsg rsg1(j, seed, integer);
+                for (Size l = 0; l < k; l++)
+                    rsg1.nextInt32Sequence();
+
+                // skip n samples at once
+                SobolRsg rsg2(j, seed, integer);
+                rsg2.skipTo(k);
+
+                // compare next 100 samples
+                for (Size m = 0; m < 100; m++) {
+                    std::vector<boost::uint_least32_t> s1 = rsg1.nextInt32Sequence();
+                    std::vector<boost::uint_least32_t> s2 = rsg2.nextInt32Sequence();
+                    for (Size n = 0; n < s1.size(); n++) {
+                        if (s1[n] != s2[n]) {
+                            BOOST_ERROR("Mismatch after skipping:"
+                                        << "\n  size:     " << j << "\n  integers: " << integer
+                                        << "\n  skipped:  " << k << "\n  at index: " << n
+                                        << "\n  expected: " << s1[n] << "\n  found:    " << s2[n]);
+                        }
                     }
                 }
             }
         }
-      }
     }
 }
 
diff --git a/test-suite/margrabeoption.cpp b/test-suite/margrabeoption.cpp
index 470828f3a41..b0fd0a837fd 100644
--- a/test-suite/margrabeoption.cpp
+++ b/test-suite/margrabeoption.cpp
@@ -178,18 +178,18 @@ void MargrabeOptionTest::testEuroExchangeTwoAssets() {
     ext::shared_ptr<SimpleQuote> vol2(new SimpleQuote(0.0));
     ext::shared_ptr<BlackVolTermStructure> volTS2 = flatVol(today, vol2, dc);
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        Date exDate = today + timeToDays(values[i].t);
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-        spot1 ->setValue(values[i].s1);
-        spot2 ->setValue(values[i].s2);
-        qRate1->setValue(values[i].q1);
-        qRate2->setValue(values[i].q2);
-        rRate ->setValue(values[i].r );
-        vol1  ->setValue(values[i].v1);
-        vol2  ->setValue(values[i].v2);
+        spot1->setValue(value.s1);
+        spot2->setValue(value.s2);
+        qRate1->setValue(value.q1);
+        qRate2->setValue(value.q2);
+        rRate->setValue(value.r);
+        vol1->setValue(value.v1);
+        vol2->setValue(value.v2);
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess1(new
             BlackScholesMertonProcess(Handle<Quote>(spot1),
@@ -207,104 +207,81 @@ void MargrabeOptionTest::testEuroExchangeTwoAssets() {
         procs.push_back(stochProcess1);
         procs.push_back(stochProcess2);
 
-        Matrix correlationMatrix(2,2, values[i].rho);
+        Matrix correlationMatrix(2, 2, value.rho);
         for (Integer j=0; j < 2; j++) {
             correlationMatrix[j][j] = 1.0;
         }
 
         ext::shared_ptr<PricingEngine> engine(
-                             new AnalyticEuropeanMargrabeEngine(stochProcess1,
-                                                                stochProcess2,
-                                                                values[i].rho));
+            new AnalyticEuropeanMargrabeEngine(stochProcess1, stochProcess2, value.rho));
 
-        MargrabeOption margrabeOption(values[i].Q1, values[i].Q2, exercise);
+        MargrabeOption margrabeOption(value.Q1, value.Q2, exercise);
 
         // analytic engine
         margrabeOption.setPricingEngine(engine);
 
         Real calculated = margrabeOption.NPV();
-        Real expected = values[i].result;
+        Real expected = value.result;
         Real error = std::fabs(calculated-expected);
-        Real tolerance = values[i].tol;
+        Real tolerance = value.tol;
         if (error > tolerance) {
-            REPORT_FAILURE("value", exercise,
-                             values[i].s1, values[i].s2, values[i].Q1,
-                             values[i].Q2, values[i].q1, values[i].q2,
-                             values[i].r, today, values[i].v1,
-                             values[i].v2, values[i].rho, expected,
-                             calculated, error, tolerance);
+            REPORT_FAILURE("value", exercise, value.s1, value.s2, value.Q1, value.Q2, value.q1,
+                           value.q2, value.r, today, value.v1, value.v2, value.rho, expected,
+                           calculated, error, tolerance);
         }
 
         calculated = margrabeOption.delta1();
-        expected = values[i].delta1;
+        expected = value.delta1;
         error= std::fabs(calculated-expected);
         if (error>tolerance) {
-            REPORT_FAILURE("delta1", exercise,
-                             values[i].s1, values[i].s2, values[i].Q1,
-                             values[i].Q2, values[i].q1, values[i].q2,
-                             values[i].r, today, values[i].v1,
-                             values[i].v2, values[i].rho, expected,
-                             calculated, error, tolerance);
+            REPORT_FAILURE("delta1", exercise, value.s1, value.s2, value.Q1, value.Q2, value.q1,
+                           value.q2, value.r, today, value.v1, value.v2, value.rho, expected,
+                           calculated, error, tolerance);
         }
 
         calculated = margrabeOption.delta2();
-        expected = values[i].delta2;
+        expected = value.delta2;
         error= std::fabs(calculated-expected);
         if (error>tolerance) {
-            REPORT_FAILURE("delta2", exercise,
-                             values[i].s1, values[i].s2, values[i].Q1,
-                             values[i].Q2, values[i].q1, values[i].q2,
-                             values[i].r, today, values[i].v1,
-                             values[i].v2, values[i].rho, expected,
-                             calculated, error, tolerance);
+            REPORT_FAILURE("delta2", exercise, value.s1, value.s2, value.Q1, value.Q2, value.q1,
+                           value.q2, value.r, today, value.v1, value.v2, value.rho, expected,
+                           calculated, error, tolerance);
         }
 
         calculated = margrabeOption.gamma1();
-        expected = values[i].gamma1;
+        expected = value.gamma1;
         error= std::fabs(calculated-expected);
         if (error>tolerance) {
-            REPORT_FAILURE("gamma1", exercise,
-                             values[i].s1, values[i].s2, values[i].Q1,
-                             values[i].Q2, values[i].q1, values[i].q2,
-                             values[i].r, today, values[i].v1,
-                             values[i].v2, values[i].rho, expected,
-                             calculated, error, tolerance);
+            REPORT_FAILURE("gamma1", exercise, value.s1, value.s2, value.Q1, value.Q2, value.q1,
+                           value.q2, value.r, today, value.v1, value.v2, value.rho, expected,
+                           calculated, error, tolerance);
         }
 
         calculated = margrabeOption.gamma2();
-        expected = values[i].gamma2;
+        expected = value.gamma2;
         error= std::fabs(calculated-expected);
         if (error>tolerance) {
-            REPORT_FAILURE("gamma2", exercise,
-                             values[i].s1, values[i].s2, values[i].Q1,
-                             values[i].Q2, values[i].q1, values[i].q2,
-                             values[i].r, today, values[i].v1,
-                             values[i].v2, values[i].rho, expected,
-                             calculated, error, tolerance);
+            REPORT_FAILURE("gamma2", exercise, value.s1, value.s2, value.Q1, value.Q2, value.q1,
+                           value.q2, value.r, today, value.v1, value.v2, value.rho, expected,
+                           calculated, error, tolerance);
         }
 
         calculated = margrabeOption.theta();
-        expected = values[i].theta;
+        expected = value.theta;
         error= std::fabs(calculated-expected);
         if (error>tolerance) {
-            REPORT_FAILURE("theta", exercise,
-                             values[i].s1, values[i].s2, values[i].Q1,
-                             values[i].Q2, values[i].q1, values[i].q2,
-                             values[i].r, today, values[i].v1,
-                             values[i].v2, values[i].rho, expected,
-                             calculated, error, tolerance);
+            REPORT_FAILURE("theta", exercise, value.s1, value.s2, value.Q1, value.Q2, value.q1,
+                           value.q2, value.r, today, value.v1, value.v2, value.rho, expected,
+                           calculated, error, tolerance);
         }
 
         calculated = margrabeOption.rho();
-        expected = values[i].rho_greek;
+        expected = value.rho_greek;
         error= std::fabs(calculated-expected);
         if (error>tolerance) {
-            REPORT_FAILURE("rho_greek", exercise,
-                             values[i].s1, values[i].s2, values[i].Q1,
-                             values[i].Q2, values[i].q1, values[i].q2,
-                             values[i].r, today, values[i].v1,
-                             values[i].v2, values[i].rho, expected,
-                             calculated, error, tolerance);
+            REPORT_FAILURE("rho_greek", exercise, value.s1, value.s2, value.Q1, value.Q2, value.q1,
+                           value.q2, value.r, today, value.v1, value.v2, value.rho, expected,
+                           calculated, error, tolerance);
         }
     }
 }
@@ -352,135 +329,121 @@ void MargrabeOptionTest::testGreeks() {
     ext::shared_ptr<SimpleQuote> vol2(new SimpleQuote(0.0));
     ext::shared_ptr<BlackVolTermStructure> volTS2 = flatVol(vol2, dc);
 
-    for (Size k=0; k<LENGTH(residualTimes); k++) {
-          Date exDate = today + timeToDays(residualTimes[k]);
-          ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
+    for (double residualTime : residualTimes) {
+        Date exDate = today + timeToDays(residualTime);
+        ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-          // option to check
-          ext::shared_ptr<BlackScholesMertonProcess> stochProcess1(new
-              BlackScholesMertonProcess(Handle<Quote>(spot1),
-                                      Handle<YieldTermStructure>(qTS1),
-                                      Handle<YieldTermStructure>(rTS),
-                                      Handle<BlackVolTermStructure>(volTS1)));
+        // option to check
+        ext::shared_ptr<BlackScholesMertonProcess> stochProcess1(new BlackScholesMertonProcess(
+            Handle<Quote>(spot1), Handle<YieldTermStructure>(qTS1), Handle<YieldTermStructure>(rTS),
+            Handle<BlackVolTermStructure>(volTS1)));
 
-          ext::shared_ptr<BlackScholesMertonProcess> stochProcess2(new
-              BlackScholesMertonProcess(Handle<Quote>(spot2),
-                                      Handle<YieldTermStructure>(qTS2),
-                                      Handle<YieldTermStructure>(rTS),
-                                      Handle<BlackVolTermStructure>(volTS2)));
+        ext::shared_ptr<BlackScholesMertonProcess> stochProcess2(new BlackScholesMertonProcess(
+            Handle<Quote>(spot2), Handle<YieldTermStructure>(qTS2), Handle<YieldTermStructure>(rTS),
+            Handle<BlackVolTermStructure>(volTS2)));
 
-          std::vector<ext::shared_ptr<StochasticProcess1D> > procs;
-          procs.push_back(stochProcess1);
-          procs.push_back(stochProcess2);
+        std::vector<ext::shared_ptr<StochasticProcess1D> > procs;
+        procs.push_back(stochProcess1);
+        procs.push_back(stochProcess2);
 
-          //The correlation -0.5 can be different real between -1 and 1 for more tests
-          Real correlation = -0.5;
-          Matrix correlationMatrix(2,2, correlation);
-          for (Integer j=0; j < 2; j++) {
-              correlationMatrix[j][j] = 1.0;
+        // The correlation -0.5 can be different real between -1 and 1 for more tests
+        Real correlation = -0.5;
+        Matrix correlationMatrix(2, 2, correlation);
+        for (Integer j = 0; j < 2; j++) {
+            correlationMatrix[j][j] = 1.0;
 
-          ext::shared_ptr<PricingEngine> engine(
-                             new AnalyticEuropeanMargrabeEngine(stochProcess1,
-                                                                stochProcess2,
-                                                                correlation));
+            ext::shared_ptr<PricingEngine> engine(
+                new AnalyticEuropeanMargrabeEngine(stochProcess1, stochProcess2, correlation));
 
-          //The quantities of S1 and S2 can be different from 1 & 1 for more tests
-          MargrabeOption margrabeOption(1, 1, exercise);
+            // The quantities of S1 and S2 can be different from 1 & 1 for more tests
+            MargrabeOption margrabeOption(1, 1, exercise);
 
-          // analytic engine
-          margrabeOption.setPricingEngine(engine);
+            // analytic engine
+            margrabeOption.setPricingEngine(engine);
 
-              for (Size l=0; l<LENGTH(underlyings1); l++) {
+            for (Size l = 0; l < LENGTH(underlyings1); l++) {
                 for (Size m=0; m<LENGTH(qRates1); m++) {
-                  for (Size n=0; n<LENGTH(rRates); n++) {
-                    for (Size p=0; p<LENGTH(vols1); p++) {
-                      Real u1 = underlyings1[l],
-                           u2 = underlyings2[l],
-                           u;
-                      Rate q1 = qRates1[m],
-                           q2 = qRates2[m],
-                           r = rRates[n];
-                      Volatility v1 = vols1[p],
-                                 v2 = vols2[p];
-
-                      spot1 ->setValue(u1);
-                      spot2 ->setValue(u2);
-                      qRate1->setValue(q1);
-                      qRate2->setValue(q2);
-                      rRate ->setValue(r);
-                      vol1  ->setValue(v1);
-                      vol2  ->setValue(v2);
-
-                      Real value = margrabeOption.NPV();
-
-                      calculated["delta1"]  = margrabeOption.delta1();
-                      calculated["delta2"]  = margrabeOption.delta2();
-                      calculated["gamma1"]  = margrabeOption.gamma1();
-                      calculated["gamma2"]  = margrabeOption.gamma2();
-                      calculated["theta"]   = margrabeOption.theta();
-                      calculated["rho"]     = margrabeOption.rho();
-
-                      if (value > spot1->value()*1.0e-5) {
-                          // perturb spot and get delta1 and gamma
-                          u = u1;
-                          Real du = u*1.0e-4;
-                          spot1->setValue(u+du);
-                          Real value_p = margrabeOption.NPV(),
-                               delta_p = margrabeOption.delta1();
-                          spot1->setValue(u-du);
-                          Real value_m = margrabeOption.NPV(),
-                               delta_m = margrabeOption.delta1();
-                          spot1->setValue(u);
-                          expected["delta1"] = (value_p - value_m)/(2*du);
-                          expected["gamma1"] = (delta_p - delta_m)/(2*du);
-
-                          u = u2;
-                          spot2->setValue(u+du);
-                               value_p = margrabeOption.NPV();
-                               delta_p = margrabeOption.delta2();
-                          spot2->setValue(u-du);
-                               value_m = margrabeOption.NPV();
-                               delta_m = margrabeOption.delta2();
-                          spot2->setValue(u);
-                          expected["delta2"] = (value_p - value_m)/(2*du);
-                          expected["gamma2"] = (delta_p - delta_m)/(2*du);
-
-                          // perturb rates and get rho
-                          Spread dr = r*1.0e-4;
-                          rRate->setValue(r+dr);
-                               value_p = margrabeOption.NPV();
-                          rRate->setValue(r-dr);
-                               value_m = margrabeOption.NPV();
-                          rRate->setValue(r);
-                          expected["rho"] = (value_p - value_m)/(2*dr);
-
-                          // perturb date and get theta
-                          Time dT = dc.yearFraction(today-1, today+1);
-                          Settings::instance().evaluationDate() = today-1;
-                               value_m = margrabeOption.NPV();
-                          Settings::instance().evaluationDate() = today+1;
-                               value_p = margrabeOption.NPV();
-                          Settings::instance().evaluationDate() = today;
-                          expected["theta"] = (value_p - value_m)/dT;
-
-                          // compare
-                          std::map<std::string,Real>::iterator it;
-                          for (it = calculated.begin();
-                               it != calculated.end(); ++it) {
-                              std::string greek = it->first;
-                              Real expct = expected  [greek],
-                                   calcl = calculated[greek],
-                                   tol   = tolerance [greek];
-                              Real error = relativeError(expct,calcl,u1);
-                              if (error>tol) {
-                                  REPORT_FAILURE2(greek, exercise,
-                                                 u1, u2, q1, q2, r, today, v1, v2,
-                                                 expct, calcl, error, tol);
-                              }
-                          }
-                      }
+                    for (double n : rRates) {
+                        for (Size p = 0; p < LENGTH(vols1); p++) {
+                            Real u1 = underlyings1[l], u2 = underlyings2[l], u;
+                            Rate q1 = qRates1[m], q2 = qRates2[m], r = n;
+                            Volatility v1 = vols1[p], v2 = vols2[p];
+
+                            spot1->setValue(u1);
+                            spot2->setValue(u2);
+                            qRate1->setValue(q1);
+                            qRate2->setValue(q2);
+                            rRate->setValue(r);
+                            vol1->setValue(v1);
+                            vol2->setValue(v2);
+
+                            Real value = margrabeOption.NPV();
+
+                            calculated["delta1"] = margrabeOption.delta1();
+                            calculated["delta2"] = margrabeOption.delta2();
+                            calculated["gamma1"] = margrabeOption.gamma1();
+                            calculated["gamma2"] = margrabeOption.gamma2();
+                            calculated["theta"] = margrabeOption.theta();
+                            calculated["rho"] = margrabeOption.rho();
+
+                            if (value > spot1->value() * 1.0e-5) {
+                                // perturb spot and get delta1 and gamma
+                                u = u1;
+                                Real du = u * 1.0e-4;
+                                spot1->setValue(u + du);
+                                Real value_p = margrabeOption.NPV(),
+                                     delta_p = margrabeOption.delta1();
+                                spot1->setValue(u - du);
+                                Real value_m = margrabeOption.NPV(),
+                                     delta_m = margrabeOption.delta1();
+                                spot1->setValue(u);
+                                expected["delta1"] = (value_p - value_m) / (2 * du);
+                                expected["gamma1"] = (delta_p - delta_m) / (2 * du);
+
+                                u = u2;
+                                spot2->setValue(u + du);
+                                value_p = margrabeOption.NPV();
+                                delta_p = margrabeOption.delta2();
+                                spot2->setValue(u - du);
+                                value_m = margrabeOption.NPV();
+                                delta_m = margrabeOption.delta2();
+                                spot2->setValue(u);
+                                expected["delta2"] = (value_p - value_m) / (2 * du);
+                                expected["gamma2"] = (delta_p - delta_m) / (2 * du);
+
+                                // perturb rates and get rho
+                                Spread dr = r * 1.0e-4;
+                                rRate->setValue(r + dr);
+                                value_p = margrabeOption.NPV();
+                                rRate->setValue(r - dr);
+                                value_m = margrabeOption.NPV();
+                                rRate->setValue(r);
+                                expected["rho"] = (value_p - value_m) / (2 * dr);
+
+                                // perturb date and get theta
+                                Time dT = dc.yearFraction(today - 1, today + 1);
+                                Settings::instance().evaluationDate() = today - 1;
+                                value_m = margrabeOption.NPV();
+                                Settings::instance().evaluationDate() = today + 1;
+                                value_p = margrabeOption.NPV();
+                                Settings::instance().evaluationDate() = today;
+                                expected["theta"] = (value_p - value_m) / dT;
+
+                                // compare
+                                std::map<std::string, Real>::iterator it;
+                                for (it = calculated.begin(); it != calculated.end(); ++it) {
+                                    std::string greek = it->first;
+                                    Real expct = expected[greek], calcl = calculated[greek],
+                                         tol = tolerance[greek];
+                                    Real error = relativeError(expct, calcl, u1);
+                                    if (error > tol) {
+                                        REPORT_FAILURE2(greek, exercise, u1, u2, q1, q2, r, today,
+                                                        v1, v2, expct, calcl, error, tol);
+                                    }
+                                }
+                            }
+                        }
                     }
-                  }
                 }
               }
           }
@@ -539,18 +502,18 @@ void MargrabeOptionTest::testAmericanExchangeTwoAssets() {
     ext::shared_ptr<SimpleQuote> vol2(new SimpleQuote(0.0));
     ext::shared_ptr<BlackVolTermStructure> volTS2 = flatVol(today, vol2, dc);
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        Date exDate = today + timeToDays(values[i].t);
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise(new AmericanExercise(today, exDate));
 
-        spot1 ->setValue(values[i].s1);
-        spot2 ->setValue(values[i].s2);
-        qRate1->setValue(values[i].q1);
-        qRate2->setValue(values[i].q2);
-        rRate ->setValue(values[i].r );
-        vol1  ->setValue(values[i].v1);
-        vol2  ->setValue(values[i].v2);
+        spot1->setValue(value.s1);
+        spot2->setValue(value.s2);
+        qRate1->setValue(value.q1);
+        qRate2->setValue(value.q2);
+        rRate->setValue(value.r);
+        vol1->setValue(value.v1);
+        vol2->setValue(value.v2);
 
         ext::shared_ptr<BlackScholesMertonProcess> stochProcess1(new
             BlackScholesMertonProcess(Handle<Quote>(spot1),
@@ -568,32 +531,27 @@ void MargrabeOptionTest::testAmericanExchangeTwoAssets() {
         procs.push_back(stochProcess1);
         procs.push_back(stochProcess2);
 
-        Matrix correlationMatrix(2,2, values[i].rho);
+        Matrix correlationMatrix(2, 2, value.rho);
         for (Integer j=0; j < 2; j++) {
             correlationMatrix[j][j] = 1.0;
         }
 
         ext::shared_ptr<PricingEngine> engine(
-                             new AnalyticAmericanMargrabeEngine(stochProcess1,
-                                                                stochProcess2,
-                                                                values[i].rho));
+            new AnalyticAmericanMargrabeEngine(stochProcess1, stochProcess2, value.rho));
 
-        MargrabeOption margrabeOption(values[i].Q1, values[i].Q2, exercise);
+        MargrabeOption margrabeOption(value.Q1, value.Q2, exercise);
 
         // analytic engine
         margrabeOption.setPricingEngine(engine);
 
         Real calculated = margrabeOption.NPV();
-        Real expected = values[i].result;
+        Real expected = value.result;
         Real error = std::fabs(calculated-expected);
-        Real tolerance = values[i].tol;
+        Real tolerance = value.tol;
         if (error > tolerance) {
-            REPORT_FAILURE("value", exercise,
-                             values[i].s1, values[i].s2, values[i].Q1,
-                             values[i].Q2, values[i].q1, values[i].q2,
-                             values[i].r, today, values[i].v1,
-                             values[i].v2, values[i].rho, expected,
-                             calculated, error, tolerance);
+            REPORT_FAILURE("value", exercise, value.s1, value.s2, value.Q1, value.Q2, value.q1,
+                           value.q2, value.r, today, value.v1, value.v2, value.rho, expected,
+                           calculated, error, tolerance);
         }
     }
 }
diff --git a/test-suite/marketmodel.cpp b/test-suite/marketmodel.cpp
index 51b04e60371..ad7eae08bfe 100644
--- a/test-suite/marketmodel.cpp
+++ b/test-suite/marketmodel.cpp
@@ -476,8 +476,8 @@ namespace market_model_test {
 
             // size check
             Size nbOfResults = 0;
-            for (Size i=0; i<subProductExpectedValues.size(); ++i) {
-                for (Size j=0; j<subProductExpectedValues[i].values.size(); ++j)
+            for (const auto& subProductExpectedValue : subProductExpectedValues) {
+                for (Size j = 0; j < subProductExpectedValue.values.size(); ++j)
                     ++nbOfResults;
             }
 
@@ -494,10 +494,9 @@ namespace market_model_test {
                     Real minError = QL_MAX_REAL;
                     Real maxError = QL_MIN_REAL;
                     Real errorThreshold = subProductExpectedValue->errorThreshold;
-                    for (Size j=0; j<subProductExpectedValue->values.size(); ++j) {
+                    for (double value : subProductExpectedValue->values) {
                         Real stdDev =
-                            (results[currentResultIndex]-subProductExpectedValue->values[j])
-                            /errors[currentResultIndex];
+                            (results[currentResultIndex] - value) / errors[currentResultIndex];
                         stdDevs.push_back(stdDev);
                         maxError = std::max(maxError, stdDev);
                         minError = std::min(minError, stdDev);
@@ -746,60 +745,53 @@ void MarketModelTest::testOneStepForwardsAndOptionlets() {
         // CalibratedMM,
         ExponentialCorrelationFlatVolatility,
         ExponentialCorrelationAbcdVolatility };
-        for (Size j=0; j<LENGTH(marketModels); j++) {
+    for (auto& j : marketModels) {
 
-            // one step must be always full factors
-            Size testedFactors[] = { todaysForwards.size()};
-            for (Size m=0; m<LENGTH(testedFactors); ++m) {
-                Size factors = testedFactors[m];
+        // one step must be always full factors
+        Size testedFactors[] = {todaysForwards.size()};
+        for (unsigned long factors : testedFactors) {
+            // for one step product ProductSuggested is equal to Terminal
+            // for one step product MoneyMarketPlus is equal to Terminal
+            MeasureType measures[] = {MoneyMarket, Terminal};
+            for (auto& measure : measures) {
+                std::vector<Size> numeraires = makeMeasure(product, measure);
 
-                // for one step product ProductSuggested is equal to Terminal
-                // for one step product MoneyMarketPlus is equal to Terminal
-                MeasureType measures[] = { MoneyMarket,
-                    Terminal };
-                for (Size k=0; k<LENGTH(measures); k++) {
-                    std::vector<Size> numeraires = makeMeasure(product, measures[k]);
+                bool logNormal = true;
+                ext::shared_ptr<MarketModel> marketModel =
+                    makeMarketModel(logNormal, evolution, factors, j);
 
-                    bool logNormal = true;
-                    ext::shared_ptr<MarketModel> marketModel =
-                        makeMarketModel(logNormal, evolution, factors, marketModels[j]);
-
-                    EvolverType evolvers[] = { Pc,  Balland, Ipc};
-                    ext::shared_ptr<MarketModelEvolver> evolver;
-                    Size stop =
-                        isInTerminalMeasure(evolution, numeraires) ? 0 : 1;
-                    for (Size i=0; i<LENGTH(evolvers)-stop; i++) {
-
-                        for (Size n=0; n<1; n++) {
-                            MTBrownianGeneratorFactory generatorFactory(seed_);
-                            //SobolBrownianGeneratorFactory generatorFactory(
-                            //    SobolBrownianGenerator::Diagonal, seed_);
-
-                            evolver = makeMarketModelEvolver(marketModel,
-                                numeraires,
-                                generatorFactory,
-                                evolvers[i]);
-                            std::ostringstream config;
-                            config <<
-                                marketModelTypeToString(marketModels[j]) << ", " <<
-                                factors << (factors>1 ? (factors==todaysForwards.size() ? " (full) factors, " : " factors, ") : " factor,") <<
-                                measureTypeToString(measures[k]) << ", " <<
-                                evolverTypeToString(evolvers[i]) << ", " <<
-                                "MT BGF";
-                            if (printReport_)
-                                BOOST_TEST_MESSAGE("    " << config.str());
-
-                            ext::shared_ptr<SequenceStatisticsInc> stats =
-                                simulate(evolver, product);
-                            checkForwardsAndOptionlets(*stats,
-                                forwardStrikes,
-                                displacedPayoffs,
-                                config.str());
-                        }
+                EvolverType evolvers[] = {Pc, Balland, Ipc};
+                ext::shared_ptr<MarketModelEvolver> evolver;
+                Size stop = isInTerminalMeasure(evolution, numeraires) ? 0 : 1;
+                for (Size i = 0; i < LENGTH(evolvers) - stop; i++) {
+
+                    for (Size n = 0; n < 1; n++) {
+                        MTBrownianGeneratorFactory generatorFactory(seed_);
+                        // SobolBrownianGeneratorFactory generatorFactory(
+                        //    SobolBrownianGenerator::Diagonal, seed_);
+
+                        evolver = makeMarketModelEvolver(marketModel, numeraires, generatorFactory,
+                                                         evolvers[i]);
+                        std::ostringstream config;
+                        config << marketModelTypeToString(j) << ", " << factors
+                               << (factors > 1 ?
+                                       (factors == todaysForwards.size() ? " (full) factors, " :
+                                                                           " factors, ") :
+                                       " factor,")
+                               << measureTypeToString(measure) << ", "
+                               << evolverTypeToString(evolvers[i]) << ", "
+                               << "MT BGF";
+                        if (printReport_)
+                            BOOST_TEST_MESSAGE("    " << config.str());
+
+                        ext::shared_ptr<SequenceStatisticsInc> stats = simulate(evolver, product);
+                        checkForwardsAndOptionlets(*stats, forwardStrikes, displacedPayoffs,
+                                                   config.str());
                     }
                 }
             }
         }
+    }
 }
 
 void MarketModelTest::testOneStepNormalForwardsAndOptionlets() {
@@ -839,60 +831,53 @@ void MarketModelTest::testOneStepNormalForwardsAndOptionlets() {
         // CalibratedMM,
         ExponentialCorrelationFlatVolatility,
         ExponentialCorrelationAbcdVolatility };
-        for (Size j=0; j<LENGTH(marketModels); j++) {
+    for (auto& j : marketModels) {
+
+        // one step must be always full factors
+        Size testedFactors[] = {todaysForwards.size()};
+        for (unsigned long factors : testedFactors) {
+            // for one step product ProductSuggested is equal to Terminal
+            // for one step product MoneyMarketPlus is equal to Terminal
+            MeasureType measures[] = {MoneyMarket, Terminal};
+            for (auto& measure : measures) {
+                std::vector<Size> numeraires = makeMeasure(product, measure);
+
+                bool logNormal = false;
+                ext::shared_ptr<MarketModel> marketModel =
+                    makeMarketModel(logNormal, evolution, factors, j);
 
-            // one step must be always full factors
-            Size testedFactors[] = { todaysForwards.size()};
-            for (Size m=0; m<LENGTH(testedFactors); ++m) {
-                Size factors = testedFactors[m];
+                EvolverType evolvers[] = {NormalPc};
+                ext::shared_ptr<MarketModelEvolver> evolver;
+                Size stop = isInTerminalMeasure(evolution, numeraires) ? 0 : 1;
+                for (Size i = 0; i < LENGTH(evolvers) - stop; i++) {
 
-                // for one step product ProductSuggested is equal to Terminal
-                // for one step product MoneyMarketPlus is equal to Terminal
-                MeasureType measures[] = { MoneyMarket,
-                    Terminal };
-                for (Size k=0; k<LENGTH(measures); k++) {
-                    std::vector<Size> numeraires = makeMeasure(product, measures[k]);
+                    for (Size n = 0; n < 1; n++) {
+                        MTBrownianGeneratorFactory generatorFactory(seed_);
+                        // SobolBrownianGeneratorFactory generatorFactory(
+                        //    SobolBrownianGenerator::Diagonal, seed_);
 
-                    bool logNormal = false;
-                    ext::shared_ptr<MarketModel> marketModel =
-                        makeMarketModel(logNormal, evolution, factors, marketModels[j]);
-
-                    EvolverType evolvers[] = { NormalPc};
-                    ext::shared_ptr<MarketModelEvolver> evolver;
-                    Size stop =
-                        isInTerminalMeasure(evolution, numeraires) ? 0 : 1;
-                    for (Size i=0; i<LENGTH(evolvers)-stop; i++) {
-
-                        for (Size n=0; n<1; n++) {
-                            MTBrownianGeneratorFactory generatorFactory(seed_);
-                            //SobolBrownianGeneratorFactory generatorFactory(
-                            //    SobolBrownianGenerator::Diagonal, seed_);
-
-                            evolver = makeMarketModelEvolver(marketModel,
-                                numeraires,
-                                generatorFactory,
-                                evolvers[i]);
-                            std::ostringstream config;
-                            config <<
-                                marketModelTypeToString(marketModels[j]) << ", " <<
-                                factors << (factors>1 ? (factors==todaysForwards.size() ? " (full) factors, " : " factors, ") : " factor,") <<
-                                measureTypeToString(measures[k]) << ", " <<
-                                evolverTypeToString(evolvers[i]) << ", " <<
-                                "MT BGF";
-                            if (printReport_)
-                                BOOST_TEST_MESSAGE("    " << config.str());
-
-                            ext::shared_ptr<SequenceStatisticsInc> stats =
-                                simulate(evolver, product);
-                            checkNormalForwardsAndOptionlets(*stats,
-                                forwardStrikes,
-                                displacedPayoffs,
-                                config.str());
-                        }
+                        evolver = makeMarketModelEvolver(marketModel, numeraires, generatorFactory,
+                                                         evolvers[i]);
+                        std::ostringstream config;
+                        config << marketModelTypeToString(j) << ", " << factors
+                               << (factors > 1 ?
+                                       (factors == todaysForwards.size() ? " (full) factors, " :
+                                                                           " factors, ") :
+                                       " factor,")
+                               << measureTypeToString(measure) << ", "
+                               << evolverTypeToString(evolvers[i]) << ", "
+                               << "MT BGF";
+                        if (printReport_)
+                            BOOST_TEST_MESSAGE("    " << config.str());
+
+                        ext::shared_ptr<SequenceStatisticsInc> stats = simulate(evolver, product);
+                        checkNormalForwardsAndOptionlets(*stats, forwardStrikes, displacedPayoffs,
+                                                         config.str());
                     }
                 }
             }
         }
+    }
 }
 
 void MarketModelTest::testInverseFloater() 
@@ -952,94 +937,84 @@ void MarketModelTest::testInverseFloater()
         // CalibratedMM,
         ExponentialCorrelationFlatVolatility,
         ExponentialCorrelationAbcdVolatility };
-        for (Size j=0; j<LENGTH(marketModels); j++)
-        {
+    for (auto& j : marketModels) {
 
-            Size testedFactors[] = { std::min<Size>(todaysForwards.size(),3)};
-            for (Size m=0; m<LENGTH(testedFactors); ++m) 
-            {
-                Size factors = testedFactors[m];
+        Size testedFactors[] = {std::min<Size>(todaysForwards.size(), 3)};
+        for (unsigned long factors : testedFactors) {
+            MeasureType measures[] = {MoneyMarket};
+            for (auto& measure : measures) {
+                std::vector<Size> numeraires = makeMeasure(product, measure);
 
-                MeasureType measures[] = { MoneyMarket};
-                for (Size k=0; k<LENGTH(measures); k++) 
-                {
-                    std::vector<Size> numeraires = makeMeasure(product, measures[k]);
+                bool logNormal = false;
+                ext::shared_ptr<MarketModel> marketModel =
+                    makeMarketModel(logNormal, evolution, factors, j);
 
-                    bool logNormal = false;
-                    ext::shared_ptr<MarketModel> marketModel =
-                        makeMarketModel(logNormal, evolution, factors, marketModels[j]);
+                EvolverType evolvers[] = {Pc};
+                ext::shared_ptr<MarketModelEvolver> evolver;
 
-                    EvolverType evolvers[] = {Pc};
-                    ext::shared_ptr<MarketModelEvolver> evolver;
-        
-                    for (Size i=0; i<LENGTH(evolvers); i++)
-                    {
+                for (auto& i : evolvers) {
 
-                      
-                            MTBrownianGeneratorFactory generatorFactory(seed_);
-                            //SobolBrownianGeneratorFactory generatorFactory(
-                            //    SobolBrownianGenerator::Diagonal, seed_);
-
-                            evolver = makeMarketModelEvolver(marketModel,
-                                numeraires,
-                                generatorFactory,
-                                evolvers[i]);
-                            std::ostringstream config;
-                            config <<
-                                marketModelTypeToString(marketModels[j]) << ", " <<
-                                factors << (factors>1 ? (factors==todaysForwards.size() ? " (full) factors, " : " factors, ") : " factor,") <<
-                                measureTypeToString(measures[k]) << ", " <<
-                                evolverTypeToString(evolvers[i]) << ", " <<
-                                "MT BGF";
-                            if (printReport_)
-                                BOOST_TEST_MESSAGE("    " << config.str());
-
-                            ext::shared_ptr<SequenceStatisticsInc> stats =
-                                simulate(evolver, productComposite);
-
-                            std::vector<Real> modelVolatilities(accruals.size());
-                            for (Size i=0; i <  accruals.size(); ++i)
-                                    modelVolatilities[i] = sqrt(marketModel->totalCovariance(i)[i][i]);
-                           
-
-
-                             Real truePrice =0.0;
-
-                             for (Size i=0; i < accruals.size(); ++i)
-                             {
-                                        Real floatingCouponPV = floatingAccruals[i] *(todaysForwards[i]+floatingSpreads[i])*todaysDiscounts[i+1];
-                                        Real inverseCouponPV =  2*fixedAccruals[i] *todaysDiscounts[i+1]* blackFormula(Option::Put,
-                                        fixedStrikes[i]/2.0,
-                                        todaysForwards[i],
-                                        modelVolatilities[i]);
-
-                                        truePrice += floatingCouponPV - inverseCouponPV;
-                              }
-
-                                           
-    
 
+                    MTBrownianGeneratorFactory generatorFactory(seed_);
+                    // SobolBrownianGeneratorFactory generatorFactory(
+                    //    SobolBrownianGenerator::Diagonal, seed_);
+
+                    evolver = makeMarketModelEvolver(marketModel, numeraires, generatorFactory, i);
+                    std::ostringstream config;
+                    config << marketModelTypeToString(j) << ", " << factors
+                           << (factors > 1 ?
+                                   (factors == todaysForwards.size() ? " (full) factors, " :
+                                                                       " factors, ") :
+                                   " factor,")
+                           << measureTypeToString(measure) << ", " << evolverTypeToString(i) << ", "
+                           << "MT BGF";
+                    if (printReport_)
+                        BOOST_TEST_MESSAGE("    " << config.str());
+
+                    ext::shared_ptr<SequenceStatisticsInc> stats =
+                        simulate(evolver, productComposite);
+
+                    std::vector<Real> modelVolatilities(accruals.size());
+                    for (Size i = 0; i < accruals.size(); ++i)
+                        modelVolatilities[i] = sqrt(marketModel->totalCovariance(i)[i][i]);
 
-                            Real priceError = stats->mean()[0] - truePrice;
-                            Real priceSD = stats->errorEstimate()[0];
 
-                            Real errorInSds = priceError/priceSD;
-                            if (fabs(errorInSds) > 4.0)
-                                BOOST_FAIL("Inverse floater product has price error equal to " <<errorInSds << " sds . Price " <<truePrice << " MC price " << stats->mean()[0] <<  " \n" );
+                    Real truePrice = 0.0;
 
-                            Real numericalTolerance = 1E-12;
+                    for (Size i = 0; i < accruals.size(); ++i) {
+                        Real floatingCouponPV = floatingAccruals[i] *
+                                                (todaysForwards[i] + floatingSpreads[i]) *
+                                                todaysDiscounts[i + 1];
+                        Real inverseCouponPV =
+                            2 * fixedAccruals[i] * todaysDiscounts[i + 1] *
+                            blackFormula(Option::Put, fixedStrikes[i] / 2.0, todaysForwards[i],
+                                         modelVolatilities[i]);
 
-                            if (fabs(stats->mean()[0] - stats->mean()[1]) > numericalTolerance)
-                                BOOST_FAIL("Inverse floater and wrapper pathwise inverse floater do not agree:" << stats->mean()[0]  << "  " << stats->mean()[1] );
-                       
+                        truePrice += floatingCouponPV - inverseCouponPV;
+                    }
 
 
+                    Real priceError = stats->mean()[0] - truePrice;
+                    Real priceSD = stats->errorEstimate()[0];
 
-                        
-                    } // evolvers
-                } // measures
-            } // factors 
-        }
+                    Real errorInSds = priceError / priceSD;
+                    if (fabs(errorInSds) > 4.0)
+                        BOOST_FAIL("Inverse floater product has price error equal to "
+                                   << errorInSds << " sds . Price " << truePrice << " MC price "
+                                   << stats->mean()[0] << " \n");
+
+                    Real numericalTolerance = 1E-12;
+
+                    if (fabs(stats->mean()[0] - stats->mean()[1]) > numericalTolerance)
+                        BOOST_FAIL(
+                            "Inverse floater and wrapper pathwise inverse floater do not agree:"
+                            << stats->mean()[0] << "  " << stats->mean()[1]);
+
+
+                } // evolvers
+            }     // measures
+        }         // factors
+    }
 }
 
 void testMultiProductComposite(const MarketModelMultiProduct& product,
@@ -1061,61 +1036,70 @@ void testMultiProductComposite(const MarketModelMultiProduct& product,
                                        // CalibratedMM,
                                            MarketModelTest::ExponentialCorrelationFlatVolatility,
                                            MarketModelTest::ExponentialCorrelationAbcdVolatility };
-                                       for (Size j=0; j<LENGTH(marketModels); j++) {
-
-                                           Size testedFactors[] = { 4, 8,
-                                               todaysForwards.size()};
-                                           for (Size m=0; m<LENGTH(testedFactors); ++m) {
-                                               Size factors = testedFactors[m];
-
-                                               // Composite's ProductSuggested is the Terminal one
-                                               MeasureType measures[] = { // ProductSuggested,
-                                                   Terminal,
-                                                   MoneyMarketPlus,
-                                                   MoneyMarket};
-                                                   for (Size k=0; k<LENGTH(measures); k++) {
-                                                       std::vector<Size> numeraires = makeMeasure(product, measures[k]);
-
-                                                       bool logNormal = true;
-                                                       ext::shared_ptr<MarketModel> marketModel =
-                                                           makeMarketModel(logNormal, evolution, factors, marketModels[j]);
-
-
-                                                       EvolverType evolvers[] = { Pc, Balland, Ipc };
-                                                       ext::shared_ptr<MarketModelEvolver> evolver;
-                                                       Size stop =
-                                                           isInTerminalMeasure(evolution, numeraires) ? 0 : 1;
-                                                       for (Size i=0; i<LENGTH(evolvers)-stop; i++) {
-
-                                                           for (Size n=0; n<1; n++) {
-                                                               //MTBrownianGeneratorFactory generatorFactory(seed_);
-                                                               SobolBrownianGeneratorFactory generatorFactory(
-                                                                   SobolBrownianGenerator::Diagonal, seed_);
-
-                                                               evolver = makeMarketModelEvolver(marketModel,
-                                                                   numeraires,
-                                                                   generatorFactory,
-                                                                   evolvers[i]);
-                                                               std::ostringstream config;
-                                                               config <<
-                                                                   marketModelTypeToString(marketModels[j]) << ", " <<
-                                                                   factors << (factors>1 ? (factors==todaysForwards.size() ? " (full) factors, " : " factors, ") : " factor,") <<
-                                                                   measureTypeToString(measures[k]) << ", " <<
-                                                                   evolverTypeToString(evolvers[i]) << ", " <<
-                                                                   "MT BGF";
-                                                               if (printReport_)
-                                                                   BOOST_TEST_MESSAGE("    " << config.str());
-
-                                                               ext::shared_ptr<SequenceStatisticsInc> stats =
-                                                                   simulate(evolver, product);
-                                                               checkMultiProductCompositeResults(*stats,
-                                                                   subProductExpectedValues,
-                                                                   config.str());
-                                                           }
-                                                       }
+                                   for (auto& j : marketModels) {
+
+                                       Size testedFactors[] = {4, 8, todaysForwards.size()};
+                                       for (unsigned long factors : testedFactors) {
+                                           // Composite's ProductSuggested is the Terminal one
+                                           MeasureType measures[] = {// ProductSuggested,
+                                                                     Terminal, MoneyMarketPlus,
+                                                                     MoneyMarket};
+                                           for (auto& measure : measures) {
+                                               std::vector<Size> numeraires =
+                                                   makeMeasure(product, measure);
+
+                                               bool logNormal = true;
+                                               ext::shared_ptr<MarketModel> marketModel =
+                                                   makeMarketModel(logNormal, evolution, factors,
+                                                                   j);
+
+
+                                               EvolverType evolvers[] = {Pc, Balland, Ipc};
+                                               ext::shared_ptr<MarketModelEvolver> evolver;
+                                               Size stop =
+                                                   isInTerminalMeasure(evolution, numeraires) ? 0 :
+                                                                                                1;
+                                               for (Size i = 0; i < LENGTH(evolvers) - stop; i++) {
+
+                                                   for (Size n = 0; n < 1; n++) {
+                                                       // MTBrownianGeneratorFactory
+                                                       // generatorFactory(seed_);
+                                                       SobolBrownianGeneratorFactory
+                                                           generatorFactory(
+                                                               SobolBrownianGenerator::Diagonal,
+                                                               seed_);
+
+                                                       evolver = makeMarketModelEvolver(
+                                                           marketModel, numeraires,
+                                                           generatorFactory, evolvers[i]);
+                                                       std::ostringstream config;
+                                                       config
+                                                           << marketModelTypeToString(j) << ", "
+                                                           << factors
+                                                           << (factors > 1 ?
+                                                                   (factors ==
+                                                                            todaysForwards.size() ?
+                                                                        " (full) factors, " :
+                                                                        " factors, ") :
+                                                                   " factor,")
+                                                           << measureTypeToString(measure) << ", "
+                                                           << evolverTypeToString(evolvers[i])
+                                                           << ", "
+                                                           << "MT BGF";
+                                                       if (printReport_)
+                                                           BOOST_TEST_MESSAGE("    "
+                                                                              << config.str());
+
+                                                       ext::shared_ptr<SequenceStatisticsInc>
+                                                           stats = simulate(evolver, product);
+                                                       checkMultiProductCompositeResults(
+                                                           *stats, subProductExpectedValues,
+                                                           config.str());
                                                    }
+                                               }
                                            }
                                        }
+                                   }
 }
 
 void addForwards(MultiProductComposite& product,
@@ -1484,129 +1468,113 @@ void MarketModelTest::testCallableSwapNaif() {
         // CalibratedMM,
         ExponentialCorrelationFlatVolatility,
         ExponentialCorrelationAbcdVolatility };
-        for (Size j=0; j<LENGTH(marketModels); j++) {
-
-            Size testedFactors[] = { 4, // 8,
-                todaysForwards.size()};
-            for (Size m=0; m<LENGTH(testedFactors); ++m) {
-                Size factors = testedFactors[m];
-
-                // Composite's ProductSuggested is the Terminal one
-                MeasureType measures[] = { // ProductSuggested,
-                    MoneyMarketPlus
-                    // MoneyMarket,
-                    // Terminal
-                };
-                for (Size k=0; k<LENGTH(measures); k++) {
-                    std::vector<Size> numeraires = makeMeasure(dummyProduct, measures[k]);
+    for (auto& j : marketModels) {
 
-                    bool logNormal = true;
-                    ext::shared_ptr<MarketModel> marketModel =
-                        makeMarketModel(logNormal, evolution, factors, marketModels[j]);
-
-
-                    EvolverType evolvers[] = { Pc, Balland, Ipc };
-                    ext::shared_ptr<MarketModelEvolver> evolver;
-                    Size stop =
-                        isInTerminalMeasure(evolution, numeraires) ? 0 : 1;
-                    for (Size i=0; i<LENGTH(evolvers)-stop; i++) {
-
-                        for (Size n=0; n<1; n++) {
-                            //MTBrownianGeneratorFactory generatorFactory(seed_);
-                            SobolBrownianGeneratorFactory generatorFactory(
-                                SobolBrownianGenerator::Diagonal, seed_);
-
-                            evolver = makeMarketModelEvolver(marketModel,
-                                numeraires,
-                                generatorFactory,
-                                evolvers[i]);
-                            std::ostringstream config;
-                            config <<
-                                marketModelTypeToString(marketModels[j]) << ", " <<
-                                factors << (factors>1 ? (factors==todaysForwards.size() ? " (full) factors, " : " factors, ") : " factor,") <<
-                                measureTypeToString(measures[k]) << ", " <<
-                                evolverTypeToString(evolvers[i]) << ", " <<
-                                "MT BGF";
-                            if (printReport_)
-                                BOOST_TEST_MESSAGE("    " << config.str());
-
-                            // use the naif strategy
-
-                            // 2. bermudan swaption to enter into the payer swap
-                            CallSpecifiedMultiProduct bermudanProduct =
-                                CallSpecifiedMultiProduct(
-                                MultiStepNothing(evolution),
-                                naifStrategy, payerSwap);
-
-                            // 3. callable receiver swap
-                            CallSpecifiedMultiProduct callableProduct =
-                                CallSpecifiedMultiProduct(
-                                receiverSwap, naifStrategy,
-                                ExerciseAdapter(nullRebate));
-
-                            // lower bound: evolve all 4 products togheter
-                            MultiProductComposite allProducts;
-                            allProducts.add(payerSwap);
-                            allProducts.add(receiverSwap);
-                            allProducts.add(bermudanProduct);
-                            allProducts.add(callableProduct);
-                            allProducts.finalize();
-
-                            ext::shared_ptr<SequenceStatisticsInc> stats =
-                                simulate(evolver, allProducts);
-                            checkCallableSwap(*stats, config.str());
-
-
-                            // upper bound
-
-                            //MTBrownianGeneratorFactory uFactory(seed_+142);
-                            SobolBrownianGeneratorFactory uFactory(
-                                SobolBrownianGenerator::Diagonal, seed_+142);
-                            evolver = makeMarketModelEvolver(marketModel,
-                                numeraires,
-                                uFactory,
-                                evolvers[i]);
-
-                            std::vector<ext::shared_ptr<MarketModelEvolver> >
-                                innerEvolvers;
-
-                            std::valarray<bool> isExerciseTime =
-                                isInSubset(evolution.evolutionTimes(),
-                                           naifStrategy.exerciseTimes());
-                            for (Size s=0; s < isExerciseTime.size(); ++s) {
-                                if (isExerciseTime[s]) {
-                                    MTBrownianGeneratorFactory iFactory(seed_+s);
-                                    ext::shared_ptr<MarketModelEvolver> e =
-                                        makeMarketModelEvolver(marketModel,
-                                        numeraires,
-                                        iFactory,
-                                        evolvers[i],
-                                        s);
-                                    innerEvolvers.push_back(e);
-                                }
-                            }
+        Size testedFactors[] = {4, // 8,
+                                todaysForwards.size()};
+        for (unsigned long factors : testedFactors) {
+            // Composite's ProductSuggested is the Terminal one
+            MeasureType measures[] = {
+                // ProductSuggested,
+                MoneyMarketPlus
+                // MoneyMarket,
+                // Terminal
+            };
+            for (auto& measure : measures) {
+                std::vector<Size> numeraires = makeMeasure(dummyProduct, measure);
 
-                            Size initialNumeraire = evolver->numeraires().front();
-                            Real initialNumeraireValue =
-                                todaysDiscounts[initialNumeraire];
+                bool logNormal = true;
+                ext::shared_ptr<MarketModel> marketModel =
+                    makeMarketModel(logNormal, evolution, factors, j);
 
-                            UpperBoundEngine uEngine(evolver, innerEvolvers,
-                                receiverSwap, nullRebate,
-                                receiverSwap, nullRebate,
-                                naifStrategy,
-                                initialNumeraireValue);
-                            Statistics uStats;
-                            uEngine.multiplePathValues(uStats,255,256);
-                            Real delta = uStats.mean();
-                            Real deltaError = uStats.errorEstimate();
-                            if (printReport_)
-                                BOOST_TEST_MESSAGE("    upper bound delta: " << io::rate(delta) << " +- " << io::rate(deltaError));
 
+                EvolverType evolvers[] = {Pc, Balland, Ipc};
+                ext::shared_ptr<MarketModelEvolver> evolver;
+                Size stop = isInTerminalMeasure(evolution, numeraires) ? 0 : 1;
+                for (Size i = 0; i < LENGTH(evolvers) - stop; i++) {
+
+                    for (Size n = 0; n < 1; n++) {
+                        // MTBrownianGeneratorFactory generatorFactory(seed_);
+                        SobolBrownianGeneratorFactory generatorFactory(
+                            SobolBrownianGenerator::Diagonal, seed_);
+
+                        evolver = makeMarketModelEvolver(marketModel, numeraires, generatorFactory,
+                                                         evolvers[i]);
+                        std::ostringstream config;
+                        config << marketModelTypeToString(j) << ", " << factors
+                               << (factors > 1 ?
+                                       (factors == todaysForwards.size() ? " (full) factors, " :
+                                                                           " factors, ") :
+                                       " factor,")
+                               << measureTypeToString(measure) << ", "
+                               << evolverTypeToString(evolvers[i]) << ", "
+                               << "MT BGF";
+                        if (printReport_)
+                            BOOST_TEST_MESSAGE("    " << config.str());
+
+                        // use the naif strategy
+
+                        // 2. bermudan swaption to enter into the payer swap
+                        CallSpecifiedMultiProduct bermudanProduct = CallSpecifiedMultiProduct(
+                            MultiStepNothing(evolution), naifStrategy, payerSwap);
+
+                        // 3. callable receiver swap
+                        CallSpecifiedMultiProduct callableProduct = CallSpecifiedMultiProduct(
+                            receiverSwap, naifStrategy, ExerciseAdapter(nullRebate));
+
+                        // lower bound: evolve all 4 products togheter
+                        MultiProductComposite allProducts;
+                        allProducts.add(payerSwap);
+                        allProducts.add(receiverSwap);
+                        allProducts.add(bermudanProduct);
+                        allProducts.add(callableProduct);
+                        allProducts.finalize();
+
+                        ext::shared_ptr<SequenceStatisticsInc> stats =
+                            simulate(evolver, allProducts);
+                        checkCallableSwap(*stats, config.str());
+
+
+                        // upper bound
+
+                        // MTBrownianGeneratorFactory uFactory(seed_+142);
+                        SobolBrownianGeneratorFactory uFactory(SobolBrownianGenerator::Diagonal,
+                                                               seed_ + 142);
+                        evolver =
+                            makeMarketModelEvolver(marketModel, numeraires, uFactory, evolvers[i]);
+
+                        std::vector<ext::shared_ptr<MarketModelEvolver> > innerEvolvers;
+
+                        std::valarray<bool> isExerciseTime =
+                            isInSubset(evolution.evolutionTimes(), naifStrategy.exerciseTimes());
+                        for (Size s = 0; s < isExerciseTime.size(); ++s) {
+                            if (isExerciseTime[s]) {
+                                MTBrownianGeneratorFactory iFactory(seed_ + s);
+                                ext::shared_ptr<MarketModelEvolver> e = makeMarketModelEvolver(
+                                    marketModel, numeraires, iFactory, evolvers[i], s);
+                                innerEvolvers.push_back(e);
+                            }
                         }
+
+                        Size initialNumeraire = evolver->numeraires().front();
+                        Real initialNumeraireValue = todaysDiscounts[initialNumeraire];
+
+                        UpperBoundEngine uEngine(evolver, innerEvolvers, receiverSwap, nullRebate,
+                                                 receiverSwap, nullRebate, naifStrategy,
+                                                 initialNumeraireValue);
+                        Statistics uStats;
+                        uEngine.multiplePathValues(uStats, 255, 256);
+                        Real delta = uStats.mean();
+                        Real deltaError = uStats.errorEstimate();
+                        if (printReport_)
+                            BOOST_TEST_MESSAGE("    upper bound delta: " << io::rate(delta)
+                                                                         << " +- "
+                                                                         << io::rate(deltaError));
                     }
                 }
             }
         }
+    }
 }
 
 void MarketModelTest::testCallableSwapLS() {
@@ -1655,138 +1623,119 @@ void MarketModelTest::testCallableSwapLS() {
         // CalibratedMM,
         ExponentialCorrelationFlatVolatility,
         ExponentialCorrelationAbcdVolatility };
-        for (Size j=0; j<LENGTH(marketModels); j++) {
-
-            Size testedFactors[] = { 4, // 8,
-                todaysForwards.size()};
-            for (Size m=0; m<LENGTH(testedFactors); ++m) {
-                Size factors = testedFactors[m];
-
-                // Composite's ProductSuggested is the Terminal one
-                MeasureType measures[] = { // ProductSuggested,
-                    // MoneyMarketPlus,
-                    MoneyMarket
-                    //Terminal
-                };
-                for (Size k=0; k<LENGTH(measures); k++) {
-                    std::vector<Size> numeraires = makeMeasure(dummyProduct, measures[k]);
+    for (auto& j : marketModels) {
 
-                    bool logNormal = true;
-                    ext::shared_ptr<MarketModel> marketModel =
-                        makeMarketModel(logNormal, evolution, factors, marketModels[j]);
-
-
-                    EvolverType evolvers[] = { Pc, Balland, Ipc };
-                    ext::shared_ptr<MarketModelEvolver> evolver;
-                    Size stop =
-                        isInTerminalMeasure(evolution, numeraires) ? 0 : 1;
-                    for (Size i=0; i<LENGTH(evolvers)-stop; i++) {
-
-                        for (Size n=0; n<1; n++) {
-                            //MTBrownianGeneratorFactory generatorFactory(seed_);
-                            SobolBrownianGeneratorFactory generatorFactory(
-                                SobolBrownianGenerator::Diagonal, seed_);
-
-                            evolver = makeMarketModelEvolver(marketModel,
-                                numeraires,
-                                generatorFactory,
-                                evolvers[i]);
-                            std::ostringstream config;
-                            config <<
-                                marketModelTypeToString(marketModels[j]) << ", " <<
-                                factors << (factors>1 ? (factors==todaysForwards.size() ? " (full) factors, " : " factors, ") : " factor,") <<
-                                measureTypeToString(measures[k]) << ", " <<
-                                evolverTypeToString(evolvers[i]) << ", " <<
-                                "MT BGF";
-                            if (printReport_)
-                                BOOST_TEST_MESSAGE("    " << config.str());
-
-                            // calculate the exercise strategy
-                            collectNodeData(*evolver,
-                                receiverSwap, basisSystem, nullRebate,
-                                control, trainingPaths_, collectedData);
-                            genericLongstaffSchwartzRegression(collectedData,
-                                basisCoefficients);
-                            LongstaffSchwartzExerciseStrategy exerciseStrategy(
-                                basisSystem, basisCoefficients,
-                                evolution, numeraires,
-                                nullRebate, control);
-
-                            // 2. bermudan swaption to enter into the payer swap
-                            CallSpecifiedMultiProduct bermudanProduct =
-                                CallSpecifiedMultiProduct(
-                                MultiStepNothing(evolution),
-                                exerciseStrategy, payerSwap);
-
-                            // 3. callable receiver swap
-                            CallSpecifiedMultiProduct callableProduct =
-                                CallSpecifiedMultiProduct(
-                                receiverSwap, exerciseStrategy,
-                                ExerciseAdapter(nullRebate));
-
-                            // lower bound: evolve all 4 products togheter
-                            MultiProductComposite allProducts;
-                            allProducts.add(payerSwap);
-                            allProducts.add(receiverSwap);
-                            allProducts.add(bermudanProduct);
-                            allProducts.add(callableProduct);
-                            allProducts.finalize();
-
-                            ext::shared_ptr<SequenceStatisticsInc> stats =
-                                simulate(evolver, allProducts);
-                            checkCallableSwap(*stats, config.str());
-
-
-                            // upper bound
-
-                            //MTBrownianGeneratorFactory uFactory(seed_+142);
-                            SobolBrownianGeneratorFactory uFactory(
-                                SobolBrownianGenerator::Diagonal, seed_+142);
-                            evolver = makeMarketModelEvolver(marketModel,
-                                numeraires,
-                                uFactory,
-                                evolvers[i]);
-
-                            std::vector<ext::shared_ptr<MarketModelEvolver> >
-                                innerEvolvers;
-
-                            std::valarray<bool> isExerciseTime =
-                                isInSubset(evolution.evolutionTimes(),
-                                           exerciseStrategy.exerciseTimes());
-                            for (Size s=0; s < isExerciseTime.size(); ++s) {
-                                if (isExerciseTime[s]) {
-                                    MTBrownianGeneratorFactory iFactory(seed_+s);
-                                    ext::shared_ptr<MarketModelEvolver> e =
-                                        makeMarketModelEvolver(marketModel,
-                                        numeraires,
-                                        iFactory,
-                                        evolvers[i],
-                                        s);
-                                    innerEvolvers.push_back(e);
-                                }
-                            }
+        Size testedFactors[] = {4, // 8,
+                                todaysForwards.size()};
+        for (unsigned long factors : testedFactors) {
+            // Composite's ProductSuggested is the Terminal one
+            MeasureType measures[] = {
+                // ProductSuggested,
+                // MoneyMarketPlus,
+                MoneyMarket
+                // Terminal
+            };
+            for (auto& measure : measures) {
+                std::vector<Size> numeraires = makeMeasure(dummyProduct, measure);
 
-                            Size initialNumeraire = evolver->numeraires().front();
-                            Real initialNumeraireValue =
-                                todaysDiscounts[initialNumeraire];
+                bool logNormal = true;
+                ext::shared_ptr<MarketModel> marketModel =
+                    makeMarketModel(logNormal, evolution, factors, j);
 
-                            UpperBoundEngine uEngine(evolver, innerEvolvers,
-                                receiverSwap, nullRebate,
-                                receiverSwap, nullRebate,
-                                exerciseStrategy,
-                                initialNumeraireValue);
-                            Statistics uStats;
-                            uEngine.multiplePathValues(uStats,255,256);
-                            Real delta = uStats.mean();
-                            Real deltaError = uStats.errorEstimate();
-                            if (printReport_)
-                                BOOST_TEST_MESSAGE("    upper bound delta: " << io::rate(delta) << " +- " << io::rate(deltaError));
 
+                EvolverType evolvers[] = {Pc, Balland, Ipc};
+                ext::shared_ptr<MarketModelEvolver> evolver;
+                Size stop = isInTerminalMeasure(evolution, numeraires) ? 0 : 1;
+                for (Size i = 0; i < LENGTH(evolvers) - stop; i++) {
+
+                    for (Size n = 0; n < 1; n++) {
+                        // MTBrownianGeneratorFactory generatorFactory(seed_);
+                        SobolBrownianGeneratorFactory generatorFactory(
+                            SobolBrownianGenerator::Diagonal, seed_);
+
+                        evolver = makeMarketModelEvolver(marketModel, numeraires, generatorFactory,
+                                                         evolvers[i]);
+                        std::ostringstream config;
+                        config << marketModelTypeToString(j) << ", " << factors
+                               << (factors > 1 ?
+                                       (factors == todaysForwards.size() ? " (full) factors, " :
+                                                                           " factors, ") :
+                                       " factor,")
+                               << measureTypeToString(measure) << ", "
+                               << evolverTypeToString(evolvers[i]) << ", "
+                               << "MT BGF";
+                        if (printReport_)
+                            BOOST_TEST_MESSAGE("    " << config.str());
+
+                        // calculate the exercise strategy
+                        collectNodeData(*evolver, receiverSwap, basisSystem, nullRebate, control,
+                                        trainingPaths_, collectedData);
+                        genericLongstaffSchwartzRegression(collectedData, basisCoefficients);
+                        LongstaffSchwartzExerciseStrategy exerciseStrategy(
+                            basisSystem, basisCoefficients, evolution, numeraires, nullRebate,
+                            control);
+
+                        // 2. bermudan swaption to enter into the payer swap
+                        CallSpecifiedMultiProduct bermudanProduct = CallSpecifiedMultiProduct(
+                            MultiStepNothing(evolution), exerciseStrategy, payerSwap);
+
+                        // 3. callable receiver swap
+                        CallSpecifiedMultiProduct callableProduct = CallSpecifiedMultiProduct(
+                            receiverSwap, exerciseStrategy, ExerciseAdapter(nullRebate));
+
+                        // lower bound: evolve all 4 products togheter
+                        MultiProductComposite allProducts;
+                        allProducts.add(payerSwap);
+                        allProducts.add(receiverSwap);
+                        allProducts.add(bermudanProduct);
+                        allProducts.add(callableProduct);
+                        allProducts.finalize();
+
+                        ext::shared_ptr<SequenceStatisticsInc> stats =
+                            simulate(evolver, allProducts);
+                        checkCallableSwap(*stats, config.str());
+
+
+                        // upper bound
+
+                        // MTBrownianGeneratorFactory uFactory(seed_+142);
+                        SobolBrownianGeneratorFactory uFactory(SobolBrownianGenerator::Diagonal,
+                                                               seed_ + 142);
+                        evolver =
+                            makeMarketModelEvolver(marketModel, numeraires, uFactory, evolvers[i]);
+
+                        std::vector<ext::shared_ptr<MarketModelEvolver> > innerEvolvers;
+
+                        std::valarray<bool> isExerciseTime = isInSubset(
+                            evolution.evolutionTimes(), exerciseStrategy.exerciseTimes());
+                        for (Size s = 0; s < isExerciseTime.size(); ++s) {
+                            if (isExerciseTime[s]) {
+                                MTBrownianGeneratorFactory iFactory(seed_ + s);
+                                ext::shared_ptr<MarketModelEvolver> e = makeMarketModelEvolver(
+                                    marketModel, numeraires, iFactory, evolvers[i], s);
+                                innerEvolvers.push_back(e);
+                            }
                         }
+
+                        Size initialNumeraire = evolver->numeraires().front();
+                        Real initialNumeraireValue = todaysDiscounts[initialNumeraire];
+
+                        UpperBoundEngine uEngine(evolver, innerEvolvers, receiverSwap, nullRebate,
+                                                 receiverSwap, nullRebate, exerciseStrategy,
+                                                 initialNumeraireValue);
+                        Statistics uStats;
+                        uEngine.multiplePathValues(uStats, 255, 256);
+                        Real delta = uStats.mean();
+                        Real deltaError = uStats.errorEstimate();
+                        if (printReport_)
+                            BOOST_TEST_MESSAGE("    upper bound delta: " << io::rate(delta)
+                                                                         << " +- "
+                                                                         << io::rate(deltaError));
                     }
                 }
             }
         }
+    }
 }
 
 void MarketModelTest::testCallableSwapAnderson(
@@ -1845,8 +1794,8 @@ void MarketModelTest::testCallableSwapAnderson(
         // MoneyMarket,
         Terminal
     };
-    for (Size k=0; k<LENGTH(measures); k++) {
-        std::vector<Size> numeraires = makeMeasure(dummyProduct, measures[k]);
+    for (auto& measure : measures) {
+        std::vector<Size> numeraires = makeMeasure(dummyProduct, measure);
         bool logNormal = true;
         ext::shared_ptr<MarketModel> marketModel =
             makeMarketModel(logNormal, evolution, factors, marketModelType);
@@ -1864,12 +1813,13 @@ void MarketModelTest::testCallableSwapAnderson(
                     generatorFactory,
                     evolvers[i]);
                 std::ostringstream config;
-                config <<
-                    marketModelTypeToString(marketModelType) << ", " <<
-                    factors << (factors>1 ? (factors==todaysForwards.size() ? " (full) factors, " : " factors, ") : " factor,") <<
-                    measureTypeToString(measures[k]) << ", " <<
-                    evolverTypeToString(evolvers[i]) << ", " <<
-                    "MT BGF";
+                config << marketModelTypeToString(marketModelType) << ", " << factors
+                       << (factors > 1 ? (factors == todaysForwards.size() ? " (full) factors, " :
+                                                                             " factors, ") :
+                                         " factor,")
+                       << measureTypeToString(measure) << ", " << evolverTypeToString(evolvers[i])
+                       << ", "
+                       << "MT BGF";
                 if (printReport_)
                     BOOST_TEST_MESSAGE("    " << config.str());
                 // 1. calculate the exercise strategy
@@ -1982,213 +1932,188 @@ void MarketModelTest::testGreeks() {
         // CalibratedMM,
         // ExponentialCorrelationFlatVolatility,
         ExponentialCorrelationAbcdVolatility };
-        for (Size j=0; j<LENGTH(marketModels); j++) {
-
-            Size testedFactors[] = { 4, 8, todaysForwards.size() };
-            for (Size m=0; m<LENGTH(testedFactors); ++m) {
-                Size factors = testedFactors[m];
-
-                MeasureType measures[] = { //MoneyMarketPlus,
-                    MoneyMarket//,
-                    //Terminal
-                };
-                for (Size k=0; k<LENGTH(measures); k++) {
-                    std::vector<Size> numeraires = makeMeasure(product, measures[k]);
+    for (auto& j : marketModels) {
 
-                    for (Size n=0; n<1; n++) {
-                        //MTBrownianGeneratorFactory generatorFactory(seed_);
-                        SobolBrownianGeneratorFactory generatorFactory(
-                            SobolBrownianGenerator::Diagonal,
-                            seed_);
-
-                        bool logNormal = true;
-                        ext::shared_ptr<MarketModel> marketModel =
-                            makeMarketModel(logNormal, evolution, factors,
-                            marketModels[j]);
-
-                        ext::shared_ptr<MarketModelEvolver> evolver(new
-                            LogNormalFwdRateEuler(marketModel,
-                            generatorFactory,
-                            numeraires));
-                        SequenceStatisticsInc stats(product.numberOfProducts());
-
-
-                        std::vector<Size> startIndexOfConstraint;
-                        std::vector<Size> endIndexOfConstraint;
-
-                        for (Size i=0; i<evolution.evolutionTimes().size(); ++i) {
-                            startIndexOfConstraint.push_back(i);
-                            endIndexOfConstraint.push_back(i+1);
-                        }
+        Size testedFactors[] = {4, 8, todaysForwards.size()};
+        for (unsigned long factors : testedFactors) {
+            MeasureType measures[] = {
+                // MoneyMarketPlus,
+                MoneyMarket //,
+                // Terminal
+            };
+            for (auto& measure : measures) {
+                std::vector<Size> numeraires = makeMeasure(product, measure);
+
+                for (Size n = 0; n < 1; n++) {
+                    // MTBrownianGeneratorFactory generatorFactory(seed_);
+                    SobolBrownianGeneratorFactory generatorFactory(SobolBrownianGenerator::Diagonal,
+                                                                   seed_);
 
+                    bool logNormal = true;
+                    ext::shared_ptr<MarketModel> marketModel =
+                        makeMarketModel(logNormal, evolution, factors, j);
 
-                        std::vector<
-                            std::vector<ext::shared_ptr<ConstrainedEvolver> > >
-                            constrainedEvolvers;
-                        std::vector<std::vector<std::vector<Real> > > diffWeights;
-                        std::vector<std::vector<SequenceStatisticsInc> > greekStats;
+                    ext::shared_ptr<MarketModelEvolver> evolver(
+                        new LogNormalFwdRateEuler(marketModel, generatorFactory, numeraires));
+                    SequenceStatisticsInc stats(product.numberOfProducts());
 
-                        std::vector<ext::shared_ptr<ConstrainedEvolver> >
-                            deltaGammaEvolvers;
-                        std::vector<std::vector<Real> > deltaGammaWeights(
-                            2, std::vector<Real>(3));
-                        std::vector<SequenceStatisticsInc> deltaGammaStats(2,stats);
 
+                    std::vector<Size> startIndexOfConstraint;
+                    std::vector<Size> endIndexOfConstraint;
 
-                        Spread forwardBump = 1.0e-6;
-                        marketModel =
-                            makeMarketModel(logNormal, evolution, factors,
-                            marketModels[j], -forwardBump);
-                        deltaGammaEvolvers.push_back(
-                            ext::shared_ptr<ConstrainedEvolver>(new
-                            LogNormalFwdRateEulerConstrained(marketModel,
-                            generatorFactory,
-                            numeraires)));
-                        deltaGammaEvolvers.back()->setConstraintType(
-                            startIndexOfConstraint, endIndexOfConstraint);
-                        marketModel =
-                            makeMarketModel(logNormal, evolution, factors,
-                            marketModels[j], forwardBump);
-                        deltaGammaEvolvers.push_back(
-                            ext::shared_ptr<ConstrainedEvolver>(new
-                            LogNormalFwdRateEulerConstrained(marketModel,
-                            generatorFactory,
-                            numeraires)));
-                        deltaGammaEvolvers.back()->setConstraintType(
-                            startIndexOfConstraint, endIndexOfConstraint);
-
-                        deltaGammaWeights[0][0] = 0.0;
-                        deltaGammaWeights[0][1] = -1.0/(2.0*forwardBump);
-                        deltaGammaWeights[0][2] = 1.0/(2.0*forwardBump);
-
-                        deltaGammaWeights[1][0] = -2.0/(forwardBump*forwardBump);
-                        deltaGammaWeights[1][1] = 1.0/(forwardBump*forwardBump);
-                        deltaGammaWeights[1][2] = 1.0/(forwardBump*forwardBump);
-
-
-                        std::vector<ext::shared_ptr<ConstrainedEvolver> >
-                            vegaEvolvers;
-                        std::vector<std::vector<Real> > vegaWeights(
-                            1, std::vector<Real>(3));
-                        std::vector<SequenceStatisticsInc> vegaStats(1,stats);
-
-                        Volatility volBump = 1.0e-4;
-                        marketModel =
-                            makeMarketModel(logNormal, evolution, factors,
-                            marketModels[j], 0.0, -volBump);
-                        vegaEvolvers.push_back(
-                            ext::shared_ptr<ConstrainedEvolver>(new
-                            LogNormalFwdRateEulerConstrained(marketModel,
-                            generatorFactory,
-                            numeraires)));
-                        vegaEvolvers.back()->setConstraintType(
-                            startIndexOfConstraint, endIndexOfConstraint);
-                        marketModel =
-                            makeMarketModel(logNormal, evolution, factors,
-                            marketModels[j], 0.0, volBump);
-                        vegaEvolvers.push_back(
-                            ext::shared_ptr<ConstrainedEvolver>(new
-                            LogNormalFwdRateEulerConstrained(marketModel,
-                            generatorFactory,
-                            numeraires)));
-                        vegaEvolvers.back()->setConstraintType(
-                            startIndexOfConstraint, endIndexOfConstraint);
-
-                        vegaWeights[0][0] = 0.0;
-                        vegaWeights[0][1] = -1.0/(2.0*volBump);
-                        vegaWeights[0][2] = 1.0/(2.0*volBump);
-
-
-
-                        constrainedEvolvers.push_back(deltaGammaEvolvers);
-                        diffWeights.push_back(deltaGammaWeights);
-                        greekStats.push_back(deltaGammaStats);
-
-                        constrainedEvolvers.push_back(vegaEvolvers);
-                        diffWeights.push_back(vegaWeights);
-                        greekStats.push_back(vegaStats);
+                    for (Size i = 0; i < evolution.evolutionTimes().size(); ++i) {
+                        startIndexOfConstraint.push_back(i);
+                        endIndexOfConstraint.push_back(i + 1);
+                    }
 
-                        std::ostringstream config;
-                        config <<
-                            marketModelTypeToString(marketModels[j]) << ", " <<
-                            factors << (factors>1 ? (factors==todaysForwards.size() ? " (full) factors, " : " factors, ") : " factor,") <<
-                            measureTypeToString(measures[k]) << ", " <<
-                            "MT BGF";
-                        if (printReport_)
-                            BOOST_TEST_MESSAGE("    " << config.str());
 
-                        Size initialNumeraire = evolver->numeraires().front();
-                        Real initialNumeraireValue =
-                            todaysDiscounts[initialNumeraire];
-
-                        ProxyGreekEngine engine(evolver,
-                            constrainedEvolvers, diffWeights,
-                            startIndexOfConstraint,
-                            endIndexOfConstraint,
-                            product,
-                            initialNumeraireValue);
+                    std::vector<std::vector<ext::shared_ptr<ConstrainedEvolver> > >
+                        constrainedEvolvers;
+                    std::vector<std::vector<std::vector<Real> > > diffWeights;
+                    std::vector<std::vector<SequenceStatisticsInc> > greekStats;
+
+                    std::vector<ext::shared_ptr<ConstrainedEvolver> > deltaGammaEvolvers;
+                    std::vector<std::vector<Real> > deltaGammaWeights(2, std::vector<Real>(3));
+                    std::vector<SequenceStatisticsInc> deltaGammaStats(2, stats);
+
+
+                    Spread forwardBump = 1.0e-6;
+                    marketModel = makeMarketModel(logNormal, evolution, factors, j, -forwardBump);
+                    deltaGammaEvolvers.push_back(
+                        ext::shared_ptr<ConstrainedEvolver>(new LogNormalFwdRateEulerConstrained(
+                            marketModel, generatorFactory, numeraires)));
+                    deltaGammaEvolvers.back()->setConstraintType(startIndexOfConstraint,
+                                                                 endIndexOfConstraint);
+                    marketModel = makeMarketModel(logNormal, evolution, factors, j, forwardBump);
+                    deltaGammaEvolvers.push_back(
+                        ext::shared_ptr<ConstrainedEvolver>(new LogNormalFwdRateEulerConstrained(
+                            marketModel, generatorFactory, numeraires)));
+                    deltaGammaEvolvers.back()->setConstraintType(startIndexOfConstraint,
+                                                                 endIndexOfConstraint);
+
+                    deltaGammaWeights[0][0] = 0.0;
+                    deltaGammaWeights[0][1] = -1.0 / (2.0 * forwardBump);
+                    deltaGammaWeights[0][2] = 1.0 / (2.0 * forwardBump);
+
+                    deltaGammaWeights[1][0] = -2.0 / (forwardBump * forwardBump);
+                    deltaGammaWeights[1][1] = 1.0 / (forwardBump * forwardBump);
+                    deltaGammaWeights[1][2] = 1.0 / (forwardBump * forwardBump);
+
+
+                    std::vector<ext::shared_ptr<ConstrainedEvolver> > vegaEvolvers;
+                    std::vector<std::vector<Real> > vegaWeights(1, std::vector<Real>(3));
+                    std::vector<SequenceStatisticsInc> vegaStats(1, stats);
+
+                    Volatility volBump = 1.0e-4;
+                    marketModel = makeMarketModel(logNormal, evolution, factors, j, 0.0, -volBump);
+                    vegaEvolvers.push_back(
+                        ext::shared_ptr<ConstrainedEvolver>(new LogNormalFwdRateEulerConstrained(
+                            marketModel, generatorFactory, numeraires)));
+                    vegaEvolvers.back()->setConstraintType(startIndexOfConstraint,
+                                                           endIndexOfConstraint);
+                    marketModel = makeMarketModel(logNormal, evolution, factors, j, 0.0, volBump);
+                    vegaEvolvers.push_back(
+                        ext::shared_ptr<ConstrainedEvolver>(new LogNormalFwdRateEulerConstrained(
+                            marketModel, generatorFactory, numeraires)));
+                    vegaEvolvers.back()->setConstraintType(startIndexOfConstraint,
+                                                           endIndexOfConstraint);
+
+                    vegaWeights[0][0] = 0.0;
+                    vegaWeights[0][1] = -1.0 / (2.0 * volBump);
+                    vegaWeights[0][2] = 1.0 / (2.0 * volBump);
+
+
+                    constrainedEvolvers.push_back(deltaGammaEvolvers);
+                    diffWeights.push_back(deltaGammaWeights);
+                    greekStats.push_back(deltaGammaStats);
+
+                    constrainedEvolvers.push_back(vegaEvolvers);
+                    diffWeights.push_back(vegaWeights);
+                    greekStats.push_back(vegaStats);
 
-                        engine.multiplePathValues(stats, greekStats, paths_);
+                    std::ostringstream config;
+                    config << marketModelTypeToString(j) << ", " << factors
+                           << (factors > 1 ?
+                                   (factors == todaysForwards.size() ? " (full) factors, " :
+                                                                       " factors, ") :
+                                   " factor,")
+                           << measureTypeToString(measure) << ", "
+                           << "MT BGF";
+                    if (printReport_)
+                        BOOST_TEST_MESSAGE("    " << config.str());
 
-                        std::vector<Real> values = stats.mean();
-                        std::vector<Real> errors = stats.errorEstimate();
-                        std::vector<Real> deltas = greekStats[0][0].mean();
-                        std::vector<Real> deltaErrors = greekStats[0][0].errorEstimate();
-                        std::vector<Real> gammas = greekStats[0][1].mean();
-                        std::vector<Real> gammaErrors = greekStats[0][1].errorEstimate();
-                        std::vector<Real> vegas = greekStats[1][0].mean();
-                        std::vector<Real> vegaErrors = greekStats[1][0].errorEstimate();
-
-                        std::vector<DiscountFactor> discPlus(todaysForwards.size()+1, todaysDiscounts[0]);
-                        std::vector<DiscountFactor> discMinus(todaysForwards.size()+1, todaysDiscounts[0]);
-                        std::vector<Rate> fwdPlus(todaysForwards.size());
-                        std::vector<Rate> fwdMinus(todaysForwards.size());
-                        std::vector<Rate> pricePlus(todaysForwards.size());
-                        std::vector<Rate> price0(todaysForwards.size());
-                        std::vector<Rate> priceMinus(todaysForwards.size());
-                        for (Size i=0; i<todaysForwards.size(); ++i) {
-                            Time tau = rateTimes[i+1]-rateTimes[i];
-                            fwdPlus[i]=todaysForwards[i]+forwardBump;
-                            fwdMinus[i]=todaysForwards[i]-forwardBump;
-                            discPlus[i+1]=discPlus[i]/(1.0+fwdPlus[i]*tau);
-                            discMinus[i+1]=discMinus[i]/(1.0+fwdMinus[i]*tau);
-                            pricePlus[i]=BlackCalculator(displacedPayoffs[i], fwdPlus[i],
-                                volatilities[i]*sqrt(rateTimes[i]),
-                                discPlus[i+1]*tau).value();
-                            price0[i]=BlackCalculator(displacedPayoffs[i], todaysForwards[i],
-                                volatilities[i]*sqrt(rateTimes[i]),
-                                todaysDiscounts[i+1]*tau).value();
-                            priceMinus[i]=BlackCalculator(displacedPayoffs[i], fwdMinus[i],
-                                volatilities[i]*sqrt(rateTimes[i]),
-                                discMinus[i+1]*tau).value();
-                        }
+                    Size initialNumeraire = evolver->numeraires().front();
+                    Real initialNumeraireValue = todaysDiscounts[initialNumeraire];
+
+                    ProxyGreekEngine engine(evolver, constrainedEvolvers, diffWeights,
+                                            startIndexOfConstraint, endIndexOfConstraint, product,
+                                            initialNumeraireValue);
+
+                    engine.multiplePathValues(stats, greekStats, paths_);
+
+                    std::vector<Real> values = stats.mean();
+                    std::vector<Real> errors = stats.errorEstimate();
+                    std::vector<Real> deltas = greekStats[0][0].mean();
+                    std::vector<Real> deltaErrors = greekStats[0][0].errorEstimate();
+                    std::vector<Real> gammas = greekStats[0][1].mean();
+                    std::vector<Real> gammaErrors = greekStats[0][1].errorEstimate();
+                    std::vector<Real> vegas = greekStats[1][0].mean();
+                    std::vector<Real> vegaErrors = greekStats[1][0].errorEstimate();
+
+                    std::vector<DiscountFactor> discPlus(todaysForwards.size() + 1,
+                                                         todaysDiscounts[0]);
+                    std::vector<DiscountFactor> discMinus(todaysForwards.size() + 1,
+                                                          todaysDiscounts[0]);
+                    std::vector<Rate> fwdPlus(todaysForwards.size());
+                    std::vector<Rate> fwdMinus(todaysForwards.size());
+                    std::vector<Rate> pricePlus(todaysForwards.size());
+                    std::vector<Rate> price0(todaysForwards.size());
+                    std::vector<Rate> priceMinus(todaysForwards.size());
+                    for (Size i = 0; i < todaysForwards.size(); ++i) {
+                        Time tau = rateTimes[i + 1] - rateTimes[i];
+                        fwdPlus[i] = todaysForwards[i] + forwardBump;
+                        fwdMinus[i] = todaysForwards[i] - forwardBump;
+                        discPlus[i + 1] = discPlus[i] / (1.0 + fwdPlus[i] * tau);
+                        discMinus[i + 1] = discMinus[i] / (1.0 + fwdMinus[i] * tau);
+                        pricePlus[i] = BlackCalculator(displacedPayoffs[i], fwdPlus[i],
+                                                       volatilities[i] * sqrt(rateTimes[i]),
+                                                       discPlus[i + 1] * tau)
+                                           .value();
+                        price0[i] = BlackCalculator(displacedPayoffs[i], todaysForwards[i],
+                                                    volatilities[i] * sqrt(rateTimes[i]),
+                                                    todaysDiscounts[i + 1] * tau)
+                                        .value();
+                        priceMinus[i] = BlackCalculator(displacedPayoffs[i], fwdMinus[i],
+                                                        volatilities[i] * sqrt(rateTimes[i]),
+                                                        discMinus[i + 1] * tau)
+                                            .value();
+                    }
 
-                        for (Size i=0; i<product.numberOfProducts(); ++i) {
-                            Real numDelta = (pricePlus[i]-priceMinus[i])/(2.0*forwardBump);
-                            Real numGamma = (pricePlus[i]-2*price0[i]+priceMinus[i])/(forwardBump*forwardBump);
-                            if (printReport_) {
-                                BOOST_TEST_MESSAGE(io::ordinal(i+1) << " caplet: "
-                                    << "value = " << price0[i] << ", "
-                                    << "delta = " << numDelta << ", "
-                                    << "gamma = " << numGamma);
-                                BOOST_TEST_MESSAGE(io::ordinal(i+1) << " caplet: "
-                                    << "value = " << values[i]
-                                << " +- " << errors[i]
-                                << " (" << (values[i]-price0[i])/errors[i] << " s.e.), "
-                                    << "delta = " << deltas[i]
-                                << " +- " << deltaErrors[i]
-                                << " (" << (deltas[i]-numDelta)/deltaErrors[i] << " s.e.), "
-                                    << "gamma = " << gammas[i]
-                                << " +- " << gammaErrors[i]
-                                << " (" << (gammas[i]-numGamma)/gammaErrors[i] << " s.e.), "
-                                    << "vega = " << vegas[i]
-                                << " +- " << vegaErrors[i]);
-                            }
+                    for (Size i = 0; i < product.numberOfProducts(); ++i) {
+                        Real numDelta = (pricePlus[i] - priceMinus[i]) / (2.0 * forwardBump);
+                        Real numGamma = (pricePlus[i] - 2 * price0[i] + priceMinus[i]) /
+                                        (forwardBump * forwardBump);
+                        if (printReport_) {
+                            BOOST_TEST_MESSAGE(io::ordinal(i + 1) << " caplet: "
+                                                                  << "value = " << price0[i] << ", "
+                                                                  << "delta = " << numDelta << ", "
+                                                                  << "gamma = " << numGamma);
+                            BOOST_TEST_MESSAGE(
+                                io::ordinal(i + 1)
+                                << " caplet: "
+                                << "value = " << values[i] << " +- " << errors[i] << " ("
+                                << (values[i] - price0[i]) / errors[i] << " s.e.), "
+                                << "delta = " << deltas[i] << " +- " << deltaErrors[i] << " ("
+                                << (deltas[i] - numDelta) / deltaErrors[i] << " s.e.), "
+                                << "gamma = " << gammas[i] << " +- " << gammaErrors[i] << " ("
+                                << (gammas[i] - numGamma) / gammaErrors[i] << " s.e.), "
+                                << "vega = " << vegas[i] << " +- " << vegaErrors[i]);
                         }
                     }
                 }
             }
         }
+    }
 }
 
 // pathwise deltas
@@ -2245,209 +2170,191 @@ void MarketModelTest::testPathwiseGreeks()
             // ExponentialCorrelationFlatVolatility,
             ExponentialCorrelationAbcdVolatility };
 
-            for (Size j=0; j<LENGTH(marketModels); j++)
-            {
-
-                Size testedFactors[] = { 2
-                    //, 4, 8, todaysForwards.size()
-                };
-
-                for (Size m=0; m<LENGTH(testedFactors); ++m)
-                {
-                    Size factors = testedFactors[m];
-
-                    MeasureType measures[] = {
-                        MoneyMarket
-                    };
+        for (auto& j : marketModels) {
 
-                    for (Size k=0; k<LENGTH(measures); k++)
-                    {
-                        std::vector<Size> numeraires = makeMeasure(productDummy, measures[k]);
+            Size testedFactors[] = {
+                2
+                //, 4, 8, todaysForwards.size()
+            };
 
-                        for (Size n=0; n<1; n++)
-                        {
-                            MTBrownianGeneratorFactory generatorFactory(seed_);
+            for (unsigned long factors : testedFactors) {
+                MeasureType measures[] = {MoneyMarket};
 
-                            bool logNormal = true;
-                            ext::shared_ptr<MarketModel> marketModel =
-                                makeMarketModel(logNormal, evolution, factors,
-                                marketModels[j]);
+                for (auto& measure : measures) {
+                    std::vector<Size> numeraires = makeMeasure(productDummy, measure);
 
-                            LogNormalFwdRateEuler evolver(marketModel,
-                                generatorFactory,
-                                numeraires);
-                            SequenceStatisticsInc stats(product->numberOfProducts()*(todaysForwards.size()+1));
+                    for (Size n = 0; n < 1; n++) {
+                        MTBrownianGeneratorFactory generatorFactory(seed_);
 
+                        bool logNormal = true;
+                        ext::shared_ptr<MarketModel> marketModel =
+                            makeMarketModel(logNormal, evolution, factors, j);
 
+                        LogNormalFwdRateEuler evolver(marketModel, generatorFactory, numeraires);
+                        SequenceStatisticsInc stats(product->numberOfProducts() *
+                                                    (todaysForwards.size() + 1));
 
 
+                        Spread forwardBump = 1.0e-6;
 
+                        std::ostringstream config;
+                        config << marketModelTypeToString(j) << ", " << factors
+                               << (factors > 1 ?
+                                       (factors == todaysForwards.size() ? " (full) factors, " :
+                                                                           " factors, ") :
+                                       " factor,")
+                               << measureTypeToString(measure) << ", "
+                               << "MT BGF";
+                        if (printReport_)
+                            BOOST_TEST_MESSAGE("    " << config.str());
 
+                        Size initialNumeraire = evolver.numeraires().front();
+                        Real initialNumeraireValue = todaysDiscounts[initialNumeraire];
 
-                            Spread forwardBump = 1.0e-6;
 
-                            std::ostringstream config;
-                            config <<
-                                marketModelTypeToString(marketModels[j]) << ", " <<
-                                factors << (factors>1 ? (factors==todaysForwards.size() ? " (full) factors, " : " factors, ") : " factor,") <<
-                                measureTypeToString(measures[k]) << ", " <<
-                                "MT BGF";
-                            if (printReport_)
-                                BOOST_TEST_MESSAGE("    " << config.str());
+                        {
 
-                            Size initialNumeraire = evolver.numeraires().front();
-                            Real initialNumeraireValue =
-                                todaysDiscounts[initialNumeraire];
+                            PathwiseAccountingEngine accountingengine(
+                                ext::make_shared<LogNormalFwdRateEuler>(
+                                    evolver), // method relies heavily on LMM Euler
+                                *product,
+                                marketModel, // we need pseudo-roots and displacements
+                                initialNumeraireValue);
 
 
+                            accountingengine.multiplePathValues(stats, paths_);
+                        }
 
-                            {
 
-                                PathwiseAccountingEngine accountingengine(ext::make_shared<LogNormalFwdRateEuler>(evolver), // method relies heavily on LMM Euler
-                                    *product,
-                                    marketModel, // we need pseudo-roots and displacements
-                                    initialNumeraireValue);
+                        std::vector<Real> valuesAndDeltas = stats.mean();
+                        std::vector<Real> errors = stats.errorEstimate();
 
+                        std::vector<Real> prices(product->numberOfProducts());
+                        std::vector<Real> priceErrors(product->numberOfProducts());
 
+                        Matrix deltas(product->numberOfProducts(), todaysForwards.size());
+                        Matrix deltasErrors(product->numberOfProducts(), todaysForwards.size());
+                        std::vector<Real> modelPrices(product->numberOfProducts());
 
-                                accountingengine.multiplePathValues(stats,paths_);
-                            }
 
+                        for (Size i = 0; i < product->numberOfProducts(); ++i) {
+                            prices[i] = valuesAndDeltas[i];
 
-                            std::vector<Real> valuesAndDeltas = stats.mean();
-                            std::vector<Real> errors = stats.errorEstimate();
+                            priceErrors[i] = errors[i];
 
-                            std::vector<Real> prices(product->numberOfProducts());
-                            std::vector<Real> priceErrors(product->numberOfProducts());
+                            modelPrices[i] = BlackCalculator(displacedPayoffs[i], todaysForwards[i],
+                                                             volatilities[i] * sqrt(rateTimes[i]),
+                                                             todaysDiscounts[i + 1] *
+                                                                 (rateTimes[i + 1] - rateTimes[i]))
+                                                 .value();
 
-                            Matrix deltas( product->numberOfProducts(), todaysForwards.size());
-                            Matrix deltasErrors( product->numberOfProducts(), todaysForwards.size());
-                            std::vector<Real> modelPrices(product->numberOfProducts());
 
+                            for (Size j = 0; j < todaysForwards.size(); ++j) {
+                                deltas[i][j] =
+                                    valuesAndDeltas[(i + 1) * product->numberOfProducts() + j];
+                                deltasErrors[i][j] =
+                                    errors[(i + 1) * product->numberOfProducts() + j];
+                            }
+                        }
 
-                            for (Size i=0; i < product->numberOfProducts(); ++i)
-                            {
-                                prices[i] = valuesAndDeltas[i];
+                        Matrix modelDeltas(product->numberOfProducts(), todaysForwards.size());
 
-                                priceErrors[i] = errors[i];
 
-                                modelPrices[i] = BlackCalculator(displacedPayoffs[i], todaysForwards[i],
-                                    volatilities[i]*sqrt(rateTimes[i]),
-                                    todaysDiscounts[i+1]*(rateTimes[i+1]-rateTimes[i])).value();
+                        std::vector<DiscountFactor> discPlus(todaysForwards.size() + 1,
+                                                             todaysDiscounts[0]);
+                        std::vector<DiscountFactor> discMinus(todaysForwards.size() + 1,
+                                                              todaysDiscounts[0]);
+                        std::vector<Rate> fwdPlus(todaysForwards.size());
+                        std::vector<Rate> fwdMinus(todaysForwards.size());
 
 
-                                for (Size j=0; j <  todaysForwards.size(); ++j)
-                                {
-                                    deltas[i][j] = valuesAndDeltas[(i+1)*product->numberOfProducts()+j];
-                                    deltasErrors[i][j]  = errors[(i+1)* product->numberOfProducts()+j];
+                        for (Size i = 0; i < todaysForwards.size(); ++i) {
+                            for (Size j = 0; j < todaysForwards.size(); ++j) {
+                                if (i != j) {
+                                    fwdPlus[j] = todaysForwards[j];
+                                    fwdMinus[j] = todaysForwards[j];
 
+                                } else {
+                                    fwdPlus[j] = todaysForwards[j] + forwardBump;
+                                    fwdMinus[j] = todaysForwards[j] - forwardBump;
                                 }
 
+                                Time tau = rateTimes[j + 1] - rateTimes[j];
+                                discPlus[j + 1] = discPlus[j] / (1.0 + fwdPlus[j] * tau);
+                                discMinus[j + 1] = discMinus[j] / (1.0 + fwdMinus[j] * tau);
                             }
 
-                            Matrix modelDeltas(product->numberOfProducts(), todaysForwards.size());
-
-
-                            std::vector<DiscountFactor> discPlus(todaysForwards.size()+1, todaysDiscounts[0]);
-                            std::vector<DiscountFactor> discMinus(todaysForwards.size()+1, todaysDiscounts[0]);
-                            std::vector<Rate> fwdPlus(todaysForwards.size());
-                            std::vector<Rate> fwdMinus(todaysForwards.size());
-
+                            for (Size k = 0; k < product->numberOfProducts(); ++k) {
+                                Real tau = rateTimes[k + 1] - rateTimes[k];
+                                Real priceUp = BlackCalculator(displacedPayoffs[k], fwdPlus[k],
+                                                               volatilities[k] * sqrt(rateTimes[k]),
+                                                               discPlus[k + 1] * tau)
+                                                   .value();
+                                Real priceDown =
+                                    BlackCalculator(displacedPayoffs[k], fwdMinus[k],
+                                                    volatilities[k] * sqrt(rateTimes[k]),
+                                                    discMinus[k + 1] * tau)
+                                        .value();
+
+                                modelDeltas[k][i] = (priceUp - priceDown) / (2 * forwardBump);
+                            }
+                        }
 
-                            for (Size i=0; i < todaysForwards.size(); ++i)
-                            {
-                                for (Size j=0; j < todaysForwards.size(); ++j)
-                                {
-                                    if (i != j)
-                                    {
-                                        fwdPlus[j] = todaysForwards[j];
-                                        fwdMinus[j] = todaysForwards[j];
 
-                                    }
-                                    else
-                                    {
-                                        fwdPlus[j] = todaysForwards[j]+forwardBump;
-                                        fwdMinus[j] = todaysForwards[j]-forwardBump;
-                                    }
+                        Integer numberErrors = 0;
 
-                                    Time tau = rateTimes[j+1]-rateTimes[j];
-                                    discPlus[j+1]=discPlus[j]/(1.0+fwdPlus[j]*tau);
-                                    discMinus[j+1]=discMinus[j]/(1.0+fwdMinus[j]*tau);
+                        for (Size i = 0; i < product->numberOfProducts(); ++i) {
 
-                                }
+                            Real thisPrice = prices[i];
+                            Real thisModelPrice = modelPrices[i];
+                            Real priceErrorInSds = ((thisPrice - thisModelPrice) / priceErrors[i]);
 
-                                for (Size k=0; k  < product->numberOfProducts(); ++k)
-                                {
-                                    Real tau = rateTimes[k+1] - rateTimes[k];
-                                    Real priceUp = BlackCalculator(displacedPayoffs[k], fwdPlus[k],
-                                        volatilities[k]*sqrt(rateTimes[k]),
-                                        discPlus[k+1]*tau).value();
-                                    Real priceDown = BlackCalculator(displacedPayoffs[k], fwdMinus[k],
-                                        volatilities[k]*sqrt(rateTimes[k]),
-                                        discMinus[k+1]*tau).value();
+                            Real errorTheshold = 3.5;
 
-                                    modelDeltas[k][i] = (priceUp-priceDown)/(2*forwardBump);
+                            if (fabs(priceErrorInSds) > errorTheshold) {
+                                BOOST_TEST_MESSAGE("Caplet "
+                                                   << i << " price " << prices[i] << " model price "
+                                                   << modelPrices[i]
+                                                   << "   Standard error: " << priceErrors[i]
+                                                   << " errors in sds: " << priceErrorInSds);
 
-                                }
+                                ++numberErrors;
                             }
 
+                            Real threshold = 1e-10;
 
-                            Integer numberErrors =0;
+                            for (Size j = 0; j < todaysForwards.size(); ++j) {
+                                Real delta = deltas[i][j];
+                                Real modelDelta = modelDeltas[i][j];
 
-                            for (Size i=0; i<product->numberOfProducts(); ++i)
-                            {
+                                Real deltaErrorInSds = 100;
 
-                                Real thisPrice = prices[i];
-                                Real thisModelPrice =  modelPrices[i];
-                                Real priceErrorInSds = ((thisPrice - thisModelPrice)/priceErrors[i]);
+                                if (deltasErrors[i][j] > 0.0)
+                                    deltaErrorInSds = ((delta - modelDelta) / deltasErrors[i][j]);
+                                else if (fabs(modelDelta - delta) <
+                                         threshold) // to cope with zero over zero
+                                    deltaErrorInSds = 0.0;
 
-                                Real errorTheshold = 3.5;
+                                if (fabs(deltaErrorInSds) > errorTheshold) {
 
-                                if (fabs(priceErrorInSds) > errorTheshold)
-                                {
-                                    BOOST_TEST_MESSAGE("Caplet " << i << " price " << prices[i] << " model price " << modelPrices[i]
-                                    << "   Standard error: " <<priceErrors[i] << " errors in sds: " << priceErrorInSds);
+                                    BOOST_TEST_MESSAGE("Caplet "
+                                                       << i << " delta " << j << "has value "
+                                                       << deltas[i][j] << " model value "
+                                                       << modelDeltas[i][j] << "   Standard error: "
+                                                       << deltasErrors[i][j]
+                                                       << " errors in sds: " << deltaErrorInSds);
 
                                     ++numberErrors;
-
                                 }
-
-                                Real threshold =1e-10;
-
-                                for (Size j =0; j < todaysForwards.size(); ++j)
-                                {
-                                    Real delta = deltas[i][j];
-                                    Real modelDelta = modelDeltas[i][j];
-
-                                    Real deltaErrorInSds =100;
-
-                                    if (deltasErrors[i][j] > 0.0)
-                                        deltaErrorInSds = (( delta  - modelDelta )/deltasErrors[i][j]);
-                                    else
-                                        if (fabs(modelDelta -delta) < threshold) // to cope with zero over zero
-                                            deltaErrorInSds =0.0;
-
-                                    if (fabs(deltaErrorInSds) > errorTheshold)
-                                    {
-
-                                        BOOST_TEST_MESSAGE("Caplet " << i << " delta " << j << "has value " << deltas[i][j] << " model value " << modelDeltas[i][j]
-                                        << "   Standard error: " <<deltasErrors[i][j] << " errors in sds: " << deltaErrorInSds);
-
-                                        ++numberErrors;
-                                    }
-
-
-                                }
-
-
                             }
-
-                            if (numberErrors >0)
-                                BOOST_FAIL("Pathwise greeks test has " << numberErrors <<"\n");
                         }
+
+                        if (numberErrors > 0)
+                            BOOST_FAIL("Pathwise greeks test has " << numberErrors << "\n");
                     }
                 }
             }
+        }
     }
 }
 
@@ -2523,8 +2430,7 @@ void MarketModelTest::testPathwiseVegas()
     };
     /////////////////////////////////// test derivative of swaption implied vol with respect to pseudo-root elements
 
-    for (Size j=0; j<LENGTH(marketModels); j++)
-    {
+    for (auto& j : marketModels) {
 
         Size testedFactors[] = { std::min<Size>(3UL,todaysForwards.size())
             //    todaysForwards.size()
@@ -2532,18 +2438,11 @@ void MarketModelTest::testPathwiseVegas()
         };
 
 
-
-
-        for (Size m=0; m<LENGTH(testedFactors); ++m)
-        {
-            Size factors = testedFactors[m];
-
-
+        for (unsigned long factors : testedFactors) {
             bool logNormal = true;
 
             ext::shared_ptr<MarketModel> marketModel =
-                makeMarketModel(logNormal, evolution, factors,
-                marketModels[j]);
+                makeMarketModel(logNormal, evolution, factors, j);
 
             Size startIndex = std::min<Size>(1,evolution.numberOfRates()-2) ;
             Size endIndex = evolution.numberOfRates()-1;
@@ -2629,8 +2528,7 @@ void MarketModelTest::testPathwiseVegas()
 
     /////////////////////////////////////
 
-    for (Size j=0; j<LENGTH(marketModels); j++)
-    {
+    for (auto& j : marketModels) {
 
         Size testedFactors[] = { std::min<Size>(3UL,todaysForwards.size())
             //    todaysForwards.size()
@@ -2638,18 +2536,11 @@ void MarketModelTest::testPathwiseVegas()
                                                           };
 
 
-
-
-        for (Size m=0; m<LENGTH(testedFactors); ++m)
-        {
-            Size factors = testedFactors[m];
-
-
+        for (unsigned long factors : testedFactors) {
             bool logNormal = true;
 
             ext::shared_ptr<MarketModel> marketModel =
-                makeMarketModel(logNormal, evolution, factors,
-                marketModels[j]);
+                makeMarketModel(logNormal, evolution, factors, j);
 
             for (Size startIndex = 1; startIndex < evolution.numberOfRates()-1; ++startIndex)
                 for (Size endIndex = startIndex+1; endIndex < evolution.numberOfRates(); ++endIndex)
@@ -2783,7 +2674,6 @@ void MarketModelTest::testPathwiseVegas()
             if (numberCapImpVolFailures >0)
                 BOOST_ERROR("cap pseudo test failed for implied vols "
                             << numberCapImpVolFailures << " times" );
-
         }
 
         // we have tested the price derivative and the implied vol function, now the derivative of the cap implied vols
@@ -2792,16 +2682,11 @@ void MarketModelTest::testPathwiseVegas()
         // since we have already tested the imp vol function we use it here
 
 
-        for (Size m=0; m<LENGTH(testedFactors); ++m)
-        {
-            Size factors = testedFactors[m];
-
-
+        for (unsigned long factors : testedFactors) {
             bool logNormal = true;
 
             ext::shared_ptr<MarketModel> marketModel =
-                makeMarketModel(logNormal, evolution, factors,
-                marketModels[j]);
+                makeMarketModel(logNormal, evolution, factors, j);
 
             for (Size startIndex = 1; startIndex < evolution.numberOfRates()-1; ++startIndex)
                 for (Size endIndex = startIndex+1; endIndex < evolution.numberOfRates(); ++endIndex)
@@ -2880,17 +2765,10 @@ void MarketModelTest::testPathwiseVegas()
             if (numberCapVolPseudoFailures >0)
                 BOOST_ERROR("cap pseudo test failed for implied vols "
                             << numberCapVolPseudoFailures << " times" );
-
         }
     }
 
 
-
-
-
-
-
-
     /////////////////////////////////////
 
     for (Size j=0; j<LENGTH(marketModels); j++)
@@ -2904,12 +2782,9 @@ void MarketModelTest::testPathwiseVegas()
                                                             };
 
 
-
-
-        for (Size m=0; m<LENGTH(testedFactors); ++m)
-        {
-            Size factors = testedFactors[m];
-            Size factorsToTest = std::min<Size>(2,factors); // doing all possible vegas is combinatorially explosive
+        for (unsigned long factors : testedFactors) {
+            Size factorsToTest =
+                std::min<Size>(2, factors); // doing all possible vegas is combinatorially explosive
 
 
             MeasureType measures[] = {
@@ -2959,13 +2834,9 @@ void MarketModelTest::testPathwiseVegas()
             }
 
 
+            for (auto& measure : measures) {
 
-
-
-            for (Size k=0; k<LENGTH(measures); k++)
-            {
-
-                std::vector<Size> numeraires = makeMeasure(product, measures[k]);
+                std::vector<Size> numeraires = makeMeasure(product, measure);
 
                 std::vector<RatePseudoRootJacobian> testees;
                 std::vector<RatePseudoRootJacobianAllElements> testees2;
@@ -3180,10 +3051,9 @@ void MarketModelTest::testPathwiseVegas()
                 else
                     productToUse = capletsDeflated;
 
-                for (Size k=0; k<LENGTH(measures); k++)
-                {
+                for (auto& measure : measures) {
 
-                    std::vector<Size> numeraires = makeMeasure(product, measures[k]);
+                    std::vector<Size> numeraires = makeMeasure(product, measure);
 
                     MTBrownianGeneratorFactory generatorFactory(seed_);
 
@@ -3200,11 +3070,13 @@ void MarketModelTest::testPathwiseVegas()
 
 
                     std::ostringstream config;
-                    config <<
-                        marketModelTypeToString(marketModels[j]) << ", " <<
-                        factors << (factors>1 ? (factors==todaysForwards.size() ? " (full) factors, " : " factors, ") : " factor,") <<
-                        measureTypeToString(measures[k]) << ", " <<
-                        "MT BGF";
+                    config << marketModelTypeToString(marketModels[j]) << ", " << factors
+                           << (factors > 1 ?
+                                   (factors == todaysForwards.size() ? " (full) factors, " :
+                                                                       " factors, ") :
+                                   " factor,")
+                           << measureTypeToString(measure) << ", "
+                           << "MT BGF";
                     if (printReport_)
                         BOOST_TEST_MESSAGE("    " << config.str());
 
@@ -3448,10 +3320,9 @@ void MarketModelTest::testPathwiseVegas()
                     capStrike,
                     startsAndEnds);
 
-                for (Size k=0; k<LENGTH(measures); k++)
-                {
+                for (auto& measure : measures) {
 
-                    std::vector<Size> numeraires = makeMeasure(product, measures[k]);
+                    std::vector<Size> numeraires = makeMeasure(product, measure);
 
                     MTBrownianGeneratorFactory generatorFactory(seed_);
                     MTBrownianGeneratorFactory generatorFactory2(seed_);
@@ -3473,11 +3344,13 @@ void MarketModelTest::testPathwiseVegas()
 
 
                     std::ostringstream config;
-                    config <<
-                        marketModelTypeToString(marketModels[j]) << ", " <<
-                        factors << (factors>1 ? (factors==todaysForwards.size() ? " (full) factors, " : " factors, ") : " factor,") <<
-                        measureTypeToString(measures[k]) << ", " <<
-                        "MT BGF";
+                    config << marketModelTypeToString(marketModels[j]) << ", " << factors
+                           << (factors > 1 ?
+                                   (factors == todaysForwards.size() ? " (full) factors, " :
+                                                                       " factors, ") :
+                                   " factor,")
+                           << measureTypeToString(measure) << ", "
+                           << "MT BGF";
                     if (printReport_)
                         BOOST_TEST_MESSAGE("    " << config.str());
 
@@ -3645,7 +3518,6 @@ void MarketModelTest::testPathwiseVegas()
 
                 } // end of k loop over measures
             }
-
         }
     }
 
@@ -3756,8 +3628,7 @@ void MarketModelTest::testPathwiseMarketVegas()
     ///////////////////////////////////
     // test analytically first, it's faster!
 
-    for (Size j=0; j<LENGTH(marketModels); j++)
-    {
+    for (auto& j : marketModels) {
 
         Size testedFactors[] = { std::min<Size>(1UL,todaysForwards.size())
             //    todaysForwards.size()
@@ -3765,17 +3636,11 @@ void MarketModelTest::testPathwiseMarketVegas()
         };
 
 
-
-        for (Size m=0; m<LENGTH(testedFactors); ++m)
-        {
-            Size factors = testedFactors[m];
-
-
+        for (unsigned long factors : testedFactors) {
             bool logNormal = true;
 
             ext::shared_ptr<MarketModel> marketModel =
-                makeMarketModel(logNormal, evolution, factors,
-                marketModels[j]);
+                makeMarketModel(logNormal, evolution, factors, j);
 
 
             // we need to work out our bumps
@@ -3897,7 +3762,7 @@ void MarketModelTest::testPathwiseMarketVegas()
 
 
         } // end of  for (Size m=0; m<LENGTH(testedFactors); ++m)
-    } // end of   for (Size j=0; j<LENGTH(marketModels); j++)
+    }     // end of   for (Size j=0; j<LENGTH(marketModels); j++)
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     // test numerically differentiated swaptions against analytically done ones
     // we require equality on very path so we don't need many paths
@@ -3920,9 +3785,7 @@ void MarketModelTest::testPathwiseMarketVegas()
         cashFlowsGenerated2(cashFlowsGenerated1);
 
 
-
-    for (Size j=0; j<LENGTH(marketModels); j++)
-    {
+    for (auto& j : marketModels) {
 
         Size testedFactors[] = { std::min<Size>(1UL,todaysForwards.size())
             //    todaysForwards.size()
@@ -3930,19 +3793,13 @@ void MarketModelTest::testPathwiseMarketVegas()
         };
 
 
-
-
-        for (Size m=0; m<LENGTH(testedFactors); ++m)
-        {
-            Size factors = testedFactors[m];
-
+        for (unsigned long factors : testedFactors) {
             MTBrownianGeneratorFactory generatorFactory(seed_);
 
             bool logNormal = true;
 
             ext::shared_ptr<MarketModel> marketModel =
-                makeMarketModel(logNormal, evolution, factors,
-                marketModels[j]);
+                makeMarketModel(logNormal, evolution, factors, j);
 
             LogNormalFwdRateEuler evolver1(marketModel,
                 generatorFactory,swaptionsDeflated.suggestedNumeraires()
@@ -4007,15 +3864,14 @@ void MarketModelTest::testPathwiseMarketVegas()
 
 
         } // end of  for (Size m=0; m<LENGTH(testedFactors); ++m)
-    } // end of   for (Size j=0; j<LENGTH(marketModels); j++)
+    }     // end of   for (Size j=0; j<LENGTH(marketModels); j++)
 
     /////////////////////////////////////
 
     // now time for the full simulation test
     // measure vega of each swaption with respect to itself, the other swaptions and the caps
     // should get 0.01 and 0 respectively.
-    for (Size j=0; j<LENGTH(marketModels); j++)
-    {
+    for (auto& j : marketModels) {
 
         Size testedFactors[] = { std::min<Size>(1UL,todaysForwards.size())
             //    todaysForwards.size()
@@ -4023,19 +3879,13 @@ void MarketModelTest::testPathwiseMarketVegas()
         };
 
 
-
-
-        for (Size m=0; m<LENGTH(testedFactors); ++m)
-        {
-            Size factors = testedFactors[m];
-
+        for (unsigned long factors : testedFactors) {
             MTBrownianGeneratorFactory generatorFactory(seed_);
 
             bool logNormal = true;
 
             ext::shared_ptr<MarketModel> marketModel =
-                makeMarketModel(logNormal, evolution, factors,
-                marketModels[j]);
+                makeMarketModel(logNormal, evolution, factors, j);
 
             LogNormalFwdRateEuler evolver(marketModel,
                 generatorFactory,swaptionsDeflated.suggestedNumeraires()
@@ -4158,10 +4008,8 @@ void MarketModelTest::testPathwiseMarketVegas()
                            << " and " << numberDiagonalFailures << " on the diagonal." );
 
 
-
-
         } // end of  for (Size m=0; m<LENGTH(testedFactors); ++m)
-    } // end of   for (Size j=0; j<LENGTH(marketModels); j++)
+    }     // end of   for (Size j=0; j<LENGTH(marketModels); j++)
 
     /////////////////////////////////////
     /////////////////////////////////////
@@ -4169,8 +4017,7 @@ void MarketModelTest::testPathwiseMarketVegas()
     // now time for the full simulation test
     // measure vega of each caps with respect to itself, the swaptions and the other caps
     // should get 0.01, 0 and 0 respectively.
-    for (Size j=0; j<LENGTH(marketModels); j++)
-    {
+    for (auto& j : marketModels) {
 
         Size testedFactors[] = { std::min<Size>(2UL,todaysForwards.size())
             //    todaysForwards.size()
@@ -4178,19 +4025,13 @@ void MarketModelTest::testPathwiseMarketVegas()
         };
 
 
-
-
-        for (Size m=0; m<LENGTH(testedFactors); ++m)
-        {
-            Size factors = testedFactors[m];
-
+        for (unsigned long factors : testedFactors) {
             MTBrownianGeneratorFactory generatorFactory(seed_);
 
             bool logNormal = true;
 
             ext::shared_ptr<MarketModel> marketModel =
-                makeMarketModel(logNormal, evolution, factors,
-                marketModels[j]);
+                makeMarketModel(logNormal, evolution, factors, j);
 
             LogNormalFwdRateEuler evolver(marketModel,
                 generatorFactory,capsDeflated.suggestedNumeraires()
@@ -4330,10 +4171,8 @@ void MarketModelTest::testPathwiseMarketVegas()
                            << " and " << numberDiagonalFailures << " on the diagonal." );
 
 
-
-
         } // end of  for (Size m=0; m<LENGTH(testedFactors); ++m)
-    } // end of   for (Size j=0; j<LENGTH(marketModels); j++)
+    }     // end of   for (Size j=0; j<LENGTH(marketModels); j++)
 
     /////////////////////////////////////
 
@@ -4569,22 +4408,18 @@ void MarketModelTest::testStochVolForwardsAndOptionlets() {
                              w2,
                              cutPoint));
 
-    for (Size j=0; j<LENGTH(marketModels); j++)
-    {
+    for (auto& j : marketModels) {
 
         Size testedFactors[] = {1, 2, todaysForwards.size()};
-        for (Size m=0; m<LENGTH(testedFactors); ++m) {
-            Size factors = testedFactors[m];
-
-            MeasureType measures[] = { MoneyMarket, Terminal };
+        for (unsigned long factors : testedFactors) {
+            MeasureType measures[] = {MoneyMarket, Terminal};
 
-            for (Size k=0; k<LENGTH(measures); k++)
-            {
-                std::vector<Size> numeraires = makeMeasure(product, measures[k]);
+            for (auto& measure : measures) {
+                std::vector<Size> numeraires = makeMeasure(product, measure);
 
                 bool logNormal = true;
                 ext::shared_ptr<MarketModel> marketModel =
-                    makeMarketModel(logNormal, evolution, factors, marketModels[j]);
+                    makeMarketModel(logNormal, evolution, factors, j);
 
 
                 for (Size n=0; n<1; n++)
@@ -4601,12 +4436,15 @@ void MarketModelTest::testStochVolForwardsAndOptionlets() {
 
 
                     std::ostringstream config;
-                    config <<
-                        marketModelTypeToString(marketModels[j]) << ", " <<
-                        factors << (factors>1 ? (factors==todaysForwards.size() ? " (full) factors, " : " factors, ") : " factor,") <<
-                        measureTypeToString(measures[k]) << ", " <<
-                        "SVDDFwdRatePc" << ", " <<
-                        "MT BGF";
+                    config << marketModelTypeToString(j) << ", " << factors
+                           << (factors > 1 ?
+                                   (factors == todaysForwards.size() ? " (full) factors, " :
+                                                                       " factors, ") :
+                                   " factor,")
+                           << measureTypeToString(measure) << ", "
+                           << "SVDDFwdRatePc"
+                           << ", "
+                           << "MT BGF";
                     if (printReport_)
                         BOOST_TEST_MESSAGE("    " << config.str());
 
@@ -4730,10 +4568,10 @@ void MarketModelTest::testDriftCalculator() {
     std::vector<Real> drifts(numberOfSteps), driftsReduced(numberOfSteps);
     MarketModelType marketModels[] = {ExponentialCorrelationFlatVolatility,
         ExponentialCorrelationAbcdVolatility};
-    for (Size k=0; k<LENGTH(marketModels); ++k) {   // loop over market models
+    for (auto& k : marketModels) { // loop over market models
         bool logNormal = true;
         ext::shared_ptr<MarketModel> marketModel =
-            makeMarketModel(logNormal, evolution, factors, marketModels[k]);
+            makeMarketModel(logNormal, evolution, factors, k);
         std::vector<Rate> displacements = marketModel->displacements();
         for (Size j=0; j<numberOfSteps; ++j) {     // loop over steps
             const Matrix& A = marketModel->pseudoRoot(j);
@@ -4748,15 +4586,14 @@ void MarketModelTest::testDriftCalculator() {
                 for (Size i=0; i<drifts.size(); ++i) {
                     Real error = std::abs(driftsReduced[i]-drifts[i]);
                     if (error>tolerance)
-                        BOOST_ERROR("MarketModel: " <<
-                        marketModelTypeToString(marketModels[k]) <<
-                        ", " << io::ordinal(j+1) << " step, " <<
-                        ", " << io::ordinal(h+1) << " numeraire, " <<
-                        ", " << io::ordinal(i+1) << " drift, " <<
-                        "\ndrift        =" << drifts[i] <<
-                        "\ndriftReduced =" << driftsReduced[i] <<
-                        "\n       error =" << error <<
-                        "\n   tolerance =" << tolerance);
+                        BOOST_ERROR("MarketModel: " << marketModelTypeToString(k) << ", "
+                                                    << io::ordinal(j + 1) << " step, "
+                                                    << ", " << io::ordinal(h + 1) << " numeraire, "
+                                                    << ", " << io::ordinal(i + 1) << " drift, "
+                                                    << "\ndrift        =" << drifts[i]
+                                                    << "\ndriftReduced =" << driftsReduced[i]
+                                                    << "\n       error =" << error
+                                                    << "\n   tolerance =" << tolerance);
                 }
             }
         }
diff --git a/test-suite/marketmodel_cms.cpp b/test-suite/marketmodel_cms.cpp
index d89ed9136c6..ab3b68e554c 100644
--- a/test-suite/marketmodel_cms.cpp
+++ b/test-suite/marketmodel_cms.cpp
@@ -474,22 +474,19 @@ void MarketModelCmsTest::testMultiStepCmSwapsAndSwaptions() {
                                     ExponentialCorrelationFlatVolatility,
                                     ExponentialCorrelationAbcdVolatility };
 
-    for (Size j=0; j<LENGTH(marketModels); j++) {
+    for (auto& j : marketModels) {
 
         Size testedFactors[] = { /*4, 8,*/ todaysForwards.size()};
-        for (Size m=0; m<LENGTH(testedFactors); ++m) {
-            Size factors = testedFactors[m];
-
+        for (unsigned long factors : testedFactors) {
             // Composite's ProductSuggested is the Terminal one
             MeasureType measures[] = { // ProductSuggested,
                                        Terminal,
                                       // MoneyMarketPlus,
                                        MoneyMarket};
-            for (Size k=0; k<LENGTH(measures); k++) {
-                std::vector<Size> numeraires = makeMeasure(product, measures[k]);
+            for (auto& measure : measures) {
+                std::vector<Size> numeraires = makeMeasure(product, measure);
 
-                ext::shared_ptr<MarketModel> marketModel =
-                    makeMarketModel(evolution, factors, marketModels[j]);
+                ext::shared_ptr<MarketModel> marketModel = makeMarketModel(evolution, factors, j);
 
                 EvolverType evolvers[] = { Pc/*, Ipc*/ };
 
@@ -505,12 +502,14 @@ void MarketModelCmsTest::testMultiStepCmSwapsAndSwaptions() {
                                                          generatorFactory,
                                                          evolvers[i]);
                         std::ostringstream config;
-                        config <<
-                            marketModelTypeToString(marketModels[j]) << ", " <<
-                            factors << (factors>1 ? (factors==todaysForwards.size() ? " (full) factors, " : " factors, ") : " factor,") <<
-                            measureTypeToString(measures[k]) << ", " <<
-                            evolverTypeToString(evolvers[i]) << ", " <<
-                            "MT BGF";
+                        config << marketModelTypeToString(j) << ", " << factors
+                               << (factors > 1 ?
+                                       (factors == todaysForwards.size() ? " (full) factors, " :
+                                                                           " factors, ") :
+                                       " factor,")
+                               << measureTypeToString(measure) << ", "
+                               << evolverTypeToString(evolvers[i]) << ", "
+                               << "MT BGF";
                         if (printReport_)
                             BOOST_TEST_MESSAGE("    " << config.str());
 
diff --git a/test-suite/marketmodel_smm.cpp b/test-suite/marketmodel_smm.cpp
index dfee03d767e..7118df40bb9 100644
--- a/test-suite/marketmodel_smm.cpp
+++ b/test-suite/marketmodel_smm.cpp
@@ -463,19 +463,17 @@ void MarketModelSmmTest::testMultiStepCoterminalSwapsAndSwaptions() {
     MarketModelType marketModels[] = {// CalibratedMM,
                                        ExponentialCorrelationFlatVolatility,
                                        ExponentialCorrelationAbcdVolatility };
-    for (Size j=0; j<LENGTH(marketModels); j++) {
+    for (auto& j : marketModels) {
         Size testedFactors[] = { /*4, 8,*/ todaysForwards.size()};
-        for (Size m=0; m<LENGTH(testedFactors); ++m) {
-            Size factors = testedFactors[m];
+        for (unsigned long factors : testedFactors) {
             // Composite's ProductSuggested is the Terminal one
             MeasureType measures[] = { // ProductSuggested,
                                        Terminal,
                                        //MoneyMarketPlus,
                                        MoneyMarket};
-            for (Size k=0; k<LENGTH(measures); k++) {
-                std::vector<Size> numeraires = makeMeasure(product, measures[k]);
-                ext::shared_ptr<MarketModel> marketModel =
-                    makeMarketModel(evolution, factors, marketModels[j]);
+            for (auto& measure : measures) {
+                std::vector<Size> numeraires = makeMeasure(product, measure);
+                ext::shared_ptr<MarketModel> marketModel = makeMarketModel(evolution, factors, j);
                 EvolverType evolvers[] = { Pc /*, Ipc */};
                 ext::shared_ptr<MarketModelEvolver> evolver;
                 Size stop = isInTerminalMeasure(evolution, numeraires) ? 0 : 1;
@@ -489,12 +487,14 @@ void MarketModelSmmTest::testMultiStepCoterminalSwapsAndSwaptions() {
                                                          generatorFactory,
                                                          evolvers[i]);
                         std::ostringstream config;
-                        config <<
-                            marketModelTypeToString(marketModels[j]) << ", " <<
-                            factors << (factors>1 ? (factors==todaysForwards.size() ? " (full) factors, " : " factors, ") : " factor,") <<
-                            measureTypeToString(measures[k]) << ", " <<
-                            evolverTypeToString(evolvers[i]) << ", " <<
-                            "MT BGF";
+                        config << marketModelTypeToString(j) << ", " << factors
+                               << (factors > 1 ?
+                                       (factors == todaysForwards.size() ? " (full) factors, " :
+                                                                           " factors, ") :
+                                       " factor,")
+                               << measureTypeToString(measure) << ", "
+                               << evolverTypeToString(evolvers[i]) << ", "
+                               << "MT BGF";
                         if (printReport_)
                             BOOST_TEST_MESSAGE("    " << config.str());
                         ext::shared_ptr<SequenceStatisticsInc> stats = simulate(evolver, product);
diff --git a/test-suite/markovfunctional.cpp b/test-suite/markovfunctional.cpp
index 47527ca5e57..29ac06341b0 100644
--- a/test-suite/markovfunctional.cpp
+++ b/test-suite/markovfunctional.cpp
@@ -241,8 +241,8 @@ namespace {
         };
 
         q6m.reserve(10 + 15 + 35);
-        for (int i = 0; i < 10 + 15 + 35; i++) {
-            q6m.push_back(ext::shared_ptr<Quote>(new SimpleQuote(q6mh[i])));
+        for (double i : q6mh) {
+            q6m.push_back(ext::shared_ptr<Quote>(new SimpleQuote(i)));
         }
 
         r6m.reserve(10);
@@ -292,15 +292,15 @@ namespace {
                             3 * Years,  4 * Years,  5 * Years,   6 * Years,
                             7 * Years,  8 * Years,  9 * Years,   10 * Years,
                             15 * Years, 20 * Years, 25 * Years,  30 * Years };
-        for (Size i = 0; i < 20; i++)
-            optionTenors.push_back(optTen[i]);
+        for (auto& i : optTen)
+            optionTenors.push_back(i);
 
         Period swpTen[] = { 1 * Years,  2 * Years,  3 * Years,  4 * Years,
                             5 * Years,  6 * Years,  7 * Years,  8 * Years,
                             9 * Years,  10 * Years, 15 * Years, 20 * Years,
                             25 * Years, 30 * Years };
-        for (Size i = 0; i < 14; i++)
-            swapTenors.push_back(swpTen[i]);
+        for (auto& i : swpTen)
+            swapTenors.push_back(i);
 
         double qSwAtmh[] = {
             1.81,  0.897, 0.819, 0.692, 0.551, 0.47,  0.416, 0.379, 0.357,
@@ -365,12 +365,12 @@ namespace {
         Real strksp[] = { -0.02,  -0.01,  -0.0050, -0.0025, 0.0,
                           0.0025, 0.0050, 0.01,    0.02 };
 
-        for (Size i = 0; i < 6; i++)
-            optionTenorsSmile.push_back(optTenSm[i]);
-        for (Size i = 0; i < 5; i++)
-            swapTenorsSmile.push_back(swpTenSm[i]);
-        for (Size i = 0; i < 9; i++)
-            strikeSpreads.push_back(strksp[i]);
+        for (auto& i : optTenSm)
+            optionTenorsSmile.push_back(i);
+        for (auto& i : swpTenSm)
+            swapTenorsSmile.push_back(i);
+        for (double& i : strksp)
+            strikeSpreads.push_back(i);
 
         std::vector<std::vector<Handle<Quote> > > qSwSmile;
 
@@ -682,10 +682,9 @@ void MarkovFunctionalTest::testKahaleSmileSection() {
     std::vector<Real> money;
     std::vector<Real> calls0;
 
-    for (Size i = 0; i < strikes.size(); i++) {
-        money.push_back(strikes[i] / atm);
-        calls0.push_back(blackFormula(Option::Call, strikes[i], atm,
-                                      0.50 * std::sqrt(t), 1.0, 0.0));
+    for (double strike : strikes) {
+        money.push_back(strike / atm);
+        calls0.push_back(blackFormula(Option::Call, strike, atm, 0.50 * std::sqrt(t), 1.0, 0.0));
     }
 
     std::vector<Real> stdDevs0 = impliedStdDevs(atm, strikes, calls0);
@@ -1256,11 +1255,11 @@ void MarkovFunctionalTest::testVanillaEngines() {
     c2.push_back(MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex2, 0.07));
     c2.push_back(MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex2, 0.10));
 
-    for (Size i = 0; i < c2.size(); i++) {
-        c2[i].setPricingEngine(blackCapFloorEngine2);
-        Real blackPrice = c2[i].NPV();
-        c2[i].setPricingEngine(mfCapFloorEngine2);
-        Real mfPrice = c2[i].NPV();
+    for (auto& i : c2) {
+        i.setPricingEngine(blackCapFloorEngine2);
+        Real blackPrice = i.NPV();
+        i.setPricingEngine(mfCapFloorEngine2);
+        Real mfPrice = i.NPV();
         if (fabs(blackPrice - mfPrice) > tol1)
             BOOST_ERROR(
                 "Basket 2 / flat termstructures: Cap/Floor premium market ("
@@ -1389,11 +1388,11 @@ void MarkovFunctionalTest::testVanillaEngines() {
     // c4.push_back(MakeCapFloor(CapFloor::Floor,5*Years,iborIndex4,0.10));
     // //exclude because caplet stripper fails for this strike
 
-    for (Size i = 0; i < c4.size(); i++) {
-        c4[i].setPricingEngine(blackCapFloorEngine4);
-        Real blackPrice = c4[i].NPV();
-        c4[i].setPricingEngine(mfCapFloorEngine4);
-        Real mfPrice = c4[i].NPV();
+    for (auto& i : c4) {
+        i.setPricingEngine(blackCapFloorEngine4);
+        Real blackPrice = i.NPV();
+        i.setPricingEngine(mfCapFloorEngine4);
+        Real mfPrice = i.NPV();
         if (fabs(blackPrice - mfPrice) > tol1)
             BOOST_ERROR(
                 "Basket 2 / real termstructures: Cap/Floor premium market ("
diff --git a/test-suite/matrices.cpp b/test-suite/matrices.cpp
index 26cb4b8c71c..a6dd3ed17f3 100644
--- a/test-suite/matrices.cpp
+++ b/test-suite/matrices.cpp
@@ -118,9 +118,8 @@ void MatricesTest::testEigenvectors() {
 
     Matrix testMatrices[] = { M1, M2 };
 
-    for (Size k=0; k<LENGTH(testMatrices); k++) {
+    for (auto& M : testMatrices) {
 
-        Matrix& M = testMatrices[k];
         SymmetricSchurDecomposition dec(M);
         Array eigenValues = dec.eigenvalues();
         Matrix eigenVectors = dec.eigenvectors();
@@ -203,9 +202,8 @@ void MatricesTest::testSVD() {
     Real tol = 1.0e-12;
     Matrix testMatrices[] = { M1, M2, M3, M4 };
 
-    for (Size j = 0; j < LENGTH(testMatrices); j++) {
+    for (auto& A : testMatrices) {
         // m >= n required (rows >= columns)
-        Matrix& A = testMatrices[j];
         SVD svd(A);
         // U is m x n
         const Matrix& U = svd.U();
@@ -251,11 +249,9 @@ void MatricesTest::testQRDecomposition() {
     Matrix testMatrices[] = { M1, M2, I,
                               M3, transpose(M3), M4, transpose(M4), M5 };
 
-    for (Size j = 0; j < LENGTH(testMatrices); j++) {
+    for (const auto& A : testMatrices) {
         Matrix Q, R;
         bool pivot = true;
-        const Matrix& A = testMatrices[j];
-
         const std::vector<Size> ipvt = qrDecomposition(A, Q, R, pivot);
 
         Matrix P(A.columns(), A.columns(), 0.0);
@@ -303,13 +299,12 @@ void MatricesTest::testQRSolve() {
                               bigM, transpose(bigM),
                               randM, transpose(randM) };
 
-    for (Size j = 0; j < LENGTH(testMatrices); j++) {
-        const Matrix& A = testMatrices[j];
+    for (const auto& A : testMatrices) {
         Array b(A.rows());
 
         for (Size k=0; k < 10; ++k) {
-            for (Array::iterator iter = b.begin(); iter != b.end(); ++iter) {
-                *iter = rng.next().value;
+            for (double& iter : b) {
+                iter = rng.next().value;
             }
             const Array x = qrSolve(A, b, true);
 
@@ -362,8 +357,7 @@ void MatricesTest::testInverse() {
     Real tol = 1.0e-12;
     Matrix testMatrices[] = { M1, M2, I, M5 };
 
-    for (Size j = 0; j < LENGTH(testMatrices); j++) {
-        const Matrix& A = testMatrices[j];
+    for (const auto& A : testMatrices) {
         const Matrix invA = inverse(A);
 
         const Matrix I1 = invA*A;
@@ -407,8 +401,8 @@ void MatricesTest::testDeterminant() {
     MersenneTwisterUniformRng rng(1234);
     for (Size j=0; j<100; ++j) {
         Matrix m(3, 3, 0.0);
-        for (Matrix::iterator iter = m.begin(); iter != m.end(); ++iter)
-            *iter = rng.next().value;
+        for (double& iter : m)
+            iter = rng.next().value;
 
         if ((j % 3) == 0U) {
             // every third matrix is a singular matrix
@@ -668,11 +662,11 @@ void MatricesTest::testIterativeSolvers() {
                 << "\n  rel tolerance : " << relTol);
     }
     const Array errors = Array(u.errors.begin(), u.errors.end());
-    for (Size i=0; i < errors.size(); ++i) {
-        const Array x = GMRES(MatrixMult(M1), 10, 1.01*errors[i]).solve(b, b).x;
+    for (double error : errors) {
+        const Array x = GMRES(MatrixMult(M1), 10, 1.01 * error).solve(b, b).x;
 
         const Real calculated = norm2(M1*x-b)/norm2(b);
-        const Real expected = errors[i];
+        const Real expected = error;
 
         if (std::fabs(calculated - expected) > relTol) {
             BOOST_FAIL("Failed to calculate solution error"
@@ -681,7 +675,7 @@ void MatricesTest::testIterativeSolvers() {
         }
     }
 
-    #if !defined(QL_NO_UBLAS_SUPPORT)
+#if !defined(QL_NO_UBLAS_SUPPORT)
     const Array v = GMRES(MatrixMult(M1), 1, relTol,
         MatrixMult(inverse(M1))).solve(b, b).x;
 
diff --git a/test-suite/nthorderderivativeop.cpp b/test-suite/nthorderderivativeop.cpp
index 4feaf1584e9..c71ff3a8666 100644
--- a/test-suite/nthorderderivativeop.cpp
+++ b/test-suite/nthorderderivativeop.cpp
@@ -520,8 +520,8 @@ namespace {
 
                     const Real offset = (specialPoint - 0.5*d) - loc[i];
 
-                    for (Size l = 0; l < loc.size(); ++l)
-                        loc[l] += offset;
+                    for (double& l : loc)
+                        l += offset;
 
                     break;
                 }
diff --git a/test-suite/nthtodefault.cpp b/test-suite/nthtodefault.cpp
index 08c38eadfd4..01021960857 100644
--- a/test-suite/nthtodefault.cpp
+++ b/test-suite/nthtodefault.cpp
@@ -146,8 +146,8 @@ void NthToDefaultTest::testGauss() {
 
     vector<Handle<DefaultProbabilityTermStructure> > probabilities;
     Period maxTerm (10, Years);
-    for (Size i = 0; i < lambda.size(); i++) {
-        Handle<Quote> h(ext::shared_ptr<Quote>(new SimpleQuote(lambda[i])));
+    for (double i : lambda) {
+        Handle<Quote> h(ext::shared_ptr<Quote>(new SimpleQuote(i)));
         ext::shared_ptr<DefaultProbabilityTermStructure> ptr (
                                          new FlatHazardRate(asofDate, h, dc));
         probabilities.push_back(Handle<DefaultProbabilityTermStructure>(ptr));
@@ -292,8 +292,8 @@ void NthToDefaultTest::testStudent() {
 
     vector<Handle<DefaultProbabilityTermStructure> > probabilities;
     Period maxTerm (10, Years);
-    for (Size i = 0; i < lambda.size(); i++) {
-        Handle<Quote> h(ext::shared_ptr<Quote>(new SimpleQuote(lambda[i])));
+    for (double i : lambda) {
+        Handle<Quote> h(ext::shared_ptr<Quote>(new SimpleQuote(i)));
         ext::shared_ptr<DefaultProbabilityTermStructure> ptr (
                                          new FlatHazardRate(asofDate, h, dc));
         probabilities.push_back(Handle<DefaultProbabilityTermStructure>(ptr));
diff --git a/test-suite/optimizers.cpp b/test-suite/optimizers.cpp
index 62d245bb616..b6ee37f1bed 100644
--- a/test-suite/optimizers.cpp
+++ b/test-suite/optimizers.cpp
@@ -213,8 +213,8 @@ namespace {
     Real maxDifference(const Array& a, const Array& b) {
         Array diff = a-b;
         Real maxDiff = 0.0;
-        for (Size i=0; i<diff.size(); ++i)
-            maxDiff = std::max(maxDiff, std::fabs(diff[i]));
+        for (double i : diff)
+            maxDiff = std::max(maxDiff, std::fabs(i));
         return maxDiff;
     }
 
@@ -401,8 +401,8 @@ namespace {
         }
         Real value(const Array& x) const override {
             Real fx = 0.0;
-            for (Size i=0; i<x.size(); ++i) {
-                fx += std::floor(x[i])*std::floor(x[i]);
+            for (double i : x) {
+                fx += std::floor(i) * std::floor(i);
             }
             return fx;
         }
@@ -435,8 +435,8 @@ namespace {
         }
         Real value(const Array& x) const override {
             Real fx = 0.0;
-            for (Size i=0; i<x.size(); ++i) {
-                fx += x[i]*x[i]/4000.0;
+            for (double i : x) {
+                fx += i * i / 4000.0;
             }
             Real p = 1.0;
             for (Size i=0; i<x.size(); ++i) {
diff --git a/test-suite/optionletstripper.cpp b/test-suite/optionletstripper.cpp
index 1f6077c29d6..8f155e9e399 100644
--- a/test-suite/optionletstripper.cpp
+++ b/test-suite/optionletstripper.cpp
@@ -104,8 +104,9 @@ struct CommonVars {
                 43956, 44321, 44686, 45051, 45418, 45782, 46147, 46512, 47609,
                 49436, 51263, 53087, 56739, 60392;
 
-            for (auto it = datesTmp.begin(); it != datesTmp.end(); ++it)
-                dates.push_back(Date(*it));
+            dates.reserve(datesTmp.size());
+            for (int& it : datesTmp)
+                dates.push_back(Date(it));
 
             rates += -0.00292, -0.00292, -0.001441, -0.00117, -0.001204,
                 -0.001212, -0.001223, -0.001236, -0.001221, -0.001238,
@@ -129,8 +130,8 @@ struct CommonVars {
                 49800, 50165, 50530, 50895, 51263, 51627, 51991, 52356, 52722,
                 53087, 54913, 56739, 60392, 64045;
 
-            for (auto it = datesTmp.begin(); it != datesTmp.end(); ++it)
-                dates.push_back(Date(*it));
+            for (int& it : datesTmp)
+                dates.push_back(Date(it));
 
             rates += 0.000649, 0.000649, 0.000684, 0.000717, 0.000745, 0.000872,
                 0.000905, 0.000954, 0.001532, 0.002319, 0.003147, 0.003949,
diff --git a/test-suite/overnightindexedswap.cpp b/test-suite/overnightindexedswap.cpp
index 7a5cb9a7586..e775b711aa8 100644
--- a/test-suite/overnightindexedswap.cpp
+++ b/test-suite/overnightindexedswap.cpp
@@ -190,39 +190,32 @@ void OvernightIndexedSwapTest::testFairRate() {
     Period lengths[] = { 1*Years, 2*Years, 5*Years, 10*Years, 20*Years };
     Spread spreads[] = { -0.001, -0.01, 0.0, 0.01, 0.001 };
 
-    for (Size i=0; i<LENGTH(lengths); i++) {
-        for (Size j=0; j<LENGTH(spreads); j++) {
+    for (auto& length : lengths) {
+        for (double spread : spreads) {
 
-            ext::shared_ptr<OvernightIndexedSwap> swap =
-                vars.makeSwap(lengths[i],0.0,spreads[j],false);
-            ext::shared_ptr<OvernightIndexedSwap> swap2 =
-                vars.makeSwap(lengths[i],0.0,spreads[j],true);
+            ext::shared_ptr<OvernightIndexedSwap> swap = vars.makeSwap(length, 0.0, spread, false);
+            ext::shared_ptr<OvernightIndexedSwap> swap2 = vars.makeSwap(length, 0.0, spread, true);
             if(std::fabs(swap->fairRate()-swap2->fairRate()) > 1.0e-10) {
                 BOOST_ERROR("fair rates are different:\n"
-                            << std::setprecision(2)
-                            << "    length: " << lengths[i] << " \n"
-                            << "    floating spread: "
-                            << io::rate(spreads[j]) << "\n"
+                            << std::setprecision(2) << "    length: " << length << " \n"
+                            << "    floating spread: " << io::rate(spread) << "\n"
                             << std::setprecision(12)
-                            << "    fair rate (non telescopic value dates): " << swap->fairRate() << "\n"
+                            << "    fair rate (non telescopic value dates): " << swap->fairRate()
+                            << "\n"
                             << "    fair rate (telescopic value dates)    : " << swap2->fairRate());
             }
-            swap = vars.makeSwap(lengths[i],swap->fairRate(),spreads[j],false);
+            swap = vars.makeSwap(length, swap->fairRate(), spread, false);
             if (std::fabs(swap->NPV()) > 1.0e-10) {
                 BOOST_ERROR("recalculating with implied rate (non telescopic value dates):\n"
-                            << std::setprecision(2)
-                            << "    length: " << lengths[i] << " \n"
-                            << "    floating spread: "
-                            << io::rate(spreads[j]) << "\n"
+                            << std::setprecision(2) << "    length: " << length << " \n"
+                            << "    floating spread: " << io::rate(spread) << "\n"
                             << "    swap value: " << swap->NPV());
             }
-            swap = vars.makeSwap(lengths[i],swap->fairRate(),spreads[j],true);
+            swap = vars.makeSwap(length, swap->fairRate(), spread, true);
             if (std::fabs(swap->NPV()) > 1.0e-10) {
                 BOOST_ERROR("recalculating with implied rate (telescopic value dates):\n"
-                            << std::setprecision(2)
-                            << "    length: " << lengths[i] << " \n"
-                            << "    floating spread: "
-                            << io::rate(spreads[j]) << "\n"
+                            << std::setprecision(2) << "    length: " << length << " \n"
+                            << "    floating spread: " << io::rate(spread) << "\n"
                             << "    swap value: " << swap->NPV());
             }
         }
@@ -242,45 +235,37 @@ void OvernightIndexedSwapTest::testFairSpread() {
     Period lengths[] = { 1*Years, 2*Years, 5*Years, 10*Years, 20*Years };
     Rate rates[] = { 0.04, 0.05, 0.06, 0.07 };
 
-    for (Size i=0; i<LENGTH(lengths); i++) {
-        for (Size j=0; j<LENGTH(rates); j++) {
+    for (auto& length : lengths) {
+        for (double j : rates) {
 
-            ext::shared_ptr<OvernightIndexedSwap> swap =
-                vars.makeSwap(lengths[i], rates[j], 0.0,false);
-            ext::shared_ptr<OvernightIndexedSwap> swap2 =
-                vars.makeSwap(lengths[i], rates[j], 0.0,true);
+            ext::shared_ptr<OvernightIndexedSwap> swap = vars.makeSwap(length, j, 0.0, false);
+            ext::shared_ptr<OvernightIndexedSwap> swap2 = vars.makeSwap(length, j, 0.0, true);
             Spread fairSpread = swap->fairSpread();
             Spread fairSpread2 = swap2->fairSpread();
             if(std::fabs(fairSpread-fairSpread2) > 1.0e-10) {
-                BOOST_ERROR("fair spreads are different:\n" <<
-                            std::setprecision(2) <<
-                            "\n     length: " << lengths[i] <<
-                            "\n fixed rate: " << io::rate(rates[j]) <<
-                            "\nfair spread (non telescopic value dates): " << io::rate(fairSpread) <<
-                            "\nfair spread (telescopic value dates)    : " << io::rate(fairSpread2));
-
+                BOOST_ERROR(
+                    "fair spreads are different:\n"
+                    << std::setprecision(2) << "\n     length: " << length
+                    << "\n fixed rate: " << io::rate(j)
+                    << "\nfair spread (non telescopic value dates): " << io::rate(fairSpread)
+                    << "\nfair spread (telescopic value dates)    : " << io::rate(fairSpread2));
             }
-            swap = vars.makeSwap(lengths[i], rates[j], fairSpread,false);
+            swap = vars.makeSwap(length, j, fairSpread, false);
             if (std::fabs(swap->NPV()) > 1.0e-10) {
-                BOOST_ERROR("\nrecalculating with implied spread (non telescopic value dates):" <<
-                            std::setprecision(2) <<
-                            "\n     length: " << lengths[i] <<
-                            "\n fixed rate: " << io::rate(rates[j]) <<
-                            "\nfair spread: " << io::rate(fairSpread) <<
-                            "\n swap value: " << swap->NPV());
+                BOOST_ERROR("\nrecalculating with implied spread (non telescopic value dates):"
+                            << std::setprecision(2) << "\n     length: " << length
+                            << "\n fixed rate: " << io::rate(j) << "\nfair spread: "
+                            << io::rate(fairSpread) << "\n swap value: " << swap->NPV());
             }
-            swap = vars.makeSwap(lengths[i], rates[j], fairSpread,true);
+            swap = vars.makeSwap(length, j, fairSpread, true);
             if (std::fabs(swap->NPV()) > 1.0e-10) {
-                BOOST_ERROR("\nrecalculating with implied spread (telescopic value dates):" <<
-                            std::setprecision(2) <<
-                            "\n     length: " << lengths[i] <<
-                            "\n fixed rate: " << io::rate(rates[j]) <<
-                            "\nfair spread: " << io::rate(fairSpread) <<
-                            "\n swap value: " << swap->NPV());
+                BOOST_ERROR("\nrecalculating with implied spread (telescopic value dates):"
+                            << std::setprecision(2) << "\n     length: " << length
+                            << "\n fixed rate: " << io::rate(j) << "\nfair spread: "
+                            << io::rate(fairSpread) << "\n swap value: " << swap->NPV());
             }
         }
     }
-
 }
 
 void OvernightIndexedSwapTest::testCachedValue() {
@@ -329,31 +314,26 @@ namespace overnight_indexed_swap_test {
     ext::shared_ptr<IborIndex> euribor3m(new Euribor3M);
     ext::shared_ptr<Eonia> eonia(new Eonia);
 
-    for (Size i = 0; i < LENGTH(depositData); i++) {
-        Real rate = 0.01 * depositData[i].rate;
+    for (auto& i : depositData) {
+        Real rate = 0.01 * i.rate;
         ext::shared_ptr<SimpleQuote> simple = ext::make_shared<SimpleQuote>(rate);
         ext::shared_ptr<Quote> quote (simple);
-        Period term = depositData[i].n * depositData[i].unit;
-        ext::shared_ptr<RateHelper> helper(new
-                    DepositRateHelper(Handle<Quote>(quote),
-                                      term,
-                                      depositData[i].settlementDays,
-                                      euribor3m->fixingCalendar(),
-                                      euribor3m->businessDayConvention(),
-                                      euribor3m->endOfMonth(),
-                                      euribor3m->dayCounter()));
+        Period term = i.n * i.unit;
+        ext::shared_ptr<RateHelper> helper(new DepositRateHelper(
+            Handle<Quote>(quote), term, i.settlementDays, euribor3m->fixingCalendar(),
+            euribor3m->businessDayConvention(), euribor3m->endOfMonth(), euribor3m->dayCounter()));
 
         if (term <= 2*Days)
             eoniaHelpers.push_back(helper);
     }
 
-    for (Size i = 0; i < LENGTH(eoniaSwapData); i++) {
-        Real rate = 0.01 * eoniaSwapData[i].rate;
+    for (auto& i : eoniaSwapData) {
+        Real rate = 0.01 * i.rate;
         ext::shared_ptr<SimpleQuote> simple = ext::make_shared<SimpleQuote>(rate);
         ext::shared_ptr<Quote> quote (simple);
-        Period term = eoniaSwapData[i].n * eoniaSwapData[i].unit;
+        Period term = i.n * i.unit;
         ext::shared_ptr<RateHelper> helper(new
-                     OISRateHelper(eoniaSwapData[i].settlementDays,
+                     OISRateHelper(i.settlementDays,
                                    term,
                                    Handle<Quote>(quote),
                                    eonia,
@@ -377,9 +357,9 @@ namespace overnight_indexed_swap_test {
     vars.eoniaTermStructure.linkTo(eoniaTS);
 
     // test curve consistency
-    for (Size i = 0; i < LENGTH(eoniaSwapData); i++) {
-        Rate expected = eoniaSwapData[i].rate/100;
-        Period term = eoniaSwapData[i].n * eoniaSwapData[i].unit;
+    for (auto& i : eoniaSwapData) {
+        Rate expected = i.rate / 100;
+        Period term = i.n * i.unit;
         // test telescopic value dates (in bootstrap) against non telescopic value dates (swap here)
         ext::shared_ptr<OvernightIndexedSwap> swap =
             vars.makeSwap(term, 0.0, 0.0, false, Null<Date>(), paymentLag, averagingMethod);
@@ -440,19 +420,17 @@ void OvernightIndexedSwapTest::testSeasonedSwaps() {
     vars.eoniaIndex->addFixing(Date(4,February,2009), 0.0012);
     vars.eoniaIndex->addFixing(Date(5,February,2009), 0.0013);
 
-    for (Size i=0; i<LENGTH(lengths); i++) {
-        for (Size j=0; j<LENGTH(spreads); j++) {
+    for (auto& length : lengths) {
+        for (double spread : spreads) {
 
             ext::shared_ptr<OvernightIndexedSwap> swap =
-                vars.makeSwap(lengths[i],0.0,spreads[j],false,effectiveDate);
+                vars.makeSwap(length, 0.0, spread, false, effectiveDate);
             ext::shared_ptr<OvernightIndexedSwap> swap2 =
-                vars.makeSwap(lengths[i],0.0,spreads[j],true,effectiveDate);
+                vars.makeSwap(length, 0.0, spread, true, effectiveDate);
             if (std::fabs(swap->NPV() - swap2->NPV()) > 1.0e-10) {
                 BOOST_ERROR("swap npv is different:\n"
-                            << std::setprecision(2)
-                            << "    length: " << lengths[i] << " \n"
-                            << "    floating spread: "
-                            << io::rate(spreads[j]) << "\n"
+                            << std::setprecision(2) << "    length: " << length << " \n"
+                            << "    floating spread: " << io::rate(spread) << "\n"
                             << "    swap value (non telescopic value dates): " << swap->NPV()
                             << "\n    swap value (telescopic value dates    ): " << swap2->NPV());
             }
diff --git a/test-suite/partialtimebarrieroption.cpp b/test-suite/partialtimebarrieroption.cpp
index 88e3cdbbb81..710b9f4055a 100644
--- a/test-suite/partialtimebarrieroption.cpp
+++ b/test-suite/partialtimebarrieroption.cpp
@@ -101,10 +101,10 @@ void PartialTimeBarrierOptionTest::testAnalyticEngine() {
         { 105.0, 110.0, 359, 13.1376 }
     };
 
-    for (Size i=0; i<LENGTH(cases); ++i) {
-        Date coverEventDate = today + cases[i].days;
+    for (auto& i : cases) {
+        Date coverEventDate = today + i.days;
         ext::shared_ptr<StrikedTypePayoff> payoff =
-            ext::make_shared<PlainVanillaPayoff>(type, cases[i].strike);
+            ext::make_shared<PlainVanillaPayoff>(type, i.strike);
         PartialTimeBarrierOption option(PartialBarrier::DownOut,
                                         PartialBarrier::EndB1,
                                         barrier, rebate,
@@ -112,9 +112,9 @@ void PartialTimeBarrierOptionTest::testAnalyticEngine() {
                                         payoff, exercise);
         option.setPricingEngine(engine);
 
-        spot->setValue(cases[i].underlying);
+        spot->setValue(i.underlying);
         Real calculated = option.NPV();
-        Real expected = cases[i].result;
+        Real expected = i.result;
         Real error = std::fabs(calculated-expected);
         Real tolerance = 1e-4;
         if (error > tolerance)
diff --git a/test-suite/piecewiseyieldcurve.cpp b/test-suite/piecewiseyieldcurve.cpp
index 06c43499e43..ed2556c2ffc 100644
--- a/test-suite/piecewiseyieldcurve.cpp
+++ b/test-suite/piecewiseyieldcurve.cpp
@@ -1044,8 +1044,8 @@ namespace piecewise_yield_curve_test {
             BOOST_ERROR("failed to link original and copied curve");
         }
 
-        for (Size i=0; i<vars.rates.size(); ++i) {
-            vars.rates[i]->setValue(vars.rates[i]->value() + 0.001);
+        for (auto& rate : vars.rates) {
+            rate->setValue(rate->value() + 0.001);
         }
 
         // now the original curve should have changed; the copied
@@ -1162,12 +1162,9 @@ void PiecewiseYieldCurveTest::testBadPreviousCurve() {
 
     std::vector<ext::shared_ptr<RateHelper> > helpers;
     ext::shared_ptr<Euribor> euribor1m(new Euribor1M);
-    for (Size i=0; i<LENGTH(data); ++i) {
-        helpers.push_back(
-           ext::make_shared<SwapRateHelper>(data[i].rate,
-                                              Period(data[i].n, data[i].units),
-                                              TARGET(), Monthly, Unadjusted,
-                                              Thirty360(), euribor1m));
+    for (auto& i : data) {
+        helpers.push_back(ext::make_shared<SwapRateHelper>(
+            i.rate, Period(i.n, i.units), TARGET(), Monthly, Unadjusted, Thirty360(), euribor1m));
     }
 
     Date today = Date(12, October, 2017);
@@ -1189,8 +1186,8 @@ void PiecewiseYieldCurveTest::testBadPreviousCurve() {
     h.linkTo(curve);
 
     ext::shared_ptr<Euribor1M> index = ext::make_shared<Euribor1M>(h);
-    for (Size i=0; i<LENGTH(data); i++) {
-        Period tenor = data[i].n*data[i].units;
+    for (auto& i : data) {
+        Period tenor = i.n * i.units;
 
         VanillaSwap swap = MakeVanillaSwap(tenor, index, 0.0)
             .withFixedLegDayCount(Thirty360())
@@ -1198,8 +1195,7 @@ void PiecewiseYieldCurveTest::testBadPreviousCurve() {
             .withFixedLegConvention(Unadjusted);
         swap.setPricingEngine(ext::make_shared<DiscountingSwapEngine>(h));
 
-        Rate expectedRate = data[i].rate,
-             estimatedRate = swap.fairRate();
+        Rate expectedRate = i.rate, estimatedRate = swap.fairRate();
         Spread error = std::fabs(expectedRate-estimatedRate);
         Real tolerance = 1.0e-9;
         if (error > tolerance) {
@@ -1255,12 +1251,9 @@ void PiecewiseYieldCurveTest::testLargeRates() {
     };
 
     std::vector<ext::shared_ptr<RateHelper> > helpers;
-    for (Size i=0; i<LENGTH(data); ++i) {
-        helpers.push_back(
-           ext::make_shared<DepositRateHelper>(data[i].rate,
-                                               Period(data[i].n, data[i].units),
-                                               0, WeekendsOnly(), Following,
-                                               false, Actual360()));
+    for (auto& i : data) {
+        helpers.push_back(ext::make_shared<DepositRateHelper>(
+            i.rate, Period(i.n, i.units), 0, WeekendsOnly(), Following, false, Actual360()));
     }
 
     Date today = Date(12, October, 2017);
diff --git a/test-suite/quantooption.cpp b/test-suite/quantooption.cpp
index d99276e04dd..0c9f1235390 100644
--- a/test-suite/quantooption.cpp
+++ b/test-suite/quantooption.cpp
@@ -264,37 +264,33 @@ void QuantoOptionTest::testValues() {
                                                  stochProcess, fxrTS, fxVolTS,
                                                  Handle<Quote>(correlation)));
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(
-                    new PlainVanillaPayoff(values[i].type, values[i].strike));
-        Date exDate = today + timeToDays(values[i].t);
+        ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(value.type, value.strike));
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
-        fxRate->setValue(values[i].fxr);
-        fxVol->setValue(values[i].fxv);
-        correlation->setValue(values[i].corr);
+        fxRate->setValue(value.fxr);
+        fxVol->setValue(value.fxv);
+        correlation->setValue(value.corr);
 
         QuantoVanillaOption option(payoff, exercise);
         option.setPricingEngine(engine);
 
         Real calculated = option.NPV();
-        Real error = std::fabs(calculated-values[i].result);
+        Real error = std::fabs(calculated - value.result);
         Real tolerance = 1e-4;
         if (error>tolerance) {
-            QUANTO_REPORT_FAILURE("value", payoff, exercise, values[i].s,
-                           values[i].q, values[i].r, today,
-                           values[i].v, values[i].fxr, values[i].fxv,
-                           values[i].corr, values[i].result, calculated,
-                           error, tolerance);
+            QUANTO_REPORT_FAILURE("value", payoff, exercise, value.s, value.q, value.r, today,
+                                  value.v, value.fxr, value.fxv, value.corr, value.result,
+                                  calculated, error, tolerance);
         }
     }
-
 }
 
 
@@ -349,154 +345,149 @@ void QuantoOptionTest::testGreeks() {
                                                   stochProcess,fxrTS, fxVolTS,
                                                   Handle<Quote>(correlation)));
 
-    for (Size i=0; i<LENGTH(types); i++) {
-      for (Size j=0; j<LENGTH(strikes); j++) {
-        for (Size k=0; k<LENGTH(lengths); k++) {
-
-          Date exDate = today + lengths[k]*Years;
-          ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
-
-          ext::shared_ptr<StrikedTypePayoff> payoff(
-                                new PlainVanillaPayoff(types[i], strikes[j]));
-
-          QuantoVanillaOption option(payoff, exercise);
-          option.setPricingEngine(engine);
-
-          for (Size l=0; l<LENGTH(underlyings); l++) {
-            for (Size m=0; m<LENGTH(qRates); m++) {
-              for (Size n=0; n<LENGTH(rRates); n++) {
-                for (Size p=0; p<LENGTH(vols); p++) {
-                  for (Size a=0; a<LENGTH(rRates); a++) {
-                    for (Size b=0; b<LENGTH(vols); b++) {
-                      for (Size c=0; c<LENGTH(correlations); c++) {
-
-                        Real u = underlyings[l];
-                        Rate q = qRates[m],
-                             r = rRates[n];
-                        Volatility v = vols[p];
-                        Rate fxr = rRates[a];
-                        Volatility fxv = vols[b];
-                        Rate corr = correlations[c];
-                        spot->setValue(u);
-                        qRate->setValue(q);
-                        rRate->setValue(r);
-                        vol->setValue(v);
-                        fxRate->setValue(fxr);
-                        fxVol->setValue(fxv);
-                        correlation->setValue(corr);
-
-                        Real value = option.NPV();
-                        calculated["delta"]   = option.delta();
-                        calculated["gamma"]   = option.gamma();
-                        calculated["theta"]   = option.theta();
-                        calculated["rho"]     = option.rho();
-                        calculated["divRho"]  = option.dividendRho();
-                        calculated["vega"]    = option.vega();
-                        calculated["qrho"]    = option.qrho();
-                        calculated["qvega"]   = option.qvega();
-                        calculated["qlambda"] = option.qlambda();
-
-                        if (value > spot->value()*1.0e-5) {
-                          // perturb spot and get delta and gamma
-                          Real du = u*1.0e-4;
-                          spot->setValue(u+du);
-                          Real value_p = option.NPV(),
-                               delta_p = option.delta();
-                          spot->setValue(u-du);
-                          Real value_m = option.NPV(),
-                               delta_m = option.delta();
-                          spot->setValue(u);
-                          expected["delta"] = (value_p - value_m)/(2*du);
-                          expected["gamma"] = (delta_p - delta_m)/(2*du);
-
-                          // perturb rates and get rho and dividend rho
-                          Spread dr = r*1.0e-4;
-                          rRate->setValue(r+dr);
-                          value_p = option.NPV();
-                          rRate->setValue(r-dr);
-                          value_m = option.NPV();
-                          rRate->setValue(r);
-                          expected["rho"] = (value_p - value_m)/(2*dr);
-
-                          Spread dq = q*1.0e-4;
-                          qRate->setValue(q+dq);
-                          value_p = option.NPV();
-                          qRate->setValue(q-dq);
-                          value_m = option.NPV();
-                          qRate->setValue(q);
-                          expected["divRho"] = (value_p - value_m)/(2*dq);
-
-                          // perturb volatility and get vega
-                          Volatility dv = v*1.0e-4;
-                          vol->setValue(v+dv);
-                          value_p = option.NPV();
-                          vol->setValue(v-dv);
-                          value_m = option.NPV();
-                          vol->setValue(v);
-                          expected["vega"] = (value_p - value_m)/(2*dv);
-
-                          // perturb fx rate and get qrho
-                          Spread dfxr = fxr*1.0e-4;
-                          fxRate->setValue(fxr+dfxr);
-                          value_p = option.NPV();
-                          fxRate->setValue(fxr-dfxr);
-                          value_m = option.NPV();
-                          fxRate->setValue(fxr);
-                          expected["qrho"] = (value_p - value_m)/(2*dfxr);
-
-                          // perturb fx volatility and get qvega
-                          Volatility dfxv = fxv*1.0e-4;
-                          fxVol->setValue(fxv+dfxv);
-                          value_p = option.NPV();
-                          fxVol->setValue(fxv-dfxv);
-                          value_m = option.NPV();
-                          fxVol->setValue(fxv);
-                          expected["qvega"] = (value_p - value_m)/(2*dfxv);
-
-                          // perturb correlation and get qlambda
-                          Real dcorr = corr*1.0e-4;
-                          correlation->setValue(corr+dcorr);
-                          value_p = option.NPV();
-                          correlation->setValue(corr-dcorr);
-                          value_m = option.NPV();
-                          correlation->setValue(corr);
-                          expected["qlambda"] = (value_p - value_m)/(2*dcorr);
-
-                          // perturb date and get theta
-                          Time dT = dc.yearFraction(today-1, today+1);
-                          Settings::instance().evaluationDate() = today-1;
-                          value_m = option.NPV();
-                          Settings::instance().evaluationDate() = today+1;
-                          value_p = option.NPV();
-                          Settings::instance().evaluationDate() = today;
-                          expected["theta"] = (value_p - value_m)/dT;
-
-                          // compare
-                          std::map<std::string,Real>::iterator it;
-                          for (it = calculated.begin();
-                               it != calculated.end(); ++it) {
-                              std::string greek = it->first;
-                              Real expct = expected  [greek],
-                                   calcl = calculated[greek],
-                                   tol   = tolerance [greek];
-                              Real error = relativeError(expct,calcl,u);
-                              if (error>tol) {
-                                  QUANTO_REPORT_FAILURE(greek, payoff, exercise,
-                                                 u, q, r, today, v,
-                                                 fxr, fxv, corr,
-                                                 expct, calcl, error, tol);
-                              }
-                          }
+    for (auto& type : types) {
+        for (double strike : strikes) {
+            for (int length : lengths) {
+
+                Date exDate = today + length * Years;
+                ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
+
+                ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(type, strike));
+
+                QuantoVanillaOption option(payoff, exercise);
+                option.setPricingEngine(engine);
+
+                for (double u : underlyings) {
+                    for (double m : qRates) {
+                        for (double n : rRates) {
+                            for (double v : vols) {
+                                for (double fxr : rRates) {
+                                    for (double fxv : vols) {
+                                        for (double corr : correlations) {
+
+                                            Rate q = m, r = n;
+                                            spot->setValue(u);
+                                            qRate->setValue(q);
+                                            rRate->setValue(r);
+                                            vol->setValue(v);
+                                            fxRate->setValue(fxr);
+                                            fxVol->setValue(fxv);
+                                            correlation->setValue(corr);
+
+                                            Real value = option.NPV();
+                                            calculated["delta"] = option.delta();
+                                            calculated["gamma"] = option.gamma();
+                                            calculated["theta"] = option.theta();
+                                            calculated["rho"] = option.rho();
+                                            calculated["divRho"] = option.dividendRho();
+                                            calculated["vega"] = option.vega();
+                                            calculated["qrho"] = option.qrho();
+                                            calculated["qvega"] = option.qvega();
+                                            calculated["qlambda"] = option.qlambda();
+
+                                            if (value > spot->value() * 1.0e-5) {
+                                                // perturb spot and get delta and gamma
+                                                Real du = u * 1.0e-4;
+                                                spot->setValue(u + du);
+                                                Real value_p = option.NPV(),
+                                                     delta_p = option.delta();
+                                                spot->setValue(u - du);
+                                                Real value_m = option.NPV(),
+                                                     delta_m = option.delta();
+                                                spot->setValue(u);
+                                                expected["delta"] = (value_p - value_m) / (2 * du);
+                                                expected["gamma"] = (delta_p - delta_m) / (2 * du);
+
+                                                // perturb rates and get rho and dividend rho
+                                                Spread dr = r * 1.0e-4;
+                                                rRate->setValue(r + dr);
+                                                value_p = option.NPV();
+                                                rRate->setValue(r - dr);
+                                                value_m = option.NPV();
+                                                rRate->setValue(r);
+                                                expected["rho"] = (value_p - value_m) / (2 * dr);
+
+                                                Spread dq = q * 1.0e-4;
+                                                qRate->setValue(q + dq);
+                                                value_p = option.NPV();
+                                                qRate->setValue(q - dq);
+                                                value_m = option.NPV();
+                                                qRate->setValue(q);
+                                                expected["divRho"] = (value_p - value_m) / (2 * dq);
+
+                                                // perturb volatility and get vega
+                                                Volatility dv = v * 1.0e-4;
+                                                vol->setValue(v + dv);
+                                                value_p = option.NPV();
+                                                vol->setValue(v - dv);
+                                                value_m = option.NPV();
+                                                vol->setValue(v);
+                                                expected["vega"] = (value_p - value_m) / (2 * dv);
+
+                                                // perturb fx rate and get qrho
+                                                Spread dfxr = fxr * 1.0e-4;
+                                                fxRate->setValue(fxr + dfxr);
+                                                value_p = option.NPV();
+                                                fxRate->setValue(fxr - dfxr);
+                                                value_m = option.NPV();
+                                                fxRate->setValue(fxr);
+                                                expected["qrho"] = (value_p - value_m) / (2 * dfxr);
+
+                                                // perturb fx volatility and get qvega
+                                                Volatility dfxv = fxv * 1.0e-4;
+                                                fxVol->setValue(fxv + dfxv);
+                                                value_p = option.NPV();
+                                                fxVol->setValue(fxv - dfxv);
+                                                value_m = option.NPV();
+                                                fxVol->setValue(fxv);
+                                                expected["qvega"] =
+                                                    (value_p - value_m) / (2 * dfxv);
+
+                                                // perturb correlation and get qlambda
+                                                Real dcorr = corr * 1.0e-4;
+                                                correlation->setValue(corr + dcorr);
+                                                value_p = option.NPV();
+                                                correlation->setValue(corr - dcorr);
+                                                value_m = option.NPV();
+                                                correlation->setValue(corr);
+                                                expected["qlambda"] =
+                                                    (value_p - value_m) / (2 * dcorr);
+
+                                                // perturb date and get theta
+                                                Time dT = dc.yearFraction(today - 1, today + 1);
+                                                Settings::instance().evaluationDate() = today - 1;
+                                                value_m = option.NPV();
+                                                Settings::instance().evaluationDate() = today + 1;
+                                                value_p = option.NPV();
+                                                Settings::instance().evaluationDate() = today;
+                                                expected["theta"] = (value_p - value_m) / dT;
+
+                                                // compare
+                                                std::map<std::string, Real>::iterator it;
+                                                for (it = calculated.begin();
+                                                     it != calculated.end(); ++it) {
+                                                    std::string greek = it->first;
+                                                    Real expct = expected[greek],
+                                                         calcl = calculated[greek],
+                                                         tol = tolerance[greek];
+                                                    Real error = relativeError(expct, calcl, u);
+                                                    if (error > tol) {
+                                                        QUANTO_REPORT_FAILURE(
+                                                            greek, payoff, exercise, u, q, r, today,
+                                                            v, fxr, fxv, corr, expct, calcl, error,
+                                                            tol);
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
                         }
-                      }
                     }
-                  }
                 }
-              }
             }
-          }
         }
-      }
     }
 }
 
@@ -547,40 +538,35 @@ void QuantoOptionTest::testForwardValues() {
                                                  stochProcess, fxrTS, fxVolTS,
                                                  Handle<Quote>(correlation)));
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(
-                                 new PlainVanillaPayoff(values[i].type, 0.0));
-        Date exDate = today + timeToDays(values[i].t);
+        ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(value.type, 0.0));
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
-        Date reset = today + timeToDays(values[i].start);
+        Date reset = today + timeToDays(value.start);
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
-        fxRate->setValue(values[i].fxr);
-        fxVol->setValue(values[i].fxv);
-        correlation->setValue(values[i].corr);
+        fxRate->setValue(value.fxr);
+        fxVol->setValue(value.fxv);
+        correlation->setValue(value.corr);
 
-        QuantoForwardVanillaOption option(values[i].moneyness, reset,
-                                          payoff, exercise);
+        QuantoForwardVanillaOption option(value.moneyness, reset, payoff, exercise);
         option.setPricingEngine(engine);
 
         Real calculated = option.NPV();
-        Real error = std::fabs(calculated-values[i].result);
+        Real error = std::fabs(calculated - value.result);
         Real tolerance = 1e-4;
         if (error>tolerance) {
-            QUANTO_FORWARD_REPORT_FAILURE("value", payoff, values[i].moneyness,
-                            exercise, values[i].s,
-                            values[i].q, values[i].r, today, reset,
-                            values[i].v, values[i].fxr, values[i].fxv,
-                            values[i].corr, values[i].result, calculated,
-                            error, tolerance);
+            QUANTO_FORWARD_REPORT_FAILURE("value", payoff, value.moneyness, exercise, value.s,
+                                          value.q, value.r, today, reset, value.v, value.fxr,
+                                          value.fxv, value.corr, value.result, calculated, error,
+                                          tolerance);
         }
     }
-
 }
 
 
@@ -637,160 +623,161 @@ void QuantoOptionTest::testForwardGreeks() {
                                                  stochProcess, fxrTS, fxVolTS,
                                                  Handle<Quote>(correlation)));
 
-    for (Size i=0; i<LENGTH(types); i++) {
-      for (Size j=0; j<LENGTH(moneyness); j++) {
-        for (Size k=0; k<LENGTH(lengths); k++) {
-          for (Size h=0; h<LENGTH(startMonths); h++) {
-
-            Date exDate = today + lengths[k]*Years;
-            ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
-
-            Date reset = today + startMonths[h]*Months;
-
-            ext::shared_ptr<StrikedTypePayoff> payoff(
-                                       new PlainVanillaPayoff(types[i], 0.0));
-
-            QuantoForwardVanillaOption option(moneyness[j], reset,
-                                              payoff, exercise);
-            option.setPricingEngine(engine);
-
-            for (Size l=0; l<LENGTH(underlyings); l++) {
-              for (Size m=0; m<LENGTH(qRates); m++) {
-                for (Size n=0; n<LENGTH(rRates); n++) {
-                  for (Size p=0; p<LENGTH(vols); p++) {
-                    for (Size a=0; a<LENGTH(rRates); a++) {
-                      for (Size b=0; b<LENGTH(vols); b++) {
-                        for (Size c=0; c<LENGTH(correlations); c++) {
-
-                          Real u = underlyings[l];
-                          Rate q = qRates[m],
-                               r = rRates[n];
-                          Volatility v = vols[p];
-                          Rate fxr = rRates[a];
-                          Volatility fxv = vols[b];
-                          Real corr = correlations[c];
-                          spot->setValue(u);
-                          qRate->setValue(q);
-                          rRate->setValue(r);
-                          vol->setValue(v);
-                          fxRate->setValue(fxr);
-                          fxVol->setValue(fxv);
-                          correlation->setValue(corr);
-
-                          Real value = option.NPV();
-                          calculated["delta"]   = option.delta();
-                          calculated["gamma"]   = option.gamma();
-                          calculated["theta"]   = option.theta();
-                          calculated["rho"]     = option.rho();
-                          calculated["divRho"]  = option.dividendRho();
-                          calculated["vega"]    = option.vega();
-                          calculated["qrho"]    = option.qrho();
-                          calculated["qvega"]   = option.qvega();
-                          calculated["qlambda"] = option.qlambda();
-
-                          if (value > spot->value()*1.0e-5) {
-                            // perturb spot and get delta and gamma
-                            Real du = u*1.0e-4;
-                            spot->setValue(u+du);
-                            Real value_p = option.NPV(),
-                                 delta_p = option.delta();
-                            spot->setValue(u-du);
-                            Real value_m = option.NPV(),
-                                 delta_m = option.delta();
-                            spot->setValue(u);
-                            expected["delta"] = (value_p - value_m)/(2*du);
-                            expected["gamma"] = (delta_p - delta_m)/(2*du);
-
-                            // perturb rates and get rho and dividend rho
-                            Spread dr = r*1.0e-4;
-                            rRate->setValue(r+dr);
-                            value_p = option.NPV();
-                            rRate->setValue(r-dr);
-                            value_m = option.NPV();
-                            rRate->setValue(r);
-                            expected["rho"] = (value_p - value_m)/(2*dr);
-
-                            Spread dq = q*1.0e-4;
-                            qRate->setValue(q+dq);
-                            value_p = option.NPV();
-                            qRate->setValue(q-dq);
-                            value_m = option.NPV();
-                            qRate->setValue(q);
-                            expected["divRho"] = (value_p - value_m)/(2*dq);
-
-                            // perturb volatility and get vega
-                            Volatility dv = v*1.0e-4;
-                            vol->setValue(v+dv);
-                            value_p = option.NPV();
-                            vol->setValue(v-dv);
-                            value_m = option.NPV();
-                            vol->setValue(v);
-                            expected["vega"] = (value_p - value_m)/(2*dv);
-
-                            // perturb fx rate and get qrho
-                            Spread dfxr = fxr*1.0e-4;
-                            fxRate->setValue(fxr+dfxr);
-                            value_p = option.NPV();
-                            fxRate->setValue(fxr-dfxr);
-                            value_m = option.NPV();
-                            fxRate->setValue(fxr);
-                            expected["qrho"] = (value_p - value_m)/(2*dfxr);
-
-                            // perturb fx volatility and get qvega
-                            Volatility dfxv = fxv*1.0e-4;
-                            fxVol->setValue(fxv+dfxv);
-                            value_p = option.NPV();
-                            fxVol->setValue(fxv-dfxv);
-                            value_m = option.NPV();
-                            fxVol->setValue(fxv);
-                            expected["qvega"] = (value_p - value_m)/(2*dfxv);
-
-                            // perturb correlation and get qlambda
-                            Real dcorr = corr*1.0e-4;
-                            correlation->setValue(corr+dcorr);
-                            value_p = option.NPV();
-                            correlation->setValue(corr-dcorr);
-                            value_m = option.NPV();
-                            correlation->setValue(corr);
-                            expected["qlambda"] =
-                                (value_p - value_m)/(2*dcorr);
-
-                            // perturb date and get theta
-                            Time dT = dc.yearFraction(today-1, today+1);
-                            Settings::instance().evaluationDate() = today-1;
-                            value_m = option.NPV();
-                            Settings::instance().evaluationDate() = today+1;
-                            value_p = option.NPV();
-                            Settings::instance().evaluationDate() = today;
-                            expected["theta"] = (value_p - value_m)/dT;
-
-                            // compare
-                            std::map<std::string,Real>::iterator it;
-                            for (it = calculated.begin();
-                                 it != calculated.end(); ++it) {
-                              std::string greek = it->first;
-                              Real expct = expected  [greek],
-                                   calcl = calculated[greek],
-                                   tol   = tolerance [greek];
-                              Real error = relativeError(expct,calcl,u);
-                              if (error>tol) {
-                                  QUANTO_FORWARD_REPORT_FAILURE(greek, payoff,
-                                      moneyness[j],
-                                      exercise, u, q, r, today, reset, v, fxr,
-                                      fxv, corr, expct, calcl, error, tol);
-                              }
+    for (auto& type : types) {
+        for (double moneynes : moneyness) {
+            for (int length : lengths) {
+                for (int startMonth : startMonths) {
+
+                    Date exDate = today + length * Years;
+                    ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
+
+                    Date reset = today + startMonth * Months;
+
+                    ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(type, 0.0));
+
+                    QuantoForwardVanillaOption option(moneynes, reset, payoff, exercise);
+                    option.setPricingEngine(engine);
+
+                    for (double u : underlyings) {
+                        for (double m : qRates) {
+                            for (double n : rRates) {
+                                for (double v : vols) {
+                                    for (double fxr : rRates) {
+                                        for (double fxv : vols) {
+                                            for (double corr : correlations) {
+
+                                                Rate q = m, r = n;
+                                                spot->setValue(u);
+                                                qRate->setValue(q);
+                                                rRate->setValue(r);
+                                                vol->setValue(v);
+                                                fxRate->setValue(fxr);
+                                                fxVol->setValue(fxv);
+                                                correlation->setValue(corr);
+
+                                                Real value = option.NPV();
+                                                calculated["delta"] = option.delta();
+                                                calculated["gamma"] = option.gamma();
+                                                calculated["theta"] = option.theta();
+                                                calculated["rho"] = option.rho();
+                                                calculated["divRho"] = option.dividendRho();
+                                                calculated["vega"] = option.vega();
+                                                calculated["qrho"] = option.qrho();
+                                                calculated["qvega"] = option.qvega();
+                                                calculated["qlambda"] = option.qlambda();
+
+                                                if (value > spot->value() * 1.0e-5) {
+                                                    // perturb spot and get delta and gamma
+                                                    Real du = u * 1.0e-4;
+                                                    spot->setValue(u + du);
+                                                    Real value_p = option.NPV(),
+                                                         delta_p = option.delta();
+                                                    spot->setValue(u - du);
+                                                    Real value_m = option.NPV(),
+                                                         delta_m = option.delta();
+                                                    spot->setValue(u);
+                                                    expected["delta"] =
+                                                        (value_p - value_m) / (2 * du);
+                                                    expected["gamma"] =
+                                                        (delta_p - delta_m) / (2 * du);
+
+                                                    // perturb rates and get rho and dividend rho
+                                                    Spread dr = r * 1.0e-4;
+                                                    rRate->setValue(r + dr);
+                                                    value_p = option.NPV();
+                                                    rRate->setValue(r - dr);
+                                                    value_m = option.NPV();
+                                                    rRate->setValue(r);
+                                                    expected["rho"] =
+                                                        (value_p - value_m) / (2 * dr);
+
+                                                    Spread dq = q * 1.0e-4;
+                                                    qRate->setValue(q + dq);
+                                                    value_p = option.NPV();
+                                                    qRate->setValue(q - dq);
+                                                    value_m = option.NPV();
+                                                    qRate->setValue(q);
+                                                    expected["divRho"] =
+                                                        (value_p - value_m) / (2 * dq);
+
+                                                    // perturb volatility and get vega
+                                                    Volatility dv = v * 1.0e-4;
+                                                    vol->setValue(v + dv);
+                                                    value_p = option.NPV();
+                                                    vol->setValue(v - dv);
+                                                    value_m = option.NPV();
+                                                    vol->setValue(v);
+                                                    expected["vega"] =
+                                                        (value_p - value_m) / (2 * dv);
+
+                                                    // perturb fx rate and get qrho
+                                                    Spread dfxr = fxr * 1.0e-4;
+                                                    fxRate->setValue(fxr + dfxr);
+                                                    value_p = option.NPV();
+                                                    fxRate->setValue(fxr - dfxr);
+                                                    value_m = option.NPV();
+                                                    fxRate->setValue(fxr);
+                                                    expected["qrho"] =
+                                                        (value_p - value_m) / (2 * dfxr);
+
+                                                    // perturb fx volatility and get qvega
+                                                    Volatility dfxv = fxv * 1.0e-4;
+                                                    fxVol->setValue(fxv + dfxv);
+                                                    value_p = option.NPV();
+                                                    fxVol->setValue(fxv - dfxv);
+                                                    value_m = option.NPV();
+                                                    fxVol->setValue(fxv);
+                                                    expected["qvega"] =
+                                                        (value_p - value_m) / (2 * dfxv);
+
+                                                    // perturb correlation and get qlambda
+                                                    Real dcorr = corr * 1.0e-4;
+                                                    correlation->setValue(corr + dcorr);
+                                                    value_p = option.NPV();
+                                                    correlation->setValue(corr - dcorr);
+                                                    value_m = option.NPV();
+                                                    correlation->setValue(corr);
+                                                    expected["qlambda"] =
+                                                        (value_p - value_m) / (2 * dcorr);
+
+                                                    // perturb date and get theta
+                                                    Time dT = dc.yearFraction(today - 1, today + 1);
+                                                    Settings::instance().evaluationDate() =
+                                                        today - 1;
+                                                    value_m = option.NPV();
+                                                    Settings::instance().evaluationDate() =
+                                                        today + 1;
+                                                    value_p = option.NPV();
+                                                    Settings::instance().evaluationDate() = today;
+                                                    expected["theta"] = (value_p - value_m) / dT;
+
+                                                    // compare
+                                                    std::map<std::string, Real>::iterator it;
+                                                    for (it = calculated.begin();
+                                                         it != calculated.end(); ++it) {
+                                                        std::string greek = it->first;
+                                                        Real expct = expected[greek],
+                                                             calcl = calculated[greek],
+                                                             tol = tolerance[greek];
+                                                        Real error = relativeError(expct, calcl, u);
+                                                        if (error > tol) {
+                                                            QUANTO_FORWARD_REPORT_FAILURE(
+                                                                greek, payoff, moneynes, exercise,
+                                                                u, q, r, today, reset, v, fxr, fxv,
+                                                                corr, expct, calcl, error, tol);
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
                             }
-                          }
                         }
-                      }
                     }
-                  }
                 }
-              }
             }
-          }
         }
-      }
     }
 }
 
@@ -841,40 +828,38 @@ void QuantoOptionTest::testForwardPerformanceValues() {
                                                  stochProcess, fxrTS, fxVolTS,
                                                  Handle<Quote>(correlation)));
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
         ext::shared_ptr<StrikedTypePayoff> payoff(
-//                               new PercentageStrikePayoff(values[i].type, values[i].moneyness));
-                                 new PlainVanillaPayoff(values[i].type, 0.0));
-        Date exDate = today + timeToDays(values[i].t);
+            //                               new PercentageStrikePayoff(values[i].type,
+            //                               values[i].moneyness));
+            new PlainVanillaPayoff(value.type, 0.0));
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
-        Date reset = today + timeToDays(values[i].start);
+        Date reset = today + timeToDays(value.start);
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
-        fxRate->setValue(values[i].fxr);
-        fxVol->setValue(values[i].fxv);
-        correlation->setValue(values[i].corr);
+        fxRate->setValue(value.fxr);
+        fxVol->setValue(value.fxv);
+        correlation->setValue(value.corr);
 
-        QuantoForwardVanillaOption option(values[i].moneyness, reset,
-                                          payoff, exercise);
+        QuantoForwardVanillaOption option(value.moneyness, reset, payoff, exercise);
         option.setPricingEngine(engine);
 
         Real calculated = option.NPV();
-        Real error = std::fabs(calculated-values[i].result);
+        Real error = std::fabs(calculated - value.result);
         Real tolerance = 1e-4;
         if (error>tolerance) {
-            QUANTO_FORWARD_REPORT_FAILURE("value", payoff, values[i].moneyness,
-                exercise,
-                values[i].s, values[i].q, values[i].r, today, reset,
-                values[i].v, values[i].fxr, values[i].fxv, values[i].corr,
-                values[i].result, calculated, error, tolerance);
+            QUANTO_FORWARD_REPORT_FAILURE("value", payoff, value.moneyness, exercise, value.s,
+                                          value.q, value.r, today, reset, value.v, value.fxr,
+                                          value.fxv, value.corr, value.result, calculated, error,
+                                          tolerance);
         }
     }
-
 }
 
 void QuantoOptionTest::testBarrierValues()  {
@@ -923,44 +908,36 @@ void QuantoOptionTest::testBarrierValues()  {
                                                  stochProcess, fxrTS, fxVolTS,
                                                  Handle<Quote>(correlation)));
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(
-                    new PlainVanillaPayoff(values[i].type, values[i].strike));
+        ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(value.type, value.strike));
 
-        Date exDate = today + timeToDays(values[i].t);
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
-        fxRate->setValue(values[i].fxr);
-        fxVol->setValue(values[i].fxv);
-        correlation->setValue(values[i].corr);
+        fxRate->setValue(value.fxr);
+        fxVol->setValue(value.fxv);
+        correlation->setValue(value.corr);
 
-        QuantoBarrierOption option(values[i].barrierType,
-                                   values[i].barrier,
-                                   values[i].rebate,
-                                   payoff,
+        QuantoBarrierOption option(value.barrierType, value.barrier, value.rebate, payoff,
                                    exercise);
 
         option.setPricingEngine(engine);
 
         Real calculated = option.NPV();
-        Real error = std::fabs(calculated-values[i].result);
-        Real tolerance = values[i].tol;
+        Real error = std::fabs(calculated - value.result);
+        Real tolerance = value.tol;
 
         if (error>tolerance) {
-            QUANTO_BARRIER_REPORT_FAILURE("value", payoff,
-                values[i].barrierType,
-                values[i].barrier,
-                values[i].rebate,
-                exercise,
-                values[i].s, values[i].q, values[i].r, today,
-                values[i].v, values[i].fxr, values[i].fxv, values[i].corr,
-                values[i].result, calculated, error, tolerance);
+            QUANTO_BARRIER_REPORT_FAILURE("value", payoff, value.barrierType, value.barrier,
+                                          value.rebate, exercise, value.s, value.q, value.r, today,
+                                          value.v, value.fxr, value.fxv, value.corr, value.result,
+                                          calculated, error, tolerance);
         }
     }
 }
@@ -1008,46 +985,36 @@ void QuantoOptionTest::testDoubleBarrierValues()  {
                                                  stochProcess, fxrTS, fxVolTS,
                                                  Handle<Quote>(correlation)));
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(
-                    new PlainVanillaPayoff(values[i].type, values[i].strike));
+        ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(value.type, value.strike));
 
-        Date exDate = today + timeToDays(values[i].t);
+        Date exDate = today + timeToDays(value.t);
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vol  ->setValue(values[i].v);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vol->setValue(value.v);
 
-        fxRate->setValue(values[i].fxr);
-        fxVol->setValue(values[i].fxv);
-        correlation->setValue(values[i].corr);
+        fxRate->setValue(value.fxr);
+        fxVol->setValue(value.fxv);
+        correlation->setValue(value.corr);
 
-        QuantoDoubleBarrierOption option(values[i].barrierType,
-                                   values[i].barrier_lo,
-                                   values[i].barrier_hi,
-                                   values[i].rebate,
-                                   payoff,
-                                   exercise);
+        QuantoDoubleBarrierOption option(value.barrierType, value.barrier_lo, value.barrier_hi,
+                                         value.rebate, payoff, exercise);
 
         option.setPricingEngine(engine);
 
         Real calculated = option.NPV();
-        Real error = std::fabs(calculated-values[i].result);
-        Real tolerance = values[i].tol;
+        Real error = std::fabs(calculated - value.result);
+        Real tolerance = value.tol;
 
         if (error>tolerance) {
-            QUANTO_DOUBLE_BARRIER_REPORT_FAILURE("value", payoff,
-                values[i].barrierType,
-                values[i].barrier_lo,
-                values[i].barrier_hi,
-                values[i].rebate,
-                exercise,
-                values[i].s, values[i].q, values[i].r, today,
-                values[i].v, values[i].fxr, values[i].fxv, values[i].corr,
-                values[i].result, calculated, error, tolerance);
+            QUANTO_DOUBLE_BARRIER_REPORT_FAILURE(
+                "value", payoff, value.barrierType, value.barrier_lo, value.barrier_hi,
+                value.rebate, exercise, value.s, value.q, value.r, today, value.v, value.fxr,
+                value.fxv, value.corr, value.result, calculated, error, tolerance);
         }
     }
 }
@@ -1165,7 +1132,7 @@ void QuantoOptionTest::testPDEOptionValues()  {
         { Option::Call, 0.0,   100.0, 0.04,     0.08,      0.3,  0.3,     0.05,      0.10,     0.75, Null<Real>(), Null<Real>() },
     };
 
-    for (Size i=0; i < LENGTH(values); ++i) {
+    for (auto& value : values) {
 
         std::map<std::string,Real> calculated, expected, tolerance;
         tolerance["npv"]   = 2e-4;
@@ -1173,32 +1140,26 @@ void QuantoOptionTest::testPDEOptionValues()  {
         tolerance["gamma"] = 1e-4;
         tolerance["theta"] = 1e-4;
 
-        const Handle<Quote> spot(
-            ext::make_shared<SimpleQuote>(values[i].s));
+        const Handle<Quote> spot(ext::make_shared<SimpleQuote>(value.s));
 
-        const Real strike = values[i].strike;
+        const Real strike = value.strike;
 
-        const Handle<YieldTermStructure> domesticTS(
-            flatRate(today, values[i].r, dc));
+        const Handle<YieldTermStructure> domesticTS(flatRate(today, value.r, dc));
 
-        const Handle<YieldTermStructure> divTS(
-            flatRate(today, values[i].q, dc));
+        const Handle<YieldTermStructure> divTS(flatRate(today, value.q, dc));
 
-        const Handle<BlackVolTermStructure> volTS(
-            flatVol(today, values[i].v, dc));
+        const Handle<BlackVolTermStructure> volTS(flatVol(today, value.v, dc));
 
         const ext::shared_ptr<BlackScholesMertonProcess> bsmProcess
             = ext::make_shared<BlackScholesMertonProcess>(
                 spot, divTS, domesticTS, volTS);
 
-        const Handle<YieldTermStructure> foreignTS(
-            flatRate(today, values[i].fxr, dc));
+        const Handle<YieldTermStructure> foreignTS(flatRate(today, value.fxr, dc));
 
-        const Handle<BlackVolTermStructure> fxVolTS(
-            flatVol(today, values[i].fxv, dc));
+        const Handle<BlackVolTermStructure> fxVolTS(flatVol(today, value.fxv, dc));
 
         const Real exchRateATMlevel = 1.0;
-        const Real equityFxCorrelation = values[i].corr;
+        const Real equityFxCorrelation = value.corr;
 
         const ext::shared_ptr<FdmQuantoHelper> quantoHelper
             = ext::make_shared<FdmQuantoHelper>(
@@ -1207,17 +1168,16 @@ void QuantoOptionTest::testPDEOptionValues()  {
                   fxVolTS.currentLink(),
                   equityFxCorrelation, exchRateATMlevel);
 
-        const ext::shared_ptr<StrikedTypePayoff> payoff
-            = ext::make_shared<PlainVanillaPayoff>(
-                values[i].type, strike);
-        const Date exDate = today + timeToDays(values[i].t);
+        const ext::shared_ptr<StrikedTypePayoff> payoff =
+            ext::make_shared<PlainVanillaPayoff>(value.type, strike);
+        const Date exDate = today + timeToDays(value.t);
         const ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
         VanillaOption option(payoff, exercise);
 
         const ext::shared_ptr<PricingEngine> pdeEngine =
-            ext::make_shared<FdBlackScholesVanillaEngine>(
-                bsmProcess, quantoHelper, Size(values[i].t*200), 500, 1);
+            ext::make_shared<FdBlackScholesVanillaEngine>(bsmProcess, quantoHelper,
+                                                          Size(value.t * 200), 500, 1);
 
         option.setPricingEngine(pdeEngine);
 
@@ -1251,10 +1211,9 @@ void QuantoOptionTest::testPDEOptionValues()  {
             const Real tol = tolerance[greek];
 
             if (error > tol) {
-                QUANTO_REPORT_FAILURE(greek, payoff, exercise,
-                    values[i].s, values[i].q, values[i].r, today,
-                    values[i].v, values[i].fxr, values[i].fxv,
-                    values[i].corr, expct, calcl, error, tol)
+                QUANTO_REPORT_FAILURE(greek, payoff, exercise, value.s, value.q, value.r, today,
+                                      value.v, value.fxr, value.fxv, value.corr, expct, calcl,
+                                      error, tol)
             }
         }
     }
diff --git a/test-suite/quotes.cpp b/test-suite/quotes.cpp
index 50830805213..cd3452a32b8 100644
--- a/test-suite/quotes.cpp
+++ b/test-suite/quotes.cpp
@@ -93,10 +93,9 @@ void QuoteTest::testDerived() {
     ext::shared_ptr<Quote> me(new SimpleQuote(17.0));
     Handle<Quote> h(me);
 
-    for (Integer i=0; i<3; i++) {
-        DerivedQuote<unary_f> derived(h,funcs[i]);
-        Real x = derived.value(),
-             y = funcs[i](me->value());
+    for (auto& func : funcs) {
+        DerivedQuote<unary_f> derived(h, func);
+        Real x = derived.value(), y = func(me->value());
         if (std::fabs(x-y) > 1.0e-10)
             BOOST_FAIL("derived quote yields " << x << "\n"
                        << "function result is " << y);
@@ -114,10 +113,9 @@ void QuoteTest::testComposite() {
                              me2(new SimpleQuote(13.0));
     Handle<Quote> h1(me1), h2(me2);
 
-    for (Integer i=0; i<3; i++) {
-        CompositeQuote<binary_f> composite(h1,h2,funcs[i]);
-        Real x = composite.value(),
-             y = funcs[i](me1->value(),me2->value());
+    for (auto& func : funcs) {
+        CompositeQuote<binary_f> composite(h1, h2, func);
+        Real x = composite.value(), y = func(me1->value(), me2->value());
         if (std::fabs(x-y) > 1.0e-10)
             BOOST_FAIL("composite quote yields " << x << "\n"
                        << "function result is " << y);
diff --git a/test-suite/riskneutraldensitycalculator.cpp b/test-suite/riskneutraldensitycalculator.cpp
index 00b0f86d2ca..eea90e95579 100644
--- a/test-suite/riskneutraldensitycalculator.cpp
+++ b/test-suite/riskneutraldensitycalculator.cpp
@@ -77,14 +77,12 @@ void RiskNeutralDensityCalculatorTest::testDensityAgainstOptionPrices() {
     const Time times[] = { 0.5, 1.0, 2.0 };
     const Real strikes[] = { 75.0, 100.0, 150.0 };
 
-    for (Size i=0; i < LENGTH(times); ++i) {
-        const Time t = times[i];
-        const Volatility stdDev = v*std::sqrt(t);
+    for (double t : times) {
+        const Volatility stdDev = v * std::sqrt(t);
         const DiscountFactor df = rTS->discount(t);
         const Real fwd = s0*qTS->discount(t)/df;
 
-        for (Size j=0; j < LENGTH(strikes); ++j) {
-            const Real strike = strikes[j];
+        for (double strike : strikes) {
             const Real xs = std::log(strike);
             const BlackCalculator blackCalc(
                 Option::Put, strike, fwd, stdDev, df);
@@ -163,11 +161,8 @@ void RiskNeutralDensityCalculatorTest::testBSMagainstHestonRND() {
     const Real strikes[] = { 7.5, 10, 15 };
     const Real probs[] = { 1e-6, 0.01, 0.5, 0.99, 1.0-1e-6 };
 
-    for (Size i=0; i < LENGTH(times); ++i) {
-        const Time t = times[i];
-
-        for (Size j=0; j < LENGTH(strikes); ++j) {
-            const Real strike = strikes[j];
+    for (double t : times) {
+        for (double strike : strikes) {
             const Real xs = std::log(strike);
 
             const Real expectedPDF = bsm.pdf(xs, t);
@@ -196,8 +191,7 @@ void RiskNeutralDensityCalculatorTest::testBSMagainstHestonRND() {
             }
         }
 
-        for (Size j=0; j < LENGTH(probs); ++j) {
-            const Real prob = probs[j];
+        for (double prob : probs) {
             const Real expectedInvCDF = bsm.invcdf(prob, t);
             const Real calculatedInvCDF = heston.invcdf(prob, t);
 
@@ -431,24 +425,19 @@ void RiskNeutralDensityCalculatorTest::testLocalVolatilityRND() {
         maturityDates, maturityDates + LENGTH(maturityDates));
 
 
-    for (Size i=0; i < maturities.size(); ++i) {
-        const Time expiry
-            = rTS->dayCounter().yearFraction(todaysDate, maturities[i]);
+    for (auto maturitie : maturities) {
+        const Time expiry = rTS->dayCounter().yearFraction(todaysDate, maturitie);
 
         const ext::shared_ptr<PricingEngine> engine(
             new FdBlackScholesVanillaEngine(
                 bsmProcess, std::max(Size(51), Size(expiry*101)),
                 201, 0, FdmSchemeDesc::Douglas(), true, b1));
 
-        const ext::shared_ptr<Exercise> exercise(
-            new EuropeanExercise(maturities[i]));
+        const ext::shared_ptr<Exercise> exercise(new EuropeanExercise(maturitie));
 
-        for (Size k=0; k < LENGTH(strikes); ++k) {
-            const Real strike = strikes[k];
-            const ext::shared_ptr<StrikedTypePayoff> payoff(
-                new PlainVanillaPayoff(
-                    (strike > spot->value()) ? Option::Call : Option::Put
-                    , strike));
+        for (double strike : strikes) {
+            const ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(
+                (strike > spot->value()) ? Option::Call : Option::Put, strike));
 
             VanillaOption option(payoff, exercise);
             option.setPricingEngine(engine);
@@ -492,15 +481,15 @@ void RiskNeutralDensityCalculatorTest::testSquareRootProcessRND() {
             { 1.0, 0.6, 0.1, 0.75 },
             { 0.005, 0.6, 0.1, 0.05 } };
 
-    for (Size i=0; i < LENGTH(params); ++i) {
-        const SquareRootProcessRNDCalculator rndCalculator(
-            params[i].v0, params[i].kappa, params[i].theta, params[i].sigma);
+    for (const auto& param : params) {
+        const SquareRootProcessRNDCalculator rndCalculator(param.v0, param.kappa, param.theta,
+                                                           param.sigma);
 
         const Time t = 0.75;
-        const Time tInfty = 60.0/params[i].kappa;
+        const Time tInfty = 60.0 / param.kappa;
 
         const Real tol = 1e-10;
-        for (Real v = 1e-5; v < 1.0; v+=(v < params[i].theta) ? 0.005 : 0.1) {
+        for (Real v = 1e-5; v < 1.0; v += (v < param.theta) ? 0.005 : 0.1) {
 
             const Real cdfCalculated = rndCalculator.cdf(v, t);
             const Real cdfExpected = GaussLobattoIntegral(10000, 0.01*tol)(
@@ -628,8 +617,7 @@ void RiskNeutralDensityCalculatorTest::testBlackScholesWithSkew() {
 
     const Real strikes[] = { 85, 75, 90, 110, 125, 150 };
 
-    for (Size i=0; i < LENGTH(strikes); ++i) {
-        const Real strike = strikes[i];
+    for (double strike : strikes) {
         const Real logStrike = std::log(strike);
 
         const Real expected = hestonCalc.cdf(logStrike, maturity);
@@ -661,8 +649,7 @@ void RiskNeutralDensityCalculatorTest::testBlackScholesWithSkew() {
         }
     }
 
-    for (Size i=0; i < LENGTH(strikes); ++i) {
-        const Real strike = strikes[i];
+    for (double strike : strikes) {
         const Real logStrike = std::log(strike);
 
         const Real expected = hestonCalc.pdf(logStrike, maturity)/strike;
@@ -696,9 +683,7 @@ void RiskNeutralDensityCalculatorTest::testBlackScholesWithSkew() {
     }
 
     const Real quantiles[] = { 0.05, 0.25, 0.5, 0.75, 0.95 };
-    for (Size i=0; i < LENGTH(quantiles); ++i) {
-        const Real quantile = quantiles[i];
-
+    for (double quantile : quantiles) {
         const Real expected = std::exp(hestonCalc.invcdf(quantile, maturity));
         const Real calculatedGBSM = gbsmCalc.invcdf(quantile, maturity);
 
@@ -746,9 +731,9 @@ void RiskNeutralDensityCalculatorTest::testMassAtZeroCEVProcessRND() {
 
     const Real tol = 1e-4;
 
-    for (Size i=0; i < LENGTH(params); ++i) {
-        const Real alpha = params[i].first;
-        const Real beta = params[i].second;
+    for (const auto& param : params) {
+        const Real alpha = param.first;
+        const Real beta = param.second;
 
         const ext::shared_ptr<CEVRNDCalculator> calculator =
             ext::make_shared<CEVRNDCalculator>(f0, alpha, beta);
diff --git a/test-suite/rngtraits.cpp b/test-suite/rngtraits.cpp
index 6c0869829ff..a2f83d972d5 100644
--- a/test-suite/rngtraits.cpp
+++ b/test-suite/rngtraits.cpp
@@ -35,8 +35,8 @@ void RngTraitsTest::testGaussian() {
 
     const std::vector<Real>& values = rsg.nextSequence().value;
     Real sum = 0.0;
-    for (Size i=0; i<values.size(); i++)
-        sum += values[i];
+    for (double value : values)
+        sum += value;
 
     Real stored = 4.09916;
     Real tolerance = 1.0e-5;
@@ -58,8 +58,8 @@ void RngTraitsTest::testDefaultPoisson() {
 
     const std::vector<Real>& values = rsg.nextSequence().value;
     Real sum = 0.0;
-    for (Size i=0; i<values.size(); i++)
-        sum += values[i];
+    for (double value : values)
+        sum += value;
 
     Real stored = 108.0;
     if (!close(sum, stored))
@@ -81,8 +81,8 @@ void RngTraitsTest::testCustomPoisson() {
 
     const std::vector<Real>& values = rsg.nextSequence().value;
     Real sum = 0.0;
-    for (Size i=0; i<values.size(); i++)
-        sum += values[i];
+    for (double value : values)
+        sum += value;
 
     Real stored = 409.0;
     if (!close(sum, stored))
diff --git a/test-suite/rounding.cpp b/test-suite/rounding.cpp
index 76af01d4d7f..80afb623b7a 100644
--- a/test-suite/rounding.cpp
+++ b/test-suite/rounding.cpp
@@ -70,17 +70,16 @@ void RoundingTest::testClosest() {
 
     using namespace rounding_test;
 
-    for (Size i=0; i<LENGTH(testData); i++) {
-        Integer digits = testData[i].precision;
+    for (auto& i : testData) {
+        Integer digits = i.precision;
         ClosestRounding closest(digits);
-        Real calculated = closest(testData[i].x);
-        Real expected = testData[i].closest;
+        Real calculated = closest(i.x);
+        Real expected = i.closest;
         if (!close(calculated,expected,1))
-            BOOST_ERROR(std::fixed << std::setprecision(8)
-                        << "Original number: " << testData[i].x << "\n"
-                        << std::setprecision(digits)
-                        << "Expected:        " << expected << "\n"
-                        << "Calculated:      " << calculated);
+            BOOST_ERROR(std::fixed << std::setprecision(8) << "Original number: " << i.x << "\n"
+                                   << std::setprecision(digits) << "Expected:        " << expected
+                                   << "\n"
+                                   << "Calculated:      " << calculated);
     }
 }
 
@@ -90,17 +89,16 @@ void RoundingTest::testUp() {
 
     using namespace rounding_test;
 
-    for (Size i=0; i<LENGTH(testData); i++) {
-        Integer digits = testData[i].precision;
+    for (auto& i : testData) {
+        Integer digits = i.precision;
         UpRounding up(digits);
-        Real calculated = up(testData[i].x);
-        Real expected = testData[i].up;
+        Real calculated = up(i.x);
+        Real expected = i.up;
         if (!close(calculated,expected,1))
-            BOOST_ERROR(std::fixed << std::setprecision(8)
-                        << "Original number: " << testData[i].x << "\n"
-                        << std::setprecision(digits)
-                        << "Expected:        " << expected << "\n"
-                        << "Calculated:      " << calculated);
+            BOOST_ERROR(std::fixed << std::setprecision(8) << "Original number: " << i.x << "\n"
+                                   << std::setprecision(digits) << "Expected:        " << expected
+                                   << "\n"
+                                   << "Calculated:      " << calculated);
     }
 }
 
@@ -110,17 +108,16 @@ void RoundingTest::testDown() {
 
     using namespace rounding_test;
 
-    for (Size i=0; i<LENGTH(testData); i++) {
-        Integer digits = testData[i].precision;
+    for (auto& i : testData) {
+        Integer digits = i.precision;
         DownRounding down(digits);
-        Real calculated = down(testData[i].x);
-        Real expected = testData[i].down;
+        Real calculated = down(i.x);
+        Real expected = i.down;
         if (!close(calculated,expected,1))
-            BOOST_ERROR(std::fixed << std::setprecision(8)
-                        << "Original number: " << testData[i].x << "\n"
-                        << std::setprecision(digits)
-                        << "Expected:        " << expected << "\n"
-                        << "Calculated:      " << calculated);
+            BOOST_ERROR(std::fixed << std::setprecision(8) << "Original number: " << i.x << "\n"
+                                   << std::setprecision(digits) << "Expected:        " << expected
+                                   << "\n"
+                                   << "Calculated:      " << calculated);
     }
 }
 
@@ -130,17 +127,16 @@ void RoundingTest::testFloor() {
 
     using namespace rounding_test;
 
-    for (Size i=0; i<LENGTH(testData); i++) {
-        Integer digits = testData[i].precision;
+    for (auto& i : testData) {
+        Integer digits = i.precision;
         FloorTruncation floor(digits);
-        Real calculated = floor(testData[i].x);
-        Real expected = testData[i].floor;
+        Real calculated = floor(i.x);
+        Real expected = i.floor;
         if (!close(calculated,expected,1))
-            BOOST_ERROR(std::fixed << std::setprecision(8)
-                        << "Original number: " << testData[i].x << "\n"
-                        << std::setprecision(digits)
-                        << "Expected:        " << expected << "\n"
-                        << "Calculated:      " << calculated);
+            BOOST_ERROR(std::fixed << std::setprecision(8) << "Original number: " << i.x << "\n"
+                                   << std::setprecision(digits) << "Expected:        " << expected
+                                   << "\n"
+                                   << "Calculated:      " << calculated);
     }
 }
 
@@ -150,17 +146,16 @@ void RoundingTest::testCeiling() {
 
     using namespace rounding_test;
 
-    for (Size i=0; i<LENGTH(testData); i++) {
-        Integer digits = testData[i].precision;
+    for (auto& i : testData) {
+        Integer digits = i.precision;
         CeilingTruncation ceiling(digits);
-        Real calculated = ceiling(testData[i].x);
-        Real expected = testData[i].ceiling;
+        Real calculated = ceiling(i.x);
+        Real expected = i.ceiling;
         if (!close(calculated,expected,1))
-            BOOST_ERROR(std::fixed << std::setprecision(8)
-                        << "Original number: " << testData[i].x << "\n"
-                        << std::setprecision(digits)
-                        << "Expected:        " << expected << "\n"
-                        << "Calculated:      " << calculated);
+            BOOST_ERROR(std::fixed << std::setprecision(8) << "Original number: " << i.x << "\n"
+                                   << std::setprecision(digits) << "Expected:        " << expected
+                                   << "\n"
+                                   << "Calculated:      " << calculated);
     }
 }
 
diff --git a/test-suite/shortratemodels.cpp b/test-suite/shortratemodels.cpp
index e7f5daf9df0..82576d169ce 100644
--- a/test-suite/shortratemodels.cpp
+++ b/test-suite/shortratemodels.cpp
@@ -80,15 +80,11 @@ void ShortRateModelTest::testCachedHullWhite() {
                                          new JamshidianSwaptionEngine(model));
 
     std::vector<ext::shared_ptr<CalibrationHelper> > swaptions;
-    for (Size i=0; i<LENGTH(data); i++) {
-        ext::shared_ptr<Quote> vol(new SimpleQuote(data[i].volatility));
+    for (auto& i : data) {
+        ext::shared_ptr<Quote> vol(new SimpleQuote(i.volatility));
         ext::shared_ptr<BlackCalibrationHelper> helper(
-                             new SwaptionHelper(Period(data[i].start, Years),
-                                                Period(data[i].length, Years),
-                                                Handle<Quote>(vol),
-                                                index,
-                                                Period(1, Years), Thirty360(),
-                                                Actual360(), termStructure));
+            new SwaptionHelper(Period(i.start, Years), Period(i.length, Years), Handle<Quote>(vol),
+                               index, Period(1, Years), Thirty360(), Actual360(), termStructure));
         helper->setPricingEngine(engine);
         swaptions.push_back(helper);
     }
@@ -159,15 +155,11 @@ void ShortRateModelTest::testCachedHullWhiteFixedReversion() {
                                          new JamshidianSwaptionEngine(model));
 
     std::vector<ext::shared_ptr<CalibrationHelper> > swaptions;
-    for (Size i=0; i<LENGTH(data); i++) {
-        ext::shared_ptr<Quote> vol(new SimpleQuote(data[i].volatility));
+    for (auto& i : data) {
+        ext::shared_ptr<Quote> vol(new SimpleQuote(i.volatility));
         ext::shared_ptr<BlackCalibrationHelper> helper(
-                             new SwaptionHelper(Period(data[i].start, Years),
-                                                Period(data[i].length, Years),
-                                                Handle<Quote>(vol),
-                                                index,
-                                                Period(1, Years), Thirty360(),
-                                                Actual360(), termStructure));
+            new SwaptionHelper(Period(i.start, Years), Period(i.length, Years), Handle<Quote>(vol),
+                               index, Period(1, Years), Thirty360(), Actual360(), termStructure));
         helper->setPricingEngine(engine);
         swaptions.push_back(helper);
     }
@@ -243,15 +235,11 @@ void ShortRateModelTest::testCachedHullWhite2() {
                                          new JamshidianSwaptionEngine(model));
 
     std::vector<ext::shared_ptr<CalibrationHelper> > swaptions;
-    for (Size i=0; i<LENGTH(data); i++) {
-        ext::shared_ptr<Quote> vol(new SimpleQuote(data[i].volatility));
+    for (auto& i : data) {
+        ext::shared_ptr<Quote> vol(new SimpleQuote(i.volatility));
         ext::shared_ptr<BlackCalibrationHelper> helper(
-                             new SwaptionHelper(Period(data[i].start, Years),
-                                                Period(data[i].length, Years),
-                                                Handle<Quote>(vol),
-                                                index0,
-                                                Period(1, Years), Thirty360(),
-                                                Actual360(), termStructure));
+            new SwaptionHelper(Period(i.start, Years), Period(i.length, Years), Handle<Quote>(vol),
+                               index0, Period(1, Years), Thirty360(), Actual360(), termStructure));
         helper->setPricingEngine(engine);
         swaptions.push_back(helper);
     }
@@ -385,10 +373,9 @@ void ShortRateModelTest::testSwaps() {
             Schedule floatSchedule(startDate, maturity, Period(Semiannual),
                                    calendar, Following, Following,
                                    DateGeneration::Forward, false);
-            for (Size k=0; k<LENGTH(rates); k++) {
+            for (double rate : rates) {
 
-                VanillaSwap swap(VanillaSwap::Payer, 1000000.0,
-                                 fixedSchedule, rates[k], Thirty360(),
+                VanillaSwap swap(VanillaSwap::Payer, 1000000.0, fixedSchedule, rate, Thirty360(),
                                  floatSchedule, euribor, 0.0, Actual360());
                 swap.setPricingEngine(ext::shared_ptr<PricingEngine>(
                                    new DiscountingSwapEngine(termStructure)));
diff --git a/test-suite/sofrfutures.cpp b/test-suite/sofrfutures.cpp
index 3f815a5f255..e77b7823b8c 100644
--- a/test-suite/sofrfutures.cpp
+++ b/test-suite/sofrfutures.cpp
@@ -87,10 +87,10 @@ void SofrFuturesTest::testBootstrap() {
     index->addFixing(Date(25, October, 2018), 0.0219);
 
     std::vector<ext::shared_ptr<RateHelper> > helpers;
-    for (Size i = 0; i < LENGTH(sofrQuotes); i++) {
+    for (const auto& sofrQuote : sofrQuotes) {
         helpers.push_back(ext::make_shared<SofrFutureRateHelper>(
-            sofrQuotes[i].price, sofrQuotes[i].month, sofrQuotes[i].year,
-            sofrQuotes[i].freq, index, 0.0, sofrQuotes[i].averagingMethod));
+            sofrQuote.price, sofrQuote.month, sofrQuote.year, sofrQuote.freq,
+            index, 0.0, sofrQuote.averagingMethod));
     }
 
     ext::shared_ptr<PiecewiseYieldCurve<Discount, Linear> > curve =
diff --git a/test-suite/solvers.cpp b/test-suite/solvers.cpp
index 303666cf547..aa0c6068e48 100644
--- a/test-suite/solvers.cpp
+++ b/test-suite/solvers.cpp
@@ -57,13 +57,13 @@ namespace {
                             const F& f, Real guess) {
         Real accuracy[] = { 1.0e-4, 1.0e-6, 1.0e-8 };
         Real expected = 1.0;
-        for (Size i=0; i<LENGTH(accuracy); i++) {
-            Real root = solver.solve(f,accuracy[i],guess,0.1);
-            if (std::fabs(root-expected) > accuracy[i]) {
+        for (double& i : accuracy) {
+            Real root = solver.solve(f, i, guess, 0.1);
+            if (std::fabs(root - expected) > i) {
                 BOOST_FAIL(name << " solver (not bracketed):\n"
-                           << "    expected:   " << expected << "\n"
-                           << "    calculated: " << root << "\n"
-                           << "    accuracy:   " << accuracy[i]);
+                                << "    expected:   " << expected << "\n"
+                                << "    calculated: " << root << "\n"
+                                << "    accuracy:   " << i);
             }
         }
     }
@@ -73,14 +73,14 @@ namespace {
                         const F& f, Real guess) {
         Real accuracy[] = { 1.0e-4, 1.0e-6, 1.0e-8 };
         Real expected = 1.0;
-        for (Size i=0; i<LENGTH(accuracy); i++) {
+        for (double& i : accuracy) {
             // guess on the left side of the root, increasing function
-            Real root = solver.solve(f,accuracy[i],guess,0.0,2.0);
-            if (std::fabs(root-expected) > accuracy[i]) {
+            Real root = solver.solve(f, i, guess, 0.0, 2.0);
+            if (std::fabs(root - expected) > i) {
                 BOOST_FAIL(name << " solver (bracketed):\n"
-                           << "    expected:   " << expected << "\n"
-                           << "    calculated: " << root << "\n"
-                           << "    accuracy:   " << accuracy[i]);
+                                << "    expected:   " << expected << "\n"
+                                << "    calculated: " << root << "\n"
+                                << "    accuracy:   " << i);
             }
         }
     }
diff --git a/test-suite/spreadoption.cpp b/test-suite/spreadoption.cpp
index 4c1a6f2f86f..90555614943 100644
--- a/test-suite/spreadoption.cpp
+++ b/test-suite/spreadoption.cpp
@@ -95,29 +95,29 @@ void SpreadOptionTest::testKirkEngine() {
         { 122.0, 120.0, 3.0, 0.10, 0.20, 0.25,  0.5, 180,  6.9284,  6.6761 }
     };
 
-    for (Size i=0; i<LENGTH(cases); ++i) {
+    for (auto& i : cases) {
 
         // First step: preparing the test values
         // Useful dates
         DayCounter dc = Actual360();
         Date today = Date::todaysDate();
-        Date exerciseDate = today  + cases[i].length;
+        Date exerciseDate = today + i.length;
 
         // Futures values
-        ext::shared_ptr<SimpleQuote> F1(new SimpleQuote(cases[i].F1));
-        ext::shared_ptr<SimpleQuote> F2(new SimpleQuote(cases[i].F2));
+        ext::shared_ptr<SimpleQuote> F1(new SimpleQuote(i.F1));
+        ext::shared_ptr<SimpleQuote> F2(new SimpleQuote(i.F2));
 
         // Risk-free interest rate
-        Rate riskFreeRate = cases[i].r;
+        Rate riskFreeRate = i.r;
         ext::shared_ptr<YieldTermStructure> forwardRate =
             flatRate(today,riskFreeRate,dc);
 
         // Correlation
-        ext::shared_ptr<Quote> rho(new SimpleQuote(cases[i].rho));
+        ext::shared_ptr<Quote> rho(new SimpleQuote(i.rho));
 
         // Volatilities
-        Volatility vol1 = cases[i].sigma1;
-        Volatility vol2 = cases[i].sigma2;
+        Volatility vol1 = i.sigma1;
+        Volatility vol2 = i.sigma2;
         ext::shared_ptr<BlackVolTermStructure> volTS1 =
             flatVol(today,vol1,dc);
         ext::shared_ptr<BlackVolTermStructure> volTS2 =
@@ -142,7 +142,7 @@ void SpreadOptionTest::testKirkEngine() {
 
         // Finally, create the option:
         Option::Type type = Option::Call;
-        Real strike = cases[i].X;
+        Real strike = i.X;
         ext::shared_ptr<PlainVanillaPayoff> payoff(
                                         new PlainVanillaPayoff(type, strike));
         ext::shared_ptr<Exercise> exercise(
@@ -156,16 +156,12 @@ void SpreadOptionTest::testKirkEngine() {
         Real theta = option.theta();
         Real tolerance = 1e-4;
 
-        if (std::fabs(value-cases[i].value) > tolerance) {
-            REPORT_FAILURE("value",
-                           payoff, exercise,
-                           cases[i].value, value, tolerance);
+        if (std::fabs(value - i.value) > tolerance) {
+            REPORT_FAILURE("value", payoff, exercise, i.value, value, tolerance);
         }
 
-        if (std::fabs(theta-cases[i].theta) > tolerance) {
-            REPORT_FAILURE("theta",
-                            payoff, exercise,
-                            cases[i].theta, theta, tolerance);
+        if (std::fabs(theta - i.theta) > tolerance) {
+            REPORT_FAILURE("theta", payoff, exercise, i.theta, theta, tolerance);
         }
     }
 }
diff --git a/test-suite/squarerootclvmodel.cpp b/test-suite/squarerootclvmodel.cpp
index 9ceeee3034e..99ce986aba0 100644
--- a/test-suite/squarerootclvmodel.cpp
+++ b/test-suite/squarerootclvmodel.cpp
@@ -156,10 +156,8 @@ void SquareRootCLVModelTest::testSquareRootCLVVanillaPricing() {
     const chi_squared_type dist(df, ncp);
         
     const Real strikes[] = { 50, 75, 100, 125, 150, 200 };
-    for (Size i=0; i < LENGTH(strikes); ++i) {
-        const Real strike = strikes[i];
-        const Option::Type optionType =
-            (strike > fwd) ? Option::Call : Option::Put;
+    for (double strike : strikes) {
+        const Option::Type optionType = (strike > fwd) ? Option::Call : Option::Put;
 
         const Real expected = BlackCalculator(
             optionType, strike, fwd,
@@ -242,8 +240,8 @@ void SquareRootCLVModelTest::testSquareRootCLVMappingFunction() {
 
     const Real strikes[] = { 80, 100, 120 };
     const Size offsets[] = { 92, 182, 183, 184, 185, 186, 365 };
-    for (Size i=0; i < LENGTH(offsets); ++i) {
-        const Date m = todaysDate + Period(offsets[i], Days);
+    for (unsigned long offset : offsets) {
+        const Date m = todaysDate + Period(offset, Days);
         const Time t = dc.yearFraction(todaysDate, m);
 
         const Real df  = 4*theta*kappa/(sigma*sigma);
@@ -254,10 +252,8 @@ void SquareRootCLVModelTest::testSquareRootCLVMappingFunction() {
 
         const Real fwd = s0*qTS->discount(m)/rTS->discount(m);
 
-        for (Size j=0; j < LENGTH(strikes); ++j) {
-            const Real strike = strikes[j];
-            const Option::Type optionType =
-                (strike > fwd) ? Option::Call : Option::Put;
+        for (double strike : strikes) {
+            const Option::Type optionType = (strike > fwd) ? Option::Call : Option::Put;
 
             const Real expected = BlackCalculator(
                 optionType, strike, fwd,
@@ -310,8 +306,8 @@ namespace square_root_clv_model {
             const Array diff = values(params);
 
             Real retVal = 0.0;
-            for (Size i=0; i < diff.size(); ++i)
-                retVal += diff[i]*diff[i];
+            for (double i : diff)
+                retVal += i * i;
 
             return retVal;
         }
@@ -562,9 +558,9 @@ void SquareRootCLVModelTest::testForwardSkew() {
 
     // forward skew of the Heston-SLV model
     std::vector<Time> mandatoryTimes;
-    for (Size i=0, n = calibrationDates.size(); i < n; ++i)
-        mandatoryTimes.push_back(
-            dc.yearFraction(todaysDate, calibrationDates[i]));
+    mandatoryTimes.reserve(calibrationDates.size());
+    for (auto& calibrationDate : calibrationDates)
+        mandatoryTimes.push_back(dc.yearFraction(todaysDate, calibrationDate));
 
     const Size tSteps = 200;
     const TimeGrid grid(mandatoryTimes.begin(), mandatoryTimes.end(), tSteps);
diff --git a/test-suite/swap.cpp b/test-suite/swap.cpp
index 93b782ea8fe..a11202d4e1d 100644
--- a/test-suite/swap.cpp
+++ b/test-suite/swap.cpp
@@ -112,18 +112,15 @@ void SwapTest::testFairRate() {
     Integer lengths[] = { 1, 2, 5, 10, 20 };
     Spread spreads[] = { -0.001, -0.01, 0.0, 0.01, 0.001 };
 
-    for (Size i=0; i<LENGTH(lengths); i++) {
-        for (Size j=0; j<LENGTH(spreads); j++) {
+    for (int& length : lengths) {
+        for (double spread : spreads) {
 
-            ext::shared_ptr<VanillaSwap> swap =
-                vars.makeSwap(lengths[i],0.0,spreads[j]);
-            swap = vars.makeSwap(lengths[i],swap->fairRate(),spreads[j]);
+            ext::shared_ptr<VanillaSwap> swap = vars.makeSwap(length, 0.0, spread);
+            swap = vars.makeSwap(length, swap->fairRate(), spread);
             if (std::fabs(swap->NPV()) > 1.0e-10) {
                 BOOST_ERROR("recalculating with implied rate:\n"
-                            << std::setprecision(2)
-                            << "    length: " << lengths[i] << " years\n"
-                            << "    floating spread: "
-                            << io::rate(spreads[j]) << "\n"
+                            << std::setprecision(2) << "    length: " << length << " years\n"
+                            << "    floating spread: " << io::rate(spread) << "\n"
                             << "    swap value: " << swap->NPV());
             }
         }
@@ -142,17 +139,15 @@ void SwapTest::testFairSpread() {
     Integer lengths[] = { 1, 2, 5, 10, 20 };
     Rate rates[] = { 0.04, 0.05, 0.06, 0.07 };
 
-    for (Size i=0; i<LENGTH(lengths); i++) {
-        for (Size j=0; j<LENGTH(rates); j++) {
+    for (int& length : lengths) {
+        for (double j : rates) {
 
-            ext::shared_ptr<VanillaSwap> swap =
-                vars.makeSwap(lengths[i],rates[j],0.0);
-            swap = vars.makeSwap(lengths[i],rates[j],swap->fairSpread());
+            ext::shared_ptr<VanillaSwap> swap = vars.makeSwap(length, j, 0.0);
+            swap = vars.makeSwap(length, j, swap->fairSpread());
             if (std::fabs(swap->NPV()) > 1.0e-10) {
                 BOOST_ERROR("recalculating with implied spread:\n"
-                            << std::setprecision(2)
-                            << "    length: " << lengths[i] << " years\n"
-                            << "    fixed rate: " << io::rate(rates[j]) << "\n"
+                            << std::setprecision(2) << "    length: " << length << " years\n"
+                            << "    fixed rate: " << io::rate(j) << "\n"
                             << "    swap value: " << swap->NPV());
             }
         }
@@ -171,26 +166,24 @@ void SwapTest::testRateDependency() {
     Spread spreads[] = { -0.001, -0.01, 0.0, 0.01, 0.001 };
     Rate rates[] = { 0.03, 0.04, 0.05, 0.06, 0.07 };
 
-    for (Size i=0; i<LENGTH(lengths); i++) {
-        for (Size j=0; j<LENGTH(spreads); j++) {
+    for (int& length : lengths) {
+        for (double spread : spreads) {
             // store the results for different rates...
             std::vector<Real> swap_values;
-            for (Size k=0; k<LENGTH(rates); k++) {
-                ext::shared_ptr<VanillaSwap> swap =
-                    vars.makeSwap(lengths[i],rates[k],spreads[j]);
+            for (double rate : rates) {
+                ext::shared_ptr<VanillaSwap> swap = vars.makeSwap(length, rate, spread);
                 swap_values.push_back(swap->NPV());
             }
             // and check that they go the right way
             auto it = std::adjacent_find(swap_values.begin(), swap_values.end(), std::less<Real>());
             if (it != swap_values.end()) {
                 Size n = it - swap_values.begin();
-                BOOST_ERROR(
-                    "NPV is increasing with the fixed rate in a swap: \n"
-                    << "    length: " << lengths[i] << " years\n"
-                    << "    value:  " << swap_values[n]
-                    << " paying fixed rate: " << io::rate(rates[n]) << "\n"
-                    << "    value:  " << swap_values[n+1]
-                    << " paying fixed rate: " << io::rate(rates[n+1]));
+                BOOST_ERROR("NPV is increasing with the fixed rate in a swap: \n"
+                            << "    length: " << length << " years\n"
+                            << "    value:  " << swap_values[n]
+                            << " paying fixed rate: " << io::rate(rates[n]) << "\n"
+                            << "    value:  " << swap_values[n + 1]
+                            << " paying fixed rate: " << io::rate(rates[n + 1]));
             }
         }
     }
@@ -208,13 +201,12 @@ void SwapTest::testSpreadDependency() {
     Rate rates[] = { 0.04, 0.05, 0.06, 0.07 };
     Spread spreads[] = { -0.01, -0.002, -0.001, 0.0, 0.001, 0.002, 0.01 };
 
-    for (Size i=0; i<LENGTH(lengths); i++) {
-        for (Size j=0; j<LENGTH(rates); j++) {
+    for (int& length : lengths) {
+        for (double j : rates) {
             // store the results for different spreads...
             std::vector<Real> swap_values;
-            for (Size k=0; k<LENGTH(spreads); k++) {
-                ext::shared_ptr<VanillaSwap> swap =
-                    vars.makeSwap(lengths[i],rates[j],spreads[k]);
+            for (double spread : spreads) {
+                ext::shared_ptr<VanillaSwap> swap = vars.makeSwap(length, j, spread);
                 swap_values.push_back(swap->NPV());
             }
             // and check that they go the right way
@@ -222,13 +214,12 @@ void SwapTest::testSpreadDependency() {
                 std::adjacent_find(swap_values.begin(), swap_values.end(), std::greater<Real>());
             if (it != swap_values.end()) {
                 Size n = it - swap_values.begin();
-                BOOST_ERROR(
-                    "NPV is decreasing with the floating spread in a swap: \n"
-                    << "    length: " << lengths[i] << " years\n"
-                    << "    value:  " << swap_values[n]
-                    << " receiving spread: " << io::rate(spreads[n]) << "\n"
-                    << "    value:  " << swap_values[n+1]
-                    << " receiving spread: " << io::rate(spreads[n+1]));
+                BOOST_ERROR("NPV is decreasing with the floating spread in a swap: \n"
+                            << "    length: " << length << " years\n"
+                            << "    value:  " << swap_values[n]
+                            << " receiving spread: " << io::rate(spreads[n]) << "\n"
+                            << "    value:  " << swap_values[n + 1]
+                            << " receiving spread: " << io::rate(spreads[n + 1]));
             }
         }
     }
diff --git a/test-suite/swapforwardmappings.cpp b/test-suite/swapforwardmappings.cpp
index c08629253d2..7c01ec40b6d 100644
--- a/test-suite/swapforwardmappings.cpp
+++ b/test-suite/swapforwardmappings.cpp
@@ -173,9 +173,9 @@ namespace {
         const std::vector<Time>& rateTimes, Real strike ){
             std::vector<Time> paymentTimes(rateTimes.begin(), rateTimes.end()-1);
             std::vector<ext::shared_ptr<StrikedTypePayoff> > payoffs(paymentTimes.size());
-            for (Size i = 0; i < payoffs.size(); ++i){
-                payoffs[i] = ext::shared_ptr<StrikedTypePayoff>(new
-                    PlainVanillaPayoff(Option::Call, strike));
+            for (auto& payoff : payoffs) {
+                payoff = ext::shared_ptr<StrikedTypePayoff>(
+                    new PlainVanillaPayoff(Option::Call, strike));
             }
             return MultiStepCoterminalSwaptions (rateTimes,
                 paymentTimes, payoffs);
diff --git a/test-suite/swaption.cpp b/test-suite/swaption.cpp
index 58c81e3f182..b6c96ba0967 100644
--- a/test-suite/swaption.cpp
+++ b/test-suite/swaption.cpp
@@ -130,11 +130,10 @@ void SwaptionTest::testStrikeDependency() {
 
     Rate strikes[] = { 0.03, 0.04, 0.05, 0.06, 0.07 };
 
-    for (Size i=0; i<LENGTH(exercises); i++) {
-        for (Size j=0; j<LENGTH(lengths); j++) {
-            for (Size k=0; k<LENGTH(type); k++) {
-                Date exerciseDate = vars.calendar.advance(vars.today,
-                                                          exercises[i]);
+    for (auto& exercise : exercises) {
+        for (auto& length : lengths) {
+            for (auto& k : type) {
+                Date exerciseDate = vars.calendar.advance(vars.today, exercise);
                 Date startDate =
                     vars.calendar.advance(exerciseDate,
                                           vars.settlementDays,Days);
@@ -142,14 +141,14 @@ void SwaptionTest::testStrikeDependency() {
                 std::vector<Real> values;
                 std::vector<Real> values_cash;
                 Volatility vol = 0.20;
-                for (Size l=0; l<LENGTH(strikes); l++) {
+                for (double strike : strikes) {
                     ext::shared_ptr<VanillaSwap> swap =
-                        MakeVanillaSwap(lengths[j], vars.index, strikes[l])
-                                .withEffectiveDate(startDate)
-                                .withFixedLegTenor(1*Years)
-                                .withFixedLegDayCount(vars.fixedDayCount)
-                                .withFloatingLegSpread(0.0)
-                                .withType(type[k]);
+                        MakeVanillaSwap(length, vars.index, strike)
+                            .withEffectiveDate(startDate)
+                            .withFixedLegTenor(1 * Years)
+                            .withFixedLegDayCount(vars.fixedDayCount)
+                            .withFloatingLegSpread(0.0)
+                            .withType(k);
                     ext::shared_ptr<Swaption> swaption =
                         vars.makeSwaption(swap,exerciseDate,vol);
                     // FLOATING_POINT_EXCEPTION
@@ -160,31 +159,31 @@ void SwaptionTest::testStrikeDependency() {
                     values_cash.push_back(swaption_cash->NPV());
                 }
                 // and check that they go the right way
-                if (type[k]==VanillaSwap::Payer) {
+                if (k == VanillaSwap::Payer) {
                     auto it = std::adjacent_find(values.begin(), values.end(), std::less<Real>());
                     if (it != values.end()) {
                         Size n = it - values.begin();
                         BOOST_ERROR("NPV of Payer swaption with delivery settlement"
-                                    "is increasing with the strike:" <<
-                                    "\noption tenor: " << exercises[i] <<
-                                    "\noption date:  " << exerciseDate <<
-                                    "\nvolatility:   " << io::rate(vol) <<
-                                    "\nswap tenor:   " << lengths[j] <<
-                                    "\nvalue:        " << values[n  ] <<" at strike: " << io::rate(strikes[n  ]) <<
-                                    "\nvalue:        " << values[n+1] << " at strike: " << io::rate(strikes[n+1]));
+                                    "is increasing with the strike:"
+                                    << "\noption tenor: " << exercise << "\noption date:  "
+                                    << exerciseDate << "\nvolatility:   " << io::rate(vol)
+                                    << "\nswap tenor:   " << length << "\nvalue:        "
+                                    << values[n] << " at strike: " << io::rate(strikes[n])
+                                    << "\nvalue:        " << values[n + 1]
+                                    << " at strike: " << io::rate(strikes[n + 1]));
                     }
                     auto it_cash = std::adjacent_find(values_cash.begin(), values_cash.end(),
                                                       std::less<Real>());
                     if (it_cash != values_cash.end()) {
                         Size n = it_cash - values_cash.begin();
                         BOOST_ERROR("NPV of Payer swaption with cash settlement"
-                                    "is increasing with the strike:" <<
-                                    "\noption tenor: " << exercises[i] <<
-                                    "\noption date:  " << exerciseDate <<
-                                    "\nvolatility:   " << io::rate(vol) <<
-                                    "\nswap tenor:   " << lengths[j] <<
-                                    "\nvalue:        " << values_cash[n  ] << " at strike: " << io::rate(strikes[n  ]) <<
-                                    "\nvalue:        " << values_cash[n+1] << " at strike: " << io::rate(strikes[n+1]));
+                                    "is increasing with the strike:"
+                                    << "\noption tenor: " << exercise << "\noption date:  "
+                                    << exerciseDate << "\nvolatility:   " << io::rate(vol)
+                                    << "\nswap tenor:   " << length << "\nvalue:        "
+                                    << values_cash[n] << " at strike: " << io::rate(strikes[n])
+                                    << "\nvalue:        " << values_cash[n + 1]
+                                    << " at strike: " << io::rate(strikes[n + 1]));
                     }
                 } else {
                     auto it =
@@ -192,26 +191,26 @@ void SwaptionTest::testStrikeDependency() {
                     if (it != values.end()) {
                         Size n = it - values.begin();
                         BOOST_ERROR("NPV of Receiver swaption with delivery settlement"
-                                    "is increasing with the strike:" <<
-                                    "\noption tenor: " << exercises[i] <<
-                                    "\noption date:  " << exerciseDate <<
-                                    "\nvolatility:   " << io::rate(vol) <<
-                                    "\nswap tenor:   " << lengths[j] <<
-                                    "\nvalue:        " << values[n  ] << " at strike: " << io::rate(strikes[n  ]) <<
-                                    "\nvalue:        " << values[n+1] << " at strike: " << io::rate(strikes[n+1]));
+                                    "is increasing with the strike:"
+                                    << "\noption tenor: " << exercise << "\noption date:  "
+                                    << exerciseDate << "\nvolatility:   " << io::rate(vol)
+                                    << "\nswap tenor:   " << length << "\nvalue:        "
+                                    << values[n] << " at strike: " << io::rate(strikes[n])
+                                    << "\nvalue:        " << values[n + 1]
+                                    << " at strike: " << io::rate(strikes[n + 1]));
                     }
                     auto it_cash = std::adjacent_find(values_cash.begin(), values_cash.end(),
                                                       std::greater<Real>());
                     if (it_cash != values_cash.end()) {
                         Size n = it_cash - values_cash.begin();
                         BOOST_ERROR("NPV of Receiver swaption with cash settlement"
-                                    "is increasing with the strike:" <<
-                                    "\noption tenor: " << exercises[i] <<
-                                    "\noption date:  " << exerciseDate <<
-                                    "\nvolatility:   " << io::rate(vol) <<
-                                    "\nswap tenor:   " << lengths[j] <<
-                                    "\nvalue:        " << values_cash[n  ] << " at strike: " << io::rate(strikes[n  ]) <<
-                                    "\nvalue:        " << values_cash[n+1] << " at strike: " << io::rate(strikes[n+1]));
+                                    "is increasing with the strike:"
+                                    << "\noption tenor: " << exercise << "\noption date:  "
+                                    << exerciseDate << "\nvolatility:   " << io::rate(vol)
+                                    << "\nswap tenor:   " << length << "\nvalue:        "
+                                    << values_cash[n] << " at strike: " << io::rate(strikes[n])
+                                    << "\nvalue:        " << values_cash[n + 1]
+                                    << " at strike: " << io::rate(strikes[n + 1]));
                     }
                 }
             }
@@ -229,25 +228,24 @@ void SwaptionTest::testSpreadDependency() {
 
     Spread spreads[] = { -0.002, -0.001, 0.0, 0.001, 0.002 };
 
-    for (Size i=0; i<LENGTH(exercises); i++) {
-        for (Size j=0; j<LENGTH(lengths); j++) {
-            for (Size k=0; k<LENGTH(type); k++) {
-                Date exerciseDate = vars.calendar.advance(vars.today,
-                                                          exercises[i]);
+    for (auto exercise : exercises) {
+        for (auto& length : lengths) {
+            for (auto& k : type) {
+                Date exerciseDate = vars.calendar.advance(vars.today, exercise);
                 Date startDate =
                     vars.calendar.advance(exerciseDate,
                                           vars.settlementDays,Days);
                 // store the results for different rates...
                 std::vector<Real> values;
                 std::vector<Real> values_cash;
-                for (Size l=0; l<LENGTH(spreads); l++) {
+                for (double spread : spreads) {
                     ext::shared_ptr<VanillaSwap> swap =
-                        MakeVanillaSwap(lengths[j], vars.index, 0.06)
-                                .withFixedLegTenor(1*Years)
-                                .withFixedLegDayCount(vars.fixedDayCount)
-                                .withEffectiveDate(startDate)
-                                .withFloatingLegSpread(spreads[l])
-                                .withType(type[k]);
+                        MakeVanillaSwap(length, vars.index, 0.06)
+                            .withFixedLegTenor(1 * Years)
+                            .withFixedLegDayCount(vars.fixedDayCount)
+                            .withEffectiveDate(startDate)
+                            .withFloatingLegSpread(spread)
+                            .withType(k);
                     ext::shared_ptr<Swaption> swaption =
                         vars.makeSwaption(swap,exerciseDate,0.20);
                     // FLOATING_POINT_EXCEPTION
@@ -258,50 +256,52 @@ void SwaptionTest::testSpreadDependency() {
                     values_cash.push_back(swaption_cash->NPV());
                 }
                 // and check that they go the right way
-                if (type[k]==VanillaSwap::Payer) {
+                if (k == VanillaSwap::Payer) {
                     auto it =
                         std::adjacent_find(values.begin(), values.end(), std::greater<Real>());
                     if (it != values.end()) {
                         Size n = it - values.begin();
-                        BOOST_ERROR("NPV is decreasing with the spread " <<
-                            "in a payer swaption (physical delivered):" <<
-                            "\nexercise date: " << exerciseDate <<
-                            "\nlength:        " << lengths[j] <<
-                            "\nvalue:         " << values[n  ] << " for spread: " << io::rate(spreads[n]) <<
-                            "\nvalue:         " << values[n+1] << " for spread: " << io::rate(spreads[n+1]));
+                        BOOST_ERROR("NPV is decreasing with the spread "
+                                    << "in a payer swaption (physical delivered):"
+                                    << "\nexercise date: " << exerciseDate << "\nlength:        "
+                                    << length << "\nvalue:         " << values[n] << " for spread: "
+                                    << io::rate(spreads[n]) << "\nvalue:         " << values[n + 1]
+                                    << " for spread: " << io::rate(spreads[n + 1]));
                     }
                     auto it_cash = std::adjacent_find(values_cash.begin(), values_cash.end(),
                                                       std::greater<Real>());
                     if (it_cash != values_cash.end()) {
                         Size n = it_cash - values_cash.begin();
-                        BOOST_ERROR("NPV is decreasing with the spread " <<
-                            "in a payer swaption (cash delivered):" <<
-                            "\nexercise date: " << exerciseDate <<
-                            "\nlength: " << lengths[j] <<
-                            "\nvalue:  " << values_cash[n  ] << " for spread: " << io::rate(spreads[n]) <<
-                            "\nvalue:  " << values_cash[n+1] << " for spread: " << io::rate(spreads[n+1]));
+                        BOOST_ERROR("NPV is decreasing with the spread "
+                                    << "in a payer swaption (cash delivered):"
+                                    << "\nexercise date: " << exerciseDate << "\nlength: " << length
+                                    << "\nvalue:  " << values_cash[n] << " for spread: "
+                                    << io::rate(spreads[n]) << "\nvalue:  " << values_cash[n + 1]
+                                    << " for spread: " << io::rate(spreads[n + 1]));
                     }
                 } else {
                     auto it = std::adjacent_find(values.begin(), values.end(), std::less<Real>());
                     if (it != values.end()) {
                         Size n = it - values.begin();
-                        BOOST_ERROR("NPV is increasing with the spread " <<
-                            "in a receiver swaption (physical delivered):"
-                            "\nexercise date: " << exerciseDate <<
-                            "\nlength: " << lengths[j] <<
-                            "\nvalue:  " << values[n  ] << " for spread: " << io::rate(spreads[n]) <<
-                            "\nvalue:  " << values[n+1] << " for spread: " << io::rate(spreads[n+1]));
+                        BOOST_ERROR("NPV is increasing with the spread "
+                                    << "in a receiver swaption (physical delivered):"
+                                       "\nexercise date: "
+                                    << exerciseDate << "\nlength: " << length << "\nvalue:  "
+                                    << values[n] << " for spread: " << io::rate(spreads[n])
+                                    << "\nvalue:  " << values[n + 1]
+                                    << " for spread: " << io::rate(spreads[n + 1]));
                     }
                     auto it_cash = std::adjacent_find(values_cash.begin(), values_cash.end(),
                                                       std::less<Real>());
                     if (it_cash != values_cash.end()) {
                         Size n = it_cash - values_cash.begin();
-                        BOOST_ERROR("NPV is increasing with the spread " <<
-                            "in a receiver swaption (cash delivered):"
-                            "\nexercise date: " << exerciseDate <<
-                            "\nlength: " << lengths[j] <<
-                            "\nvalue:  " << values_cash[n  ] << " for spread: " << io::rate(spreads[n]) <<
-                            "\nvalue:  " << values_cash[n+1] << " for spread: " << io::rate(spreads[n+1]));
+                        BOOST_ERROR("NPV is increasing with the spread "
+                                    << "in a receiver swaption (cash delivered):"
+                                       "\nexercise date: "
+                                    << exerciseDate << "\nlength: " << length << "\nvalue:  "
+                                    << values_cash[n] << " for spread: " << io::rate(spreads[n])
+                                    << "\nvalue:  " << values_cash[n + 1]
+                                    << " for spread: " << io::rate(spreads[n + 1]));
                     }
                 }
             }
@@ -319,33 +319,30 @@ void SwaptionTest::testSpreadTreatment() {
 
     Spread spreads[] = { -0.002, -0.001, 0.0, 0.001, 0.002 };
 
-    for (Size i=0; i<LENGTH(exercises); i++) {
-        for (Size j=0; j<LENGTH(lengths); j++) {
-            for (Size k=0; k<LENGTH(type); k++) {
-                Date exerciseDate = vars.calendar.advance(vars.today,
-                                                          exercises[i]);
+    for (auto exercise : exercises) {
+        for (auto& length : lengths) {
+            for (auto& k : type) {
+                Date exerciseDate = vars.calendar.advance(vars.today, exercise);
                 Date startDate =
                     vars.calendar.advance(exerciseDate,
                                           vars.settlementDays,Days);
-                for (Size l=0; l<LENGTH(spreads); l++) {
+                for (double spread : spreads) {
                     ext::shared_ptr<VanillaSwap> swap =
-                        MakeVanillaSwap(lengths[j], vars.index, 0.06)
-                                .withFixedLegTenor(1*Years)
-                                .withFixedLegDayCount(vars.fixedDayCount)
-                                .withEffectiveDate(startDate)
-                                .withFloatingLegSpread(spreads[l])
-                                .withType(type[k]);
+                        MakeVanillaSwap(length, vars.index, 0.06)
+                            .withFixedLegTenor(1 * Years)
+                            .withFixedLegDayCount(vars.fixedDayCount)
+                            .withEffectiveDate(startDate)
+                            .withFloatingLegSpread(spread)
+                            .withType(k);
                     // FLOATING_POINT_EXCEPTION
-                    Spread correction = spreads[l] *
-                                        swap->floatingLegBPS() /
-                                        swap->fixedLegBPS();
+                    Spread correction = spread * swap->floatingLegBPS() / swap->fixedLegBPS();
                     ext::shared_ptr<VanillaSwap> equivalentSwap =
-                        MakeVanillaSwap(lengths[j], vars.index, 0.06+correction)
-                                .withFixedLegTenor(1*Years)
-                                .withFixedLegDayCount(vars.fixedDayCount)
-                                .withEffectiveDate(startDate)
-                                .withFloatingLegSpread(0.0)
-                                .withType(type[k]);
+                        MakeVanillaSwap(length, vars.index, 0.06 + correction)
+                            .withFixedLegTenor(1 * Years)
+                            .withFixedLegDayCount(vars.fixedDayCount)
+                            .withEffectiveDate(startDate)
+                            .withFloatingLegSpread(0.0)
+                            .withType(k);
                     ext::shared_ptr<Swaption> swaption1 =
                         vars.makeSwaption(swap,exerciseDate,0.20);
                     ext::shared_ptr<Swaption> swaption2 =
@@ -357,24 +354,20 @@ void SwaptionTest::testSpreadTreatment() {
                         vars.makeSwaption(equivalentSwap,exerciseDate,0.20,
                                           Settlement::Cash, Settlement::ParYieldCurve);
                     if (std::fabs(swaption1->NPV()-swaption2->NPV()) > 1.0e-6)
-                        BOOST_ERROR("wrong spread treatment:" <<
-                            "\nexercise: " << exerciseDate <<
-                            "\nlength:   " << lengths[j] <<
-                            "\ntype      " << type[k] <<
-                            "\nspread:   " << io::rate(spreads[l]) <<
-                            "\noriginal swaption value:   " << swaption1->NPV() <<
-                            "\nequivalent swaption value: " << swaption2->NPV());
+                        BOOST_ERROR("wrong spread treatment:"
+                                    << "\nexercise: " << exerciseDate << "\nlength:   " << length
+                                    << "\ntype      " << k << "\nspread:   " << io::rate(spread)
+                                    << "\noriginal swaption value:   " << swaption1->NPV()
+                                    << "\nequivalent swaption value: " << swaption2->NPV());
 
                     if (std::fabs(swaption1_cash->NPV()-swaption2_cash->NPV()) > 1.0e-6)
-                        BOOST_ERROR("wrong spread treatment:" <<
-                            "\nexercise date: " << exerciseDate <<
-                            "\nlength: " << lengths[j] <<
-                            "\npay " << (type[k] ? "fixed" : "floating") <<
-                            "\nspread: " << io::rate(spreads[l]) <<
-                            "\nvalue of original swaption:   "  << swaption1_cash->NPV() <<
-                            "\nvalue of equivalent swaption: "  << swaption2_cash->NPV());
+                        BOOST_ERROR("wrong spread treatment:"
+                                    << "\nexercise date: " << exerciseDate << "\nlength: " << length
+                                    << "\npay " << (k ? "fixed" : "floating")
+                                    << "\nspread: " << io::rate(spread)
+                                    << "\nvalue of original swaption:   " << swaption1_cash->NPV()
+                                    << "\nvalue of equivalent swaption: " << swaption2_cash->NPV());
                 }
-
             }
         }
     }
@@ -431,31 +424,28 @@ void SwaptionTest::testVega() {
     Rate strikes[] = { 0.03, 0.04, 0.05, 0.06, 0.07 };
     Volatility vols[] = { 0.01, 0.20, 0.30, 0.70, 0.90 };
     Volatility shift = 1e-8;
-    for (Size i=0; i<LENGTH(exercises); i++) {
-        Date exerciseDate = vars.calendar.advance(vars.today, exercises[i]);
+    for (auto& exercise : exercises) {
+        Date exerciseDate = vars.calendar.advance(vars.today, exercise);
         Date startDate = vars.calendar.advance(exerciseDate,
                                            vars.settlementDays*Days);
-        for (Size j=0; j<LENGTH(lengths); j++) {
-            for (Size t=0; t<LENGTH(strikes); t++) {
+        for (auto& length : lengths) {
+            for (double strike : strikes) {
                 for (Size h=0; h<LENGTH(type); h++) {
                     ext::shared_ptr<VanillaSwap> swap =
-                        MakeVanillaSwap(lengths[j], vars.index, strikes[t])
-                                .withEffectiveDate(startDate)
-                                .withFixedLegTenor(1*Years)
-                                .withFixedLegDayCount(vars.fixedDayCount)
-                                .withFloatingLegSpread(0.0)
-                                .withType(type[h]);
-                    for (Size u=0; u<LENGTH(vols); u++) {
+                        MakeVanillaSwap(length, vars.index, strike)
+                            .withEffectiveDate(startDate)
+                            .withFixedLegTenor(1 * Years)
+                            .withFixedLegDayCount(vars.fixedDayCount)
+                            .withFloatingLegSpread(0.0)
+                            .withType(type[h]);
+                    for (double vol : vols) {
                         ext::shared_ptr<Swaption> swaption =
-                            vars.makeSwaption(swap, exerciseDate,
-                                              vols[u], types[h], methods[h]);
+                            vars.makeSwaption(swap, exerciseDate, vol, types[h], methods[h]);
                         // FLOATING_POINT_EXCEPTION
-                        ext::shared_ptr<Swaption> swaption1 =
-                            vars.makeSwaption(swap, exerciseDate,
-                                              vols[u]-shift, types[h], methods[h]);
-                        ext::shared_ptr<Swaption> swaption2 =
-                            vars.makeSwaption(swap, exerciseDate,
-                                              vols[u]+shift, types[h], methods[h]);
+                        ext::shared_ptr<Swaption> swaption1 = vars.makeSwaption(
+                            swap, exerciseDate, vol - shift, types[h], methods[h]);
+                        ext::shared_ptr<Swaption> swaption2 = vars.makeSwaption(
+                            swap, exerciseDate, vol + shift, types[h], methods[h]);
 
                         Real swaptionNPV = swaption->NPV();
                         Real numericalVegaPerPoint =
@@ -469,19 +459,20 @@ void SwaptionTest::testVega() {
                             discrepancy /= numericalVegaPerPoint;
                             Real tolerance = 0.015;
                             if (discrepancy > tolerance)
-                                BOOST_FAIL("failed to compute swaption vega:" <<
-                                    "\n  option tenor:    " << exercises[i] <<
-                                    "\n  volatility:      " << io::rate(vols[u]) <<
-                                    "\n  option type:     " << swaption->type() <<
-                                    "\n  swap tenor:      " << lengths[j] <<
-                                    "\n  strike:          " << io::rate(strikes[t]) <<
-                                    "\n  settlement:      " << types[h] <<
-                                    "\n  nominal:         " << swaption->underlyingSwap()->nominal() <<
-                                    "\n  npv:             " << swaptionNPV <<
-                                    "\n  calculated vega: " << analyticalVegaPerPoint <<
-                                    "\n  expected vega:   " << numericalVegaPerPoint <<
-                                    "\n  discrepancy:     " << io::rate(discrepancy) <<
-                                    "\n  tolerance:       " << io::rate(tolerance));
+                                BOOST_FAIL("failed to compute swaption vega:"
+                                           << "\n  option tenor:    " << exercise
+                                           << "\n  volatility:      " << io::rate(vol)
+                                           << "\n  option type:     " << swaption->type()
+                                           << "\n  swap tenor:      " << length
+                                           << "\n  strike:          " << io::rate(strike)
+                                           << "\n  settlement:      " << types[h]
+                                           << "\n  nominal:         "
+                                           << swaption->underlyingSwap()->nominal()
+                                           << "\n  npv:             " << swaptionNPV
+                                           << "\n  calculated vega: " << analyticalVegaPerPoint
+                                           << "\n  expected vega:   " << numericalVegaPerPoint
+                                           << "\n  discrepancy:     " << io::rate(discrepancy)
+                                           << "\n  tolerance:       " << io::rate(tolerance));
                         }
                     }
                 }
@@ -502,15 +493,13 @@ void SwaptionTest::testCashSettledSwaptions() {
 
     Rate strike = 0.05;
 
-    for (Size i=0; i<LENGTH(exercises); i++) {
-        for (Size j=0; j<LENGTH(lengths); j++) {
+    for (auto exercise : exercises) {
+        for (auto length : lengths) {
 
-            Date exerciseDate = vars.calendar.advance(vars.today,exercises[i]);
+            Date exerciseDate = vars.calendar.advance(vars.today, exercise);
             Date startDate = vars.calendar.advance(exerciseDate,
                                                    vars.settlementDays,Days);
-            Date maturity =
-                vars.calendar.advance(startDate,lengths[j],
-                                      vars.floatingConvention);
+            Date maturity = vars.calendar.advance(startDate, length, vars.floatingConvention);
             Schedule floatSchedule(startDate, maturity, vars.floatingTenor,
                                    vars.calendar,vars.floatingConvention,
                                    vars.floatingConvention,
@@ -702,132 +691,92 @@ void SwaptionTest::testCashSettledSwaptions() {
             Real annuity_ratio_u365 =  cashannuity_u365 / annuity_u365;
 
             if (std::fabs(annuity_ratio_u360-npv_ratio_u360)>1e-10 ) {
-                BOOST_ERROR("\n" <<
-                            "    The npv's ratio must be equal to " <<
-                            " annuities ratio" << "\n"
-                            "    Swaption " <<
-                            exercises[i].units() << "y x " << lengths[j].units() << "y" <<
-                            " (underlying swap fixed leg Unadjusted, 30/360)" << "\n" <<
-                            "    Today           : " <<
-                            vars.today << "\n" <<
-                            "    Settlement date : " <<
-                            vars.settlement << "\n" <<
-                            "    Exercise date   : " <<
-                            exerciseDate << "\n"   <<
-                            "    Swap start date : " <<
-                            startDate << "\n"   <<
-                            "    Swap end date   : " <<
-                            maturity <<     "\n"   <<
-                            "    physical delivered swaption npv : " <<
-                            value_p_u360 << "\t\t\t" <<
-                            "    annuity : " <<
-                            annuity_u360 << "\n" <<
-                            "    cash delivered swaption npv :     " <<
-                            value_c_u360 << "\t\t\t" <<
-                            "    annuity : " <<
-                            cashannuity_u360 << "\n" <<
-                            "    npv ratio : " <<
-                            npv_ratio_u360 << "\n" <<
-                            "    annuity ratio : " <<
-                            annuity_ratio_u360 << "\n" <<
-                            "    difference : " <<
-                            (annuity_ratio_u360-npv_ratio_u360) );
+                BOOST_ERROR("\n"
+                            << "    The npv's ratio must be equal to "
+                            << " annuities ratio"
+                            << "\n"
+                               "    Swaption "
+                            << exercises[i].units() << "y x " << length.units() << "y"
+                            << " (underlying swap fixed leg Unadjusted, 30/360)"
+                            << "\n"
+                            << "    Today           : " << vars.today << "\n"
+                            << "    Settlement date : " << vars.settlement << "\n"
+                            << "    Exercise date   : " << exerciseDate << "\n"
+                            << "    Swap start date : " << startDate << "\n"
+                            << "    Swap end date   : " << maturity << "\n"
+                            << "    physical delivered swaption npv : " << value_p_u360 << "\t\t\t"
+                            << "    annuity : " << annuity_u360 << "\n"
+                            << "    cash delivered swaption npv :     " << value_c_u360 << "\t\t\t"
+                            << "    annuity : " << cashannuity_u360 << "\n"
+                            << "    npv ratio : " << npv_ratio_u360 << "\n"
+                            << "    annuity ratio : " << annuity_ratio_u360 << "\n"
+                            << "    difference : " << (annuity_ratio_u360 - npv_ratio_u360));
             }
             if (std::fabs(annuity_ratio_a365-npv_ratio_a365)>1e-10) {
-                BOOST_ERROR("\n" <<
-                            "    The npv's ratio must be equal to " <<
-                            " annuities ratio" << "\n"
-                            "    Swaption " <<
-                            exercises[i].units() << "y x " << lengths[j].units() << "y" <<
-                            " (underlying swap fixed leg Modified Following, act/365" << "\n" <<
-                            "    Today           : " <<
-                            vars.today << "\n" <<
-                            "    Settlement date : " <<
-                            vars.settlement << "\n" <<
-                            "    Exercise date   : " <<
-                            exerciseDate <<  "\n"  <<
-                            "    Swap start date : " <<
-                            startDate << "\n"   <<
-                            "    Swap end date   : " <<
-                            maturity <<     "\n"   <<
-                            "    physical delivered swaption npv : "  <<
-                            value_p_a365 << "\t\t\t" <<
-                            "    annuity : " <<
-                            annuity_a365 << "\n" <<
-                            "    cash delivered swaption npv :     "  <<
-                            value_c_a365 << "\t\t\t" <<
-                            "    annuity : " <<
-                            cashannuity_a365 << "\n" <<
-                            "    npv ratio : " <<
-                            npv_ratio_a365 << "\n" <<
-                            "    annuity ratio : " <<
-                            annuity_ratio_a365 << "\n" <<
-                            "    difference : " <<
-                            (annuity_ratio_a365-npv_ratio_a365) );
+                BOOST_ERROR("\n"
+                            << "    The npv's ratio must be equal to "
+                            << " annuities ratio"
+                            << "\n"
+                               "    Swaption "
+                            << exercises[i].units() << "y x " << length.units() << "y"
+                            << " (underlying swap fixed leg Modified Following, act/365"
+                            << "\n"
+                            << "    Today           : " << vars.today << "\n"
+                            << "    Settlement date : " << vars.settlement << "\n"
+                            << "    Exercise date   : " << exerciseDate << "\n"
+                            << "    Swap start date : " << startDate << "\n"
+                            << "    Swap end date   : " << maturity << "\n"
+                            << "    physical delivered swaption npv : " << value_p_a365 << "\t\t\t"
+                            << "    annuity : " << annuity_a365 << "\n"
+                            << "    cash delivered swaption npv :     " << value_c_a365 << "\t\t\t"
+                            << "    annuity : " << cashannuity_a365 << "\n"
+                            << "    npv ratio : " << npv_ratio_a365 << "\n"
+                            << "    annuity ratio : " << annuity_ratio_a365 << "\n"
+                            << "    difference : " << (annuity_ratio_a365 - npv_ratio_a365));
                 }
             if (std::fabs(annuity_ratio_a360-npv_ratio_a360)>1e-10) {
-                BOOST_ERROR("\n" <<
-                            "    The npv's ratio must be equal to " <<
-                            " annuities ratio" << "\n"
-                            "    Swaption " <<
-                            exercises[i].units() << "y x " << lengths[j].units() << "y" <<
-                            " (underlying swap fixed leg Unadjusted, 30/360)" << "\n" <<
-                            "    Today           : " <<
-                            vars.today << "\n" <<
-                            "    Settlement date : " <<
-                            vars.settlement << "\n" <<
-                            "    Exercise date   : " <<
-                            exerciseDate << "\n"   <<
-                            "    Swap start date : " <<
-                            startDate << "\n"   <<
-                            "    Swap end date   : " <<
-                            maturity <<     "\n"   <<
-                            "    physical delivered swaption npv : " <<
-                            value_p_a360 << "\t\t\t" <<
-                            "    annuity : " <<
-                            annuity_a360 << "\n" <<
-                            "    cash delivered swaption npv :     " <<
-                            value_c_a360 << "\t\t\t" <<
-                            "    annuity : " <<
-                            cashannuity_a360 << "\n" <<
-                            "    npv ratio : " <<
-                            npv_ratio_a360 << "\n" <<
-                            "    annuity ratio : " <<
-                            annuity_ratio_a360 << "\n" <<
-                            "    difference : " <<
-                            (annuity_ratio_a360-npv_ratio_a360) );
+                BOOST_ERROR("\n"
+                            << "    The npv's ratio must be equal to "
+                            << " annuities ratio"
+                            << "\n"
+                               "    Swaption "
+                            << exercises[i].units() << "y x " << length.units() << "y"
+                            << " (underlying swap fixed leg Unadjusted, 30/360)"
+                            << "\n"
+                            << "    Today           : " << vars.today << "\n"
+                            << "    Settlement date : " << vars.settlement << "\n"
+                            << "    Exercise date   : " << exerciseDate << "\n"
+                            << "    Swap start date : " << startDate << "\n"
+                            << "    Swap end date   : " << maturity << "\n"
+                            << "    physical delivered swaption npv : " << value_p_a360 << "\t\t\t"
+                            << "    annuity : " << annuity_a360 << "\n"
+                            << "    cash delivered swaption npv :     " << value_c_a360 << "\t\t\t"
+                            << "    annuity : " << cashannuity_a360 << "\n"
+                            << "    npv ratio : " << npv_ratio_a360 << "\n"
+                            << "    annuity ratio : " << annuity_ratio_a360 << "\n"
+                            << "    difference : " << (annuity_ratio_a360 - npv_ratio_a360));
             }
             if (std::fabs(annuity_ratio_u365-npv_ratio_u365)>1e-10) {
-                BOOST_ERROR("\n" <<
-                            "    The npv's ratio must be equal to " <<
-                            " annuities ratio" << "\n"
-                            "    Swaption " <<
-                            exercises[i].units() << "y x " << lengths[j].units() << "y" <<
-                            " (underlying swap fixed leg Unadjusted, act/365)" << "\n" <<
-                            "    Today           : " <<
-                            vars.today << "\n" <<
-                            "    Settlement date : " <<
-                            vars.settlement << "\n" <<
-                            "    Exercise date   : " <<
-                            exerciseDate << "\n"   <<
-                            "    Swap start date : " <<
-                            startDate << "\n"   <<
-                            "    Swap end date   : " <<
-                            maturity <<     "\n"   <<
-                            "    physical delivered swaption npv : " <<
-                            value_p_u365 << "\t\t\t" <<
-                            "    annuity : " <<
-                            annuity_u365 << "\n" <<
-                            "    cash delivered swaption npv :     " <<
-                            value_c_u365 << "\t\t\t" <<
-                            "    annuity : " <<
-                            cashannuity_u365 << "\n" <<
-                            "    npv ratio : " <<
-                            npv_ratio_u365 << "\n" <<
-                            "    annuity ratio : " <<
-                            annuity_ratio_u365 << "\n" <<
-                            "    difference : " <<
-                            (annuity_ratio_u365-npv_ratio_u365) );
+                BOOST_ERROR("\n"
+                            << "    The npv's ratio must be equal to "
+                            << " annuities ratio"
+                            << "\n"
+                               "    Swaption "
+                            << exercises[i].units() << "y x " << length.units() << "y"
+                            << " (underlying swap fixed leg Unadjusted, act/365)"
+                            << "\n"
+                            << "    Today           : " << vars.today << "\n"
+                            << "    Settlement date : " << vars.settlement << "\n"
+                            << "    Exercise date   : " << exerciseDate << "\n"
+                            << "    Swap start date : " << startDate << "\n"
+                            << "    Swap end date   : " << maturity << "\n"
+                            << "    physical delivered swaption npv : " << value_p_u365 << "\t\t\t"
+                            << "    annuity : " << annuity_u365 << "\n"
+                            << "    cash delivered swaption npv :     " << value_c_u365 << "\t\t\t"
+                            << "    annuity : " << cashannuity_u365 << "\n"
+                            << "    npv ratio : " << npv_ratio_u365 << "\n"
+                            << "    annuity ratio : " << annuity_ratio_u365 << "\n"
+                            << "    difference : " << (annuity_ratio_u365 - npv_ratio_u365));
             }
         }
     }
@@ -852,28 +801,26 @@ void SwaptionTest::testImpliedVolatility() {
     Rate strikes[] = { 0.02, 0.03, 0.04, 0.05, 0.06, 0.07 };
     Volatility vols[] = { 0.01, 0.05, 0.10, 0.20, 0.30, 0.70, 0.90 };
 
-    for (Size i=0; i<LENGTH(exercises); i++) {
-        for (Size j=0; j<LENGTH(lengths); j++) {
-            Date exerciseDate = vars.calendar.advance(vars.today,exercises[i]);
+    for (auto& exercise : exercises) {
+        for (auto& length : lengths) {
+            Date exerciseDate = vars.calendar.advance(vars.today, exercise);
             Date startDate = vars.calendar.advance(exerciseDate,
                                                    vars.settlementDays, Days);
 
-            for (Size t=0; t<LENGTH(strikes); t++) {
-                for (Size k=0; k<LENGTH(type); k++) {
+            for (double& strike : strikes) {
+                for (auto& k : type) {
                     ext::shared_ptr<VanillaSwap> swap =
-                        MakeVanillaSwap(lengths[j], vars.index, strikes[t])
-                                .withEffectiveDate(startDate)
-                                .withFixedLegTenor(1*Years)
-                                .withFixedLegDayCount(vars.fixedDayCount)
-                                .withFloatingLegSpread(0.0)
-                                .withType(type[k]);
+                        MakeVanillaSwap(length, vars.index, strike)
+                            .withEffectiveDate(startDate)
+                            .withFixedLegTenor(1 * Years)
+                            .withFixedLegDayCount(vars.fixedDayCount)
+                            .withFloatingLegSpread(0.0)
+                            .withType(k);
                     for (Size h=0; h<LENGTH(types); h++) {
-                        for (Size u=0; u<LENGTH(vols); u++) {
+                        for (double vol : vols) {
                             ext::shared_ptr<Swaption> swaption =
-                                vars.makeSwaption(
-                                    swap, exerciseDate, vols[u], types[h],
-                                    methods[h],
-                                    BlackSwaptionEngine::DiscountCurve);
+                                vars.makeSwaption(swap, exerciseDate, vol, types[h], methods[h],
+                                                  BlackSwaptionEngine::DiscountCurve);
                             // Black price
                             Real value = swaption->NPV();
                             Volatility implVol = 0.0;
@@ -897,31 +844,31 @@ void SwaptionTest::testImpliedVolatility() {
                                     continue;
                                 }
                                 // otherwise, report error
-                                BOOST_ERROR("implied vol failure: " <<
-                                            exercises[i] << "x" << lengths[j] << " " << type[k] <<
-                                            "\nsettlement: " << types[h] <<
-                                            "\nstrike      " << strikes[t] <<
-                                            "\natm level:  " << io::rate(swap->fairRate()) <<
-                                            "\nvol:        " << io::volatility(vols[u]) <<
-                                            "\nprice:      " << value <<
-                                            "\n" << e.what());
+                                BOOST_ERROR("implied vol failure: "
+                                            << exercise << "x" << length << " " << k
+                                            << "\nsettlement: " << types[h] << "\nstrike      "
+                                            << strike
+                                            << "\natm level:  " << io::rate(swap->fairRate())
+                                            << "\nvol:        " << io::volatility(vol)
+                                            << "\nprice:      " << value << "\n"
+                                            << e.what());
                             }
-                            if (std::fabs(implVol-vols[u]) > tolerance) {
+                            if (std::fabs(implVol - vol) > tolerance) {
                                 // the difference might not matter
                                 swaption->setPricingEngine(vars.makeEngine(implVol, BlackSwaptionEngine::DiscountCurve));
                                 Real value2 = swaption->NPV();
                                 if (std::fabs(value-value2) > tolerance) {
-                                    BOOST_ERROR("implied vol failure: " <<
-                                        exercises[i] << "x" << lengths[j] << " " << type[k] <<
-                                        "\nsettlement:    " << types[h] <<
-                                        "\nstrike         " << strikes[t] <<
-                                        "\natm level:     " << io::rate(swap->fairRate()) <<
-                                        "\nvol:           " << io::volatility(vols[u]) <<
-                                        "\nprice:         " << value <<
-                                        "\nimplied vol:   " << io::volatility(implVol) <<
-                                        "\nimplied price: " << value2);
+                                    BOOST_ERROR("implied vol failure: "
+                                                << exercise << "x" << length << " " << k
+                                                << "\nsettlement:    " << types[h]
+                                                << "\nstrike         " << strike
+                                                << "\natm level:     " << io::rate(swap->fairRate())
+                                                << "\nvol:           " << io::volatility(vol)
+                                                << "\nprice:         " << value
+                                                << "\nimplied vol:   " << io::volatility(implVol)
+                                                << "\nimplied price: " << value2);
                                 }
-                             }
+                            }
                         }
                     }
                 }
@@ -974,27 +921,27 @@ void checkSwaptionDelta(bool useBachelierVol)
     
     Rate strikes[] = { 0.03, 0.04, 0.05, 0.06, 0.07 };
     Volatility vols[] = { 0.0, 0.10, 0.20, 0.30, 0.70, 0.90 };
-    
-    for (Size u=0; u<LENGTH(vols); u++) {
-        for (Size i=0; i<LENGTH(exercises); i++) {
-            for (Size j=0; j<LENGTH(lengths); j++) {
-                for (Size t=0; t<LENGTH(strikes); t++) {
+
+    for (double vol : vols) {
+        for (auto exercise : exercises) {
+            for (auto& length : lengths) {
+                for (double& strike : strikes) {
                     for (Size h=0; h<LENGTH(type); h++) {
-                        Volatility volatility = useBachelierVol ? vols[u] / 100.0 : vols[u];
+                        Volatility volatility = useBachelierVol ? vol / 100.0 : vol;
                         ext::shared_ptr<Engine> swaptionEngine = makeConstVolEngine<Engine>(
                             discountHandle, volatility);
 
-                        Date exerciseDate = calendar.advance(today, exercises[i]);
+                        Date exerciseDate = calendar.advance(today, exercise);
                         Date startDate = calendar.advance(exerciseDate, 2*Days);
                         projectionQuoteHandle.linkTo(ext::make_shared<SimpleQuote>(projectionRate));
-                        
-                        ext::shared_ptr<VanillaSwap> underlying = MakeVanillaSwap(
-                            lengths[j], idx, strikes[t])
-                            .withEffectiveDate(startDate)
-                            .withFixedLegTenor(1 * Years)
-                            .withFixedLegDayCount(Thirty360())
-                            .withFloatingLegSpread(0.0)
-                            .withType(type[h]);
+
+                        ext::shared_ptr<VanillaSwap> underlying =
+                            MakeVanillaSwap(length, idx, strike)
+                                .withEffectiveDate(startDate)
+                                .withFixedLegTenor(1 * Years)
+                                .withFixedLegDayCount(Thirty360())
+                                .withFloatingLegSpread(0.0)
+                                .withType(type[h]);
                         underlying->setPricingEngine(swapEngine);
                         
                         Real fairRate = underlying->fairRate();
@@ -1029,18 +976,17 @@ void checkSwaptionDelta(bool useBachelierVol)
                         bool checkIsCorrect = (lowerBound < approxDelta) && (approxDelta < upperBound);
                         
                         if (!checkIsCorrect)
-                            BOOST_FAIL("failed to compute swaption delta:" <<
-                                "\n  option tenor:     " << exerciseDate <<
-                                "\n  volatility:       " << io::rate(volatility) <<
-                                "\n  option type:      " << swaption->type() <<
-                                "\n  swap tenor:       " << lengths[j] <<
-                                "\n  strike:           " << strikes[t] <<
-                                "\n  settlement:       " << types[h] <<
-                                "\n  method:           " << methods[h] <<
-                                "\n  nominal:          " << swaption->underlyingSwap()->nominal() <<
-                                "\n  npv:              " << value <<
-                                "\n  calculated delta: " << delta <<
-                                "\n  expected delta:   " << approxDelta);
+                            BOOST_FAIL(
+                                "failed to compute swaption delta:"
+                                << "\n  option tenor:     " << exerciseDate
+                                << "\n  volatility:       " << io::rate(volatility)
+                                << "\n  option type:      " << swaption->type()
+                                << "\n  swap tenor:       " << length << "\n  strike:           "
+                                << strike << "\n  settlement:       " << types[h]
+                                << "\n  method:           " << methods[h]
+                                << "\n  nominal:          " << swaption->underlyingSwap()->nominal()
+                                << "\n  npv:              " << value << "\n  calculated delta: "
+                                << delta << "\n  expected delta:   " << approxDelta);
                     }
                 }
             }
diff --git a/test-suite/swaptionvolatilitycube.cpp b/test-suite/swaptionvolatilitycube.cpp
index 15a6faaa345..158926d45b3 100644
--- a/test-suite/swaptionvolatilitycube.cpp
+++ b/test-suite/swaptionvolatilitycube.cpp
@@ -54,28 +54,22 @@ namespace swaption_volatility_cube_test {
         void makeAtmVolTest(const SwaptionVolatilityCube& volCube,
                             Real tolerance) {
 
-            for (Size i=0; i<atm.tenors.options.size(); i++) {
-              for (Size j=0; j<atm.tenors.swaps.size(); j++) {
-                Rate strike = volCube.atmStrike(atm.tenors.options[i],
-                                                atm.tenors.swaps[j]);
-                Volatility expVol =
-                    atmVolMatrix->volatility(atm.tenors.options[i],
-                                             atm.tenors.swaps[j],
-                                             strike, true);
-                Volatility actVol = volCube.volatility(atm.tenors.options[i],
-                                                       atm.tenors.swaps[j],
-                                                       strike, true);
-                Volatility error = std::abs(expVol-actVol);
-                if (error>tolerance)
-                  BOOST_ERROR("\nrecovery of atm vols failed:"
-                              "\nexpiry time = " << atm.tenors.options[i] <<
-                              "\nswap length = " << atm.tenors.swaps[j] <<
-                              "\n atm strike = " << io::rate(strike) <<
-                              "\n   exp. vol = " << io::volatility(expVol) <<
-                              "\n actual vol = " << io::volatility(actVol) <<
-                              "\n      error = " << io::volatility(error) <<
-                              "\n  tolerance = " << tolerance);
-              }
+            for (auto& option : atm.tenors.options) {
+                for (auto& swap : atm.tenors.swaps) {
+                    Rate strike = volCube.atmStrike(option, swap);
+                    Volatility expVol = atmVolMatrix->volatility(option, swap, strike, true);
+                    Volatility actVol = volCube.volatility(option, swap, strike, true);
+                    Volatility error = std::abs(expVol - actVol);
+                    if (error > tolerance)
+                        BOOST_ERROR("\nrecovery of atm vols failed:"
+                                    "\nexpiry time = "
+                                    << option << "\nswap length = " << swap
+                                    << "\n atm strike = " << io::rate(strike)
+                                    << "\n   exp. vol = " << io::volatility(expVol)
+                                    << "\n actual vol = " << io::volatility(actVol)
+                                    << "\n      error = " << io::volatility(error)
+                                    << "\n  tolerance = " << tolerance);
+                }
             }
         }
 
@@ -280,10 +274,11 @@ void SwaptionVolatilityCubeTest::testSpreadedCube() {
                 volCube->smileSection(vars.cube.tenors.options[i], vars.cube.tenors.swaps[j]);
             ext::shared_ptr<SmileSection> smileSectionBySpreadedCube =
                 spreadedVolCube->smileSection(vars.cube.tenors.options[i], vars.cube.tenors.swaps[j]);
-            for (Size k=0; k<strikes.size(); k++) {
-                Real strike = strikes[k];
-                Real diff = spreadedVolCube->volatility(vars.cube.tenors.options[i], vars.cube.tenors.swaps[j], strike)
-                            - volCube->volatility(vars.cube.tenors.options[i], vars.cube.tenors.swaps[j], strike);
+            for (double strike : strikes) {
+                Real diff = spreadedVolCube->volatility(vars.cube.tenors.options[i],
+                                                        vars.cube.tenors.swaps[j], strike) -
+                            volCube->volatility(vars.cube.tenors.options[i],
+                                                vars.cube.tenors.swaps[j], strike);
                 if (std::fabs(diff-spread->value())>1e-16)
                     BOOST_ERROR("\ndiff!=spread in volatility method:"
                                 "\nexpiry time = " << vars.cube.tenors.options[i] <<
@@ -301,7 +296,6 @@ void SwaptionVolatilityCubeTest::testSpreadedCube() {
                                 "\n atm strike = " << io::rate(strike) <<
                                 "\ndiff = " << diff <<
                                 "\nspread = " << spread->value());
-
             }
         }
     }
diff --git a/test-suite/twoassetbarrieroption.cpp b/test-suite/twoassetbarrieroption.cpp
index 3b7bcdb9e89..790c78701b6 100644
--- a/test-suite/twoassetbarrieroption.cpp
+++ b/test-suite/twoassetbarrieroption.cpp
@@ -106,31 +106,27 @@ void TwoAssetBarrierOptionTest::testHaugValues() {
                        new AnalyticTwoAssetBarrierEngine(process1, process2,
                                                          Handle<Quote>(rho)));
 
-    for (Size i=0; i<LENGTH(values); i++) {
+    for (auto& value : values) {
 
-        s1->setValue(values[i].s1);
-        q1->setValue(values[i].q1);
-        vol1->setValue(values[i].v1);
+        s1->setValue(value.s1);
+        q1->setValue(value.q1);
+        vol1->setValue(value.v1);
 
-        s2->setValue(values[i].s2);
-        q2->setValue(values[i].q2);
-        vol2->setValue(values[i].v2);
+        s2->setValue(value.s2);
+        q2->setValue(value.q2);
+        vol2->setValue(value.v2);
 
-        rho->setValue(values[i].correlation);
+        rho->setValue(value.correlation);
 
-        r->setValue(values[i].r);
+        r->setValue(value.r);
 
-        ext::shared_ptr<StrikedTypePayoff> payoff(
-                    new PlainVanillaPayoff(values[i].type, values[i].strike));
+        ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(value.type, value.strike));
 
-        TwoAssetBarrierOption barrierOption(values[i].barrierType,
-                                            values[i].barrier,
-                                            payoff,
-                                            exercise);
+        TwoAssetBarrierOption barrierOption(value.barrierType, value.barrier, payoff, exercise);
         barrierOption.setPricingEngine(engine);
 
         Real calculated = barrierOption.NPV();
-        Real expected = values[i].result;
+        Real expected = value.result;
         Real error = std::fabs(calculated-expected);
         Real tolerance = 4.0e-3;
         if (error > tolerance) {
diff --git a/test-suite/varianceswaps.cpp b/test-suite/varianceswaps.cpp
index e510225b830..66c00525f4b 100644
--- a/test-suite/varianceswaps.cpp
+++ b/test-suite/varianceswaps.cpp
@@ -146,14 +146,14 @@ void VarianceSwapTest::testReplicatingVarianceSwap() {
     ext::shared_ptr<SimpleQuote> rRate(new SimpleQuote(0.0));
     ext::shared_ptr<YieldTermStructure> rTS = flatRate(today, rRate, dc);
 
-    for (Size i=0; i<LENGTH(values); i++) {
-        Date exDate = today + timeToDays(values[i].t, 365);
+    for (auto& value : values) {
+        Date exDate = today + timeToDays(value.t, 365);
         std::vector<Date> dates(1);
         dates[0] = exDate;
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
 
         Size options = LENGTH(replicatingOptionData);
         std::vector<Real> callStrikes, putStrikes, callVols, putVols;
@@ -202,21 +202,16 @@ void VarianceSwapTest::testReplicatingVarianceSwap() {
                                                             callStrikes,
                                                             putStrikes));
 
-        VarianceSwap varianceSwap(values[i].type,
-                                  values[i].varStrike,
-                                  values[i].nominal,
-                                  today,
-                                  exDate);
+        VarianceSwap varianceSwap(value.type, value.varStrike, value.nominal, today, exDate);
         varianceSwap.setPricingEngine(engine);
 
         Real calculated = varianceSwap.variance();
-        Real expected = values[i].result;
+        Real expected = value.result;
         Real error = std::fabs(calculated-expected);
-        if (error>values[i].tol)
-            REPORT_FAILURE("value", values[i].type, values[i].varStrike,
-                           values[i].nominal, values[i].s, values[i].q,
-                           values[i].r, today, exDate, values[i].v, expected,
-                           calculated, error, values[i].tol);
+        if (error > value.tol)
+            REPORT_FAILURE("value", values[i].type, value.varStrike, value.nominal, value.s,
+                           value.q, value.r, today, exDate, value.v, expected, calculated, error,
+                           value.tol);
     }
 }
 
@@ -252,18 +247,18 @@ void VarianceSwapTest::testMCVarianceSwap() {
     std::vector<Volatility> vols(2);
     std::vector<Date> dates(2);
 
-    for (Size i=0; i<LENGTH(values); i++) {
-        Date exDate = today + timeToDays(values[i].t, 365);
-        Date intermDate = today + timeToDays(values[i].t1, 365);
+    for (auto& value : values) {
+        Date exDate = today + timeToDays(value.t, 365);
+        Date intermDate = today + timeToDays(value.t1, 365);
         ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
         dates[0] = intermDate;
         dates[1] = exDate;
 
-        spot ->setValue(values[i].s);
-        qRate->setValue(values[i].q);
-        rRate->setValue(values[i].r);
-        vols[0] = values[i].v1;
-        vols[1] = values[i].v;
+        spot->setValue(value.s);
+        qRate->setValue(value.q);
+        rRate->setValue(value.r);
+        vols[0] = value.v1;
+        vols[1] = value.v;
 
         ext::shared_ptr<BlackVolTermStructure> volTS(
                         new BlackVarianceCurve(today, dates, vols, dc, true));
@@ -282,21 +277,16 @@ void VarianceSwapTest::testMCVarianceSwap() {
             .withSamples(1023)
             .withSeed(42);
 
-        VarianceSwap varianceSwap(values[i].type,
-                                  values[i].varStrike,
-                                  values[i].nominal,
-                                  today,
-                                  exDate);
+        VarianceSwap varianceSwap(value.type, value.varStrike, value.nominal, today, exDate);
         varianceSwap.setPricingEngine(engine);
 
         Real calculated = varianceSwap.variance();
-        Real expected = values[i].result;
+        Real expected = value.result;
         Real error = std::fabs(calculated-expected);
-        if (error>values[i].tol)
-            REPORT_FAILURE("value", values[i].type, values[i].varStrike,
-                           values[i].nominal, values[i].s, values[i].q,
-                           values[i].r, today, exDate, values[i].v, expected,
-                           calculated, error, values[i].tol);
+        if (error > value.tol)
+            REPORT_FAILURE("value", values[i].type, value.varStrike, value.nominal, value.s,
+                           value.q, value.r, today, exDate, value.v, expected, calculated, error,
+                           value.tol);
     }
 }
 
diff --git a/test-suite/vpp.cpp b/test-suite/vpp.cpp
index 628c35e016d..52c1ed40d1e 100644
--- a/test-suite/vpp.cpp
+++ b/test-suite/vpp.cpp
@@ -919,8 +919,8 @@ void VPPTest::testKlugeExtOUMatrixDecomposition() {
     Array x(mesher->layout()->size());
 
     PseudoRandom::rng_type rng(PseudoRandom::urng_type(12345UL));
-    for (Size i=0; i < x.size(); ++i) {
-        x[i] = rng.next().value;
+    for (double& i : x) {
+        i = rng.next().value;
     }
 
     const Real tol = 1e-9;