Merge remote-tracking branch 'origin/master' into QPR-12487

Author: pcaspers

OREAnalytics/orea/app/oreapp.cpp

@@ -1477,8 +1477,9 @@ void OREAppInputParameters::loadParameters() {
             setWriteScenarios(true);
 
         tmp = params_->get("simulation", "xvaCgBumpSensis", false);
-        if (tmp != "")
-            setXvaCgBumpSensis(parseBool(tmp));
+	if (tmp != "")
+	    setXvaCgBumpSensis(parseBool(tmp));
+
     }
 
     /**********************

OREData/ored/scripting/computationgraphbuilder.cpp

@@ -1205,7 +1205,7 @@ class ASTRunner : public AcyclicVisitor,
         // if observation date is in the future, the answer is always zero
         std::size_t node;
         if (obs > model_->referenceDate()) {
-            value.push(RandomVariable(model_->size(), 0));
+            value.push(RandomVariable(model_->size(), 0.0));
             node = cg_const(g_, 0.0);
         } else {
             // otherwise check whether a fixing is present in the historical time series

OREData/ored/scripting/scriptengine.cpp

@@ -918,7 +918,7 @@ class ASTRunner : public AcyclicVisitor,
         std::string und = QuantLib::ext::get<IndexVec>(underlying).value;
         // if observation date is in the future, the answer is always zero
         if (obs > model_->referenceDate())
-            value.push(RandomVariable(model_->size(), 0));
+            value.push(RandomVariable(model_->size(), 0.0));
         else {
             // otherwise check whether a fixing is present in the historical time series
             TimeSeries<Real> series = IndexManager::instance().getHistory(IndexInfo(und).index()->name());

QuantExt/qle/math/openclenvironment.cpp

@@ -407,22 +407,28 @@ RandomVariable::RandomVariable(const Filter& f, const Real valueTrue, const Real
     time_ = time;
 }
 
-RandomVariable::RandomVariable(const QuantLib::Array& array, const Real time) {
-    n_ = array.size();
+RandomVariable::RandomVariable(const Size n, const Real* const data, const Real time) {
+    n_ = n;
     deterministic_ = false;
     time_ = time;
     if (n_ != 0) {
         resumeDataStats();
         data_ = new double[n_];
         // std::memcpy(data_, array.begin(), n_ * sizeof(double));
-        std::copy(array.begin(), array.end(), data_);
+        std::copy(data, data + n_, data_);
         stopDataStats(n_);
     } else {
         data_ = nullptr;
     }
     constantData_ = 0.0;
 }
 
+RandomVariable::RandomVariable(const std::vector<Real>& data, const Real time)
+    : RandomVariable(data.size(), &data[0], time) {}
+
+RandomVariable::RandomVariable(const QuantLib::Array& data, const Real time)
+    : RandomVariable(data.size(), data.begin(), time) {}
+
 void RandomVariable::copyToMatrixCol(QuantLib::Matrix& m, const Size j) const {
     if (deterministic_)
         std::fill(m.column_begin(j), std::next(m.column_end(j), n_), constantData_);

QuantExt/qle/math/randomvariable.cpp

@@ -161,8 +161,10 @@ struct RandomVariable {
     explicit RandomVariable(const Size n, const Real value = 0.0, const Real time = Null<Real>());
     explicit RandomVariable(const Filter& f, const Real valueTrue = 1.0, const Real valueFalse = 0.0,
                             const Real time = Null<Real>());
+    explicit RandomVariable(const Size n, const Real* const data, const Real time = Null<Real>());
+    explicit RandomVariable(const std::vector<double>& data, const Real time = Null<Real>());
     // interop with ql classes
-    explicit RandomVariable(const QuantLib::Array& array, const Real time = Null<Real>());
+    explicit RandomVariable(const QuantLib::Array& data, const Real time = Null<Real>());
     void copyToMatrixCol(QuantLib::Matrix&, const Size j) const;
     void copyToArray(QuantLib::Array& array) const;
     // modifiers

QuantExt/qle/math/randomvariable.hpp

@@ -888,11 +888,11 @@ void McMultiLegBaseEngine::calculate() const {
                 regressorModel_, regressionVarianceCutoff_);
             regModelContinuationValue[counter].train(polynomOrder_, polynomType_, pathValueOption, pathValuesRef,
                                                      simulationTimes,
-                                                     exerciseValue > RandomVariable(calibrationSamples_, 0));
+                                                     exerciseValue > RandomVariable(calibrationSamples_, 0.0));
             auto continuationValue = regModelContinuationValue[counter].apply(model_->stateProcess()->initialValues(),
                                                                               pathValuesRef, simulationTimes);
             pathValueOption = conditionalResult(exerciseValue > continuationValue &&
-                                                    exerciseValue > RandomVariable(calibrationSamples_, 0),
+                                                    exerciseValue > RandomVariable(calibrationSamples_, 0.0),
                                                 pathValueUndExInto, pathValueOption);
             regModelOption[counter] = RegressionModel(
                 *t, cashflowInfo, [&cfStatus](std::size_t i) { return cfStatus[i] == CfStatus::done; }, **model_,

QuantExt/qle/pricingengines/mcmultilegbaseengine.cpp

@@ -305,11 +305,11 @@ BOOST_AUTO_TEST_CASE(testReplayFlowError) {
     }
 }
 
-BOOST_AUTO_TEST_CASE(testRngGenerationTmp) {
+BOOST_AUTO_TEST_CASE(testRngGenerationMt19937) {
     ComputeEnvironmentFixture fixture;
     const std::size_t n = 1500;
     for (auto const& d : ComputeEnvironment::instance().getAvailableDevices()) {
-        BOOST_TEST_MESSAGE("testing rng generation on device '" << d << "'.");
+        BOOST_TEST_MESSAGE("testing rng generation mt19937 against QL on device '" << d << "'.");
         ComputeEnvironment::instance().selectContext(d);
         auto& c = ComputeEnvironment::instance().context();
         ComputeContext::Settings settings;
@@ -318,12 +318,12 @@ BOOST_AUTO_TEST_CASE(testRngGenerationTmp) {
         BOOST_TEST_MESSAGE("using double precision = " << std::boolalpha << settings.useDoublePrecision);
         c.initiateCalculation(n, 0, 0, settings);
         auto vs = c.createInputVariates(1, 1);
+        auto vs2 = c.createInputVariates(1, 1);
         for (auto const& d : vs) {
             for (auto const& r : d) {
                 c.declareOutputVariable(r);
             }
         }
-        auto vs2 = c.createInputVariates(1, 1);
         for (auto const& d : vs2) {
             for (auto const& r : d) {
                 c.declareOutputVariable(r);
@@ -357,6 +357,55 @@ BOOST_AUTO_TEST_CASE(testRngGenerationTmp) {
     BOOST_CHECK(true);
 }
 
+BOOST_AUTO_TEST_CASE(testConditionalExpectation) {
+    ComputeEnvironmentFixture fixture;
+    const std::size_t n = 100;
+    for (auto const& d : ComputeEnvironment::instance().getAvailableDevices()) {
+        BOOST_TEST_MESSAGE("testing conditional expectation on device '" << d << "'.");
+        ComputeEnvironment::instance().selectContext(d);
+        auto& c = ComputeEnvironment::instance().context();
+        ComputeContext::Settings settings;
+        settings.useDoublePrecision = c.supportsDoublePrecision();
+        BOOST_TEST_MESSAGE("using double precision = " << std::boolalpha << settings.useDoublePrecision);
+
+        c.initiateCalculation(n, 0, 0, settings);
+
+        auto one = c.createInputVariable(1.0);
+        auto vs = c.createInputVariates(1, 2);
+        auto ce = c.applyOperation(RandomVariableOpCode::ConditionalExpectation, {vs[0][0], one, vs[0][1]});
+
+        for (auto const& d : vs) {
+            for (auto const& r : d) {
+                c.declareOutputVariable(r);
+            }
+        }
+        c.declareOutputVariable(ce);
+
+        std::vector<std::vector<double>> output(3, std::vector<double>(n));
+        c.finalizeCalculation(output);
+
+        RandomVariable y(output[0]);
+        RandomVariable x(output[1]);
+        RandomVariable z = conditionalExpectation(
+            y, {&x}, multiPathBasisSystem(1, settings.regressionOrder, QuantLib::LsmBasisSystem::Monomial, x.size()));
+
+        double tol = settings.useDoublePrecision ? 1E-12 : 1E-4;
+        Size noErrors = 0, errorThreshold = 10;
+
+        for (Size i = 0; i < n; ++i) {
+            Real err = std::abs(output[2][i] - z[i]);
+            if (std::abs(z[i]) > 1E-10)
+                err /= std::abs(z[i]);
+            if (err > tol && noErrors < errorThreshold) {
+                BOOST_ERROR("gpu value (" << output[2][i] << ") at i=" << i << " does not match reference cpu value ("
+                                          << z[i] << "), error " << err << ", tol " << tol);
+                noErrors++;
+            }
+        }
+    }
+    BOOST_CHECK(true);
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 
 BOOST_AUTO_TEST_SUITE_END()