QPR-13698 Use QL::Rounding and fix gradient

Author: sebastien.bouvard

QuantExt/qle/ad/computationgraph.cpp

@@ -22,7 +22,6 @@
 
 #include <ql/errors.hpp>
 #include <ql/math/comparison.hpp>
-#include <cmath>
 
 #include <boost/math/distributions/normal.hpp>
 
@@ -330,8 +329,8 @@ std::size_t cg_frac(ComputationGraph& g, const std::size_t a, const std::string&
 
 std::size_t cg_round(ComputationGraph& g, const std::size_t a, const std::size_t b, const std::string& label) {
     if (g.isConstant(a) && g.isConstant(b)){
-        double factor = std::pow(10.0, g.constantValue(b));
-        return cg_const(g, std::round(g.constantValue(a)*factor)/factor);
+        QuantLib::Rounding rnd(g.constantValue(b), QuantLib::Rounding::Closest, 5);
+        return cg_const(g, rnd(g.constantValue(a)));
     }
     return g.insert({a, b}, RandomVariableOpCode::Round, label);
 }

QuantExt/qle/math/randomvariable.cpp

@@ -38,7 +38,6 @@
 #include <boost/functional/hash.hpp>
 
 #include <map>
-#include <cmath>
 
 // if defined, RandomVariableStats are updated (this might impact perfomance!), default is undefined
 // #define ENABLE_RANDOMVARIABLE_STATS
@@ -739,14 +738,14 @@ RandomVariable round(RandomVariable x, const RandomVariable& y) {
     if (!y.deterministic_)
         x.expand();
     if (x.deterministic()){
-        double factor = std::pow(10, y.constantData_);
-        x.constantData_ = std::round(x.constantData_*factor)/factor;
+        QuantLib::Rounding rnd(y.constantData_, QuantLib::Rounding::Closest, 5);
+        x.constantData_ = rnd(x.constantData_);
     }
     else {
         resumeCalcStats();
         for (Size i = 0; i < x.size(); ++i) {
-            double factor = std::pow(10, y[i]);
-            x.data_[i] = std::round(x.data_[i]*factor)/factor;
+            QuantLib::Rounding rnd(y.constantData_, QuantLib::Rounding::Closest, 5);
+            x.data_[i] = rnd(x.constantData_);
         }
         stopCalcStats(x.size());
     }

QuantExt/qle/math/randomvariable_ops.cpp

@@ -310,11 +310,11 @@ std::vector<RandomVariableGrad> getRandomVariableGradients(const Size size, cons
 
     // Frac = 19
     grads.push_back([](const std::vector<const RandomVariable*>& args, const RandomVariable* v,
-                       const Size node) -> std::vector<RandomVariable> { return {QuantExt::frac(*args[0])}; });
+                       const Size node) -> std::vector<RandomVariable> { return {QuantExt::frac(RandomVariable(1))}; });
 
     // Round = 20
     grads.push_back([](const std::vector<const RandomVariable*>& args, const RandomVariable* v,
-                       const Size node) -> std::vector<RandomVariable> { return {QuantExt::round(*args[0], *args[1])}; });
+                       const Size node) -> std::vector<RandomVariable> { return {QuantExt::round(RandomVariable(0),RandomVariable(0))}; });
 
     return grads;
 }
@@ -386,10 +386,10 @@ std::vector<RandomVariableOpNodeRequirements> getRandomVariableOpNodeRequirement
     res.push_back([](const std::size_t nArgs) { return std::make_pair(std::vector<bool>(nArgs, true), true); });
 
     // Frac = 19
-    res.push_back([](const std::size_t nArgs) { return std::make_pair(std::vector<bool>(nArgs, true), false); });
+    res.push_back([](const std::size_t nArgs) { return std::make_pair(std::vector<bool>(nArgs, false), false); });
 
     // Round = 20
-    res.push_back([](const std::size_t nArgs) { return std::make_pair(std::vector<bool>(nArgs, true), false); });
+    res.push_back([](const std::size_t nArgs) { return std::make_pair(std::vector<bool>(nArgs, false), false); });
 
     return res;
 }