diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9dd4976..cb861e8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -10,9 +10,23 @@ set(Boost_USE_STATIC_LIBS OFF)
 set(Boost_USE_MULTITHREADED ON)
 set(Boost_USE_STATIC_RUNTIME OFF)
 
+# Specify the target architecture for macOS
+if(APPLE)
+    # Detect the processor architecture
+    if(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "arm64")
+        set(CMAKE_OSX_ARCHITECTURES "arm64" CACHE STRING "Build architectures for Mac OS X" FORCE)
+    elseif(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "x86_64")
+        set(CMAKE_OSX_ARCHITECTURES "x86_64" CACHE STRING "Build architectures for Mac OS X" FORCE)
+    else()
+        message(WARNING "Unknown architecture: ${CMAKE_HOST_SYSTEM_PROCESSOR}. Defaulting to x86_64.")
+        set(CMAKE_OSX_ARCHITECTURES "x86_64" CACHE STRING "Build architectures for Mac OS X" FORCE)
+    endif()
+endif()
+
+
 # Set the Vcpkg toolchain file
-set(CMAKE_TOOLCHAIN_FILE "/Users/anthony/.vcpkg-clion/vcpkg/scripts/buildsystems/vcpkg.cmake"
-        CACHE STRING "Vcpkg toolchain file")
+#set(CMAKE_TOOLCHAIN_FILE "/Users/anthony/.vcpkg-clion/vcpkg/scripts/buildsystems/vcpkg.cmake"
+#        CACHE STRING "Vcpkg toolchain file")
 
 find_package(Boost REQUIRED COMPONENTS random)
 find_package(Eigen3 REQUIRED)
