added builders for each MCPricer

CMakeLists.txt

@@ -40,6 +40,7 @@ add_library(marketdata SHARED
         src/market_data/market_data.cpp
         src/market_data/market_data_observer.cpp
         src/market_data/stock_data.cpp
+        include/solver/monte_carlo/builder/mc_builder_american.h
 )
 
 # Create dynamic library for payoff
@@ -68,7 +69,6 @@ add_library(option SHARED
         src/option/path_dependent/barrier_option.cpp
         src/option/path_dependent/lookback_option.cpp
         # Factories
-        src/option/factory_option.cpp
         src/option/single_path/factory_european_option.cpp
         src/option/single_path/factory_digital_option.cpp
         src/option/single_path/factory_double_digital_option.cpp
@@ -82,27 +82,35 @@ add_library(option SHARED
 add_library(solver SHARED
         src/solver/base_solver.cpp
         src/solver/monte_carlo/mc_solver.cpp
-        include/solver/monte_carlo/mc_base_strategy.h
-        src/solver/monte_carlo/mc_base_strategy.cpp
-        include/solver/monte_carlo/stock_price_model.h
         src/solver/monte_carlo/stock_price_model.cpp
         src/solver/monte_carlo/gbm_stock_price_model.cpp
-        include/solver/monte_carlo/gbm_stock_price_model.h
-        include/solver/monte_carlo/generator.h
+        src/solver/monte_carlo/base_mc.cpp
+        src/solver/monte_carlo/mc_single_path.cpp
+        src/solver/monte_carlo/base_mc_path_dependent.cpp
+        src/solver/monte_carlo/mc_asian.cpp
+        src/solver/monte_carlo/mc_barrier.cpp
+        src/solver/monte_carlo/mc_lookback.cpp
+        src/solver/monte_carlo/mc_american.cpp
+        src/solver/monte_carlo/builder/base_mc_builder.cpp
+        src/solver/monte_carlo/builder/mc_builder_single_path.cpp
+        src/solver/monte_carlo/builder/base_mc_builder_path_dependent.cpp
+        src/solver/monte_carlo/builder/mc_builder_asian.cpp
+        src/solver/monte_carlo/builder/mc_builder_barrier.cpp
+        src/solver/monte_carlo/builder/mc_builder_lookback.cpp
+        src/solver/monte_carlo/builder/mc_builder_american.cpp
 )
 
-# Link random library to the solver ONLY
-target_link_libraries(solver PUBLIC Boost::random Eigen3::Eigen)
-
 # Link the option library against marketdata and payoff
 target_link_libraries(option PUBLIC marketdata payoff)
 
+# Link random library to the solver ONLY
+target_link_libraries(solver PUBLIC option Boost::random Eigen3::Eigen)
+
 # Create main executable
 add_executable(Option_pricer main.cpp)
 
 # Link the main executable to our dynamic libraries
 target_link_libraries(Option_pricer PUBLIC  marketdata payoff option solver)
-#target_link_libraries(Option_pricer marketdata payoff option solver)
 
 # Enable testing and add the tests directory
 enable_testing()

include/market_data/market_data.h

@@ -14,6 +14,7 @@
 #include "interface_market_data.h"
 
 namespace OptionPricer {
+
     // Declare MarketData as Singleton
     class MarketData final: public IMarketData {
     public:
@@ -67,6 +68,7 @@ namespace OptionPricer {
         std::unordered_map<std::string, std::shared_ptr<StockData>> stockDataMap_; // Map ticker symbol to StockData
         std::vector<std::weak_ptr<MarketDataObserver>> observers_; // Use weak_ptr to avoid circular references
     };
+
 }
 
 #endif //MARKET_DATA_H

include/option/base_factory_option.h

@@ -0,0 +1,81 @@
+#ifndef FACTORY_OPTION_H
+#define FACTORY_OPTION_H
+
+#include <string>
+#include <concepts>
+#include "payoff/base_payoff.h"
+#include "option/base_option.h"
+#include "option/parameter_object.h"
+#include "market_data/market_data.h"
+
+namespace OptionPricer {
+
+    // Define a concept for an Option type
+    template <typename T>
+    concept OptionTypeConcept = std::is_base_of_v<Option, T>;
+
+    template<OptionTypeConcept OptionType> 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);
+
+    protected:
+        // Template method pattern
+        std::shared_ptr<OptionType> 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::string getType(const PayoffType& type) const = 0;
+    };
+
+
+    template <OptionTypeConcept OptionType>
+    std::shared_ptr<OptionType> OptionFactory<OptionType>::createCallOption(const ParameterObject &params) {
+        return createOption(params, PayoffType::Call);
+    }
+
+    template <OptionTypeConcept OptionType>
+    std::shared_ptr<OptionType> OptionFactory<OptionType>::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) {
+        auto marketData = MarketData::getInstance();
+        std::shared_ptr<OptionType> option = nullptr;
+
+        try {
+            auto payoff = createSpecificPayoff(params, type);
+            option = createSpecificOption(params, std::move(payoff), marketData);
+        } catch (const std::invalid_argument& e) {
+            const std::string err = std::string(e.what()) + "\n" + invalidParams(getType(type));
+            throw std::invalid_argument(err);
+        }
+
+        option->initialize();
+        return option;
+    }
+
+    template <OptionTypeConcept OptionType>
+    std::string OptionFactory<OptionType>::invalidParams(const std::string &option_type) const {
+        return "Invalid parameters for " + option_type + "\n"
+               "Expected parameters:\n"
+               "  - ticker (string) for ticker symbol\n"
+               "  - T (double) for maturity\n"
+               "  - K (double) for strike\n";
+    }
+
+}
+
+#endif //FACTORY_OPTION_H

