refactor: use std::expected

Author: ChronoInferna

include/lfmc/numerical_scheme.hpp

@@ -10,14 +10,14 @@ namespace lfmc {
 template <typename S, typename P>
 concept NumericalScheme =
     requires(S const& s, P const& p, double t, double x, double dt, double z) {
-        { s.step(p, t, x, dt, z) } -> std::convertible_to<double>;
+        { s.step(p, x, t, dt, z) } -> std::convertible_to<double>;
     };
 
 template <StochasticProcess P> class EulerMaruyama {
   public:
-    double step(P const& process, double t, double x, double dt, double z) const noexcept {
-        double drift = process.drift(t, x);
-        double diffusion = process.diffusion(t, x);
+    double step(P const& process, double x, double t, double dt, double z) const noexcept {
+        double drift = process.drift(x, t);
+        double diffusion = process.diffusion(x, t);
         return x + drift * dt + diffusion * std::sqrt(dt) * z;
     }
 };

include/lfmc/path_generator.hpp

@@ -4,6 +4,10 @@
 #include "lfmc/stochastic_process.hpp"
 #include "lfmc/types.hpp"
 
+#include <expected>
+#include <string>
+#include <vector>
+
 namespace lfmc {
 
 template <StochasticProcess Process, typename Scheme>
@@ -17,9 +21,8 @@ class PathGenerator {
     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 {
+    std::expected<std::vector<Path>, std::string>
+    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;
@@ -31,7 +34,7 @@ class PathGenerator {
             path.push_back(x);
 
             for (size_t i = 0; i < steps; ++i) {
-                x = scheme_.step(process_, t, x, dt, norm[i]);
+                x = scheme_.step(process_, x, t, dt, norm[i]);
                 path.push_back(x);
                 t += dt;
             }

include/lfmc/pipeline.hpp

@@ -26,20 +26,17 @@ template <StochasticProcess SP, NumericalScheme<SP> NS> class Pipeline {
 
     std::expected<double, std::string> run(size_t steps, double T) {
         while (!estimator_->converged()) {
-            // TODO make all the return types std::expected? IDK if it's a good idea for hot loops
-            // like this but it would make error handling easier and more consistent. For now just
-            // return
             auto normals = random_source_->generate_normals(steps);
-            if (normals.empty()) {
+            if (!normals) {
                 return std::unexpected("Failed to generate random normals");
             }
 
-            auto paths = path_generator_->generate_paths(normals, steps, T);
-            if (paths.empty()) {
+            auto paths = path_generator_->generate_paths(normals.value(), steps, T);
+            if (!paths) {
                 return std::unexpected("Failed to generate paths");
             }
 
-            auto payoffs = payoff_->generate_payoffs(paths);
+            auto payoffs = payoff_->generate_payoffs(paths.value());
             if (!payoffs) {
                 return std::unexpected("Failed to generate payoffs");
             }

include/lfmc/random_source.hpp

@@ -2,6 +2,7 @@
 
 #include "lfmc/types.hpp"
 
+#include <expected>
 #include <random>
 #include <vector>
 
@@ -10,7 +11,8 @@ namespace lfmc {
 class RandomSource {
   public:
     virtual ~RandomSource() = default;
-    virtual std::vector<Normals> generate_normals(size_t steps, size_t n = 1) = 0;
+    virtual std::expected<std::vector<Normals>, std::string> generate_normals(size_t steps,
+                                                                              size_t n = 1) = 0;
 };
 
 class PseudoRandomSource : public RandomSource {
@@ -21,7 +23,8 @@ class PseudoRandomSource : public RandomSource {
   public:
     PseudoRandomSource(unsigned seed = std::random_device{}());
 
-    std::vector<Normals> generate_normals(size_t steps, size_t) override;
+    std::expected<std::vector<Normals>, std::string> generate_normals(size_t steps,
+                                                                      size_t) override;
 
     void seed(unsigned seed);
 };
@@ -35,7 +38,8 @@ class AntitheticRandomSource : public RandomSource {
   public:
     AntitheticRandomSource(unsigned seed = std::random_device{}());
 
-    std::vector<Normals> generate_normals(size_t steps, size_t) override;
+    std::expected<std::vector<Normals>, std::string> generate_normals(size_t steps,
+                                                                      size_t) override;
 
     void seed(unsigned seed);
 };

include/lfmc/stochastic_process.hpp

@@ -13,8 +13,8 @@ namespace lfmc {
 template <typename P>
 concept StochasticProcess = requires(P const& p, double t, double x) {
     { p.initial() } -> std::convertible_to<double>;
-    { p.drift(t, x) } -> std::convertible_to<double>;
-    { p.diffusion(t, x) } -> std::convertible_to<double>;
+    { p.drift(x, t) } -> std::convertible_to<double>;
+    { p.diffusion(x, t) } -> std::convertible_to<double>;
 };
 
 class GeometricBrownianMotion {
@@ -27,8 +27,8 @@ class GeometricBrownianMotion {
     GeometricBrownianMotion(double mu, double sigma, double x0);
 
     double initial() const noexcept;
-    double drift(double, double x) const noexcept;
-    double diffusion(double, double x) const noexcept;
+    double drift(double x, double) const noexcept;
+    double diffusion(double x, double) const noexcept;
 
     double mu() const noexcept;
     double sigma() const noexcept;

src/random_source/antithetic_random_source.cpp

@@ -3,7 +3,8 @@
 namespace lfmc {
 AntitheticRandomSource::AntitheticRandomSource(unsigned seed) : rng_(seed), dist_(0.0, 1.0) {}
 
-std::vector<Normals> AntitheticRandomSource::generate_normals(size_t steps, size_t samples) {
+std::expected<std::vector<Normals>, std::string>
+AntitheticRandomSource::generate_normals(size_t steps, size_t samples) {
     std::vector<Normals> result(samples, Normals(steps));
     for (size_t i = 0; i < samples; ++i) {
         Normals normals(steps);

src/random_source/pseudo_random_source.cpp

@@ -1,11 +1,14 @@
 #include "lfmc/random_source.hpp"
 #include "lfmc/types.hpp"
 
+#include <expected>
+
 namespace lfmc {
 
 PseudoRandomSource::PseudoRandomSource(unsigned seed) : rng_(seed), dist_(0.0, 1.0) {}
 
-std::vector<Normals> PseudoRandomSource::generate_normals(size_t steps, size_t samples) {
+std::expected<std::vector<Normals>, std::string>
+PseudoRandomSource::generate_normals(size_t steps, size_t samples) {
     std::vector<Normals> result(samples, Normals(steps));
     for (size_t i = 0; i < samples; ++i) {
         Normals normals(steps);