@@ -81,6 +95,13 @@ add_library(option SHARED
 add_library(model SHARED
         src/model/gbm_model.cpp
         src/model/base_model.cpp
+        src/model/heston_model.cpp
+        src/model/discretization/base_cir_discretization.cpp
+        src/model/discretization/explicit_euler_cir_discretization.cpp
+        src/model/discretization/milstein_cir_discretization.cpp
+        src/model/merton_jump_diffusion_model.cpp
+        src/model/kou_model.cpp
+        src/model/variance_gamma_model.cpp
 )
 
 # Create dynamic library for random
@@ -88,10 +109,15 @@ add_library(random SHARED
         src/random/distribution/base_distribution.cpp
         src/random/distribution/standard_normal_distribution.cpp
         src/random/number_generator/base_generator.cpp
-        src/random/number_generator/random_generator.cpp
+        src/random/number_generator/pseudo_random_generator.cpp
         src/random/number_generator/base_quasi_random_generator.cpp
         src/random/number_generator/faure_quasi_random_generator.cpp
         src/random/number_generator/sobol_quasi_random_generator.cpp
+        src/random/distribution/poisson_distrib.cpp
+        src/random/distribution/normal_distrib.cpp
+        src/random/distribution/continuous_uniform_distrib.cpp
+        src/random/distribution/exponential_distr.cpp
+        src/random/distribution/gamma_distrib.cpp
 )
 
 # Create dynamic library for solver
@@ -100,14 +126,12 @@ add_library(solver SHARED
         src/solver/monte_carlo/mc_solver.cpp
         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_american.cpp
@@ -124,14 +148,9 @@ add_library(solver SHARED
         src/solver/monte_carlo/basis_function/laguerre.cpp
 )
 
-# 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 random model Boost::random Eigen3::Eigen)
-
-target_link_libraries(model PUBLIC option)
-
+target_link_libraries(model PUBLIC option random)
+target_link_libraries(solver PUBLIC option model Boost::random Eigen3::Eigen)
 
 # Create main executable
 add_executable(Option_pricer main.cpp)
diff --git a/README.md b/README.md
index f4abd23..7b645b0 100644
--- a/README.md
+++ b/README.md
@@ -100,7 +100,7 @@ make test
 │   │       ├── base_generator.cpp
 │   │       ├── base_quasi_random_generator.cpp
 │   │       ├── faure_quasi_random_generator.cpp
-│   │       ├── random_generator.cpp
+│   │       ├── pseudo_random_generator.cpp
 │   │       └── sobol_quasi_random_generator.cpp
 │   └── solver
 │       ├── base_solver.cpp
diff --git a/include/model/base_model.h b/include/model/base_model.h
index 63f61fa..d5b70be 100644
--- a/include/model/base_model.h
+++ b/include/model/base_model.h
@@ -2,22 +2,31 @@
 #define STOCK_PRICE_MODEL_H
 
 #include <string>
+#include <random/number_generator/base_generator.h>
 #include "market_data/interface_market_data.h"
 
 namespace OptionPricer {
 
     class StockModel {
     public:
-        StockModel(const std::string& ticker, std::shared_ptr<IMarketData> marketData);
-        virtual ~StockModel();
+        StockModel(const std::string& ticker,
+                   std::shared_ptr<IMarketData> marketData,
+                   std::shared_ptr<NumberGenerator> generator);
 
-        [[nodiscard]] virtual double simulatePriceAtMaturity(const double& T, const double& z) const = 0;
-        [[nodiscard]] virtual double simulateStepPrice(const double& dt, const double& z) const = 0;
+        virtual ~StockModel();
+        unsigned int getSteps() const;
+        [[nodiscard]] std::shared_ptr<NumberGenerator> getGenerator() const;
 
+        [[nodiscard]] virtual double simulatePriceAtMaturity(const double& T) const = 0;
+        [[nodiscard]] virtual std::vector<double> simulatePrices(const double& T) const = 0;
+        [[nodiscard]] virtual double simulatePriceBackward(const double& S_next,
+                                                           const double& t_j,
+                                                           const double& t_jp1) const;
     protected:
         std::string ticker_;
-        std::shared_ptr<const StockData> stockData_; // Cache StockData for consultation
         std::shared_ptr<IMarketData> marketData_;
+        std::shared_ptr<const StockData> stockData_; // Cache StockData for consultation
+        std::shared_ptr<NumberGenerator> generator_;
     };
 
 }
diff --git a/include/model/discretization/base_cir_discretization.h b/include/model/discretization/base_cir_discretization.h
new file mode 100644
index 0000000..e1a1b8f
--- /dev/null
+++ b/include/model/discretization/base_cir_discretization.h
@@ -0,0 +1,18 @@
+#ifndef BASE_CIR_DISCRETIZATION_H
+#define BASE_CIR_DISCRETIZATION_H
+
+#include <algorithm>
+
+namespace OptionPricer {
+
+    class CIRDiscretization {
+    public:
+        virtual ~CIRDiscretization();
+        virtual double apply(const double &v, const double &dt,
+                             const double &kappa, const double &theta,
+                             const double &sigma_v, const double &z) const = 0;
+    };
+
+}
+
+#endif //BASE_CIR_DISCRETIZATION_H
diff --git a/include/model/discretization/explicit_euler_cir_discretization.h b/include/model/discretization/explicit_euler_cir_discretization.h
new file mode 100644
index 0000000..8662d7f
--- /dev/null
+++ b/include/model/discretization/explicit_euler_cir_discretization.h
@@ -0,0 +1,17 @@
+#ifndef EXPLICIT_EULER_CIR_DISCRETIZATION_H
+#define EXPLICIT_EULER_CIR_DISCRETIZATION_H
+
+#include "model/discretization/base_cir_discretization.h"
+
+namespace OptionPricer {
+
+    class CIRExplicitEulerDiscretization : public CIRDiscretization {
+    public:
+        double apply(const double &v, const double &dt,
+                     const double &kappa, const double &theta,
+                     const double &sigma_v, const double &z) const override;
+    };
+
+}
+
+#endif //EXPLICIT_EULER_CIR_DISCRETIZATION_H
diff --git a/include/model/discretization/milstein_cir_discretization.h b/include/model/discretization/milstein_cir_discretization.h
new file mode 100644
index 0000000..f9c47ef
--- /dev/null
+++ b/include/model/discretization/milstein_cir_discretization.h
@@ -0,0 +1,16 @@
+#ifndef MILSTEIN_CIR_DISCRETIZATION_H
+#define MILSTEIN_CIR_DISCRETIZATION_H
+
+#include "model/discretization/explicit_euler_cir_discretization.h"
+
+namespace OptionPricer {
+
+    class CIRMilsteinDiscretization : public CIRExplicitEulerDiscretization {
+    public:
+        double apply(const double &v, const double &dt, const double &kappa, const double &theta, const double &sigma_v,
+            const double &z) const override;
+    };
+
+}
+
+#endif //MILSTEIN_CIR_DISCRETIZATION_H
diff --git a/include/model/gbm_model.h b/include/model/gbm_model.h
index d0e0b71..e7e1503 100644
--- a/include/model/gbm_model.h
+++ b/include/model/gbm_model.h
@@ -3,17 +3,20 @@
 
 #include <cmath>
 #include <random>
-#include <model/base_model.h>
-#include <market_data/interface_market_data.h>
+#include "model/base_model.h"
 
 namespace OptionPricer {
 
-    class GeometricBrownianMotionModel : public StockModel {
+    class GeometricBrownianMotionModel final: public StockModel {
     public:
-        GeometricBrownianMotionModel(const std::string& ticker, std::shared_ptr<IMarketData> marketData);
+        using StockModel::StockModel;
+        ~GeometricBrownianMotionModel() override;
 
-        [[nodiscard]] double simulatePriceAtMaturity(const double& T, const double& z) const override;
-        [[nodiscard]] double simulateStepPrice(const double& dt, const double& z) const override;
+        [[nodiscard]] double simulatePriceAtMaturity(const double& T) const override;
+        [[nodiscard]] std::vector<double> simulatePrices(const double& T) const override;
+        [[nodiscard]] double simulatePriceBackward(const double &S_next,
+                                                   const double &t_j,
+                                                   const double &t_jp1) const override;
     };
 
 }
diff --git a/include/model/heston_model.h b/include/model/heston_model.h
new file mode 100644
index 0000000..46b78d9
--- /dev/null
+++ b/include/model/heston_model.h
@@ -0,0 +1,36 @@
+#ifndef HESTON_MODEL_H
+#define HESTON_MODEL_H
+
+#include "model/base_model.h"
+#include "model/discretization/base_cir_discretization.h"
+
+namespace OptionPricer {
+
+    class HestonModel final : public StockModel {
+    public:
+        HestonModel(const std::string& ticker,
+                    std::shared_ptr<IMarketData> marketData,
+                    std::shared_ptr<NumberGenerator> generator,
+                    const double& kappa, const double& theta, const double& sigma_v,
+                    const double& rho, const double& v0,
+                    std::shared_ptr<CIRDiscretization> varDiscretization = nullptr);
+        ~HestonModel() override;
+
+        [[nodiscard]] double simulatePriceAtMaturity(const double& T) const override;
+        [[nodiscard]] std::vector<double> simulatePrices(const double& T) const override;
+
+    private:
+        double kappa_;  // Mean reversion rate
+        double theta_;  // Long-term variance
+        double sigma_v_; // Volatility of variance
+        double rho_;  // Correlation between the two Brownian motions
+        double v0_;  // Initial variance
+        std::shared_ptr<CIRDiscretization> varDiscretization_; // Discretization scheme for the variance process
+    };
+
+}
+
+
+
+
+#endif //HESTON_MODEL_H
diff --git a/include/model/kou_model.h b/include/model/kou_model.h
new file mode 100644
index 0000000..61059fd
--- /dev/null
+++ b/include/model/kou_model.h
@@ -0,0 +1,33 @@
+#ifndef KOU_MODEL_H
+#define KOU_MODEL_H
+
+#include "model/base_model.h"
+
+namespace OptionPricer {
+
+    class KouModel final: public StockModel {
+    public:
+        /* This class implements the Kou model which is an extension of the Merton Jump Diffusion model
+         * which introduce asymmetry of jumps for modeling the skewness and kurtosis of stock returns.
+         */
+        KouModel(const std::string& ticker,
+                 std::shared_ptr<IMarketData> marketData,
+                 std::shared_ptr<NumberGenerator> generator,
+                 const double& lambda, const double& p,
+                 const double& eta1, const double& eta2);
+
+        ~KouModel() override;
+
+        double simulatePriceAtMaturity(const double& T) const override;
+        std::vector<double> simulatePrices(const double& T) const override;
+
+    private:
+        double lambda_;  // Jump intensity
+        double p_;       // Probability of upward jump
+        double eta1_;    // Rate of upward jumps
+        double eta2_;    // Rate of downward jumps
+    };
+
+}
+
+#endif //KOU_MODEL_H
diff --git a/include/model/merton_jump_diffusion_model.h b/include/model/merton_jump_diffusion_model.h
new file mode 100644
index 0000000..9c39a22
--- /dev/null
+++ b/include/model/merton_jump_diffusion_model.h
@@ -0,0 +1,28 @@
+#ifndef MERTON_JUMP_DIFFUSION_MODEL_H
+#define MERTON_JUMP_DIFFUSION_MODEL_H
+
+#include "model/base_model.h"
+
+namespace OptionPricer {
+
+    class MertonJumpDiffusionModel final : public StockModel {
+    public:
+        MertonJumpDiffusionModel(const std::string& ticker,
+                                 std::shared_ptr<IMarketData> marketData,
+                                 std::shared_ptr<NumberGenerator> generator,
+                                 const double& lambda, const double& muJ, const double& sigmaJ);
+
+        ~MertonJumpDiffusionModel() override;
+
+        double simulatePriceAtMaturity(const double& T) const override;
+        std::vector<double> simulatePrices(const double& T) const override;
+
+    private:
+        double lambda_;  // intensity of the Poisson process (mean number of jumps per unit time)
+        double muJ_;     // mean of the jump size distribution
+        double sigmaJ_;  // standard deviation of the jump size distribution
+    };
+
+}
+
+#endif // MERTON_JUMP_DIFFUSION_MODEL_H
\ No newline at end of file
diff --git a/include/model/variance_gamma_model.h b/include/model/variance_gamma_model.h
new file mode 100644
index 0000000..dfe6797
--- /dev/null
+++ b/include/model/variance_gamma_model.h
@@ -0,0 +1,29 @@
+#ifndef VARIANCE_GAMMA_MODEL_H
+#define VARIANCE_GAMMA_MODEL_H
+
+#include "model/base_model.h"
+
+namespace OptionPricer {
+
+    class VarianceGammaModel : public StockModel {
+    public:
+        VarianceGammaModel(const std::string& ticker,
+                           std::shared_ptr<IMarketData> marketData,
+                           std::shared_ptr<NumberGenerator> generator,
+                           const double& sigma, const double& nu, const double& theta);
+
+        ~VarianceGammaModel() override;
+
+        [[nodiscard]] double simulatePriceAtMaturity(const double& T) const override;
+        [[nodiscard]] std::vector<double> simulatePrices(const double& T) const override;
+
+    private:
+        double sigma_; // Volatility parameter
+        double nu_;    // Variance rate of the Gamma process
+        double theta_; // Drift of the Brownian motion
+        double omega_; // Drift correction term
+    };
+
+}
+
+#endif //VARIANCE_GAMMA_MODEL_H
\ No newline at end of file
diff --git a/include/payoff/base_payoff.h b/include/payoff/base_payoff.h
index f049f07..fb6f7c5 100644
--- a/include/payoff/base_payoff.h
+++ b/include/payoff/base_payoff.h
@@ -5,15 +5,19 @@
 #include <string>
 
 namespace OptionPricer {
+
     enum class PayoffType {
-        Call, Put, DoubleDigital
+        Call,
+        Put,
+        DoubleDigital
     };
 
     inline std::string PayoffTypeToString(const PayoffType& type) {
         switch (type) {
-            case PayoffType::Call: return "Call";
-            case PayoffType::Put: return "Put";
-            case PayoffType::DoubleDigital: return "DoubleDigital";
+            using enum PayoffType;
+            case Call: return "Call";
+            case Put: return "Put";
+            case DoubleDigital: return "DoubleDigital";
             // Add other cases as needed
             default: return "Unknown";
         }
diff --git a/include/random/distribution/base_distribution.h b/include/random/distribution/base_distribution.h
index fb869f6..91d55f1 100644
--- a/include/random/distribution/base_distribution.h
+++ b/include/random/distribution/base_distribution.h
@@ -5,11 +5,12 @@
 
 namespace OptionPricer {
 
+    // Maybe inheriting discrete and continuous and make operator() return either int or double
     class Distribution {
     public:
         virtual ~Distribution();
         [[nodiscard]] virtual double inv_cdf(const double& quantile) const = 0;
-        virtual double operator()(std::mt19937& gen) = 0;
+        virtual double operator()(std::mt19937& gen) const = 0;
     };
 
 }
diff --git a/include/random/distribution/continuous_uniform_distrib.h b/include/random/distribution/continuous_uniform_distrib.h
new file mode 100644
index 0000000..7c1e049
--- /dev/null
+++ b/include/random/distribution/continuous_uniform_distrib.h
@@ -0,0 +1,24 @@
+#ifndef CONTINUOUS_UNIFORM_DISTRIB_H
+#define CONTINUOUS_UNIFORM_DISTRIB_H
+
+#include "random/distribution/base_distribution.h"
+
+namespace OptionPricer {
+
+    class ContinuousUniformDistribution : public Distribution {
+    public:
+        explicit ContinuousUniformDistribution(const double& a = 0.0, const double& b = 1.0);
+        ~ContinuousUniformDistribution() override;
+
+        [[nodiscard]] double inv_cdf(const double& quantile) const override;
+        double operator()(std::mt19937& gen) const override;
+
+    protected:
+        double a_; // Lower bound
+        double b_; // Upper bound
+        mutable std::uniform_real_distribution<> uniform_dist_;
+    };
+
+}
+
+#endif //CONTINUOUS_UNIFORM_DISTRIB_H
diff --git a/include/random/distribution/exponential_distr.h b/include/random/distribution/exponential_distr.h
new file mode 100644
index 0000000..bcea0cf
--- /dev/null
+++ b/include/random/distribution/exponential_distr.h
@@ -0,0 +1,23 @@
+#ifndef EXPONENTIAL_DISTR_H
+#define EXPONENTIAL_DISTR_H
+
+#include "random/distribution/base_distribution.h"
+
+namespace OptionPricer {
+
+    class ExponentialDistribution : public Distribution {
+    public:
+        explicit ExponentialDistribution(const double& lambda);
+        ~ExponentialDistribution() override;
+
+        [[nodiscard]] double inv_cdf(const double& quantile) const override;
+        double operator()(std::mt19937& gen) const override;
+
+    protected:
+        double lambda_; // Intensity rate
+        mutable std::exponential_distribution<> exponential_dist_;
+    };
+
+}
+
+#endif //EXPONENTIAL_DISTR_H
\ No newline at end of file
diff --git a/include/random/distribution/gamma_distrib.h b/include/random/distribution/gamma_distrib.h
new file mode 100644
index 0000000..7cd09ea
--- /dev/null
+++ b/include/random/distribution/gamma_distrib.h
@@ -0,0 +1,24 @@
+#ifndef GAMMA_DISTRIB_H
+#define GAMMA_DISTRIB_H
+
+#include "random/distribution/base_distribution.h"
+
+namespace OptionPricer {
+
+    class GammaDistribution : public Distribution {
+    public:
+        GammaDistribution(const double& alpha, const double& beta);
+        ~GammaDistribution() override;
+
+        [[nodiscard]] double inv_cdf(const double& quantile) const override;
+        double operator()(std::mt19937& gen) const override;
+
+    protected:
+        double alpha_; // Shape parameter
+        double beta_;  // Rate parameter
+        mutable std::gamma_distribution<> gamma_dist_;
+    };
+
+}
+
+#endif //GAMMA_DISTRIB_H
diff --git a/include/random/distribution/normal_distrib.h b/include/random/distribution/normal_distrib.h
new file mode 100644
index 0000000..fbd22ec
--- /dev/null
+++ b/include/random/distribution/normal_distrib.h
@@ -0,0 +1,25 @@
+#ifndef NORMAL_DISTRIBUTION_H
+#define NORMAL_DISTRIBUTION_H
+
+#include <cmath>
+#include "random/distribution/base_distribution.h"
+
+namespace OptionPricer {
+
+    class NormalDistribution : public Distribution {
+    public:
+        explicit NormalDistribution(const double& mu, const double& sigma);
+        ~NormalDistribution() override;
+
+        [[nodiscard]] double inv_cdf(const double& quantile) const override;
+        double operator()(std::mt19937& gen) const override;
+
+    protected:
+        double mu_;
+        double sigma_;
+        mutable std::normal_distribution<> normal_dist_;
+    };
+
+}
+
+#endif //NORMAL_DISTRIBUTION_H
diff --git a/include/random/distribution/poisson_distrib.h b/include/random/distribution/poisson_distrib.h
new file mode 100644
index 0000000..6998b10
--- /dev/null
+++ b/include/random/distribution/poisson_distrib.h
@@ -0,0 +1,23 @@
+#ifndef POISSON_DISTRIB_H
+#define POISSON_DISTRIB_H
+
+#include "random/distribution/base_distribution.h"
+
+namespace OptionPricer {
+
+    class PoissonDistribution final: public Distribution {
+    public:
+        explicit PoissonDistribution(const double& lambda);
+        ~PoissonDistribution() override;
+
+        [[nodiscard]] double inv_cdf(const double& quantile) const override;
+        double operator()(std::mt19937& gen) const override;
+
+    private:
+        double lambda_;
+        mutable std::poisson_distribution<> poisson_dist_;
+    };
+
+}
+
+#endif //POISSON_DISTRIB_H
\ No newline at end of file
diff --git a/include/random/distribution/standard_normal_distribution.h b/include/random/distribution/standard_normal_distribution.h
index 1dba829..6faf563 100644
--- a/include/random/distribution/standard_normal_distribution.h
+++ b/include/random/distribution/standard_normal_distribution.h
@@ -2,20 +2,16 @@
 #define STANDARD_NORMAL_DISTRIBUTION_H
 
 #include <cmath>
-#include "random/distribution/base_distribution.h"
+#include "random/distribution/normal_distrib.h"
 
 namespace OptionPricer {
 
-    class StandardNormalDistribution final: public Distribution {
+    class StandardNormalDistribution final: public NormalDistribution {
     public:
         explicit StandardNormalDistribution();
         ~StandardNormalDistribution() override;
 
         [[nodiscard]] double inv_cdf(const double& quantile) const override;
-        double operator()(std::mt19937& gen) override;
-
-    private:
-        std::normal_distribution<> normal_dist_;
     };
 
 }
diff --git a/include/random/number_generator/base_generator.h b/include/random/number_generator/base_generator.h
index 78bea22..66bfff6 100644
--- a/include/random/number_generator/base_generator.h
+++ b/include/random/number_generator/base_generator.h
@@ -5,19 +5,19 @@
 
 namespace OptionPricer {
 
-    // MAYB PUTTING THE CREATION INSIDE A STOCKMODEL FACTORY THAT WOULD REQUIRE A THE DIM PARAMETER
-    // TO BE PASSED TO BOTH THE QUASI RANDOM NUMBER GENERATOR AS WELL AS THE STOCKPRICEMODEL CLASS
     class NumberGenerator {
     public:
-        explicit NumberGenerator(std::shared_ptr<Distribution> dist);
-        explicit NumberGenerator(std::shared_ptr<Distribution> dist, const unsigned int& seed);
+        explicit NumberGenerator(const unsigned int &dim);
+        explicit NumberGenerator(const unsigned int &dim, const unsigned int& seed);
 
         virtual ~NumberGenerator();
 
-        virtual double generate(const int& step) = 0;
+        virtual double operator()(Distribution &dist) const = 0;
+        unsigned int getDim() const;
 
     protected:
-        std::shared_ptr<Distribution> dist_;
+        void validateDim() const;
+        unsigned int dim_;
         unsigned int seed_;
     };
 
diff --git a/include/random/number_generator/base_quasi_random_generator.h b/include/random/number_generator/base_quasi_random_generator.h
index ecd2541..1cb2124 100644
--- a/include/random/number_generator/base_quasi_random_generator.h
+++ b/include/random/number_generator/base_quasi_random_generator.h
@@ -7,18 +7,14 @@ namespace OptionPricer {
 
     class QuasiRandomNumberGenerator : public NumberGenerator {
     public:
-        explicit QuasiRandomNumberGenerator(std::shared_ptr<Distribution> dist, const unsigned int& dim);
-        QuasiRandomNumberGenerator(std::shared_ptr<Distribution> dist, const unsigned int& seed, const unsigned int& dim);
+        explicit QuasiRandomNumberGenerator(const unsigned int& dim);
+        QuasiRandomNumberGenerator(const unsigned int& dim, const unsigned int& seed);
 
         ~QuasiRandomNumberGenerator() override;
 
-        unsigned int getDim() const;
-
     protected:
-        void validateDim() const;
-
-        unsigned int dim_;
-        std::vector<double> point_; // Maybe use array
+        mutable int step_;
+        mutable std::vector<double> point_; // Maybe use array
     };
 
 }
diff --git a/include/random/number_generator/faure_quasi_random_generator.h b/include/random/number_generator/faure_quasi_random_generator.h
index 10d2ab3..6700ebf 100644
--- a/include/random/number_generator/faure_quasi_random_generator.h
+++ b/include/random/number_generator/faure_quasi_random_generator.h
@@ -8,15 +8,15 @@ namespace OptionPricer {
 
     class FaureGenerator final: public QuasiRandomNumberGenerator {
     public:
-        explicit FaureGenerator(std::shared_ptr<Distribution> dist, const unsigned int& dim);
-        FaureGenerator(std::shared_ptr<Distribution> dist, const unsigned int& seed, const unsigned int& dim);
+        explicit FaureGenerator(const unsigned int& dim);
+        FaureGenerator(const unsigned int& seed, const unsigned int& dim);
 
         ~FaureGenerator() override;
 
-        [[nodiscard]] double generate(const int& step) override;
+        double operator()(Distribution& dist) const override;
 
     private:
-        boost::random::faure faureQrng_;
+        mutable boost::random::faure faureQrng_;
     };
 
 }
diff --git a/include/random/number_generator/pseudo_random_generator.h b/include/random/number_generator/pseudo_random_generator.h
new file mode 100644
index 0000000..3ffc680
--- /dev/null
+++ b/include/random/number_generator/pseudo_random_generator.h
@@ -0,0 +1,21 @@
+#ifndef PSEUDO_RANDOM_NUMBER_GENERATOR_H
+#define PSEUDO_RANDOM_NUMBER_GENERATOR_H
+
+#include "random/number_generator/base_generator.h"
+
+namespace OptionPricer {
+
+    class PseudoRandomNumberGenerator final: public NumberGenerator {
+    public:
+        using NumberGenerator::NumberGenerator;
+        ~PseudoRandomNumberGenerator() override;
+
+        double operator()(Distribution& dist) const override;
+
+    private:
+        mutable std::mt19937 generator_; // Mersenne Twister PRNG
+    };
+
+}
+
+#endif //PSEUDO_RANDOM_NUMBER_GENERATOR_H
diff --git a/include/random/number_generator/random_generator.h b/include/random/number_generator/random_generator.h
deleted file mode 100644
index 7750964..0000000
--- a/include/random/number_generator/random_generator.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef RANDOM_NUMBER_GENERATOR_H
-#define RANDOM_NUMBER_GENERATOR_H
-
-#include "random/number_generator/base_generator.h"
-
-namespace OptionPricer {
-
-    class RandomNumberGenerator final: public NumberGenerator {
-    public:
-        explicit RandomNumberGenerator(std::shared_ptr<Distribution> dist);
-        RandomNumberGenerator(std::shared_ptr<Distribution> dist, const unsigned int& seed);
-
-        [[nodiscard]] double generate(const int& step) override;
-
-    private:
-        std::mt19937 generator_; // Mersenne Twister PRNG
-    };
-
-}
-
-#endif //RANDOM_NUMBER_GENERATOR_H
diff --git a/include/random/number_generator/sobol_quasi_random_generator.h b/include/random/number_generator/sobol_quasi_random_generator.h
index 8610801..d9caee6 100644
--- a/include/random/number_generator/sobol_quasi_random_generator.h
+++ b/include/random/number_generator/sobol_quasi_random_generator.h
@@ -8,15 +8,15 @@ namespace OptionPricer {
 
     class SobolGenerator final: public QuasiRandomNumberGenerator {
     public:
-        explicit SobolGenerator(std::shared_ptr<Distribution> dist, const unsigned int& dim);
-        SobolGenerator(std::shared_ptr<Distribution> dist, const unsigned int& seed, const unsigned int& dim);
+        explicit SobolGenerator(const unsigned int& dim);
+        SobolGenerator(const unsigned int& dim, const unsigned int& seed);
 
         ~SobolGenerator() override;
 
-        [[nodiscard]] double generate(const int& step) override;
+        double operator()(Distribution& dist) const override;
 
     private:
-        boost::random::sobol sobolQrng_;
+        mutable boost::random::sobol sobolQrng_;
     };
 
 }
diff --git a/include/solver/monte_carlo/base_mc.h b/include/solver/monte_carlo/base_mc.h
index a83a13e..b040f3a 100644
--- a/include/solver/monte_carlo/base_mc.h
+++ b/include/solver/monte_carlo/base_mc.h
@@ -9,10 +9,7 @@ namespace OptionPricer {
 
     class MCPricer {
     public:
-        MCPricer(std::shared_ptr<IMarketData> marketData,
-                 std::shared_ptr<StockModel> stockModel,
-                 std::shared_ptr<NumberGenerator> generator);
-
+        MCPricer(std::shared_ptr<IMarketData> marketData, std::shared_ptr<StockModel> stockModel);
         virtual ~MCPricer();
 
         [[nodiscard]] virtual double calculatePrice(const unsigned long& N) const = 0;
@@ -20,7 +17,6 @@ namespace OptionPricer {
     protected:
         std::shared_ptr<IMarketData> marketData_;
         std::shared_ptr<StockModel> stockModel_;
-        std::shared_ptr<NumberGenerator> generator_;
     };
 
 }
diff --git a/include/solver/monte_carlo/base_mc_path_dependent.h b/include/solver/monte_carlo/base_mc_path_dependent.h
deleted file mode 100644
index 6c86b14..0000000
--- a/include/solver/monte_carlo/base_mc_path_dependent.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef BASE_MC_PATH_DEPENDENT_H
-#define BASE_MC_PATH_DEPENDENT_H
-
-#include "solver/monte_carlo/base_mc.h"
-
-namespace OptionPricer {
-
-    class PathDependentMCPricer : public MCPricer {
-    public:
-        PathDependentMCPricer(std::shared_ptr<IMarketData> marketData,
-                              std::shared_ptr<StockModel> stockModel,
-                              std::shared_ptr<NumberGenerator> generator,
-                              const unsigned int& steps);
-
-    protected:
-        unsigned int steps_;
-    };
-
-}
-
-#endif //BASE_MC_PATH_DEPENDENT_H
diff --git a/include/solver/monte_carlo/builder/base_mc_builder.h b/include/solver/monte_carlo/builder/base_mc_builder.h
index 791a7b5..a8ff909 100644
--- a/include/solver/monte_carlo/builder/base_mc_builder.h
+++ b/include/solver/monte_carlo/builder/base_mc_builder.h
@@ -2,9 +2,10 @@
 #define BASE_MC_BUILDER_H
 
 #include "solver/monte_carlo/base_mc.h"
+#include "option/base_option.h"
 #include "model/base_model.h"
+#include <random/number_generator/pseudo_random_generator.h>
 #include "model/gbm_model.h"
-#include "option/base_option.h"
 
 namespace OptionPricer {
 
@@ -15,7 +16,6 @@ namespace OptionPricer {
 
         MCBuilder& setMarketData(std::shared_ptr<IMarketData> marketData);
         MCBuilder& setStockPriceModel(std::shared_ptr<StockModel> stockModel);
-        MCBuilder& setNumberGenerator(std::shared_ptr<NumberGenerator> generator);
 
         virtual MCBuilder& setOption(std::shared_ptr<Option> option) = 0;
         virtual std::unique_ptr<MCPricer> build() = 0;
@@ -23,7 +23,6 @@ namespace OptionPricer {
     protected:
         std::shared_ptr<IMarketData> marketData_;
         std::shared_ptr<StockModel> stockModel_; // Requires specific option to be provided default values
-        std::shared_ptr<NumberGenerator> generator_;
     };
 
 }
diff --git a/include/solver/monte_carlo/builder/base_mc_builder_path_dependent.h b/include/solver/monte_carlo/builder/base_mc_builder_path_dependent.h
deleted file mode 100644
index ef7bcea..0000000
--- a/include/solver/monte_carlo/builder/base_mc_builder_path_dependent.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef BASE_MC_BUILDER_PATH_DEPENDENT_H
-#define BASE_MC_BUILDER_PATH_DEPENDENT_H
-
-#include "solver/monte_carlo/builder/base_mc_builder.h"
-
-namespace OptionPricer {
-
-    class PathDependentMCBuilder : public MCBuilder {
-    public:
-        PathDependentMCBuilder();
-        ~PathDependentMCBuilder() override;
-
-        PathDependentMCBuilder& setSteps(unsigned int steps);
-
-    protected:
-        unsigned int steps_;
-    };
-
-}
-
-#endif //BASE_MC_BUILDER_PATH_DEPENDENT_H
diff --git a/include/solver/monte_carlo/builder/mc_builder_american.h b/include/solver/monte_carlo/builder/mc_builder_american.h
index 4382ba2..63044f0 100644
--- a/include/solver/monte_carlo/builder/mc_builder_american.h
+++ b/include/solver/monte_carlo/builder/mc_builder_american.h
@@ -1,14 +1,14 @@
 #ifndef MC_BUILDER_AMERICAN_H
 #define MC_BUILDER_AMERICAN_H
 
-#include "solver/monte_carlo/builder/base_mc_builder_path_dependent.h"
+#include "solver/monte_carlo/builder/base_mc_builder.h"
 #include "solver/monte_carlo/mc_american.h"
 #include "solver/monte_carlo/regression/least_squares.h"
 #include "solver/monte_carlo/basis_function/monomial.h"
 
 namespace OptionPricer {
 
-    class AmericanMCBuilder final : public PathDependentMCBuilder {
+    class AmericanMCBuilder final : public MCBuilder {
     public:
         AmericanMCBuilder();
         ~AmericanMCBuilder() override;
diff --git a/include/solver/monte_carlo/builder/mc_builder_asian.h b/include/solver/monte_carlo/builder/mc_builder_asian.h
index 9a523b2..be6432e 100644
--- a/include/solver/monte_carlo/builder/mc_builder_asian.h
+++ b/include/solver/monte_carlo/builder/mc_builder_asian.h
@@ -1,15 +1,15 @@
 #ifndef MC_BUILDER_ASIAN_H
 #define MC_BUILDER_ASIAN_H
 
-#include "solver/monte_carlo/builder/base_mc_builder_path_dependent.h"
+#include "solver/monte_carlo/builder/base_mc_builder.h"
 #include "solver/monte_carlo/mc_asian.h"
 #include "option/path_dependent/asian_option.h"
 
 namespace OptionPricer {
 
-    class ArithmeticAsianMCBuilder final : public PathDependentMCBuilder {
+    class ArithmeticAsianMCBuilder final : public MCBuilder {
     public:
-        using PathDependentMCBuilder::PathDependentMCBuilder;
+        using MCBuilder::MCBuilder;
         ~ArithmeticAsianMCBuilder() override = default;
 
         ArithmeticAsianMCBuilder& setOption(std::shared_ptr<Option> option) override;
@@ -19,9 +19,9 @@ namespace OptionPricer {
         std::shared_ptr<ArithmeticAsianOption> option_;
     };
 
-    class GeometricAsianMCBuilder final : public PathDependentMCBuilder {
+    class GeometricAsianMCBuilder final : public MCBuilder {
     public:
-        using PathDependentMCBuilder::PathDependentMCBuilder;
+        using MCBuilder::MCBuilder;
         ~GeometricAsianMCBuilder() override = default;
 
         GeometricAsianMCBuilder& setOption(std::shared_ptr<Option> option) override;
diff --git a/include/solver/monte_carlo/builder/mc_builder_barrier.h b/include/solver/monte_carlo/builder/mc_builder_barrier.h
index 0ddc972..9d2dc41 100644
--- a/include/solver/monte_carlo/builder/mc_builder_barrier.h
+++ b/include/solver/monte_carlo/builder/mc_builder_barrier.h
@@ -1,14 +1,14 @@
 #ifndef MC_BUILDER_BARRIER_H
 #define MC_BUILDER_BARRIER_H
 
-#include "solver/monte_carlo/builder/base_mc_builder_path_dependent.h"
+#include "solver/monte_carlo/builder/base_mc_builder.h"
 #include "solver/monte_carlo/mc_barrier.h"
 
 namespace OptionPricer {
 
-    class KnockInBarrierMCBuilder final: public PathDependentMCBuilder {
+    class KnockInBarrierMCBuilder final: public MCBuilder {
     public:
-        using PathDependentMCBuilder::PathDependentMCBuilder;
+        using MCBuilder::MCBuilder;
         ~KnockInBarrierMCBuilder() override = default;
 
         KnockInBarrierMCBuilder& setOption(std::shared_ptr<Option> option) override;
@@ -18,9 +18,9 @@ namespace OptionPricer {
         std::shared_ptr<KnockInBarrierOption> option_;
     };
 
-    class KnockOutBarrierMCBuilder final: public PathDependentMCBuilder {
+    class KnockOutBarrierMCBuilder final: public MCBuilder {
     public:
-        using PathDependentMCBuilder::PathDependentMCBuilder;
+        using MCBuilder::MCBuilder;
         ~KnockOutBarrierMCBuilder() override = default;
 
         KnockOutBarrierMCBuilder& setOption(std::shared_ptr<Option> option) override;
diff --git a/include/solver/monte_carlo/builder/mc_builder_lookback.h b/include/solver/monte_carlo/builder/mc_builder_lookback.h
index 8ddbf81..f188ec6 100644
--- a/include/solver/monte_carlo/builder/mc_builder_lookback.h
+++ b/include/solver/monte_carlo/builder/mc_builder_lookback.h
@@ -1,14 +1,14 @@
 #ifndef MC_BUILDER_LOOKBACK_H
 #define MC_BUILDER_LOOKBACK_H
 
-#include "solver/monte_carlo/builder/base_mc_builder_path_dependent.h"
+#include "solver/monte_carlo/builder/base_mc_builder.h"
 #include "solver/monte_carlo/mc_lookback.h"
 
 namespace OptionPricer {
 
-    class FloatingStrikeLookbackMCBuilder final : public PathDependentMCBuilder {
+    class FloatingStrikeLookbackMCBuilder final : public MCBuilder {
     public:
-        using PathDependentMCBuilder::PathDependentMCBuilder;
+        using MCBuilder::MCBuilder;
         ~FloatingStrikeLookbackMCBuilder() override;
 
         FloatingStrikeLookbackMCBuilder& setOption(std::shared_ptr<Option> option) override;
@@ -18,9 +18,9 @@ namespace OptionPricer {
         std::shared_ptr<FloatingStrikeLookbackOption> option_;
     };
 
-    class FixedStrikeLookbackMCBuilder final : public PathDependentMCBuilder {
+    class FixedStrikeLookbackMCBuilder final : public MCBuilder {
     public:
-        using PathDependentMCBuilder::PathDependentMCBuilder;
+        using MCBuilder::MCBuilder;
         ~FixedStrikeLookbackMCBuilder() override;
 
         FixedStrikeLookbackMCBuilder& setOption(std::shared_ptr<Option> option) override;
diff --git a/include/solver/monte_carlo/builder/mc_builder_single_path.h b/include/solver/monte_carlo/builder/mc_builder_single_path.h
index c093ad4..5464548 100644
--- a/include/solver/monte_carlo/builder/mc_builder_single_path.h
+++ b/include/solver/monte_carlo/builder/mc_builder_single_path.h
@@ -7,7 +7,7 @@
 
 namespace OptionPricer {
 
-    class MCSinglePathBuilder final: MCBuilder {
+    class MCSinglePathBuilder final: public MCBuilder {
     public:
         using MCBuilder::MCBuilder;
         ~MCSinglePathBuilder() override;
diff --git a/include/solver/monte_carlo/mc_american.h b/include/solver/monte_carlo/mc_american.h
index fc2efec..df12b34 100644
--- a/include/solver/monte_carlo/mc_american.h
+++ b/include/solver/monte_carlo/mc_american.h
@@ -1,26 +1,24 @@
 #ifndef MC_AMERICAN_H
 #define MC_AMERICAN_H
 
-#include "solver/monte_carlo/base_mc_path_dependent.h"
+#include "solver/monte_carlo/base_mc.h"
 #include "option/path_dependent/american_option.h"
 #include "solver/monte_carlo/regression/base_regression_strategy.h"
 #include "solver/monte_carlo/basis_function/base_basis_function_strategy.h"
 
 namespace OptionPricer {
 
-    class AmericanMCPricer final: public PathDependentMCPricer {
+    class AmericanMCPricer final: public MCPricer {
     public:
         AmericanMCPricer(std::shared_ptr<AmericanOption> option,
                          std::shared_ptr<IMarketData> marketData,
                          std::shared_ptr<StockModel> stockModel,
-                         std::shared_ptr<NumberGenerator> generator,
                          std::shared_ptr<BasisFunctionStrategy> basisFunctionStrategy,
-                         std::shared_ptr<RegressionStrategy> regressionStrategy,
-                         const unsigned int& steps);
+                         std::shared_ptr<RegressionStrategy> regressionStrategy);
 
         double calculatePrice(const unsigned long& N) const override;
-        double standardPrice(const unsigned long& N, const double &dt, const double &discountFactor) const ;
-        double brownianBridgePrice(const unsigned long& N, const double &dt, const double &discountFactor) const ;
+        double standardPrice(const unsigned long& N) const ;
+        double brownianBridgePrice(const unsigned long& N) const ;
 
     private:
         std::shared_ptr<BasisFunctionStrategy> basisFunctionStrategy_;
diff --git a/include/solver/monte_carlo/mc_asian.h b/include/solver/monte_carlo/mc_asian.h
index cd71585..cf374c3 100644
--- a/include/solver/monte_carlo/mc_asian.h
+++ b/include/solver/monte_carlo/mc_asian.h
@@ -1,24 +1,22 @@
 #ifndef MC_ASIAN_H
 #define MC_ASIAN_H
 
-#include "solver/monte_carlo/base_mc_path_dependent.h"
+#include "solver/monte_carlo/base_mc.h"
 #include "option/path_dependent/asian_option.h"
 
 namespace OptionPricer {
 
-    class AsianMCPricer : public PathDependentMCPricer {
+    class AsianMCPricer : public MCPricer {
     public:
         AsianMCPricer(std::shared_ptr<AsianOption> option,
                       std::shared_ptr<IMarketData> marketData,
-                      std::shared_ptr<StockModel> stockModel,
-                      std::shared_ptr<NumberGenerator> generator,
-                      const unsigned int& steps);
+                      std::shared_ptr<StockModel> stockModel);
 
         [[nodiscard]] double calculatePrice(const unsigned long& N) const override;
 
     protected:
         virtual double computeSumPrices(const double& S_t) const = 0;
-        virtual double computeAveragePrice(const double& averagePrice) const = 0;
+        virtual double computeAveragePrice(const double& averagePrice, const unsigned int &steps) const = 0;
 
         std::shared_ptr<AsianOption> option_;
     };
@@ -28,14 +26,11 @@ namespace OptionPricer {
     public:
         ArithmeticAsianMCPricer(std::shared_ptr<ArithmeticAsianOption> option,
                                 std::shared_ptr<IMarketData> marketData,
-                                std::shared_ptr<StockModel> stockModel,
-                                std::shared_ptr<NumberGenerator> generator,
-                                const unsigned int& steps);
+                                std::shared_ptr<StockModel> stockModel);
 
     private:
         double computeSumPrices(const double& S_t) const override;
-
-        double computeAveragePrice(const double& averagePrice) const override;
+        double computeAveragePrice(const double& averagePrice, const unsigned int &steps) const override;
     };
 
 
@@ -43,14 +38,11 @@ namespace OptionPricer {
     public:
         GeometricAsianMCPricer(std::shared_ptr<GeometricAsianOption> option,
                                std::shared_ptr<IMarketData> marketData,
-                               std::shared_ptr<StockModel> stockModel,
-                               std::shared_ptr<NumberGenerator> generator,
-                               const unsigned int& steps);
+                               std::shared_ptr<StockModel> stockModel);
 
     private:
         double computeSumPrices(const double& S_t) const override;
-
-        double computeAveragePrice(const double& averagePrice) const override;
+        double computeAveragePrice(const double& averagePrice, const unsigned int &steps) const override;
     };
 
 }
diff --git a/include/solver/monte_carlo/mc_barrier.h b/include/solver/monte_carlo/mc_barrier.h
index 93a1607..ed24a90 100644
--- a/include/solver/monte_carlo/mc_barrier.h
+++ b/include/solver/monte_carlo/mc_barrier.h
@@ -1,24 +1,22 @@
 #ifndef MC_BARRIER_H
 #define MC_BARRIER_H
 
-#include "solver/monte_carlo/base_mc_path_dependent.h"
+#include "solver/monte_carlo/base_mc.h"
 #include "option/path_dependent/barrier_option.h"
 
 namespace OptionPricer {
 
-    class BarrierMCPricer : public PathDependentMCPricer {
+    class BarrierMCPricer : public MCPricer {
     public:
         BarrierMCPricer(std::shared_ptr<BarrierOption> option,
                         std::shared_ptr<IMarketData> marketData,
-                        std::shared_ptr<StockModel> stockModel,
-                        std::shared_ptr<NumberGenerator> generator,
-                        const unsigned int& steps);
+                        std::shared_ptr<StockModel> stockModel);
 
         [[nodiscard]] double calculatePrice(const unsigned long& N) const override;
 
     protected:
         virtual bool checkHasCrossed(const double& S_t, bool& hasCrossed) const = 0;
-        virtual double computePayoff(const double& S_t, const bool& hasCrossed) const = 0;
+        virtual double computePayoff(const double& S_T, const bool& hasCrossed) const = 0;
 
         std::shared_ptr<BarrierOption> option_;
     };
@@ -27,26 +25,22 @@ namespace OptionPricer {
     public:
         KnockInBarrierMCPricer(std::shared_ptr<KnockInBarrierOption> option,
                                std::shared_ptr<IMarketData> marketData,
-                               std::shared_ptr<StockModel> stockModel,
-                               std::shared_ptr<NumberGenerator> generator,
-                               const unsigned int& steps);
+                               std::shared_ptr<StockModel> stockModel);
 
     protected:
         bool checkHasCrossed(const double& S_t, bool& hasCrossed) const override;
-        double computePayoff(const double& S_t, const bool& hasCrossed) const override;
+        double computePayoff(const double& S_T, const bool& hasCrossed) const override;
     };
 
     class KnockOutBarrierMCPricer final: public BarrierMCPricer {
     public:
         KnockOutBarrierMCPricer(std::shared_ptr<KnockOutBarrierOption> option,
                                 std::shared_ptr<IMarketData> marketData,
-                                std::shared_ptr<StockModel> stockModel,
-                                std::shared_ptr<NumberGenerator> generator,
-                                const unsigned int& steps);
+                                std::shared_ptr<StockModel> stockModel);
 
     protected:
         bool checkHasCrossed(const double& S_t, bool& hasCrossed) const override;
-        double computePayoff(const double& S_t, const bool& hasCrossed) const override;
+        double computePayoff(const double& S_T, const bool& hasCrossed) const override;
     };
 
 }
diff --git a/include/solver/monte_carlo/mc_lookback.h b/include/solver/monte_carlo/mc_lookback.h
index deafeb1..a06bca6 100644
--- a/include/solver/monte_carlo/mc_lookback.h
+++ b/include/solver/monte_carlo/mc_lookback.h
@@ -1,23 +1,21 @@
 #ifndef MC_LOOKBACK_H
 #define MC_LOOKBACK_H
 
-#include "solver/monte_carlo/base_mc_path_dependent.h"
+#include "solver/monte_carlo/base_mc.h"
 #include "option/path_dependent/lookback_option.h"
 
 namespace OptionPricer {
 
-        class LookbackMCPricer : public PathDependentMCPricer {
+        class LookbackMCPricer : public MCPricer {
         public:
             LookbackMCPricer(std::shared_ptr<LookbackOption> option,
                              std::shared_ptr<IMarketData> marketData,
-                             std::shared_ptr<StockModel> stockModel,
-                             std::shared_ptr<NumberGenerator> generator,
-                             const unsigned int& steps);
+                             std::shared_ptr<StockModel> stockModel);
 
             [[nodiscard]] double calculatePrice(const unsigned long& N) const override;
 
         protected:
-            virtual double computePayoff(const double& S_t, const double& S_min, const double& S_max) const = 0;
+            virtual double computePayoff(const double& S_T, const double& S_min, const double& S_max) const = 0;
             std::shared_ptr<LookbackOption> option_;
     };
 
@@ -25,24 +23,20 @@ namespace OptionPricer {
     public:
         FloatingStrikeLookbackMCPricer(std::shared_ptr<FloatingStrikeLookbackOption> option,
                                        std::shared_ptr<IMarketData> marketData,
-                                       std::shared_ptr<StockModel> stockModel,
-                                       std::shared_ptr<NumberGenerator> generator,
-                                       const unsigned int& steps);
+                                       std::shared_ptr<StockModel> stockModel);
 
     private:
-        double computePayoff(const double& S_t, const double& S_min, const double& S_max) const override;
+        double computePayoff(const double& S_T, const double& S_min, const double& S_max) const override;
     };
 
     class FixedStrikeLookbackMCPricer : public LookbackMCPricer {
     public:
         FixedStrikeLookbackMCPricer(std::shared_ptr<FixedStrikeLookbackOption> option,
                                     std::shared_ptr<IMarketData> marketData,
-                                    std::shared_ptr<StockModel> stockModel,
-                                    std::shared_ptr<NumberGenerator> generator,
-                                    const unsigned int& steps);
+                                    std::shared_ptr<StockModel> stockModel);
 
     private:
-        double computePayoff(const double& S_t, const double& S_min, const double& S_max) const override;
+        double computePayoff(const double& S_T, const double& S_min, const double& S_max) const override;
     };
 
 }
diff --git a/include/solver/monte_carlo/mc_single_path.h b/include/solver/monte_carlo/mc_single_path.h
index f8683cf..b87ae04 100644
--- a/include/solver/monte_carlo/mc_single_path.h
+++ b/include/solver/monte_carlo/mc_single_path.h
@@ -10,8 +10,7 @@ namespace OptionPricer {
     public:
         SinglePathMCPricer(std::shared_ptr<SinglePathOption> option,
                            std::shared_ptr<IMarketData> marketData,
-                           std::shared_ptr<StockModel> stockModel,
-                           std::shared_ptr<NumberGenerator> generator);
+                           std::shared_ptr<StockModel> stockModel);
 
         ~SinglePathMCPricer() override = default;
 
diff --git a/main.cpp b/main.cpp
index 8111d31..b568e58 100644
--- a/main.cpp
+++ b/main.cpp
@@ -20,10 +20,15 @@
 #include "random/distribution/standard_normal_distribution.h"
 #include "random/number_generator/sobol_quasi_random_generator.h"
 #include <Eigen/Dense>
-#include <gtest/internal/gtest-param-util.h>
-#include <random/number_generator/random_generator.h>
+#include <model/heston_model.h>
+#include <model/kou_model.h>
+#include <model/merton_jump_diffusion_model.h>
+#include <model/variance_gamma_model.h>
+#include <model/discretization/milstein_cir_discretization.h>
+#include <solver/monte_carlo/mc_single_path.h>
 #include <solver/monte_carlo/basis_function/chebyshev.h>
 #include <solver/monte_carlo/basis_function/laguerre.h>
+#include <solver/monte_carlo/builder/mc_builder_single_path.h>
 #include <solver/monte_carlo/regression/lasso.h>
 #include <solver/monte_carlo/regression/ridge.h>
 #include "solver/monte_carlo/basis_function/legendre.h"
@@ -36,8 +41,29 @@ int main() {
     double K = 100.0;
     double S = 100.0;
     double sigma = 0.15;
-    double r = 0.03;
-    int dim = 150;
+    double r = 0.0319;
+    int dim = 100;
+
+    // Heston parameters
+    double kappa = 6.21;
+    double theta = 0.019;
+    double sigma_v = 0.61;
+    double rho = -0.7;
+    double v0 = 0.010201;
+
+    // Merton paremeters
+    double lambda = 0.1;  // 10% chance of a jump each time step
+    double muJ = -0.05;   // Mean jump size (5% downwards)
+    double sigmaJ = 0.2;  // Jump size volatility
+
+    // Kou parameters
+    double eta1 = 5.0;
+    double eta2 = 7.0;
+    double p = 0.5;
+
+    // Variance Gamma parameters
+    double thetaGamma = -0.05;
+    double nu = 0.5;
 
     auto marketData = MarketData::getInstance();
     marketData->addStock(ticker, S, sigma);
@@ -48,42 +74,79 @@ int main() {
     params.setParameter("T", T);
     params.setParameter("K", K);
 
-    auto normal = std::make_shared<StandardNormalDistribution>();
-    auto generator = std::make_shared<SobolGenerator>(normal, dim);
-    auto brownianMotion = std::make_shared<GeometricBrownianMotionModel>(ticker, marketData);
-    auto laguerre = std::make_shared<LaguerreBasisFunction>(4);
+    auto generator = std::make_shared<SobolGenerator>(dim);
+    auto prng = std::make_shared<PseudoRandomNumberGenerator>(dim);
+    auto geometricBrownianMotion = std::make_shared<GeometricBrownianMotionModel>(ticker, marketData, generator);
+    auto heston = std::make_shared<HestonModel>(ticker, marketData, prng, kappa, theta, sigma_v, rho, v0);
+    auto merton = std::make_shared<MertonJumpDiffusionModel>(ticker, marketData, prng, lambda, muJ, sigmaJ);
+    auto kou = std::make_shared<KouModel>(ticker, marketData, prng, lambda, p, eta1, eta2);
+    auto vg = std::make_shared<VarianceGammaModel>(ticker, marketData, prng, sigma, nu, thetaGamma);
+    auto laguerre = std::make_shared<LaguerreBasisFunction>(3);
     auto regression = std::make_shared<LeastSquaresRegression>();
 
     AmericanOptionFactory factory;
-    auto put = factory.createPutOption(params);
+    auto americanPut = factory.createPutOption(params);
 
-    auto pricer = std::make_unique<AmericanMCPricer>(put, marketData, brownianMotion, generator, laguerre, regression, dim);
     AmericanMCBuilder builder;
-    auto americanPricer = builder.setOption(put)
-    .setSteps(dim)
-    .setNumberGenerator(generator).build();
+    auto americanPricer = builder.setOption(americanPut)
+                                 .setBasisFunctionStrategy(laguerre)
+                                 .setStockPriceModel(heston)
+                                 .build();
+
+    EuropeanOptionFactory factoryEuropean;
+    auto europeanCall = factoryEuropean.createCallOption(params);
+
+    MCSinglePathBuilder singlePathBuilder;
+    auto singlePathPricer = singlePathBuilder.setOption(europeanCall).setStockPriceModel(merton).build();
 
     MCSolver mcSolver;
-    mcSolver.setN(200000);
-    mcSolver.setPricer(std::move(pricer));
+    mcSolver.setN(100000);
+    mcSolver.setPricer(std::move(singlePathPricer));
 
+    /*
     std::cout << "S = 100, dim = 50, P = ";
     std::cout << mcSolver.solve() << "\n";
+    */
+
+
+    for (int i = 0; i < 20; i++) {
+        std::cout << "Price at T Merton: " << merton->simulatePriceAtMaturity(T) << std::endl;
+    }
+
+    for (int i = 0; i < 20; i++) {
+        std::cout << "Price at T Kou: " << kou->simulatePriceAtMaturity(T)<< std::endl;
+    }
+
+    for (int i = 0; i < 20; i++) {
+        std::cout << "Price at T VG: " << vg->simulatePriceAtMaturity(T)<< std::endl;
+    }
+
+
+
+    /*
+    std::cout << "S = 100, dim = 50, P = ";
+    std::cout << mcSolver.solve() << "\n";
+    */
 
+
+    return 0;
+    /*
     marketData->updateStockPrice(ticker, 90);
     auto americanPricer2 = builder.build();
     mcSolver.setPricer(std::move(americanPricer2));
 
     std::cout << "S = 90, dim = 50, P = ";
     std::cout << mcSolver.solve() << "\n";
-
+    return 0;
+    */
+    /*
     marketData->updateStockPrice(ticker, 110);
     auto americanPricer3 = builder.build();
 
     mcSolver.setPricer(std::move(americanPricer3));
     std::cout << "S = 110, dim = 50, P = ";
     std::cout << mcSolver.solve() << "\n";
-
+    */
     /*
     dim = 100;
     marketData->updateStockPrice("AAPL", 100);
@@ -109,111 +172,4 @@ int main() {
     std::cout << mcSolver.solve() << "\n";
     */
 
-    return 0;
-
-    /*
-    AmericanOptionFactory factory;
-    FloatingStrikeLookbackOptionFactory factory2;
-    KnockOutBarrierOptionFactory factory3;
-    auto call = factory.createCallOption(params);
-    auto call2 = factory2.createCallOption(params);
-    auto call3 = factory3.createCallOption(params);
-
-    auto mcStrategy = std::make_unique<AmericanMCStrategy>(call, brownianMotion, generator, marketData, dim);
-    auto mcStrategy2 = std::make_unique<FloatingStrikeLookbackMCStrategy>(call2, brownianMotion, generator, marketData, dim);
-    auto mcStrategy3 = std::make_unique<KnockOutMCStrategy>(call3, brownianMotion, generator, marketData, dim);
-
-
-    MCSolver mcSolver;
-    mcSolver.setN(100000);
-    mcSolver.setStrategy(std::move(mcStrategy));
-
-    std::cout << mcSolver.solve() << "\n";
-
-    mcSolver.setStrategy(std::move(mcStrategy2));
-    std::cout << mcSolver.solve() << "\n";
-
-    mcSolver.setStrategy(std::move(mcStrategy3));
-    std::cout << mcSolver.solve() << "\n";
-
-
-    //std::vector<unsigned long> Ns = {100, 1000, 10000, 100000, 1000000, 10000000};
-    */
-
-
-    /*
-    std::cout << "Crude MC Call:" << std::endl;
-    for (const auto& N : Ns) {
-        mcSolver.setN(N);
-        auto mcStrategy = std::make_unique<SinglePathMCStrategy>(call, brownianMotion, generator, marketData);
-        mcSolver.setStrategy(std::move(mcStrategy));
-        std::cout << "N = " << N << ", Price: " << mcSolver.solve() << "\n";
-    }
-
-    auto put = factory.createPutOption(params);
-
-    std::cout << "Crude MC Put:" << std::endl;
-    for (const auto& N : Ns) {
-        mcSolver.setN(N);
-        auto mcStrategy = std::make_unique<SinglePathMCStrategy>(put, brownianMotion, generator, marketData);
-        mcSolver.setStrategy(std::move(mcStrategy));
-        std::cout << "N = " << N << ", Price: " << mcSolver.solve() << "\n";
-    }
-
-    auto generator2 = std::make_shared<SobolGenerator>(normal);
-
-    std::cout << "Quasi MC Sobol:" << std::endl;
-    for (const auto& N : Ns) {
-        mcSolver.setN(N);
-        auto mcStrategy = std::make_unique<SinglePathMCStrategy>(call, brownianMotion, generator2, marketData);
-        mcSolver.setStrategy(std::move(mcStrategy));
-        std::cout << "N = " << N << ", Price: " << mcSolver.solve() << "\n";
-    }
-
-    auto generator3 = std::make_shared<FaureGenerator>(normal);
-
-    std::cout << "Quasi MC Faure:" << std::endl;
-    for (const auto& N : Ns) {
-        mcSolver.setN(N);
-        auto mcStrategy = std::make_unique<SinglePathMCStrategy>(call, brownianMotion, generator3, marketData);
-        mcSolver.setStrategy(std::move(mcStrategy));
-        std::cout << "N = " << N << ", Price: " << mcSolver.solve() << "\n";
-    }
-
-    return 0;
-
-    */
-
-    /*
-auto mcStrategy = std::make_unique<SinglePathMCStrategy>(eurCall, brownianMotion, generator, marketData);
-mcSolver.setStrategy(std::move(mcStrategy));
-std::cout << "Crude: " << mcSolver.solve() << "\n";
-
-auto generator2 = std::make_shared<FaureGenerator>(normal);
-mcStrategy = std::make_unique<SinglePathMCStrategy>(eurCall, brownianMotion, generator2, marketData);
-mcSolver.setStrategy(std::move(mcStrategy));
-std::cout << "Faure: " << mcSolver.solve() << "\n";
-*/
-
-    /*
-    auto marketData = MarketData::getInstance();
-    marketData->addStock("AAPL", 120.0, 0.2);
-
-    ParameterObject params;
-    params.setParameter("ticker", "AAPL");
-    params.setParameter("T", 1.0);
-    params.setParameter("K1", 100.0);
-    params.setParameter("K2", 120.0);
-
-    DoubleDigitalOptionFactory factory;
-    try {
-        auto option = factory.createCallOption(params);
-    } catch (const std::exception& e) {
-        std::cerr << e.what();
-    }
-    std::cout << "ded";
-
-    */
-
-
 }
\ No newline at end of file
diff --git a/simplified_project_struct.txt b/simplified_project_struct.txt
index c8920c4..60f37b3 100644
--- a/simplified_project_struct.txt
+++ b/simplified_project_struct.txt
@@ -47,7 +47,7 @@
 │   │       ├── base_generator.cpp
 │   │       ├── base_quasi_random_generator.cpp
 │   │       ├── faure_quasi_random_generator.cpp
-│   │       ├── random_generator.cpp
+│   │       ├── pseudo_random_generator.cpp
 │   │       └── sobol_quasi_random_generator.cpp
 │   └── solver
 │       ├── base_solver.cpp
diff --git a/src/model/base_model.cpp b/src/model/base_model.cpp
index bfe167f..204383b 100644
--- a/src/model/base_model.cpp
+++ b/src/model/base_model.cpp
@@ -2,11 +2,26 @@
 
 namespace OptionPricer {
 
-    StockModel::StockModel(const std::string &ticker, std::shared_ptr<IMarketData> marketData)
-    : ticker_(ticker), marketData_(std::move(marketData)) {
+    StockModel::StockModel(const std::string &ticker, std::shared_ptr<IMarketData> marketData,
+                           std::shared_ptr<NumberGenerator> generator)
+    : ticker_(ticker), marketData_(std::move(marketData)), generator_(std::move(generator)) {
         stockData_ = marketData_->getStockData(ticker);
     }
 
     StockModel::~StockModel() = default;
 
-}
\ No newline at end of file
+    unsigned int StockModel::getSteps() const {
+        return generator_->getDim();
+    }
+
+    std::shared_ptr<NumberGenerator> StockModel::getGenerator() const {
+            return generator_;
+    }
+
+    double StockModel::simulatePriceBackward(const double &S_next,
+                                             const double &t_j,
+                                             const double &t_jp1) const {
+        throw std::logic_error("Backward simulation not supported for this model.");
+    }
+
+}
diff --git a/src/model/discretization/base_cir_discretization.cpp b/src/model/discretization/base_cir_discretization.cpp
new file mode 100644
index 0000000..5e1ad8e
--- /dev/null
+++ b/src/model/discretization/base_cir_discretization.cpp
@@ -0,0 +1,7 @@
+#include "model/discretization/base_cir_discretization.h"
+
+namespace OptionPricer {
+
+    CIRDiscretization::~CIRDiscretization() = default;
+
+}
diff --git a/src/model/discretization/explicit_euler_cir_discretization.cpp b/src/model/discretization/explicit_euler_cir_discretization.cpp
new file mode 100644
index 0000000..82779e1
--- /dev/null
+++ b/src/model/discretization/explicit_euler_cir_discretization.cpp
@@ -0,0 +1,13 @@
+#include "model/discretization/explicit_euler_cir_discretization.h"
+
+namespace OptionPricer {
+
+    double CIRExplicitEulerDiscretization::apply(const double &v, const double &dt,
+                                                 const double &kappa, const double &theta,
+                                                 const double &sigma_v, const double &z) const {
+        // Apply Full Truncation
+        const double vMax = std::max(v, 0.0);
+        return v + kappa * (theta-vMax) * dt + sigma_v * sqrt(vMax*dt) * z;
+    }
+
+}
diff --git a/src/model/discretization/milstein_cir_discretization.cpp b/src/model/discretization/milstein_cir_discretization.cpp
new file mode 100644
index 0000000..c559e63
--- /dev/null
+++ b/src/model/discretization/milstein_cir_discretization.cpp
@@ -0,0 +1,15 @@
+#include "model/discretization/milstein_cir_discretization.h"
+
+namespace OptionPricer {
+    double CIRMilsteinDiscretization::apply(const double &v, const double &dt,
+                                            const double &kappa, const double &theta,
+                                            const double &sigma_v, const double &z) const {
+        // Apply Explicit Euler first
+        double vNew = CIRExplicitEulerDiscretization::apply(v, dt, kappa, theta, sigma_v, z);
+
+        // Add the Milstein correction term
+        vNew += 0.25 * sigma_v*sigma_v * dt * (z*z - 1);
+
+        return vNew;
+    }
+}
diff --git a/src/model/gbm_model.cpp b/src/model/gbm_model.cpp
index 53349fc..cf295f5 100644
--- a/src/model/gbm_model.cpp
+++ b/src/model/gbm_model.cpp
@@ -1,21 +1,51 @@
 #include "model/gbm_model.h"
 
+#include <random/distribution/standard_normal_distribution.h>
+
 namespace OptionPricer {
 
-    GeometricBrownianMotionModel::GeometricBrownianMotionModel(const std::string &ticker, std::shared_ptr<IMarketData> marketData)
-    : StockModel(ticker, std::move(marketData)) {}
+    GeometricBrownianMotionModel::~GeometricBrownianMotionModel() = default;
 
-    // NEED TO ADD COUPON
-    double GeometricBrownianMotionModel::simulatePriceAtMaturity(const double &T, const double &z) const {
-        const double drift = (marketData_->getR() - (0.5 * stockData_->getSigma()*stockData_->getSigma())) * T;
-        const double diffusion = stockData_->getSigma() * sqrt(T) * z;
-        return stockData_->getPrice() * exp(drift+diffusion);
+    double GeometricBrownianMotionModel::simulatePriceAtMaturity(const double &T) const {
+        return simulatePrices(T).back();
     }
 
-    double GeometricBrownianMotionModel::simulateStepPrice(const double &dt, const double &z) const  {
-        const double drift = (marketData_->getR() - (0.5 * stockData_->getSigma()*stockData_->getSigma())) * dt;
-        const double diffusion = stockData_->getSigma() * sqrt(dt) * z;
-        return exp(drift+diffusion);
+    std::vector<double> GeometricBrownianMotionModel::simulatePrices(const double& T) const {
+        double S = stockData_->getPrice();
+        const double sigma = stockData_->getSigma();
+        const double r = marketData_->getR();
+        const double c = stockData_->getCoupon().value_or(0.0);
+        const auto steps = getSteps();
+        const double dt = T / static_cast<double>(steps);
+        StandardNormalDistribution snd;
+
+        std::vector<double> prices(steps);
+        for (int t = 0; t < steps; ++t) {
+            const double z = (*generator_)(snd);
+            const double drift = (r - c - (0.5 * sigma*sigma)) * dt;
+            const double diffusion = sigma * sqrt(dt) * z;
+
+            S *= exp(drift + diffusion);
+            prices[t] = S;
+        }
+
+        return prices;
+    }
+
+    double GeometricBrownianMotionModel::simulatePriceBackward(const double& S_next,
+                                                               const double& t_j,
+                                                               const double& t_jp1) const {
+        const double sigma = stockData_->getSigma();
+        const double S = stockData_->getPrice();
+        const double X_next = log(S_next / S);
+
+        StandardNormalDistribution snd;
+        const double z = (*generator_)(snd);
+
+        // Use the Brownian Bridge interpolation formula
+        const double X_curr = (t_j/t_jp1) * X_next + sqrt(t_j * (t_jp1-t_j)/t_jp1) * sigma * z;
+
+        return S * exp(X_curr);
     }
 
-}
+}
\ No newline at end of file
diff --git a/src/model/heston_model.cpp b/src/model/heston_model.cpp
new file mode 100644
index 0000000..7a20e4d
--- /dev/null
+++ b/src/model/heston_model.cpp
@@ -0,0 +1,76 @@
+#include "model/heston_model.h"
+#include "model/discretization/explicit_euler_cir_discretization.h"
+#include "random/distribution/standard_normal_distribution.h"
+#include <iostream>
+
+namespace OptionPricer {
+    HestonModel::HestonModel(const std::string& ticker,
+                             std::shared_ptr<IMarketData> marketData,
+                             std::shared_ptr<NumberGenerator> generator,
+                             const double& kappa, const double& theta,
+                             const double& sigma_v, const double& rho, const double& v0,
+                             std::shared_ptr<CIRDiscretization> varDiscretization)
+        : StockModel(ticker, std::move(marketData), std::move(generator)),
+          kappa_(kappa), theta_(theta), sigma_v_(sigma_v), rho_(rho), v0_(v0),
+          varDiscretization_(std::move(varDiscretization))  {
+        if (rho_ < -1.0 || rho_ > 1.0) {
+            throw std::logic_error("Correlation rho must be between [-1,1]");
+        }
+        if (v0_ < 0.0 || sigma_v < 0.0) {
+            throw std::logic_error("Initial volatility v0 and vol of vol sigma_v must be non-negative");
+        }
+    /*
+        if (2*kappa_*theta_ <= sigma_v_*sigma_v_) {
+            throw std::logic_error("Feller's condition not satisfied.\n"
+                                    "Please try again by ensuring 2*kappa*theta > sigma_v*sigma_v");
+        }
+        */
+
+        // Apply default discretization if nullptr is passed
+        if (!varDiscretization) {
+            varDiscretization_ = std::make_shared<CIRExplicitEulerDiscretization>();
+        }
+    }
+
+    HestonModel::~HestonModel() = default;
+
+    double HestonModel::simulatePriceAtMaturity(const double& T) const {
+        return simulatePrices(T).back();
+    }
+
+    std::vector<double> HestonModel::simulatePrices(const double& T) const {
+        double S = stockData_->getPrice();
+        double v = v0_;
+        const double r = marketData_->getR();
+        const double c = stockData_->getCoupon().value_or(0.0);
+        const auto steps = getSteps();
+        const double dt = T / static_cast<double>(steps);
+        StandardNormalDistribution snd;
+
+        std::vector<double> prices(steps);
+
+        // Compute S(1) using v(0)
+        const double z = (*generator_)(snd);
+        prices[0] = S * exp((r - c - 0.5*v) * dt + sqrt(v*dt) * z);
+
+        // Compute S(t+1) using v(t)
+        for (int t = 1; t < steps; ++t) {
+            const double z1 = (*generator_)(snd);  // For the stock price
+            double z2 = (*generator_)(snd);  // For the variance
+            // Apply correlation between the Brownian motions
+            z2 = rho_ * z1 + sqrt(1 - rho_*rho_) * z2;
+
+            // Apply discretization scheme to the variance process (CIR process)
+            v = varDiscretization_->apply(v, dt, kappa_, theta_, sigma_v_, z2);
+
+            // Stock price process
+            const double vMax = std::max(v, 0.0);
+            const double drift = (r - c - 0.5*vMax) * dt;
+            const double diffusion = sqrt(vMax*dt) * z1;
+
+            prices[t] = prices[t-1] * exp(drift + diffusion);
+        }
+
+        return prices;
+    }
+}
diff --git a/src/model/kou_model.cpp b/src/model/kou_model.cpp
new file mode 100644
index 0000000..77f2627
--- /dev/null
+++ b/src/model/kou_model.cpp
@@ -0,0 +1,75 @@
+#include "model/kou_model.h"
+#include <random/distribution/continuous_uniform_distrib.h>
+#include <random/distribution/exponential_distr.h>
+#include <random/distribution/poisson_distrib.h>
+#include <random/distribution/standard_normal_distribution.h>
+
+namespace OptionPricer {
+
+    KouModel::KouModel(const std::string &ticker,
+                       std::shared_ptr<IMarketData> marketData,
+                       std::shared_ptr<NumberGenerator> generator,
+                       const double &lambda, const double &p,
+                       const double &eta1, const double &eta2)
+    : StockModel(ticker, std::move(marketData), std::move(generator)),
+              lambda_(lambda), p_(p), eta1_(eta1), eta2_(eta2) {
+        if (p_ < 0 || p_ > 1)
+            throw std::invalid_argument("p must be between [0,1].");
+        if (eta1_ < 1)
+            throw std::invalid_argument("eta1 must be between larger than 1.");
+        if (eta2_ < 0)
+            throw std::invalid_argument("eta2 must be between larger than 0.");
+
+    }
+
+    KouModel::~KouModel() = default;
+
+    double KouModel::simulatePriceAtMaturity(const double &T) const {
+        return simulatePrices(T).back();
+    }
+
+    std::vector<double> KouModel::simulatePrices(const double &T) const {
+        double S = stockData_->getPrice();
+        const double sigma = stockData_->getSigma();
+        const double r = marketData_->getR();
+        const double c = stockData_->getCoupon().value_or(0.0);
+        const auto steps = getSteps();
+        const double dt = T / static_cast<double>(steps);
+
+        StandardNormalDistribution snDist;
+        PoissonDistribution poissonDist(lambda_ * dt);
+        ContinuousUniformDistribution uniformDist;
+        ExponentialDistribution exponentialDistUp(eta1_);
+        ExponentialDistribution exponentialDistDown(eta2_);
+
+        std::vector<double> prices(steps);
+        for (int t = 0; t < steps; ++t) {
+            // Drift Part
+            const double drift = (r - c - 0.5 * sigma*sigma) * dt;
+
+            // Diffusion part: Standard Brownian Motion
+            const double z = (*generator_)(snDist);
+            const double diffusion = sigma * sqrt(dt) * z;
+
+            // Jump part: Compound Poisson process
+            const int jumpCount = static_cast<int>((*generator_)(poissonDist));
+            double jumpSize = 0.0;
+            for (int j = 0; j < jumpCount; ++j) {
+                const double U = (*generator_)(uniformDist);
+                if (U < p_) {
+                    const double upsideJump = (*generator_)(exponentialDistUp);
+                    jumpSize += upsideJump;
+                }
+                const double downsideJump = -(*generator_)(exponentialDistDown);
+                jumpSize += downsideJump;
+            }
+
+            // Update stock price
+            S *= exp(drift + diffusion + jumpSize);
+            prices[t] = S;
+        }
+
+        return prices;
+    }
+
+}
diff --git a/src/model/merton_jump_diffusion_model.cpp b/src/model/merton_jump_diffusion_model.cpp
new file mode 100644
index 0000000..2007e55
--- /dev/null
+++ b/src/model/merton_jump_diffusion_model.cpp
@@ -0,0 +1,62 @@
+#include "model/merton_jump_diffusion_model.h"
+
+#include <iostream>
+#include <random/distribution/normal_distrib.h>
+#include <random/distribution/poisson_distrib.h>
+#include <random/distribution/standard_normal_distribution.h>
+
+namespace OptionPricer {
+
+    MertonJumpDiffusionModel::MertonJumpDiffusionModel(const std::string &ticker,
+                                                       std::shared_ptr<IMarketData> marketData,
+                                                       std::shared_ptr<NumberGenerator> generator,
+                                                       const double &lambda, const double &muJ, const double &sigmaJ)
+        : StockModel(ticker, std::move(marketData), std::move(generator)),
+        lambda_(lambda), muJ_(muJ), sigmaJ_(sigmaJ) {
+        if (sigmaJ_ <= 0)
+            throw std::invalid_argument("sigmaJ must be positive");
+    }
+
+    MertonJumpDiffusionModel::~MertonJumpDiffusionModel() = default;
+
+    double MertonJumpDiffusionModel::simulatePriceAtMaturity(const double &T) const {
+        return simulatePrices(T).back();
+    }
+
+    std::vector<double> MertonJumpDiffusionModel::simulatePrices(const double &T) const {
+        double S = stockData_->getPrice();
+        const double sigma = stockData_->getSigma();
+        const double r = marketData_->getR();
+        const double c = stockData_->getCoupon().value_or(0.0);
+        const auto steps = getSteps();
+        const double dt = T / static_cast<double>(steps);
+
+        StandardNormalDistribution snDist;
+        PoissonDistribution poissonDist(lambda_ * dt);
+        NormalDistribution jumpDist(muJ_, sigmaJ_);
+
+        std::vector<double> prices(steps);
+        for (int t = 0; t < steps; ++t) {
+            // Drift Part
+            const double drift = (r - c - 0.5 * sigma*sigma) * dt;
+
+            // Diffusion part: Standard Brownian Motion
+            const double z = (*generator_)(snDist);
+            const double diffusion = sigma * sqrt(dt) * z;
+
+            // Jump part: Compound Poisson process
+            const int jump_count = static_cast<int>((*generator_)(poissonDist)); // Number of jumps in this step
+            double jumpSize = 0.0;
+            for (int j = 0; j < jump_count; ++j) {
+                jumpSize += (*generator_)(jumpDist); // Add all jump sizes to the stock price
+            }
+
+            // Update stock price
+            S *= exp(drift + diffusion + jumpSize);
+            prices[t] = S;
+        }
+
+        return prices;
+    }
+
+}
diff --git a/src/model/variance_gamma_model.cpp b/src/model/variance_gamma_model.cpp
new file mode 100644
index 0000000..b54e245
--- /dev/null
+++ b/src/model/variance_gamma_model.cpp
@@ -0,0 +1,55 @@
+#include "model/variance_gamma_model.h"
+
+#include <random/distribution/standard_normal_distribution.h>
+
+#include "random/distribution/gamma_distrib.h"
+#include "random/distribution/normal_distrib.h"
+
+namespace OptionPricer {
+
+    VarianceGammaModel::VarianceGammaModel(const std::string &ticker,
+                                           std::shared_ptr<IMarketData> marketData,
+                                           std::shared_ptr<NumberGenerator> generator,
+                                           const double &sigma, const double &nu, const double &theta)
+        : StockModel(ticker, std::move(marketData), std::move(generator)),
+          sigma_(sigma), nu_(nu), theta_(theta) {
+        if (sigma_ <= 0.0 || nu_ <= 0.0) {
+            throw std::invalid_argument("Sigma and nu must be positive");
+        }
+
+        // Calculate the omega correction term that makes the actualized stock price a martingale
+        omega_ = (1.0 / nu_) * std::log(1.0 - theta_*nu_ - 0.5 * sigma_*sigma_ * nu_);
+    }
+
+    VarianceGammaModel::~VarianceGammaModel() = default;
+
+    double VarianceGammaModel::simulatePriceAtMaturity(const double &T) const {
+        return simulatePrices(T).back();
+    }
+
+    std::vector<double> VarianceGammaModel::simulatePrices(const double &T) const {
+        double S = stockData_->getPrice();
+        const double r = marketData_->getR();
+        const double c = stockData_->getCoupon().value_or(0.0);
+        const auto steps = getSteps();
+        const double dt = T / static_cast<double>(steps);
+
+        StandardNormalDistribution snDist;
+        GammaDistribution gammaDist(dt / nu_, nu_);
+
+        std::vector<double> prices(steps);
+        for (int t = 0; t < steps; ++t) {
+            const double g = (*generator_)(gammaDist); // Gamma subordinator
+            const double z = (*generator_)(snDist);  // Normal distributed increment
+
+            const double drift = (r - c + omega_) * dt;
+            const double VG = theta_ * g + sigma_ * std::sqrt(g) * z;
+
+            S *= std::exp(drift + VG);
+            prices[t] = S;
+        }
+
+        return prices;
+    }
+
+}
diff --git a/src/random/distribution/continuous_uniform_distrib.cpp b/src/random/distribution/continuous_uniform_distrib.cpp
new file mode 100644
index 0000000..ebe5c43
--- /dev/null
+++ b/src/random/distribution/continuous_uniform_distrib.cpp
@@ -0,0 +1,20 @@
+#include "random/distribution/continuous_uniform_distrib.h"
+
+namespace OptionPricer {
+    ContinuousUniformDistribution::ContinuousUniformDistribution(const double &a, const double &b)
+    : a_(a), b_(b) {
+        if (a_ >= b_)
+            throw std::invalid_argument("a must lower than b");
+    }
+
+    ContinuousUniformDistribution::~ContinuousUniformDistribution() = default;
+
+    double ContinuousUniformDistribution::inv_cdf(const double &quantile) const {
+        throw std::logic_error("Inverse CDF for Uniform Distribution not implemented yet.");
+    }
+
+    double ContinuousUniformDistribution::operator()(std::mt19937 &gen) const {
+        return uniform_dist_(gen);
+    }
+
+}
\ No newline at end of file
diff --git a/src/random/distribution/exponential_distr.cpp b/src/random/distribution/exponential_distr.cpp
new file mode 100644
index 0000000..677baaa
--- /dev/null
+++ b/src/random/distribution/exponential_distr.cpp
@@ -0,0 +1,21 @@
+#include "random/distribution/exponential_distr.h"
+
+namespace OptionPricer {
+
+    ExponentialDistribution::ExponentialDistribution(const double &lambda)
+    : lambda_(lambda), exponential_dist_(lambda_) {
+        if (lambda_ <= 0)
+            throw std::invalid_argument("lambda must be positive");
+    }
+
+    ExponentialDistribution::~ExponentialDistribution() = default;
+
+    double ExponentialDistribution::inv_cdf(const double &quantile) const {
+        throw std::logic_error("Inverse CDF for Normal Distribution nor implemented yet.");
+    }
+
+    double ExponentialDistribution::operator()(std::mt19937 &gen) const {
+        return exponential_dist_(gen);
+    }
+
+}
\ No newline at end of file
diff --git a/src/random/distribution/gamma_distrib.cpp b/src/random/distribution/gamma_distrib.cpp
new file mode 100644
index 0000000..e2d871f
--- /dev/null
+++ b/src/random/distribution/gamma_distrib.cpp
@@ -0,0 +1,22 @@
+#include "random/distribution/gamma_distrib.h"
+
+namespace OptionPricer {
+
+    GammaDistribution::GammaDistribution(const double &alpha, const double &beta)
+    : alpha_(alpha), beta_(beta), gamma_dist_(alpha_, 1.0 / beta_) {
+        if (alpha_ <= 0 || beta_ <= 0) {
+            throw std::invalid_argument("alpha (shape) and beta (rate) parameters must be positive");
+        }
+    }
+
+    GammaDistribution::~GammaDistribution() = default;
+
+    double GammaDistribution::inv_cdf(const double &quantile) const {
+        throw std::logic_error("Inverse CDF for Gamma Distribution not implemented yet.");
+    }
+
+    double GammaDistribution::operator()(std::mt19937 &gen) const {
+        return gamma_dist_(gen);
+    }
+
+}
diff --git a/src/random/distribution/normal_distrib.cpp b/src/random/distribution/normal_distrib.cpp
new file mode 100644
index 0000000..9828f7e
--- /dev/null
+++ b/src/random/distribution/normal_distrib.cpp
@@ -0,0 +1,21 @@
+#include "random/distribution/normal_distrib.h"
+
+namespace OptionPricer {
+
+    NormalDistribution::NormalDistribution(const double &mu, const double &sigma)
+    : mu_(mu), sigma_(sigma), normal_dist_(mu_, sigma_) {
+        if (sigma_ <= 0)
+            throw std::invalid_argument("sigma must be positive");
+    }
+
+    NormalDistribution::~NormalDistribution() = default;
+
+    double NormalDistribution::inv_cdf(const double &quantile) const {
+        throw std::logic_error("Inverse CDF for Normal Distribution nor implemented yet.");
+    }
+
+    double NormalDistribution::operator()(std::mt19937 &gen) const {
+        return normal_dist_(gen);
+    }
+
+}
diff --git a/src/random/distribution/poisson_distrib.cpp b/src/random/distribution/poisson_distrib.cpp
new file mode 100644
index 0000000..56938b0
--- /dev/null
+++ b/src/random/distribution/poisson_distrib.cpp
@@ -0,0 +1,22 @@
+#include "random/distribution/poisson_distrib.h"
+
+namespace OptionPricer {
+
+    PoissonDistribution::PoissonDistribution(const double& lambda)
+    : lambda_(lambda), poisson_dist_(lambda_) {
+        if (lambda_ <= 0.0) {
+            throw std::invalid_argument("lambda must be positive");
+        }
+    }
+
+    PoissonDistribution::~PoissonDistribution() = default;
+
+    double PoissonDistribution::inv_cdf(const double &quantile) const {
+        throw std::logic_error("Inverse CDF is not implemented yes for Poisson Distribution");
+    }
+
+    double PoissonDistribution::operator()(std::mt19937 &gen) const {
+        return poisson_dist_(gen);
+    }
+
+}
\ No newline at end of file
diff --git a/src/random/distribution/standard_normal_distribution.cpp b/src/random/distribution/standard_normal_distribution.cpp
index 81c8b7b..d45a22b 100644
--- a/src/random/distribution/standard_normal_distribution.cpp
+++ b/src/random/distribution/standard_normal_distribution.cpp
@@ -1,67 +1,63 @@
 #include "random/distribution/standard_normal_distribution.h"
 
 namespace OptionPricer {
+
     StandardNormalDistribution::StandardNormalDistribution()
-    : normal_dist_(0.0, 1.0) {}
+    : NormalDistribution(0.0, 1.0) {}
 
     StandardNormalDistribution::~StandardNormalDistribution() = default;
 
     double StandardNormalDistribution::inv_cdf(const double &quantile) const {
-            /* This function implements the Beasley-Springer-Moro (BSM) algorithm
-             * for approximating the inverse cumulative distribution function (CDF)
-             * of the standard normal distribution, as described in Glasserman [2004].
-             */
-
-            if (quantile <= 0.0 || quantile >= 1.0) {
-                throw std::invalid_argument("quantile must be between (0,1)");
-            }
-
-            const bool sup = quantile > 0.5;
-            const double up = sup ? 1.0 - quantile : quantile;
-
-            // Coefficients for the rational approximation of the central region
-            static constexpr double a0 = 2.50662823884;
-            static constexpr double a1 = -18.61500062529;
-            static constexpr double a2 = 41.39119773534;
-            static constexpr double a3 = -25.44106049637;
-
-            static constexpr double b0 = -8.47351093090;
-            static constexpr double b1 = 23.08336743743;
-            static constexpr double b2 = -21.06224101826;
-            static constexpr double b3 = 3.13082909833;
-
-            // Coefficients for the polynomial approximation of the tail region
-            static constexpr double c0 = 0.3374754822726147;
-            static constexpr double c1 = 0.9761690190917186;
-            static constexpr double c2 = 0.1607979714918209;
-            static constexpr double c3 = 0.0276438810333863;
-            static constexpr double c4 = 0.0038405729373609;
-            static constexpr double c5 = 0.0003951896511919;
-            static constexpr double c6 = 0.0000321767881768;
-            static constexpr double c7 = 0.0000002888167364;
-            static constexpr double c8 = 0.0000003960315187;
-
-            double x = up - 0.5;
-            double r;
-
-            // Use rational approximation for quantiles in the central right region
-            if (fabs(x) < 0.42) {
-                r = x*x;
-                r = x * (((a3*r + a2)*r + a1)*r + a0) / ((((b3*r + b2)*r + b1)*r + b0)*r + 1.0);
-                return sup ? -r: r;
-            }
-
-            // Use Chebyshev polynomial approximation for quantiles in the right tail
-            r = up;
-            r = log(-log(r));
-            r = c0 + r*(c1 + r*(c2 + r*(c3 + r*(c4 + r*(c5 + r*(c6 + r*(c7 + r*c8)))))));
+        /* This function implements the Beasley-Springer-Moro (BSM) algorithm
+         * for approximating the inverse cumulative distribution function (CDF)
+         * of the standard normal distribution, as described in Glasserman [2004].
+         */
+        if (quantile <= 0.0 || quantile >= 1.0) {
+            throw std::invalid_argument("quantile must be between (0,1)");
+        }
 
-            // Use symmetry property of the standard normal distribution
-            return sup? r: -r;
+        const bool sup = quantile > 0.5;
+        const double up = sup ? 1.0 - quantile : quantile;
+
+        // Coefficients for the rational approximation of the central region
+        static constexpr double a0 = 2.50662823884;
+        static constexpr double a1 = -18.61500062529;
+        static constexpr double a2 = 41.39119773534;
+        static constexpr double a3 = -25.44106049637;
+
+        static constexpr double b0 = -8.47351093090;
+        static constexpr double b1 = 23.08336743743;
+        static constexpr double b2 = -21.06224101826;
+        static constexpr double b3 = 3.13082909833;
+
+        // Coefficients for the polynomial approximation of the tail region
+        static constexpr double c0 = 0.3374754822726147;
+        static constexpr double c1 = 0.9761690190917186;
+        static constexpr double c2 = 0.1607979714918209;
+        static constexpr double c3 = 0.0276438810333863;
+        static constexpr double c4 = 0.0038405729373609;
+        static constexpr double c5 = 0.0003951896511919;
+        static constexpr double c6 = 0.0000321767881768;
+        static constexpr double c7 = 0.0000002888167364;
+        static constexpr double c8 = 0.0000003960315187;
+
+        double x = up - 0.5;
+        double r;
+
+        // Use rational approximation for quantiles in the central right region
+        if (fabs(x) < 0.42) {
+            r = x*x;
+            r = x * (((a3*r + a2)*r + a1)*r + a0) / ((((b3*r + b2)*r + b1)*r + b0)*r + 1.0);
+            return sup ? -r: r;
         }
 
-    double StandardNormalDistribution::operator()(std::mt19937 &gen) {
-        return normal_dist_(gen);
+        // Use Chebyshev polynomial approximation for quantiles in the right tail
+        r = up;
+        r = log(-log(r));
+        r = c0 + r*(c1 + r*(c2 + r*(c3 + r*(c4 + r*(c5 + r*(c6 + r*(c7 + r*c8)))))));
+
+        // Use symmetry property of the standard normal distribution
+        return sup? r: -r;
     }
 
 }
diff --git a/src/random/number_generator/base_generator.cpp b/src/random/number_generator/base_generator.cpp
index 173868a..163f81b 100644
--- a/src/random/number_generator/base_generator.cpp
+++ b/src/random/number_generator/base_generator.cpp
@@ -2,19 +2,29 @@
 
 namespace OptionPricer {
 
-    NumberGenerator::NumberGenerator(std::shared_ptr<Distribution> dist)
-    : dist_(std::move(dist)) {
+    NumberGenerator::NumberGenerator(const unsigned int &dim)
+    : dim_(dim) {
         std::random_device rd;
         seed_ = rd();
     }
 
-    NumberGenerator::NumberGenerator(std::shared_ptr<Distribution> dist, const unsigned int &seed)
-    : dist_(std::move(dist)), seed_(seed) {
+    NumberGenerator::NumberGenerator(const unsigned int &dim, const unsigned int& seed)
+    : dim_(dim), seed_(seed) {
         if (seed_ < 0) {
-            throw std::invalid_argument("seed parameetr must be a positve integer");
+            throw std::invalid_argument("seed parameter must be a positive integer");
         }
     }
 
     NumberGenerator::~NumberGenerator() = default;
 
+    unsigned int NumberGenerator::getDim() const {
+        return dim_;
+    }
+
+    void NumberGenerator::validateDim() const {
+        if (dim_ < 0) {
+            throw std::invalid_argument("dim must be a positive integer");
+        }
+    }
+
 }
diff --git a/src/random/number_generator/base_quasi_random_generator.cpp b/src/random/number_generator/base_quasi_random_generator.cpp
index a2a9991..ee08213 100644
--- a/src/random/number_generator/base_quasi_random_generator.cpp
+++ b/src/random/number_generator/base_quasi_random_generator.cpp
@@ -2,29 +2,16 @@
 
 namespace OptionPricer {
 
-    QuasiRandomNumberGenerator::QuasiRandomNumberGenerator(std::shared_ptr<Distribution> dist,
-                                                           const unsigned int &dim)
-    : NumberGenerator(std::move(dist)), dim_(dim), point_(dim_) {
+    QuasiRandomNumberGenerator::QuasiRandomNumberGenerator(const unsigned int &dim)
+    : NumberGenerator(dim), step_(0), point_(dim_){
         validateDim();
     }
 
-    QuasiRandomNumberGenerator::QuasiRandomNumberGenerator(std::shared_ptr<Distribution> dist,
-                                                           const unsigned int &seed,
-                                                           const unsigned int &dim)
-    : NumberGenerator(std::move(dist), seed), dim_(dim), point_(dim_) {
+    QuasiRandomNumberGenerator::QuasiRandomNumberGenerator(const unsigned int &dim, const unsigned int &seed)
+    : NumberGenerator(dim, seed), step_(0), point_(dim_) {
         validateDim();
     }
 
     QuasiRandomNumberGenerator::~QuasiRandomNumberGenerator() = default;
 
-    unsigned int QuasiRandomNumberGenerator::getDim() const {
-        return dim_;
-    }
-
-    void QuasiRandomNumberGenerator::validateDim() const {
-        if (dim_ < 0) {
-            throw std::invalid_argument("dim must be a positive integer");
-        }
-    }
-
 }
diff --git a/src/random/number_generator/faure_quasi_random_generator.cpp b/src/random/number_generator/faure_quasi_random_generator.cpp
index 3755fe6..0f63a0f 100644
--- a/src/random/number_generator/faure_quasi_random_generator.cpp
+++ b/src/random/number_generator/faure_quasi_random_generator.cpp
@@ -2,29 +2,31 @@
 
 namespace OptionPricer {
 
-    FaureGenerator::FaureGenerator(std::shared_ptr<Distribution> dist, const unsigned int &dim)
-    : QuasiRandomNumberGenerator(std::move(dist), dim), faureQrng_(dim_) {
+    FaureGenerator::FaureGenerator(const unsigned int &dim)
+    : QuasiRandomNumberGenerator(dim), faureQrng_(dim_) {
         faureQrng_.seed(seed_);
+        faureQrng_.generate(point_.begin(), point_.end()); // Initialize the point
     }
 
-    FaureGenerator::FaureGenerator(std::shared_ptr<Distribution> dist,
-                                   const unsigned int &seed,
-                                   const unsigned int &dim)
-    : QuasiRandomNumberGenerator(std::move(dist), seed, dim), faureQrng_(dim_) {
+    FaureGenerator::FaureGenerator(const unsigned int &dim,
+                                   const unsigned int &seed)
+    : QuasiRandomNumberGenerator(dim, seed), faureQrng_(dim_) {
         faureQrng_.seed(seed_);
+        faureQrng_.generate(point_.begin(), point_.end());
     }
 
     FaureGenerator::~FaureGenerator() = default;
 
-    double FaureGenerator::generate(const int &step) {
-        if (step == 0) {
-            // Generate Sobol sequence point
+    double FaureGenerator::operator()(Distribution& dist) const {
+        if (step_ >= dim_) {
             faureQrng_.generate(point_.begin(), point_.end());
+            step_ = 0; // Reset step
         }
 
         // Normalize and transform using the inverse CDF
-        const double uniform_value = point_[step] / static_cast<double>(boost::random::faure::max());
-        return dist_->inv_cdf(uniform_value);
+        const double uniform_value = point_[step_] / static_cast<double>(boost::random::faure::max());
+        ++step_;
+        return dist.inv_cdf(uniform_value);
     }
 
 }
diff --git a/src/random/number_generator/pseudo_random_generator.cpp b/src/random/number_generator/pseudo_random_generator.cpp
new file mode 100644
index 0000000..273b720
--- /dev/null
+++ b/src/random/number_generator/pseudo_random_generator.cpp
@@ -0,0 +1,12 @@
+#include "random/number_generator/pseudo_random_generator.h"
+
+namespace OptionPricer {
+
+    PseudoRandomNumberGenerator::~PseudoRandomNumberGenerator() = default;
+
+    double PseudoRandomNumberGenerator::operator()(Distribution& dist) const {
+        return dist(generator_);
+    }
+
+}
+
diff --git a/src/random/number_generator/random_generator.cpp b/src/random/number_generator/random_generator.cpp
deleted file mode 100644
index b8be9c0..0000000
--- a/src/random/number_generator/random_generator.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#include "random/number_generator/random_generator.h"
-
-namespace OptionPricer {
-
-    RandomNumberGenerator::RandomNumberGenerator(std::shared_ptr<Distribution> dist)
-    : NumberGenerator(std::move(dist)), generator_(seed_) {}
-
-    RandomNumberGenerator::RandomNumberGenerator(std::shared_ptr<Distribution> dist, const unsigned int &seed)
-    : NumberGenerator(std::move(dist), seed), generator_(seed_) {}
-
-    double RandomNumberGenerator::generate(const int &step) {
-        return (*dist_)(generator_);
-    }
-
-}
diff --git a/src/random/number_generator/sobol_quasi_random_generator.cpp b/src/random/number_generator/sobol_quasi_random_generator.cpp
index 976790e..aa0644b 100644
--- a/src/random/number_generator/sobol_quasi_random_generator.cpp
+++ b/src/random/number_generator/sobol_quasi_random_generator.cpp
@@ -2,29 +2,31 @@
 
 namespace OptionPricer {
 
-    SobolGenerator::SobolGenerator(std::shared_ptr<Distribution> dist, const unsigned int &dim)
-    : QuasiRandomNumberGenerator(std::move(dist), dim), sobolQrng_(dim_) {
+    SobolGenerator::SobolGenerator(const unsigned int &dim)
+    : QuasiRandomNumberGenerator(dim), sobolQrng_(dim_) {
         sobolQrng_.seed(seed_);
+        sobolQrng_.generate(point_.begin(), point_.end()); // Initialize the point
     }
 
-    SobolGenerator::SobolGenerator(std::shared_ptr<Distribution> dist,
-                                   const unsigned int &seed,
-                                   const unsigned int &dim)
-    : QuasiRandomNumberGenerator(std::move(dist),seed, dim), sobolQrng_(dim_) {
+    SobolGenerator::SobolGenerator(const unsigned int &dim,
+                                   const unsigned int &seed)
+    : QuasiRandomNumberGenerator(dim, seed), sobolQrng_(dim_) {
         sobolQrng_.seed(seed_);
+        sobolQrng_.generate(point_.begin(), point_.end());
     }
 
     SobolGenerator::~SobolGenerator() = default;
 
-    double SobolGenerator::generate(const int &step) {
-        if (step == 0) {
-            // Generate Sobol sequence point
+    double SobolGenerator::operator()(Distribution& dist) const {
+        if (step_ >= dim_) {
             sobolQrng_.generate(point_.begin(), point_.end());
+            step_ = 0; // Reset step
         }
 
         // Normalize and transform using Moro's inversion
-        const double uniformValue = point_[step] / static_cast<double>(boost::random::sobol::max());
-        return dist_->inv_cdf(uniformValue);
+        const double uniformValue = point_[step_] / static_cast<double>(boost::random::sobol::max());
+        ++step_;  // Increment step after use
+        return dist.inv_cdf(uniformValue);
     }
 
 }
diff --git a/src/solver/monte_carlo/base_mc.cpp b/src/solver/monte_carlo/base_mc.cpp
index 743f053..a3ea4cf 100644
--- a/src/solver/monte_carlo/base_mc.cpp
+++ b/src/solver/monte_carlo/base_mc.cpp
@@ -2,11 +2,8 @@
 
 namespace OptionPricer {
 
-    MCPricer::MCPricer(std::shared_ptr<IMarketData> marketData,
-                       std::shared_ptr<StockModel> stockModel,
-                       std::shared_ptr<NumberGenerator> generator)
-    : marketData_(std::move(marketData)), stockModel_(std::move(stockModel)),
-    generator_(std::move(generator)) {}
+    MCPricer::MCPricer(std::shared_ptr<IMarketData> marketData, std::shared_ptr<StockModel> stockModel)
+    : marketData_(std::move(marketData)), stockModel_(std::move(stockModel)) {}
 
     MCPricer::~MCPricer() = default;
 
diff --git a/src/solver/monte_carlo/base_mc_path_dependent.cpp b/src/solver/monte_carlo/base_mc_path_dependent.cpp
deleted file mode 100644
index a3b6013..0000000
--- a/src/solver/monte_carlo/base_mc_path_dependent.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#include "solver/monte_carlo/base_mc_path_dependent.h"
-#include "random/number_generator/base_quasi_random_generator.h"
-
-
-namespace OptionPricer {
-
-    PathDependentMCPricer::PathDependentMCPricer(std::shared_ptr<IMarketData> marketData,
-                                                 std::shared_ptr<StockModel> stockModel,
-                                                 std::shared_ptr<NumberGenerator> generator,
-                                                 const unsigned int &steps)
-    : MCPricer(std::move(marketData), std::move(stockModel), std::move(generator)),
-              steps_(steps) {
-        if (const auto generatorQR = std::dynamic_pointer_cast<QuasiRandomNumberGenerator>(generator_)) {
-            if (generatorQR->getDim() != steps_) {
-                steps_ = static_cast<int>(generatorQR->getDim());
-                std::cerr << "For PathDependent options, the steps parameter ";
-                std::cerr << "must be equal to the dim of derived QuasiRandomNumberGenerator." << "\n";
-                std::cerr << "steps is thus set to " << generatorQR->getDim() << "\n";
-            }
-        }
-    }
-
-}
diff --git a/src/solver/monte_carlo/builder/base_mc_builder.cpp b/src/solver/monte_carlo/builder/base_mc_builder.cpp
index 9b6a11e..d6e2f01 100644
--- a/src/solver/monte_carlo/builder/base_mc_builder.cpp
+++ b/src/solver/monte_carlo/builder/base_mc_builder.cpp
@@ -1,13 +1,10 @@
 #include "solver/monte_carlo/builder/base_mc_builder.h"
 #include "market_data/market_data.h"
-#include "random/distribution/standard_normal_distribution.h"
-#include "random/number_generator/random_generator.h"
 
 namespace OptionPricer {
 
     MCBuilder::MCBuilder()
-    : marketData_(MarketData::getInstance()), // Default to MarketData Singleton
-      generator_(std::make_shared<RandomNumberGenerator>(std::make_shared<StandardNormalDistribution>())) {}
+    : marketData_(MarketData::getInstance()) {}
 
     MCBuilder::~MCBuilder() = default;
 
@@ -20,10 +17,4 @@ namespace OptionPricer {
         stockModel_ = std::move(stockModel);
         return *this;
     }
-
-    MCBuilder & MCBuilder::setNumberGenerator(std::shared_ptr<NumberGenerator> generator) {
-        generator_ = std::move(generator);
-        return *this;
-    }
-
 }
diff --git a/src/solver/monte_carlo/builder/base_mc_builder_path_dependent.cpp b/src/solver/monte_carlo/builder/base_mc_builder_path_dependent.cpp
deleted file mode 100644
index d23a64a..0000000
--- a/src/solver/monte_carlo/builder/base_mc_builder_path_dependent.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "solver/monte_carlo/builder/base_mc_builder_path_dependent.h"
-
-namespace OptionPricer {
-
-    PathDependentMCBuilder::PathDependentMCBuilder()
-    : MCBuilder(), steps_(52) {}
-
-    PathDependentMCBuilder::~PathDependentMCBuilder() = default;
-
-    PathDependentMCBuilder & PathDependentMCBuilder::setSteps(unsigned int steps) {
-        steps_ = steps;
-        return *this;
-    }
-
-}
-
diff --git a/src/solver/monte_carlo/builder/mc_builder_american.cpp b/src/solver/monte_carlo/builder/mc_builder_american.cpp
index 9338142..96f620e 100644
--- a/src/solver/monte_carlo/builder/mc_builder_american.cpp
+++ b/src/solver/monte_carlo/builder/mc_builder_american.cpp
@@ -3,7 +3,7 @@
 namespace OptionPricer {
 
     AmericanMCBuilder::AmericanMCBuilder()
-    : PathDependentMCBuilder(), regressionStrategy_(std::make_shared<LeastSquaresRegression>()),
+    : MCBuilder(), regressionStrategy_(std::make_shared<LeastSquaresRegression>()),
     basisFunctionStrategy_(std::make_shared<MonomialBasisFunction>(3)) {}
 
     AmericanMCBuilder::~AmericanMCBuilder() = default;
@@ -29,10 +29,12 @@ namespace OptionPricer {
     std::unique_ptr<MCPricer> AmericanMCBuilder::build() {
         if (!option_) throw std::logic_error("Option is not set for AmericanMCBuilder.");
         if (!stockModel_) {
-            stockModel_ = std::make_shared<GeometricBrownianMotionModel>(option_->getID(), marketData_);
+            stockModel_ = std::make_shared<GeometricBrownianMotionModel>(option_->getID(),
+                                                                         marketData_,
+                                                                         std::make_shared<PseudoRandomNumberGenerator>(52));
         }
         return std::make_unique<AmericanMCPricer>(option_, marketData_, stockModel_,
-                                                    generator_, basisFunctionStrategy_, regressionStrategy_, steps_);
+                                                  basisFunctionStrategy_, regressionStrategy_);
     }
 
 }
diff --git a/src/solver/monte_carlo/builder/mc_builder_asian.cpp b/src/solver/monte_carlo/builder/mc_builder_asian.cpp
index 0bf58c4..4087ed6 100644
--- a/src/solver/monte_carlo/builder/mc_builder_asian.cpp
+++ b/src/solver/monte_carlo/builder/mc_builder_asian.cpp
@@ -14,9 +14,11 @@ namespace OptionPricer {
     std::unique_ptr<MCPricer> ArithmeticAsianMCBuilder::build() {
         if (!option_) throw std::logic_error("Option is not set for ArithmeticAsianMCPricerBuilder.");
         if (!stockModel_) {
-            stockModel_ = std::make_shared<GeometricBrownianMotionModel>(option_->getID(), marketData_);
+            stockModel_ = std::make_shared<GeometricBrownianMotionModel>(option_->getID(),
+                                                                         marketData_,
+                                                                         std::make_shared<PseudoRandomNumberGenerator>(52));
         }
-        return std::make_unique<ArithmeticAsianMCPricer>(option_, marketData_, stockModel_, generator_, steps_);
+        return std::make_unique<ArithmeticAsianMCPricer>(option_, marketData_, stockModel_);
     }
 
     // Geometric Asian
@@ -31,9 +33,11 @@ namespace OptionPricer {
     std::unique_ptr<MCPricer> GeometricAsianMCBuilder::build() {
         if (!option_) throw std::logic_error("Option is not set for GeometricAsianMCPricerBuilder.");
         if (!stockModel_) {
-            stockModel_ = std::make_shared<GeometricBrownianMotionModel>(option_->getID(), marketData_);
+            stockModel_ = std::make_shared<GeometricBrownianMotionModel>(option_->getID(),
+                                                                         marketData_,
+                                                                         std::make_shared<PseudoRandomNumberGenerator>(52));
         }
-        return std::make_unique<GeometricAsianMCPricer>(option_, marketData_, stockModel_, generator_, steps_);
+        return std::make_unique<GeometricAsianMCPricer>(option_, marketData_, stockModel_);
     }
 
 }
diff --git a/src/solver/monte_carlo/builder/mc_builder_barrier.cpp b/src/solver/monte_carlo/builder/mc_builder_barrier.cpp
index 132a398..a0cd91a 100644
--- a/src/solver/monte_carlo/builder/mc_builder_barrier.cpp
+++ b/src/solver/monte_carlo/builder/mc_builder_barrier.cpp
@@ -15,9 +15,11 @@ namespace OptionPricer {
     std::unique_ptr<MCPricer> KnockInBarrierMCBuilder::build() {
         if (!option_) throw std::logic_error("Option is not set for KnockInBarrierMCPricerBuilder.");
         if (!stockModel_) {
-            stockModel_ = std::make_shared<GeometricBrownianMotionModel>(option_->getID(), marketData_);
+            stockModel_ = std::make_shared<GeometricBrownianMotionModel>(option_->getID(),
+                                                                         marketData_,
+                                                                         std::make_shared<PseudoRandomNumberGenerator>(52));
         }
-        return std::make_unique<KnockInBarrierMCPricer>(option_, marketData_, stockModel_, generator_, steps_);
+        return std::make_unique<KnockInBarrierMCPricer>(option_, marketData_, stockModel_);
     }
 
     // Knock-Out
@@ -32,9 +34,11 @@ namespace OptionPricer {
     std::unique_ptr<MCPricer> KnockOutBarrierMCBuilder::build() {
         if (!option_) throw std::logic_error("Option is not set for KnockOutBarrierMCPricerBuilder.");
         if (!stockModel_) {
-            stockModel_ = std::make_shared<GeometricBrownianMotionModel>(option_->getID(), marketData_);
+            stockModel_ = std::make_shared<GeometricBrownianMotionModel>(option_->getID(),
+                                                                         marketData_,
+                                                                         std::make_shared<PseudoRandomNumberGenerator>(52));
         }
-        return std::make_unique<KnockOutBarrierMCPricer>(option_, marketData_, stockModel_, generator_, steps_);
+        return std::make_unique<KnockOutBarrierMCPricer>(option_, marketData_, stockModel_);
     }
 
 }
diff --git a/src/solver/monte_carlo/builder/mc_builder_single_path.cpp b/src/solver/monte_carlo/builder/mc_builder_single_path.cpp
index 5e5117d..7c1cb76 100644
--- a/src/solver/monte_carlo/builder/mc_builder_single_path.cpp
+++ b/src/solver/monte_carlo/builder/mc_builder_single_path.cpp
@@ -1,5 +1,4 @@
 #include "solver/monte_carlo/builder/mc_builder_single_path.h"
-#include "model/gbm_model.h"
 
 namespace OptionPricer {
 
@@ -16,9 +15,11 @@ namespace OptionPricer {
     std::unique_ptr<MCPricer> MCSinglePathBuilder::build() {
         if (!option_) throw std::logic_error("Option is not set for AmericanMCPricerBuilder.");
         if (!stockModel_) {
-            stockModel_ = std::make_unique<GeometricBrownianMotionModel>(option_->getID(), marketData_);
+            stockModel_ = std::make_unique<GeometricBrownianMotionModel>(option_->getID(),
+                                                                         marketData_,
+                                                                         std::make_shared<PseudoRandomNumberGenerator>(52));
         }
-        return std::make_unique<SinglePathMCPricer>(option_, marketData_, stockModel_, generator_);
+        return std::make_unique<SinglePathMCPricer>(option_, marketData_, stockModel_);
     }
 
 }
diff --git a/src/solver/monte_carlo/builder/mc_lookback_builder.cpp b/src/solver/monte_carlo/builder/mc_lookback_builder.cpp
index a98aa99..f38412b 100644
--- a/src/solver/monte_carlo/builder/mc_lookback_builder.cpp
+++ b/src/solver/monte_carlo/builder/mc_lookback_builder.cpp
@@ -16,9 +16,11 @@ namespace OptionPricer {
     std::unique_ptr<MCPricer> FloatingStrikeLookbackMCBuilder::build() {
         if (!option_) throw std::logic_error("Option is not set for FloatingStrikeLookbackMCBuilder.");
         if (!stockModel_) {
-            stockModel_ = std::make_shared<GeometricBrownianMotionModel>(option_->getID(), marketData_);
+            stockModel_ = std::make_shared<GeometricBrownianMotionModel>(option_->getID(),
+                                                                         marketData_,
+                                                                         std::make_shared<PseudoRandomNumberGenerator>(52));
         }
-        return std::make_unique<FloatingStrikeLookbackMCPricer>(option_, marketData_, stockModel_, generator_, steps_);
+        return std::make_unique<FloatingStrikeLookbackMCPricer>(option_, marketData_, stockModel_);
     }
 
     // Fixed Strike
@@ -35,9 +37,11 @@ namespace OptionPricer {
     std::unique_ptr<MCPricer> FixedStrikeLookbackMCBuilder::build() {
         if (!option_) throw std::logic_error("Option is not set for FixedStrikeLookbackMCBuilder.");
         if (!stockModel_) {
-            stockModel_ = std::make_shared<GeometricBrownianMotionModel>(option_->getID(), marketData_);
+            stockModel_ = std::make_shared<GeometricBrownianMotionModel>(option_->getID(),
+                                                                         marketData_,
+                                                                         std::make_shared<PseudoRandomNumberGenerator>(52));
         }
-        return std::make_unique<FixedStrikeLookbackMCPricer>(option_, marketData_, stockModel_, generator_, steps_);
+        return std::make_unique<FixedStrikeLookbackMCPricer>(option_, marketData_, stockModel_);
     }
 
 }
\ No newline at end of file
diff --git a/src/solver/monte_carlo/mc_american.cpp b/src/solver/monte_carlo/mc_american.cpp
index 219e703..b8e8558 100644
--- a/src/solver/monte_carlo/mc_american.cpp
+++ b/src/solver/monte_carlo/mc_american.cpp
@@ -1,5 +1,5 @@
 #include "solver/monte_carlo/mc_american.h"
-#include <random/number_generator/random_generator.h>
+#include "random/number_generator/pseudo_random_generator.h"
 #include "Eigen/Dense"
 
 namespace OptionPricer {
@@ -7,51 +7,42 @@ namespace OptionPricer {
     AmericanMCPricer::AmericanMCPricer(std::shared_ptr<AmericanOption> option,
                                        std::shared_ptr<IMarketData> marketData,
                                        std::shared_ptr<StockModel> stockModel,
-                                       std::shared_ptr<NumberGenerator> generator,
                                        std::shared_ptr<BasisFunctionStrategy> basisFunctionStrategy,
-                                       std::shared_ptr<RegressionStrategy> regressionStrategy,
-                                       const unsigned int& steps)
-    : PathDependentMCPricer(std::move(marketData),std::move(stockModel),
-        std::move(generator), steps), option_(std::move(option)),
+                                       std::shared_ptr<RegressionStrategy> regressionStrategy)
+    : MCPricer(std::move(marketData),std::move(stockModel)), option_(std::move(option)),
     basisFunctionStrategy_(std::move(basisFunctionStrategy)),
     regressionStrategy_(std::move(regressionStrategy)) {}
 
     double AmericanMCPricer::calculatePrice(const unsigned long &N) const {
-        const double dt = option_->getT() / static_cast<double>(steps_);
-        const double discountFactor = exp(-marketData_->getR() * dt);
-
-        if (std::dynamic_pointer_cast<RandomNumberGenerator>(generator_)) {
-            return brownianBridgePrice(N, dt, discountFactor);
+        if (std::dynamic_pointer_cast<PseudoRandomNumberGenerator>(stockModel_->getGenerator())) {
+            // Currently not supported for Quasi Random Numbers
+            return brownianBridgePrice(N);
         }
-
-        return standardPrice(N, dt, discountFactor);
+        return standardPrice(N);
     }
 
-    double AmericanMCPricer::standardPrice(const unsigned long &N,
-                                           const double &dt,
-                                           const double &discountFactor) const {
+    double AmericanMCPricer::standardPrice(const unsigned long &N) const {
        /* This algorithm uses the Least Square Monte Carlo (LSMC) method as described in
         * Longstaff and Schwartz (2001) for pricing American options.
         */
-        const double S = marketData_->getStockData(option_->getID())->getPrice();
-        Eigen::MatrixXd paths(N, steps_+1);
-        paths.col(0).setConstant(S);
+        const auto steps = stockModel_->getSteps();
+        const double dt = option_->getT() / static_cast<double>(steps);
+        const double discountFactor = exp(-marketData_->getR() * dt);
 
         // Step 1: Simulate paths
+        Eigen::MatrixXd paths(N, steps);
         for (int i = 0; i < N; ++i) {
-            for (int j = 1; j <= steps_; ++j) {
-                double z = generator_->generate(j - 1);
-                paths(i, j) = paths(i, j - 1) * stockModel_->simulateStepPrice(dt, z);
-            }
+            std::vector<double> prices = stockModel_->simulatePrices(option_->getT());
+            paths.row(i) = Eigen::Map<Eigen::VectorXd>(prices.data(), prices.size());
         }
 
         // Step 2: Initialize americanPrices with the payoff at maturity
-        Eigen::VectorXd americanPrices = paths.col(steps_).unaryExpr([this](const double& path){
+        Eigen::VectorXd americanPrices = paths.col(steps-1).unaryExpr([this](const double& path){
             return option_->payoff(path);
         });
 
         // Step 3: Perform backward induction
-        for (int j = static_cast<int>(steps_) - 1; j >= 1; --j) {
+        for (int j = static_cast<int>(steps) - 2; j >= 0; --j) {
             std::vector<double> inTheMoneyPaths, discountedCashFlows;
             std::vector<bool> isInTheMoney;
 
@@ -101,22 +92,20 @@ namespace OptionPricer {
         return americanPrices.mean() * discountFactor;
     }
 
-    double AmericanMCPricer::brownianBridgePrice(const unsigned long &N,
-                                                 const double &dt,
-                                                 const double &discountFactor) const{
+    double AmericanMCPricer::brownianBridgePrice(const unsigned long &N) const{
         /* This algorithm is an extension of the Longstaff and Schwartz (2001)
          * which introduce a brownian bridge to store only the simulated paths for 1 time step
          * instead thus reducing memory complexity from O(N x m) to O(N) where N is the number of
          * simulations and m the number of steps.
          */
-        const double S = marketData_->getStockData(option_->getID())->getPrice();
-        const double sigma = marketData_->getStockData(option_->getID())->getSigma();
+        const unsigned int steps = stockModel_->getSteps();
+        const double dt = option_->getT() / static_cast<double>(steps);
+        const double discountFactor = exp(-marketData_->getR() * dt);
 
         // Step 1: Simulate paths at maturity
         Eigen::VectorXd paths(N);
         for (int i = 0; i < N; ++i) {
-            const double z = generator_->generate(0); // For each path generate a steps_ dimensional point
-            paths(i) = stockModel_->simulatePriceAtMaturity(option_->getT(), z);
+            paths(i) = stockModel_->simulatePriceAtMaturity(option_->getT());
         }
 
         // Step 2: Initialize americanPrices with the payoff at maturity
@@ -125,7 +114,7 @@ namespace OptionPricer {
         });
 
         // Step 3: Perform backward induction
-        for (int j = static_cast<int>(steps_) - 1; j > 0; --j) {
+        for (int j = static_cast<int>(steps) - 1; j > 0; --j) {
             std::vector<double> inTheMoneyPaths, discountedCashFlows;
             std::vector<bool> isInTheMoney;
 
@@ -133,12 +122,7 @@ namespace OptionPricer {
             for (int i = 0; i < N; ++i) {
                 const double t_j = static_cast<double>(j) * dt;      // Time at current step
                 const double t_jp1 = static_cast<double>(j+1) * dt; // Time at the next step
-                const double X_next = log(paths(i) / S);
-                const double z = generator_->generate(static_cast<int>(steps_) - j);
-
-                // Use the Brownian Bridge interpolation formula
-                const double X_curr = (t_j/t_jp1) * X_next + sqrt(t_j*dt/t_jp1) * sigma * z;
-                paths(i) = S * exp(X_curr);
+                paths(i) = stockModel_->simulatePriceBackward(paths(i), t_j, t_jp1);
                 const double exerciseValue = option_->payoff(paths(i));
 
                 // Collect In-The-Money paths
@@ -184,4 +168,4 @@ namespace OptionPricer {
         return americanPrices.mean() * discountFactor;
     }
 
-}
+}
\ No newline at end of file
diff --git a/src/solver/monte_carlo/mc_asian.cpp b/src/solver/monte_carlo/mc_asian.cpp
index 1f970a6..11a4388 100644
--- a/src/solver/monte_carlo/mc_asian.cpp
+++ b/src/solver/monte_carlo/mc_asian.cpp
@@ -5,65 +5,58 @@ namespace OptionPricer {
     // Base Asian
     AsianMCPricer::AsianMCPricer(std::shared_ptr<AsianOption> option,
                                  std::shared_ptr<IMarketData> marketData,
-                                 std::shared_ptr<StockModel> stockModel,
-                                 std::shared_ptr<NumberGenerator> generator,
-                                 const unsigned int& steps)
-    : PathDependentMCPricer(std::move(marketData),
-    std::move(stockModel), std::move(generator), steps), option_(std::move(option)) {}
+                                 std::shared_ptr<StockModel> stockModel)
+    : MCPricer(std::move(marketData),
+    std::move(stockModel)), option_(std::move(option)) {}
 
     double AsianMCPricer::calculatePrice(const unsigned long& N) const {
         double sumPayoff = 0.0;
-        const double dt = option_->getT() / static_cast<double>(steps_);
+        const unsigned int steps = stockModel_->getSteps();
+        const double discountFactor = exp(-marketData_->getR() * option_->getT());
 
         for (unsigned long i = 0; i < N; ++i) {
-            double S_t = marketData_->getStockData(option_->getID())->getPrice();
             double sumPrices = 0.0;
+            std::vector<double> S = stockModel_->simulatePrices(option_->getT());
 
-            for (unsigned int step = 0; step < steps_; ++step) {
-                double z = generator_->generate(step);
-                S_t *= stockModel_->simulateStepPrice(dt, z);
-                sumPrices += computeSumPrices(S_t);
+            for (int t = 0; t < steps; ++t) {
+                sumPrices += computeSumPrices(S[t]);
             }
 
-            const double averagePrice = computeAveragePrice(sumPrices);
+            const double averagePrice = computeAveragePrice(sumPrices, steps);
             sumPayoff += option_->payoff(averagePrice);
         }
 
-        return (sumPayoff / static_cast<double>(N)) * exp(-marketData_->getR() * option_->getT());
+        return (sumPayoff / static_cast<double>(N)) * discountFactor;
     }
 
     // Arithmetic Asian
     ArithmeticAsianMCPricer::ArithmeticAsianMCPricer(std::shared_ptr<ArithmeticAsianOption> option,
                                                      std::shared_ptr<IMarketData> marketData,
-                                                     std::shared_ptr<StockModel> stockModel,
-                                                     std::shared_ptr<NumberGenerator> generator,
-                                                     const unsigned int &steps)
+                                                     std::shared_ptr<StockModel> stockModel)
     : AsianMCPricer(std::move(option),std::move(marketData),
-        std::move(stockModel), std::move(generator), steps) {}
+        std::move(stockModel)) {}
 
     double ArithmeticAsianMCPricer::computeSumPrices(const double &S_t) const {
         return S_t;
     }
 
-    double ArithmeticAsianMCPricer::computeAveragePrice(const double &averagePrice) const {
-        return averagePrice / static_cast<double>(steps_);
+    double ArithmeticAsianMCPricer::computeAveragePrice(const double &averagePrice, const unsigned int &steps) const {
+        return averagePrice / static_cast<double>(steps);
     }
 
     // Geometric Asian
     GeometricAsianMCPricer::GeometricAsianMCPricer(std::shared_ptr<GeometricAsianOption> option,
                                                    std::shared_ptr<IMarketData> marketData,
-                                                   std::shared_ptr<StockModel> stockModel,
-                                                   std::shared_ptr<NumberGenerator> generator,
-                                                   const unsigned int &steps)
+                                                   std::shared_ptr<StockModel> stockModel)
     : AsianMCPricer(std::move(option),std::move(marketData),
-        std::move(stockModel), std::move(generator), steps) {}
+        std::move(stockModel)) {}
 
     double GeometricAsianMCPricer::computeSumPrices(const double &S_t) const {
         return log(S_t);
     }
 
-    double GeometricAsianMCPricer::computeAveragePrice(const double &averagePrice) const {
-        return exp(averagePrice / static_cast<double>(steps_));
+    double GeometricAsianMCPricer::computeAveragePrice(const double &averagePrice, const unsigned int &steps) const {
+        return exp(averagePrice / static_cast<double>(steps));
     }
 
 }
diff --git a/src/solver/monte_carlo/mc_barrier.cpp b/src/solver/monte_carlo/mc_barrier.cpp
index 8c0ae80..c3e96a3 100644
--- a/src/solver/monte_carlo/mc_barrier.cpp
+++ b/src/solver/monte_carlo/mc_barrier.cpp
@@ -5,43 +5,37 @@ namespace OptionPricer {
     // Base Barrier
     BarrierMCPricer::BarrierMCPricer(std::shared_ptr<BarrierOption> option,
                                      std::shared_ptr<IMarketData> marketData,
-                                     std::shared_ptr<StockModel> stockModel,
-                                     std::shared_ptr<NumberGenerator> generator,
-                                     const unsigned int& steps)
-    : PathDependentMCPricer(std::move(marketData),std::move(stockModel),
-        std::move(generator), steps), option_(std::move(option)) {}
+                                     std::shared_ptr<StockModel> stockModel)
+    : MCPricer(std::move(marketData),std::move(stockModel)),
+      option_(std::move(option)) {}
 
     double BarrierMCPricer::calculatePrice(const unsigned long &N) const {
         double sumPayoff = 0.0;
-        const double dt = option_->getT() / static_cast<double>(steps_);
+        const unsigned int steps = stockModel_->getSteps();
+        const double discountFactor = exp(-marketData_->getR()*option_->getT());
 
         for (int i = 0; i < N; ++i) {
-            double S_t = marketData_->getStockData(option_->getID())->getPrice();
+            std::vector<double> S = stockModel_->simulatePrices(option_->getT());
             bool hasCrossed = false;
 
-            for (int step = 0; step < steps_; ++step) {
-                double z = generator_->generate(step);
-                S_t *= stockModel_->simulateStepPrice(dt, z);
-
-                if (checkHasCrossed(S_t, hasCrossed)) {
+            for (int t = 0; t < steps; ++t) {
+                if (checkHasCrossed(S[t], hasCrossed)) {
                     break;
                 }
             }
 
-            sumPayoff += computePayoff(S_t, hasCrossed);
+            sumPayoff += computePayoff(S[steps-1], hasCrossed);
         }
 
-        return (sumPayoff / static_cast<double>(N)) * exp(-marketData_->getR()*option_->getT());
+        return (sumPayoff / static_cast<double>(N)) * discountFactor;
     }
 
     // Knock In
     KnockInBarrierMCPricer::KnockInBarrierMCPricer(std::shared_ptr<KnockInBarrierOption> option,
                                                    std::shared_ptr<IMarketData> marketData,
-                                                   std::shared_ptr<StockModel> stockModel,
-                                                   std::shared_ptr<NumberGenerator> generator,
-                                                   const unsigned int& steps)
+                                                   std::shared_ptr<StockModel> stockModel)
     : BarrierMCPricer(std::move(option), std::move(marketData),
-    std::move(stockModel), std::move(generator), steps) {}
+    std::move(stockModel)) {}
 
     bool KnockInBarrierMCPricer::checkHasCrossed(const double &S_t, bool &hasCrossed) const {
         if (option_->isActive(S_t)) {
@@ -50,18 +44,16 @@ namespace OptionPricer {
         return false; // Never exit early for Knock-In
     }
 
-    double KnockInBarrierMCPricer::computePayoff(const double &S_t, const bool &hasCrossed) const {
-        return hasCrossed ? option_->payoff(S_t) : 0.0;
+    double KnockInBarrierMCPricer::computePayoff(const double &S_T, const bool &hasCrossed) const {
+        return hasCrossed ? option_->payoff(S_T) : 0.0;
     }
 
     // Knock Out
     KnockOutBarrierMCPricer::KnockOutBarrierMCPricer(std::shared_ptr<KnockOutBarrierOption> option,
                                                      std::shared_ptr<IMarketData> marketData,
-                                                     std::shared_ptr<StockModel> stockModel,
-                                                     std::shared_ptr<NumberGenerator> generator,
-                                                     const unsigned int& steps)
+                                                     std::shared_ptr<StockModel> stockModel)
     : BarrierMCPricer(std::move(option), std::move(marketData),
-        std::move(stockModel), std::move(generator), steps) {}
+        std::move(stockModel)) {}
 
     bool KnockOutBarrierMCPricer::checkHasCrossed(const double &S_t, bool &hasCrossed) const {
         if (!option_->isActive(S_t)) {
@@ -71,8 +63,8 @@ namespace OptionPricer {
         return false; // Continue the loop
     }
 
-    double KnockOutBarrierMCPricer::computePayoff(const double &S_t, const bool &hasCrossed) const {
-        return hasCrossed ? 0.0 : option_->payoff(S_t);
+    double KnockOutBarrierMCPricer::computePayoff(const double &S_T, const bool &hasCrossed) const {
+        return hasCrossed ? 0.0 : option_->payoff(S_T);
     }
 
 }
diff --git a/src/solver/monte_carlo/mc_lookback.cpp b/src/solver/monte_carlo/mc_lookback.cpp
index 6649b26..5dbf946 100644
--- a/src/solver/monte_carlo/mc_lookback.cpp
+++ b/src/solver/monte_carlo/mc_lookback.cpp
@@ -5,66 +5,58 @@ namespace OptionPricer {
     // Base Lookback
     LookbackMCPricer::LookbackMCPricer(std::shared_ptr<LookbackOption> option,
                                        std::shared_ptr<IMarketData> marketData,
-                                       std::shared_ptr<StockModel> stockModel,
-                                       std::shared_ptr<NumberGenerator> generator,
-                                       const unsigned int& steps)
-    : PathDependentMCPricer(std::move(marketData),std::move(stockModel),
-        std::move(generator), steps), option_(std::move(option)) {}
+                                       std::shared_ptr<StockModel> stockModel)
+    : MCPricer(std::move(marketData),std::move(stockModel)),
+      option_(std::move(option)) {}
 
     double LookbackMCPricer::calculatePrice(const unsigned long &N) const {
         double sumPayoff = 0.0;
-        const double dt = option_->getT() / static_cast<double>(steps_);
+        const unsigned int steps = stockModel_->getSteps();
+        const double discountFactor = exp(-marketData_->getR()*option_->getT());
 
         for (int i = 0; i < N; ++i) {
-            double S_t = marketData_->getStockData(option_->getID())->getPrice();
-            double S_min = S_t;
-            double S_max = S_t;
+            std::vector<double> S = stockModel_->simulatePrices(option_->getT());
+            double S_min = std::numeric_limits<double>::infinity();
+            double S_max = -std::numeric_limits<double>::infinity();
 
-            for (int step = 0; step < steps_; ++step) {
-                double z = generator_->generate(step);
-                S_t *= stockModel_->simulateStepPrice(dt, z);
-
-                S_min = std::min(S_min, S_t);
-                S_max = std::max(S_max, S_t);
+            for (int t = 0; t < steps; ++t) {
+                S_min = std::min(S_min, S[t]);
+                S_max = std::max(S_max, S[t]);
             }
 
-            sumPayoff += computePayoff(S_t, S_min, S_max);
-
+            sumPayoff += computePayoff(S[steps-1], S_min, S_max);
         }
 
-        return (sumPayoff / static_cast<double>(N)) * exp(-marketData_->getR() * option_->getT());
+        return (sumPayoff / static_cast<double>(N)) * discountFactor;
     }
 
-    // Floating Stike Lookback
+    // Floating Strike Lookback
     FloatingStrikeLookbackMCPricer::FloatingStrikeLookbackMCPricer(
         std::shared_ptr<FloatingStrikeLookbackOption> option,
         std::shared_ptr<IMarketData> marketData,
-        std::shared_ptr<StockModel> stockModel,
-        std::shared_ptr<NumberGenerator> generator,
-        const unsigned int &steps)
+        std::shared_ptr<StockModel> stockModel)
     : LookbackMCPricer(std::move(option),std::move(marketData),
-        std::move(stockModel), std::move(generator), steps) {}
+        std::move(stockModel)) {}
 
-    double FloatingStrikeLookbackMCPricer::computePayoff(const double &S_t, const double &S_min,
-    const double &S_max) const {
-        // Choose min for call and max for put
+    double FloatingStrikeLookbackMCPricer::computePayoff(const double &S_T,
+                                                         const double &S_min,
+                                                         const double &S_max) const {
         return option_->getPayoff().getPayoffType() == PayoffType::Call
-               ? option_->payoff(S_t, S_min)  // max(S_T - S_min, 0)
-               : option_->payoff(S_t, S_max); // max(S_max - S_T, 0)
+               ? option_->payoff(S_T, S_min)  // max(S_T - S_min, 0)
+               : option_->payoff(S_T, S_max); // max(S_max - S_T, 0)
     }
 
-    // Fixed Stike Lookback
+    // Fixed Strike Lookback
     FixedStrikeLookbackMCPricer::FixedStrikeLookbackMCPricer(
         std::shared_ptr<FixedStrikeLookbackOption> option,
         std::shared_ptr<IMarketData> marketData,
-        std::shared_ptr<StockModel> stockModel,
-        std::shared_ptr<NumberGenerator> generator,
-        const unsigned int &steps)
+        std::shared_ptr<StockModel> stockModel)
     : LookbackMCPricer(std::move(option),std::move(marketData),
-        std::move(stockModel), std::move(generator), steps) {}
+        std::move(stockModel)) {}
 
-    double FixedStrikeLookbackMCPricer::computePayoff(const double &S_t, const double &S_min,
-    const double &S_max) const {
+    double FixedStrikeLookbackMCPricer::computePayoff(const double &S_T,
+                                                      const double &S_min,
+                                                      const double &S_max) const {
         return option_->getPayoff().getPayoffType() == PayoffType::Call
                ? option_->payoff(S_max)  // max(S_max - K, 0)
                : option_->payoff(S_min); // max(K - S_min, 0)
diff --git a/src/solver/monte_carlo/mc_single_path.cpp b/src/solver/monte_carlo/mc_single_path.cpp
index 3924f83..2cc6642 100644
--- a/src/solver/monte_carlo/mc_single_path.cpp
+++ b/src/solver/monte_carlo/mc_single_path.cpp
@@ -5,27 +5,20 @@ namespace OptionPricer {
 
     SinglePathMCPricer::SinglePathMCPricer(std::shared_ptr<SinglePathOption> option,
                                            std::shared_ptr<IMarketData> marketData,
-                                           std::shared_ptr<StockModel> stockModel,
-                                           std::shared_ptr<NumberGenerator> generator)
-        : MCPricer(std::move(marketData), std::move(stockModel), std::move(generator)),
-          option_(std::move(option)) {
-        if (const auto generatorQR = std::dynamic_pointer_cast<QuasiRandomNumberGenerator>(generator_)) {
-            if (generatorQR->getDim() != 1) {
-                throw std::invalid_argument("For SinglePath options, the dim parameter of QuasiRandomNumberGenerator must be 1");
-            }
-        }
-    }
+                                           std::shared_ptr<StockModel> stockModel)
+        : MCPricer(std::move(marketData), std::move(stockModel)),
+          option_(std::move(option)) {}
 
     double SinglePathMCPricer::calculatePrice(const unsigned long& N) const {
         double sumPayoff = 0.0;
+        const double discountFactor = exp(-marketData_->getR() * option_->getT());
 
         for (int i = 0; i < N; ++i) {
-            const double z = generator_->generate(0);
-            double S_T = stockModel_->simulatePriceAtMaturity(option_->getT(), z);
+            double S_T = stockModel_->simulatePriceAtMaturity(option_->getT());
             sumPayoff += option_->payoff(S_T);
         }
 
-        return (sumPayoff / static_cast<double>(N)) * exp(-marketData_->getR() * option_->getT());
+        return (sumPayoff / static_cast<double>(N)) * discountFactor;
     }
 
 }