include/option/path_dependent/factory_american_option.h

@@ -1,13 +1,14 @@
 #ifndef FACTORY_AMERICAN_OPTION_H
 #define FACTORY_AMERICAN_OPTION_H
 
-#include "option/factory_option.h"
+#include "option/base_factory_option.h"
+#include "option/path_dependent/american_option.h"
 
 namespace OptionPricer {
-    class AmericanOptionFactory final: public OptionFactory {
+    class AmericanOptionFactory final: public OptionFactory<AmericanOption> {
         std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params, const PayoffType& type) override;
 
-        std::shared_ptr<Option> createSpecificOption(const ParameterObject& params,
+        std::shared_ptr<AmericanOption> createSpecificOption(const ParameterObject& params,
                                                      std::unique_ptr<Payoff> payoff,
                                                      const std::shared_ptr<IMarketData>& marketData) override;
 

include/option/path_dependent/factory_asian_option.h

@@ -1,21 +1,22 @@
 #ifndef FACTORY_ASIAN_OPTION_H
 #define FACTORY_ASIAN_OPTION_H
 
-#include "option/factory_option.h"
+#include "option/base_factory_option.h"
+#include "option/path_dependent/asian_option.h"
 
 namespace OptionPricer {
 
-    class ArithmeticAsianOptionFactory final: public OptionFactory {
+    class ArithmeticAsianOptionFactory final: public OptionFactory<ArithmeticAsianOption> {
         std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params, const PayoffType& type) override;
-        std::shared_ptr<Option> createSpecificOption(const ParameterObject& params,
+        std::shared_ptr<ArithmeticAsianOption> createSpecificOption(const ParameterObject& params,
                                                      std::unique_ptr<Payoff> payoff,
                                                      const std::shared_ptr<IMarketData>& marketData) override;
         std::string getType(const PayoffType& type) const override;
     };
 
-    class GeometricAsianOptionFactory final: public OptionFactory {
+    class GeometricAsianOptionFactory final: public OptionFactory<GeometricAsianOption> {
         std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params, const PayoffType& type) override;
-        std::shared_ptr<Option> createSpecificOption(const ParameterObject& params,
+        std::shared_ptr<GeometricAsianOption> createSpecificOption(const ParameterObject& params,
                                                      std::unique_ptr<Payoff> payoff,
                                                      const std::shared_ptr<IMarketData>& marketData) override;
         std::string getType(const PayoffType& type) const override;

include/option/path_dependent/factory_barrier_option.h

@@ -1,24 +1,25 @@
 #ifndef FACTORY_BARRIER_OPTION_H
 #define FACTORY_BARRIER_OPTION_H
 
-#include "option/factory_option.h"
+#include "option/base_factory_option.h"
+#include "option/path_dependent/barrier_option.h"
 
 namespace OptionPricer {
-    class KnockInBarrierOptionFactory final: public OptionFactory {
+    class KnockInBarrierOptionFactory final: public OptionFactory<KnockInBarrierOption> {
         std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params, const PayoffType& type) override;
 
-        std::shared_ptr<Option> createSpecificOption(const ParameterObject& params,
+        std::shared_ptr<KnockInBarrierOption> createSpecificOption(const ParameterObject& params,
                                                                std::unique_ptr<Payoff> payoff,
                                                                const std::shared_ptr<IMarketData>& marketData) override;
 
         std::string getType(const PayoffType& type) const override;
     };
 
 
-    class KnockOutBarrierOptionFactory final: public OptionFactory {
+    class KnockOutBarrierOptionFactory final: public OptionFactory<KnockOutBarrierOption> {
         std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params, const PayoffType& type) override;
 
-        std::shared_ptr<Option> createSpecificOption(const ParameterObject& params,
+        std::shared_ptr<KnockOutBarrierOption> createSpecificOption(const ParameterObject& params,
                                                      std::unique_ptr<Payoff> payoff,
                                                      const std::shared_ptr<IMarketData>& marketData) override;
 

include/option/path_dependent/factory_lookback_option.h

@@ -1,23 +1,24 @@
 #ifndef FACTORY_LOOKBACK_OPTION_H
 #define FACTORY_LOOKBACK_OPTION_H
 
-#include "option/factory_option.h"
+#include "option/base_factory_option.h"
+#include "option/path_dependent/lookback_option.h"
 
 namespace OptionPricer {
 
-    class FloatingStrikeLookbackOptionFactory final: public OptionFactory {
+    class FloatingStrikeLookbackOptionFactory final: public OptionFactory<FloatingStrikeLookbackOption> {
     public:
         std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params, const PayoffType& type) override;
-        std::shared_ptr<Option> createSpecificOption(const ParameterObject& params,
+        std::shared_ptr<FloatingStrikeLookbackOption> createSpecificOption(const ParameterObject& params,
                                                      std::unique_ptr<Payoff> payoff,
                                                      const std::shared_ptr<IMarketData>& marketData) override;
         std::string getType(const PayoffType& type) const override;
     };
 
-    class FixedStrikeLookbackOptionFactory final: public OptionFactory {
+    class FixedStrikeLookbackOptionFactory final: public OptionFactory<FixedStrikeLookbackOption> {
     public:
         std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params, const PayoffType& type) override;
-        std::shared_ptr<Option> createSpecificOption(const ParameterObject& params,
+        std::shared_ptr<FixedStrikeLookbackOption> createSpecificOption(const ParameterObject& params,
                                                      std::unique_ptr<Payoff> payoff,
                                                      const std::shared_ptr<IMarketData>& marketData) override;
         std::string getType(const PayoffType& type) const override;

include/option/single_path/factory_digital_option.h

@@ -1,13 +1,14 @@
 #ifndef FACTORY_DIGITAL_OPTION_H
 #define FACTORY_DIGITAL_OPTION_H
 
-#include "option/factory_option.h"
+#include "option/base_factory_option.h"
+#include "option/single_path/digital_option.h"
 
 namespace OptionPricer {
-    class DigitalOptionFactory final: public OptionFactory {
+    class DigitalOptionFactory final: public OptionFactory<DigitalOption> {
         std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params, const PayoffType& type) override;
 
-        std::shared_ptr<Option> createSpecificOption(const ParameterObject& params,
+        std::shared_ptr<DigitalOption> createSpecificOption(const ParameterObject& params,
                                                                std::unique_ptr<Payoff> payoff,
                                                                const std::shared_ptr<IMarketData>& marketData) override;
 

include/option/single_path/factory_double_digital_option.h

@@ -1,13 +1,14 @@
 #ifndef FACTORY_DOUBLE_DIGITAL_OPTION_H
 #define FACTORY_DOUBLE_DIGITAL_OPTION_H
 
-#include <option/factory_option.h>
+#include <option/base_factory_option.h>
+#include "option/single_path/double_digital_option.h"
 
 namespace OptionPricer {
-    class DoubleDigitalOptionFactory final: public OptionFactory {
+    class DoubleDigitalOptionFactory final: public OptionFactory<DoubleDigitalOption> {
         std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params, const PayoffType& type) override;
 
-        std::shared_ptr<Option> createSpecificOption(const ParameterObject& params,
+        std::shared_ptr<DoubleDigitalOption> createSpecificOption(const ParameterObject& params,
                                                                std::unique_ptr<Payoff> payoff,
                                                                const std::shared_ptr<IMarketData>& marketData) override;
 

include/option/single_path/factory_european_option.h

@@ -1,17 +1,23 @@
 #ifndef FACTORY_EUROPEAN_OPTION_H
 #define FACTORY_EUROPEAN_OPTION_H
 
-#include "option/factory_option.h"
+#include "option/single_path/european_option.h"
+#include "option/base_factory_option.h"
 
 namespace OptionPricer {
-    class EuropeanOptionFactory final: public OptionFactory {
+
+    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;
 
-        std::shared_ptr<Option> createSpecificOption(const ParameterObject& params,
+        std::shared_ptr<EuropeanOption> createSpecificOption(const ParameterObject& params,
                                                      std::unique_ptr<Payoff> payoff,
                                                      const std::shared_ptr<IMarketData>& marketData) override;
 
         std::string getType(const PayoffType& type) const override;
+
     };
 }
 

include/solver/base_solver.h

@@ -4,11 +4,13 @@
 #include <memory>
 
 namespace OptionPricer {
+
     class Solver {
     public:
         virtual ~Solver();
         [[nodiscard]] virtual double solve() const = 0;
     };
+
 }
 
 #endif //BASE_SOLVER_H