created PDE diretcory for finite_diff_method ofr one/multi factor & r…

…e factored option factory to return concrete payoff type
anthonymakarewicz · Aug 26, 2024 · 3bf3411 · 3bf3411
1 parent f2e5759
commit 3bf3411
Show file tree

Hide file tree

Showing 40 changed files with 401 additions and 78 deletions.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -147,6 +147,17 @@ add_library(solver SHARED
         src/solver/monte_carlo/basis_function/legendre.cpp
         src/solver/monte_carlo/basis_function/chebyshev.cpp
         src/solver/monte_carlo/basis_function/laguerre.cpp
+        src/solver/finite_difference_method/solver/one_factor/base_fdm_solver.cpp
+        src/solver/finite_difference_method/solver/one_factor/crank_nicolson_fdm_solver.cpp
+        src/solver/finite_difference_method/solver/one_factor/euler_explicit_fdm_solver.cpp
+        src/solver/finite_difference_method/solver/one_factor/euler_implicit_fdm_solver.cpp
+        src/solver/finite_difference_method/pde/one_factor/base_convection_diffusion_pde.cpp
+        src/solver/finite_difference_method/pde/one_factor/black_scholes_pde.cpp
+        src/solver/finite_difference_method/solver/multi_factor/base_fdm_solver.cpp
+        src/solver/finite_difference_method/solver/multi_factor/crank_nicolson_fdm_solver.cpp
+        src/solver/finite_difference_method/solver/multi_factor/euler_explicit_fdm_solver.cpp
+        src/solver/finite_difference_method/solver/multi_factor/euler_implicit_fdm_solver.cpp
+        src/solver/finite_difference_method/pde/multi_factor/base_convection_diffusion_pde.cpp
 )
 
 target_link_libraries(option PUBLIC marketdata payoff)

