QPR-11618 factor out backward solver interface

Author: pcaspers

QuantExt/qle/CMakeLists.txt

@@ -713,6 +713,7 @@ models/irmodel.hpp
 models/jyimpliedyoyinflationtermstructure.hpp
 models/jyimpliedzeroinflationtermstructure.hpp
 models/lgm.hpp
+models/lgmbackwardsolver.hpp
 models/lgmcalibrationinfo.hpp
 models/lgmconvolutionsolver2.hpp
 models/lgmfdsolver.hpp

QuantExt/qle/models/lgmbackwardsolver.hpp

@@ -0,0 +1,53 @@
+/*
+ Copyright (C) 2024 Quaternion Risk Management Ltd
+ All rights reserved.
+
+ This file is part of ORE, a free-software/open-source library
+ for transparent pricing and risk analysis - http://opensourcerisk.org
+
+ ORE is free software: you can redistribute it and/or modify it
+ under the terms of the Modified BSD License.  You should have received a
+ copy of the license along with this program.
+ The license is also available online at <http://opensourcerisk.org>
+
+ This program is distributed on the basis that it will form a useful
+ contribution to risk analytics and model standardisation, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the license for more details.
+*/
+
+/*! \file lgmbackwardsolver.hpp
+    \brief interface for LGM1F backward solver
+
+    \ingroup engines
+*/
+
+#pragma once
+
+#include <qle/math/randomvariable.hpp>
+#include <qle/models/lgm.hpp>
+
+namespace QuantExt {
+
+//! Interface for LGM1F backward solver
+class LgmBackwardSolver {
+public:
+    virtual ~LgmBackwardSolver() {}
+
+    /* get grid size */
+    virtual Size gridSize() const = 0;
+
+    /* get discretised states grid at time t */
+    virtual RandomVariable stateGrid(const Real t) const = 0;
+
+    /* roll back an deflated NPV array from t1 to t0 using the given number of steps or,
+       if the number of steps is not given, an appropriate number of steps which will
+       generally depend on the numerical method that is used. */
+    virtual RandomVariable rollback(const RandomVariable& v, const Real t1, const Real t0,
+                                    Size steps = Null<Size>()) const = 0;
+
+    /* the underlying model */
+    virtual const boost::shared_ptr<LinearGaussMarkovModel>& model() const = 0;
+};
+
+} // namespace QuantExt

QuantExt/qle/models/lgmconvolutionsolver2.cpp

@@ -68,7 +68,7 @@ RandomVariable LgmConvolutionSolver2::stateGrid(const Real t) const {
     return x;
 }
 
