refactor: renamed everything, finished pipeline, and converted each step to return vectors of results

Author: ChronoInferna

include/lfmc/Estimator.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "lfmc/types.hpp"
+
+#include <expected>
+#include <string>
+
+namespace lfmc {
+
+class Estimator {
+  public:
+    virtual std::expected<void, std::string> add_payoffs(const Payoffs& payoffs) = 0;
+    virtual bool converged() const = 0;
+    virtual std::expected<double, std::string> result() const = 0;
+    // virtual void merge(Estimator const& other) = 0;
+    virtual ~Estimator() = default;
+};
+
+class MonteCarloEstimator : public Estimator {
+  private:
+    double sum = 0.0;
+    std::size_t count = 0;
+
+  public:
+    std::expected<void, std::string> add_payoffs(const Payoffs& payoffs) override;
+    bool converged() const override;
+    std::expected<double, std::string> result() const override;
+    // void merge(Estimator const& other) override;
+};
+
+} // namespace lfmc

include/lfmc/PathGenerator.hpp

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "lfmc/numerical_scheme.hpp"
+#include "lfmc/stochastic_process.hpp"
+#include "lfmc/types.hpp"
+
+namespace lfmc {
+
+template <StochasticProcess Process, typename Scheme>
+    requires NumericalScheme<Scheme, Process>
+class PathGenerator {
+  private:
+    Process process_;
+    Scheme scheme_;
+
+  public:
+    PathGenerator(Process process, Scheme scheme)
+        : process_(std::move(process)), scheme_(std::move(scheme)) {}
+
+    // TODO move to cpp file
+    std::vector<Path> generate_paths(const std::vector<Normals>& normals, size_t steps,
+                                     double T) const {
+        const double dt = T / static_cast<double>(steps);
+
+        std::vector<Path> paths;
+        for (const auto& norm : normals) {
+            Path path(steps + 1);
+
+            double t = 0.0;
+            double x = process_.initial();
+            path.push_back(x);
+
+            for (size_t i = 0; i < steps; ++i) {
+                x = scheme_.step(process_, t, x, dt, norm[i]);
+                path.push_back(x);
+                t += dt;
+            }
+        }
+
+        return paths;
+    }
+};
+
+} // namespace lfmc

include/lfmc/Payoff.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "lfmc/types.hpp"
+
+namespace lfmc {
+
+class Payoff {
+  public:
+    virtual Payoffs generate_payoffs(const std::vector<Path>& paths) const = 0;
+    virtual ~Payoff() = default;
+};
+
+class EuropeanCall : public Payoff {
+  private:
+    double strike_;
+
+  public:
+    explicit EuropeanCall(double strike);
+
+    Payoffs generate_payoffs(const std::vector<Path>& paths) const override;
+};
+
+class EuropeanPut : public Payoff {
+  private:
+    double strike_;
+
+  public:
+    explicit EuropeanPut(double strike);
+
+    Payoffs generate_payoffs(const std::vector<Path>& paths) const override;
+};
+
+} // namespace lfmc

include/lfmc/Pipeline.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "lfmc/estimator.hpp"
+#include "lfmc/path_generator.hpp"
+#include "lfmc/payoff.hpp"
+#include "lfmc/random_source.hpp"
+
+#include <expected>
+#include <memory>
+
+namespace lfmc {
+
+template <StochasticProcess SP, NumericalScheme<SP> NS> class Pipeline {
+  private:
+    std::unique_ptr<RandomSource> random_source_;
+    std::unique_ptr<PathGenerator<SP, NS>> path_generator_;
+    std::unique_ptr<Payoff> payoff_;
+    std::unique_ptr<Estimator> estimator_;
+
+  public:
+    Pipeline(std::unique_ptr<RandomSource> random_source,
+             std::unique_ptr<PathGenerator<SP, NS>> path_generator, std::unique_ptr<Payoff> payoff,
+             std::unique_ptr<Estimator> estimator)
+        : random_source_(std::move(random_source)), path_generator_(std::move(path_generator)),
+          payoff_(std::move(payoff)), estimator_(std::move(estimator)) {}
+
+    std::expected<double, std::string> run(size_t steps, double T) {
+        while (!estimator_->converged()) {
+            auto normals = random_source_->generate_normals(steps);
+            auto paths = path_generator_->generate_paths(normals, steps, T);
+            auto payoffs = payoff_->generate_payoffs(paths);
+            auto result = estimator_->add_payoffs(payoffs);
+
+            if (!result) {
+                return std::unexpected(result.error());
+            }
+        }
+
+        return estimator_->result();
+    }
+};
+
+} // namespace lfmc