diff --git a/include/option/base_factory_option.h b/include/option/base_factory_option.h
@@ -14,46 +14,50 @@ namespace OptionPricer {
     template <typename T>
     concept OptionTypeConcept = std::is_base_of_v<Option, T>;
 
-    template<OptionTypeConcept OptionType> class OptionFactory {
+    // Define a concept for an Payoff type
+    template <typename T>
+    concept PayoffTypeConcept = std::is_base_of_v<Payoff, T>;
+
+    template<OptionTypeConcept OptionT, PayoffTypeConcept PayoffT> class OptionFactory {
     public:
         virtual ~OptionFactory() = default;
 
         // Non-static create methods as we use virtual methods
-        [[nodiscard]] std::shared_ptr<OptionType> createCallOption(const ParameterObject& params);
-        [[nodiscard]] std::shared_ptr<OptionType> createPutOption(const ParameterObject& params);
+        [[nodiscard]] std::shared_ptr<OptionT> createCallOption(const ParameterObject& params);
+        [[nodiscard]] std::shared_ptr<OptionT> createPutOption(const ParameterObject& params);
 
     protected:
         // Template method pattern
-        std::shared_ptr<OptionType> createOption(const ParameterObject& params, const PayoffType& type);
+        std::shared_ptr<OptionT> createOption(const ParameterObject& params, const PayoffType& type);
 
         // Can be overiden to add extra parameters
         virtual std::string invalidParams(const std::string& option_type) const;
 
         // To be overidden in concrete factories
-        virtual std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params,
-                                                             const PayoffType& type) = 0;
-        virtual std::shared_ptr<OptionType> createSpecificOption(const ParameterObject& params,
-                                                             std::unique_ptr<Payoff> payoff,
-                                                             const std::shared_ptr<IMarketData>& marketData) = 0;
+        virtual std::unique_ptr<PayoffT> createSpecificPayoff(const ParameterObject& params,
+                                                              const PayoffType& type) = 0;
+        virtual std::shared_ptr<OptionT> createSpecificOption(const ParameterObject& params,
+                                                              std::unique_ptr<PayoffT> payoff,
+                                                              const std::shared_ptr<IMarketData>& marketData) = 0;
         virtual std::string getType(const PayoffType& type) const = 0;
     };
 
 
-    template <OptionTypeConcept OptionType>
-    std::shared_ptr<OptionType> OptionFactory<OptionType>::createCallOption(const ParameterObject &params) {
+    template<OptionTypeConcept OptionT, PayoffTypeConcept PayoffT>
+    std::shared_ptr<OptionT> OptionFactory<OptionT, PayoffT>::createCallOption(const ParameterObject &params) {
         return createOption(params, PayoffType::Call);
     }
 
-    template <OptionTypeConcept OptionType>
-    std::shared_ptr<OptionType> OptionFactory<OptionType>::createPutOption(const ParameterObject &params) {
+    template<OptionTypeConcept OptionT, PayoffTypeConcept PayoffT>
+    std::shared_ptr<OptionT> OptionFactory<OptionT, PayoffT>::createPutOption(const ParameterObject &params) {
         return createOption(params, PayoffType::Put);
     }
 
-    template <OptionTypeConcept OptionType>
-    std::shared_ptr<OptionType> OptionFactory<OptionType>::createOption(const ParameterObject &params,
-                                                                        const PayoffType& type) {
+    template<OptionTypeConcept OptionT, PayoffTypeConcept PayoffT>
+    std::shared_ptr<OptionT> OptionFactory<OptionT, PayoffT>::createOption(const ParameterObject &params,
+                                                                           const PayoffType& type) {
         auto marketData = MarketData::getInstance();
-        std::shared_ptr<OptionType> option = nullptr;
+        std::shared_ptr<OptionT> option = nullptr;
 
         try {
             auto payoff = createSpecificPayoff(params, type);
@@ -67,8 +71,8 @@ namespace OptionPricer {
         return option;
     }
 
-    template <OptionTypeConcept OptionType>
-    std::string OptionFactory<OptionType>::invalidParams(const std::string &option_type) const {
+    template<OptionTypeConcept OptionT, PayoffTypeConcept PayoffT>
+    std::string OptionFactory<OptionT, PayoffT>::invalidParams(const std::string &option_type) const {
         return "Invalid parameters for " + option_type + "\n"
                "Expected parameters:\n"
                "  - ticker (string) for ticker symbol\n"

diff --git a/include/option/path_dependent/factory_american_option.h b/include/option/path_dependent/factory_american_option.h
@@ -6,12 +6,12 @@
 
 namespace OptionPricer {
 
-    class AmericanOptionFactory final: public OptionFactory<AmericanOption> {
-        std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params,
+    class AmericanOptionFactory final: public OptionFactory<AmericanOption, PayoffSingleStrike> {
+        std::unique_ptr<PayoffSingleStrike> createSpecificPayoff(const ParameterObject& params,
                                                      const PayoffType& type) override;
 
         std::shared_ptr<AmericanOption> createSpecificOption(const ParameterObject& params,
-                                                             std::unique_ptr<Payoff> payoff,
+                                                             std::unique_ptr<PayoffSingleStrike> payoff,
                                                              const std::shared_ptr<IMarketData>& marketData) override;
 
         std::string getType(const PayoffType& type) const override;

diff --git a/include/option/path_dependent/factory_asian_option.h b/include/option/path_dependent/factory_asian_option.h
@@ -1,25 +1,26 @@
 #ifndef FACTORY_ASIAN_OPTION_H
 #define FACTORY_ASIAN_OPTION_H
 
+#include <payoff/single_strike/base_payoff_single_strike.h>
 #include "option/base_factory_option.h"
 #include "option/path_dependent/asian_option.h"
 
 namespace OptionPricer {
 
     // ArithmeticAsianOptionFactory
-    class ArithmeticAsianOptionFactory final: public OptionFactory<ArithmeticAsianOption> {
-        std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params, const PayoffType& type) override;
+    class ArithmeticAsianOptionFactory final: public OptionFactory<ArithmeticAsianOption, PayoffSingleStrike> {
+        std::unique_ptr<PayoffSingleStrike> createSpecificPayoff(const ParameterObject& params, const PayoffType& type) override;
         std::shared_ptr<ArithmeticAsianOption> createSpecificOption(const ParameterObject& params,
-                                                     std::unique_ptr<Payoff> payoff,
+                                                     std::unique_ptr<PayoffSingleStrike> payoff,
                                                      const std::shared_ptr<IMarketData>& marketData) override;
         std::string getType(const PayoffType& type) const override;
     };
 
     // GeometricAsianOptionFactory
-    class GeometricAsianOptionFactory final: public OptionFactory<GeometricAsianOption> {
-        std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params, const PayoffType& type) override;
+    class GeometricAsianOptionFactory final: public OptionFactory<GeometricAsianOption, PayoffSingleStrike> {
+        std::unique_ptr<PayoffSingleStrike> createSpecificPayoff(const ParameterObject& params, const PayoffType& type) override;
         std::shared_ptr<GeometricAsianOption> createSpecificOption(const ParameterObject& params,
-                                                     std::unique_ptr<Payoff> payoff,
+                                                     std::unique_ptr<PayoffSingleStrike> payoff,
                                                      const std::shared_ptr<IMarketData>& marketData) override;
         std::string getType(const PayoffType& type) const override;
     };

diff --git a/include/option/path_dependent/factory_barrier_option.h b/include/option/path_dependent/factory_barrier_option.h
@@ -1,30 +1,31 @@
 #ifndef FACTORY_BARRIER_OPTION_H
 #define FACTORY_BARRIER_OPTION_H
 
+#include <payoff/single_strike/base_payoff_single_strike.h>
 #include "option/base_factory_option.h"
 #include "option/path_dependent/barrier_option.h"
 
 namespace OptionPricer {
 
     // Knock-In Barrier Factory
-    class KnockInBarrierOptionFactory final: public OptionFactory<KnockInBarrierOption> {
-        std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params, const PayoffType& type) override;
+    class KnockInBarrierOptionFactory final: public OptionFactory<KnockInBarrierOption, PayoffSingleStrike> {
+        std::unique_ptr<PayoffSingleStrike> createSpecificPayoff(const ParameterObject& params, const PayoffType& type) override;
 
         std::shared_ptr<KnockInBarrierOption> createSpecificOption(
             const ParameterObject& params,
-            std::unique_ptr<Payoff> payoff,
+            std::unique_ptr<PayoffSingleStrike> payoff,
             const std::shared_ptr<IMarketData>& marketData) override;
 
         std::string getType(const PayoffType& type) const override;
     };
 
     // Knock-Out Barrier Factory
-    class KnockOutBarrierOptionFactory final: public OptionFactory<KnockOutBarrierOption> {
-        std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params, const PayoffType& type) override;
+    class KnockOutBarrierOptionFactory final: public OptionFactory<KnockOutBarrierOption, PayoffSingleStrike> {
+        std::unique_ptr<PayoffSingleStrike> createSpecificPayoff(const ParameterObject& params, const PayoffType& type) override;
 
         std::shared_ptr<KnockOutBarrierOption> createSpecificOption(
             const ParameterObject& params,
-            std::unique_ptr<Payoff> payoff,
+            std::unique_ptr<PayoffSingleStrike> payoff,
             const std::shared_ptr<IMarketData>& marketData) override;
 
         std::string getType(const PayoffType& type) const override;

diff --git a/include/option/path_dependent/factory_lookback_option.h b/include/option/path_dependent/factory_lookback_option.h
@@ -1,27 +1,34 @@
 #ifndef FACTORY_LOOKBACK_OPTION_H
 #define FACTORY_LOOKBACK_OPTION_H
 
+#include <payoff/payoff_floating_strike_lookback.h>
+#include <payoff/single_strike/base_payoff_single_strike.h>
 #include "option/base_factory_option.h"
 #include "option/path_dependent/lookback_option.h"
 
 namespace OptionPricer {
 
     // Floating Strike Lookback Factory
-    class FloatingStrikeLookbackOptionFactory final: public OptionFactory<FloatingStrikeLookbackOption> {
+    class FloatingStrikeLookbackOptionFactory final: public OptionFactory<FloatingStrikeLookbackOption,
+                                                                          PayoffLookbackFloatingStrike> {
     public:
-        std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params, const PayoffType& type) override;
+        std::unique_ptr<PayoffLookbackFloatingStrike> createSpecificPayoff(const ParameterObject& params,
+                                                                           const PayoffType& type) override;
+
         std::shared_ptr<FloatingStrikeLookbackOption> createSpecificOption(const ParameterObject& params,
-                                                     std::unique_ptr<Payoff> payoff,
+                                                     std::unique_ptr<PayoffLookbackFloatingStrike> payoff,
                                                      const std::shared_ptr<IMarketData>& marketData) override;
+
         std::string getType(const PayoffType& type) const override;
     };
 
     // Fixed Strike Lookback Factory
-    class FixedStrikeLookbackOptionFactory final: public OptionFactory<FixedStrikeLookbackOption> {
+    class FixedStrikeLookbackOptionFactory final: public OptionFactory<FixedStrikeLookbackOption, PayoffSingleStrike> {
     public:
-        std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params, const PayoffType& type) override;
+        std::unique_ptr<PayoffSingleStrike> createSpecificPayoff(const ParameterObject& params,
+                                                                 const PayoffType& type) override;
         std::shared_ptr<FixedStrikeLookbackOption> createSpecificOption(const ParameterObject& params,
-                                                     std::unique_ptr<Payoff> payoff,
+                                                     std::unique_ptr<PayoffSingleStrike> payoff,
                                                      const std::shared_ptr<IMarketData>& marketData) override;
         std::string getType(const PayoffType& type) const override;
     };

diff --git a/include/option/single_path/factory_digital_option.h b/include/option/single_path/factory_digital_option.h
@@ -1,16 +1,19 @@
 #ifndef FACTORY_DIGITAL_OPTION_H
 #define FACTORY_DIGITAL_OPTION_H
 
+#include <payoff/single_strike/base_payoff_single_strike.h>
 #include "option/base_factory_option.h"
 #include "option/single_path/digital_option.h"
 
 namespace OptionPricer {
-    class DigitalOptionFactory final: public OptionFactory<DigitalOption> {
-        std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params, const PayoffType& type) override;
+
+    class DigitalOptionFactory final: public OptionFactory<DigitalOption, PayoffSingleStrike> {
+        std::unique_ptr<PayoffSingleStrike> createSpecificPayoff(const ParameterObject& params,
+                                                                 const PayoffType& type) override;
 
         std::shared_ptr<DigitalOption> createSpecificOption(const ParameterObject& params,
-                                                               std::unique_ptr<Payoff> payoff,
-                                                               const std::shared_ptr<IMarketData>& marketData) override;
+                                                            std::unique_ptr<PayoffSingleStrike> payoff,
+                                                            const std::shared_ptr<IMarketData>& marketData) override;
 
         std::string getType(const PayoffType& type) const override;
     };

diff --git a/include/option/single_path/factory_double_digital_option.h b/include/option/single_path/factory_double_digital_option.h
@@ -3,18 +3,20 @@
 
 #include <option/base_factory_option.h>
 #include "option/single_path/double_digital_option.h"
+#include "payoff/double_strikes/base_payoff_double_strikes.h"
 
 namespace OptionPricer {
-    class DoubleDigitalOptionFactory final: public OptionFactory<DoubleDigitalOption> {
-        std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params, const PayoffType& type) override;
+    class DoubleDigitalOptionFactory final: public OptionFactory<DoubleDigitalOption, PayoffDoubleStrikes> {
+        std::unique_ptr<PayoffDoubleStrikes> createSpecificPayoff(const ParameterObject& params,
+                                                                  const PayoffType& type) override;
 
         std::shared_ptr<DoubleDigitalOption> createSpecificOption(const ParameterObject& params,
-                                                               std::unique_ptr<Payoff> payoff,
-                                                               const std::shared_ptr<IMarketData>& marketData) override;
+                                                                  std::unique_ptr<PayoffDoubleStrikes> payoff,
+                                                                  const std::shared_ptr<IMarketData>& marketData) override;
 
         std::string invalidParams(const std::string& option_type) const override;
         std::string getType(const PayoffType& type) const override;
     };
 }
 
-#endif //FACTORY_DOUBLE_DIGITAL_OPTION_H
+#endif //FACTORY_DOUBLE_DIGITAL_OPTION_H
diff --git a/include/option/single_path/factory_european_option.h b/include/option/single_path/factory_european_option.h
@@ -6,15 +6,13 @@
 
 namespace OptionPricer {
 
-    class EuropeanOptionFactory final: public OptionFactory<EuropeanOption> {
-        // Could potentially make the createSpecificOption specific to each Factory thus returnign
-        // here returning a EuropeanOption, hwoever for createSpecificPayoff it might be ok to define it as pure
-        // virtual inside the OptionFatcory as well as the getType method
-        std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params, const PayoffType& type) override;
+    class EuropeanOptionFactory final: public OptionFactory<EuropeanOption, PayoffSingleStrike> {
+        std::unique_ptr<PayoffSingleStrike> createSpecificPayoff(const ParameterObject& params,
+                                                                 const PayoffType& type) override;
 
         std::shared_ptr<EuropeanOption> createSpecificOption(const ParameterObject& params,
-                                                     std::unique_ptr<Payoff> payoff,
-                                                     const std::shared_ptr<IMarketData>& marketData) override;
+                                                             std::unique_ptr<PayoffSingleStrike> payoff,
+                                                             const std::shared_ptr<IMarketData>& marketData) override;
 
         std::string getType(const PayoffType& type) const override;
 

diff --git a/include/payoff/single_strike/base_payoff_single_strike.h b/include/payoff/single_strike/base_payoff_single_strike.h
@@ -4,6 +4,7 @@
 #include "../base_payoff.h"
 
 namespace OptionPricer {
+
     // Abstract base class for PayoffSingleStrike
     class PayoffSingleStrike : public Payoff {
     public:

diff --git a/include/solver/finite_difference_method/pde/multi_factor/base_convection_diffusion_pde.h b/include/solver/finite_difference_method/pde/multi_factor/base_convection_diffusion_pde.h
@@ -0,0 +1,12 @@
+//
+// Created by anthony on 26/08/2024.
+//
+
+#ifndef BASE_CONVECTION_DIFFUSION_PDE_H
+#define BASE_CONVECTION_DIFFUSION_PDE_H
+
+
+
+
+
+#endif //BASE_CONVECTION_DIFFUSION_PDE_H
diff --git a/include/solver/finite_difference_method/pde/one_factor/base_convection_diffusion_pde.h b/include/solver/finite_difference_method/pde/one_factor/base_convection_diffusion_pde.h
@@ -0,0 +1,22 @@
+#ifndef BASE_CONVECTION_DIFFUSION_PDE_H
+#define BASE_CONVECTION_DIFFUSION_PDE_H
+
+namespace OptionPricer::PDE::OneFactor {
+
+    class ConvectionDiffusionPDE {
+    public:
+        virtual ~ConvectionDiffusionPDE();
+
+        virtual double diffusion(const double& t,const double& x) const = 0;
+        virtual double convection(const double& t,const double& x) const = 0;
+        virtual double reaction(const double& t,const double& x) const = 0;
+        virtual double rightHandSide(const double& t,const double& x)const = 0;
+
+        virtual double boundaryLeft(const double& t,const double& x)const = 0;
+        virtual double boundaryRight(const double& t,const double& x)const = 0;
+        virtual double initialCondition(const double& x) const = 0;
+    };
+
+}
+
+#endif //BASE_CONVECTION_DIFFUSION_PDE_H
diff --git a/include/solver/finite_difference_method/pde/one_factor/black_scholes_pde.h b/include/solver/finite_difference_method/pde/one_factor/black_scholes_pde.h
@@ -0,0 +1,30 @@
+#ifndef BLACK_SCHOLES_PDE_H
+#define BLACK_SCHOLES_PDE_H
+
+#include "option/single_path/european_option.h"
+#include "solver/finite_difference_method/pde/one_factor/base_convection_diffusion_pde.h"
+
+namespace OptionPricer::PDE::OneFactor {
+
+    class BlackScholesPDE : public ConvectionDiffusionPDE {
+    public:
+        BlackScholesPDE(std::shared_ptr<EuropeanOption> option, std::shared_ptr<IMarketData> marketData);
+        virtual ~BlackScholesPDE();
+
+        virtual double diffusion(const double& t,const double& x) const;
+        virtual double convection(const double& t,const double& x) const;
+        virtual double reaction(const double& t,const double& x) const;
+        virtual double rightHandSide(const double& t,const double& x) const;
+
+        virtual double boundaryLeft(const double& t,const double& x) const;
+        virtual double boundaryRight(const double& t,const double& x) const;
+        virtual double initialCondition(const double& x) const;
+
+    private:
+        std::shared_ptr<EuropeanOption> option_;
+        std::shared_ptr<IMarketData> marketData_;
+    };
+
+}
+
+#endif //BLACK_SCHOLES_PDE_H