-RandomVariable LgmConvolutionSolver2::rollback(const RandomVariable& v, const Real t1, const Real t0) const {
+RandomVariable LgmConvolutionSolver2::rollback(const RandomVariable& v, const Real t1, const Real t0, Size) const {
     if (QuantLib::close_enough(t0, t1) || v.deterministic())
         return v;
     QL_REQUIRE(t0 < t1, "LgmConvolutionSolver2::rollback(): t0 (" << t0 << ") < t1 (" << t1 << ") required.");

QuantExt/qle/models/lgmconvolutionsolver2.hpp

@@ -25,7 +25,7 @@
 #pragma once
 
 #include <qle/math/randomvariable.hpp>
-#include <qle/models/lgm.hpp>
+#include <qle/models/lgmbackwardsolver.hpp>
 
 namespace QuantExt {
 
@@ -34,22 +34,16 @@ namespace QuantExt {
                exercise into swaptions
 */
 
-class LgmConvolutionSolver2 {
+class LgmConvolutionSolver2 : public LgmBackwardSolver {
 public:
     LgmConvolutionSolver2(const boost::shared_ptr<LinearGaussMarkovModel>& model, const Real sy, const Size ny,
                           const Real sx, const Size nx);
-
-    /* get grid size */
-    Size gridSize() const { return 2 * mx_ + 1; }
-
-    /* get discretised states grid at time t */
-    RandomVariable stateGrid(const Real t) const;
-
-    /* roll back an deflated NPV array from t1 to t0 */
-    RandomVariable rollback(const RandomVariable& v, const Real t1, const Real t0) const;
-
-    /* the underlying model */
-    const boost::shared_ptr<LinearGaussMarkovModel>& model() const { return model_; }
+    Size gridSize() const override { return 2 * mx_ + 1; }
+    RandomVariable stateGrid(const Real t) const override;
+    // steps are always ignored, since we can take large steps
+    RandomVariable rollback(const RandomVariable& v, const Real t1, const Real t0,
+                            Size steps = Null<Size>()) const override;
+    const boost::shared_ptr<LinearGaussMarkovModel>& model() const override { return model_; }
 
 private:
     boost::shared_ptr<LinearGaussMarkovModel> model_;

QuantExt/qle/models/lgmfdsolver.cpp

@@ -41,7 +41,7 @@ LgmFdSolver::LgmFdSolver(const boost::shared_ptr<LinearGaussMarkovModel>& model,
 
 Size LgmFdSolver::gridSize() const { return stateGridPoints_; }
 
-RandomVariable LgmFdSolver::stateGrid() const { return mesherLocations_; }
+RandomVariable LgmFdSolver::stateGrid(Real) const { return mesherLocations_; }
 
 const boost::shared_ptr<LinearGaussMarkovModel>& LgmFdSolver::model() const { return model_; }
 

QuantExt/qle/models/lgmfdsolver.hpp

@@ -25,31 +25,24 @@
 #pragma once
 
 #include <qle/math/randomvariable.hpp>
-#include <qle/models/lgm.hpp>
+#include <qle/models/lgmbackwardsolver.hpp>
 
 #include <ql/methods/finitedifferences/meshers/fdmmesher.hpp>
 #include <ql/methods/finitedifferences/solvers/fdmbackwardsolver.hpp>
 
 namespace QuantExt {
 
 //! Numerical FD solver for the LGM model
-class LgmFdSolver {
+class LgmFdSolver : LgmBackwardSolver {
 public:
     LgmFdSolver(const boost::shared_ptr<LinearGaussMarkovModel>& model, const Real maxTime = 50.0,
                 const Size stateGridPoints = 64, const Size timeStepsPerYear = 24, const Real mesherEpsilon = 1E-4);
-
-    /* get grid size */
-    Size gridSize() const;
-
-    /* get discretised states grid */
-    RandomVariable stateGrid() const;
-
-    /* roll back an deflated NPV array from t1 to t0 using the given number of steps or,
-       if that is not given, the time steps per year specified in the constructor */
-    RandomVariable rollback(const RandomVariable& v, const Real t1, const Real t0, Size steps = Null<Size>()) const;
-
-    /* the underlying model */
-    const boost::shared_ptr<LinearGaussMarkovModel>& model() const;
+    Size gridSize() const override;
+    RandomVariable stateGrid(const Real t) const override;
+    // if steps are not given, the time steps per year specified in the constructor
+    RandomVariable rollback(const RandomVariable& v, const Real t1, const Real t0,
+                            Size steps = Null<Size>()) const override;
+    const boost::shared_ptr<LinearGaussMarkovModel>& model() const override;
 
 private:
     boost::shared_ptr<LinearGaussMarkovModel> model_;

QuantExt/qle/pricingengines/numericlgmmultilegoptionengine.cpp

@@ -185,9 +185,8 @@ RandomVariable getRebatePv(const LgmVectorised& lgm, const Real t, const RandomV
 }
 
 NumericLgmMultiLegOptionEngineBase::NumericLgmMultiLegOptionEngineBase(
-    const boost::shared_ptr<LinearGaussMarkovModel>& model, const Real sy, const Size ny, const Real sx, const Size nx,
-    const Handle<YieldTermStructure>& discountCurve)
-    : LgmConvolutionSolver2(model, sy, ny, sx, nx), discountCurve_(discountCurve) {}
+    const boost::shared_ptr<LgmBackwardSolver>& solver, const Handle<YieldTermStructure>& discountCurve)
+    : solver_(solver), discountCurve_(discountCurve) {}
 
 void NumericLgmMultiLegOptionEngineBase::calculate() const {
 
@@ -198,7 +197,7 @@ void NumericLgmMultiLegOptionEngineBase::calculate() const {
        TODO we should add exercise data to indicate past exercises and value outstanding cash settlement amounts,
        or - possibly (?) - the physical underlying in that we exercised into? Or would that be a separate trade? */
 
-    Date refDate = model()->parametrization()->termStructure()->referenceDate();
+    Date refDate = solver_->model()->parametrization()->termStructure()->referenceDate();
 
     /* we might have to handle an exercise with rebate, init a variable for that (null if not applicable) */
 
@@ -279,23 +278,23 @@ void NumericLgmMultiLegOptionEngineBase::calculate() const {
 
     /* Step backwards through simulation dates and compute the option npv */
 
-    LgmVectorised lgm(model()->parametrization());
+    LgmVectorised lgm(solver_->model()->parametrization());
 
     // the current option npv that we roll back through the grid
-    RandomVariable optionNpv(gridSize(), 0.0);
+    RandomVariable optionNpv(solver_->gridSize(), 0.0);
     // cashflow npvs that are part of the latest exercise into option
-    RandomVariable underlyingNpv1(gridSize(), 0.0);
+    RandomVariable underlyingNpv1(solver_->gridSize(), 0.0);
     // cashflow npvs that are estimated, but not yet part of the latest exercise into option
     std::map<std::pair<Size, Size>, RandomVariable> underlyingNpv2;
 
     for (auto it = simulationDates.rbegin(); it != simulationDates.rend(); ++it) {
 
-        Real t_from = model()->parametrization()->termStructure()->timeFromReference(*it);
+        Real t_from = solver_->model()->parametrization()->termStructure()->timeFromReference(*it);
         Real t_to = (it != std::next(simulationDates.rend(), -1))
-                        ? model()->parametrization()->termStructure()->timeFromReference(*std::next(it, 1))
+                        ? solver_->model()->parametrization()->termStructure()->timeFromReference(*std::next(it, 1))
                         : t_from;
 
-        RandomVariable state = stateGrid(t_from);
+        RandomVariable state = solver_->stateGrid(t_from);
 
         auto option = optionDates.find(*it);
         auto cashflow = cashflowDates.find(*it);
@@ -305,7 +304,7 @@ void NumericLgmMultiLegOptionEngineBase::calculate() const {
         if (cashflow != cashflowDates.end()) {
             for (auto const& cf : cashflow->second) {
                 auto tmp = getUnderlyingCashflowPv(lgm, t_from, state, discountCurve_, legs_[cf.first][cf.second]) *
-                           RandomVariable(gridSize(), payer_[cf.first]);
+                           RandomVariable(solver_->gridSize(), payer_[cf.first]);
                 auto it = underlyingNpv2.find(cf);
                 if (it != underlyingNpv2.end())
                     it->second += tmp;
@@ -334,11 +333,11 @@ void NumericLgmMultiLegOptionEngineBase::calculate() const {
         // rollback
 
         if (t_from != t_to) {
-            underlyingNpv1 = rollback(underlyingNpv1, t_from, t_to);
+            underlyingNpv1 = solver_->rollback(underlyingNpv1, t_from, t_to);
             for (auto& c : underlyingNpv2) {
-                c.second = rollback(c.second, t_from, t_to);
+                c.second = solver_->rollback(c.second, t_from, t_to);
             }
-            optionNpv = rollback(optionNpv, t_from, t_to);
+            optionNpv = solver_->rollback(optionNpv, t_from, t_to);
         }
     }
 
@@ -350,7 +349,7 @@ void NumericLgmMultiLegOptionEngineBase::calculate() const {
         underlyingNpv_ += c.second.at(0);
     }
 
-    additionalResults_ = getAdditionalResultsMap(model()->getCalibrationInfo());
+    additionalResults_ = getAdditionalResultsMap(solver_->model()->getCalibrationInfo());
 
     if (rebatedExercise) {
         for (Size i = 0; i < rebatedExercise->dates().size(); ++i) {
@@ -366,8 +365,9 @@ NumericLgmMultiLegOptionEngine::NumericLgmMultiLegOptionEngine(const boost::shar
                                                                const Real sy, const Size ny, const Real sx,
                                                                const Size nx,
                                                                const Handle<YieldTermStructure>& discountCurve)
-    : NumericLgmMultiLegOptionEngineBase(model, sy, ny, sx, nx, discountCurve) {
-    registerWith(LgmConvolutionSolver2::model());
+    : NumericLgmMultiLegOptionEngineBase(boost::make_shared<LgmConvolutionSolver2>(model, sy, ny, sx, nx),
+                                         discountCurve) {
+    registerWith(solver_->model());
     registerWith(discountCurve_);
 }
 
@@ -390,8 +390,9 @@ void NumericLgmMultiLegOptionEngine::calculate() const {
 NumericLgmSwaptionEngine::NumericLgmSwaptionEngine(const boost::shared_ptr<LinearGaussMarkovModel>& model,
                                                    const Real sy, const Size ny, const Real sx, const Size nx,
                                                    const Handle<YieldTermStructure>& discountCurve)
-    : NumericLgmMultiLegOptionEngineBase(model, sy, ny, sx, nx, discountCurve) {
-    registerWith(LgmConvolutionSolver2::model());
+    : NumericLgmMultiLegOptionEngineBase(boost::make_shared<LgmConvolutionSolver2>(model, sy, ny, sx, nx),
+                                         discountCurve) {
+    registerWith(solver_->model());
     registerWith(discountCurve_);
 }
 
@@ -413,8 +414,9 @@ void NumericLgmSwaptionEngine::calculate() const {
 NumericLgmNonstandardSwaptionEngine::NumericLgmNonstandardSwaptionEngine(
     const boost::shared_ptr<LinearGaussMarkovModel>& model, const Real sy, const Size ny, const Real sx, const Size nx,
     const Handle<YieldTermStructure>& discountCurve)
-    : NumericLgmMultiLegOptionEngineBase(model, sy, ny, sx, nx, discountCurve) {
-    registerWith(LgmConvolutionSolver2::model());
+    : NumericLgmMultiLegOptionEngineBase(boost::make_shared<LgmConvolutionSolver2>(model, sy, ny, sx, nx),
+                                         discountCurve) {
+    registerWith(solver_->model());
     registerWith(discountCurve_);
 }
 

QuantExt/qle/pricingengines/numericlgmmultilegoptionengine.hpp

@@ -28,15 +28,16 @@
 
 namespace QuantExt {
 
-class NumericLgmMultiLegOptionEngineBase : protected LgmConvolutionSolver2 {
+class NumericLgmMultiLegOptionEngineBase {
 public:
-    NumericLgmMultiLegOptionEngineBase(const boost::shared_ptr<LinearGaussMarkovModel>& model, const Real sy,
-                                       const Size ny, const Real sx, const Size nx,
+    NumericLgmMultiLegOptionEngineBase(const boost::shared_ptr<LgmBackwardSolver>& solver,
                                        const Handle<YieldTermStructure>& discountCurve = Handle<YieldTermStructure>());
 
 protected:
     void calculate() const;
 
+    // inputs set in ctor
+    boost::shared_ptr<LgmBackwardSolver> solver_;
     Handle<YieldTermStructure> discountCurve_;
 
     // inputs set by derived classes

QuantExt/qle/quantext.hpp

@@ -321,6 +321,7 @@
 #include <qle/models/jyimpliedyoyinflationtermstructure.hpp>
 #include <qle/models/jyimpliedzeroinflationtermstructure.hpp>
 #include <qle/models/lgm.hpp>
+#include <qle/models/lgmbackwardsolver.hpp>
 #include <qle/models/lgmcalibrationinfo.hpp>
 #include <qle/models/lgmconvolutionsolver2.hpp>
 #include <qle/models/lgmfdsolver.hpp>