added Different payoff structures

Author: Alexander Robbins

src/payoffs/asian_payoffs.cpp

@@ -0,0 +1,76 @@
+#pragma once
+
+#include "lfmc/payoff.hpp"
+#include "lfmc/types.hpp"
+
+#include <expected>
+#include <numeric>
+#include <algorithm>
+#include <vector>
+#include <string>
+
+namespace lfmc {
+
+
+
+
+class AsianCall : public Payoff {
+private:
+    double strike_;
+
+public:
+    explicit AsianCall(double strike) : strike_(strike) {}
+
+    std::expected<std::vector<Payoffs>, std::string>
+    generate_payoffs(const std::vector<Path>& paths) const override {
+        Payoffs payoffs;
+        
+        payoffs.reserve(paths.size());
+
+        for (const auto& path : paths) {
+            
+            if (path.empty())
+                return std::unexpected("Empty path encountered in AsianCall");
+
+            double mean = std::reduce(path.begin(), path.end(), 0.0) 
+                          / static_cast<double>(path.size());
+            payoffs.push_back(std::max(mean - strike_, 0.0));
+        }
+
+        return std::vector<Payoffs>{payoffs};
+    }
+};
+
+
+class AsianPut : public Payoff {
+private:
+    double strike_;
+
+public:
+    explicit AsianPut(double strike) : strike_(strike) {}
+
+    std::expected<std::vector<Payoffs>, std::string>
+    generate_payoffs(const std::vector<Path>& paths) const override {
+        
+        
+        Payoffs payoffs;
+        
+        
+        
+        payoffs.reserve(paths.size());
+
+        for (const auto& path : paths) {
+            if (path.empty())
+                return std::unexpected("Empty path encountered in AsianPut");
+
+            
+            double mean = std::reduce(path.begin(), path.end(), 0.0)
+                          / static_cast<double>(path.size());
+            payoffs.push_back(std::max(strike_ - mean, 0.0));
+        }
+
+        return std::vector<Payoffs>{payoffs};
+    }
+};
+
+}

src/payoffs/barrier_payoffs.cpp

@@ -0,0 +1,89 @@
+#pragma once
+
+#include "lfmc/payoff.hpp"
+#include "lfmc/types.hpp"
+
+#include <expected>
+#include <numeric>
+#include <algorithm>
+#include <vector>
+#include <string>
+
+namespace lfmc {
+
+class UpAndOutCall : public Payoff {
+private:
+    double strike_;
+    double barrier_;
+
+public:
+    UpAndOutCall(double strike, double barrier)
+        : strike_(strike), barrier_(barrier) {}
+
+
+    std::expected<std::vector<Payoffs>, std::string>
+    generate_payoffs(const std::vector<Path>& paths) const override {
+        
+        
+        Payoffs payoffs;
+        payoffs.reserve(paths.size());
+
+        for (const auto& path : paths) {
+            if (path.empty())
+                return std::unexpected("Empty path encountered in UpAndOutCall");
+
+            bool knocked_out = std::any_of(path.begin(), path.end(),
+                [this](double s) { return s >= barrier_; });
+
+
+
+
+            if (knocked_out) {
+                payoffs.push_back(0.0);
+            } else {
+                payoffs.push_back(std::max(path.back() - strike_, 0.0));
+            }
+        }
+
+        return std::vector<Payoffs>{payoffs};
+    }
+};
+
+
+
+class DownAndInPut : public Payoff {
+private:
+    double strike_;
+    double barrier_;
+
+public:
+    DownAndInPut(double strike, double barrier)
+        : strike_(strike), barrier_(barrier) {}
+
+    std::expected<std::vector<Payoffs>, std::string>
+    generate_payoffs(const std::vector<Path>& paths) const override {
+        Payoffs payoffs;
+        payoffs.reserve(paths.size());
+
+        for (const auto& path : paths) {
+ 
+ 
+            if (path.empty())
+                return std::unexpected("Empty path encountered in DownAndInPut");
+
+            bool knocked_in = std::any_of(path.begin(), path.end(),
+                [this](double s) { return s <= barrier_; });
+
+            if (knocked_in) {
+                payoffs.push_back(std::max(strike_ - path.back(), 0.0));
+ 
+ 
+            } else {
+                payoffs.push_back(0.0);
+            }
+        }
+
+        return std::vector<Payoffs>{payoffs};
+    }
+};
+}

src/payoffs/lookback_payoffs.cpp

@@ -0,0 +1,64 @@
+#pragma once
+
+#include "lfmc/payoff.hpp"
+#include "lfmc/types.hpp"
+
+#include <expected>
+#include <numeric>
+#include <algorithm>
+#include <vector>
+#include <string>
+
+namespace lfmc {
+
+
+    class LookbackCall : public Payoff {
+public:
+    std::expected<std::vector<Payoffs>, std::string>
+
+
+
+    generate_payoffs(const std::vector<Path>& paths) const override {
+        Payoffs payoffs;
+        payoffs.reserve(paths.size());
+
+        for (const auto& path : paths) {
+            if (path.empty())
+                return std::unexpected("Empty path encountered in LookbackCall");
+
+
+
+            double min_price = *std::min_element(path.begin(), path.end());
+            payoffs.push_back(path.back() - min_price);
+        }
+
+        return std::vector<Payoffs>{payoffs};
+    }
+};
+
+
+
+class LookbackPut : public Payoff {
+public:
+
+    std::expected<std::vector<Payoffs>, std::string>
+    generate_payoffs(const std::vector<Path>& paths) const override {
+        Payoffs payoffs;
+        payoffs.reserve(paths.size());
+
+        for (const auto& path : paths) {
+            if (path.empty())
+                return std::unexpected("Empty path encountered in LookbackPut");
+
+            double max_price = *std::max_element(path.begin(), path.end());
+    
+    
+    
+            payoffs.push_back(max_price - path.back());
+        }
+
+        return std::vector<Payoffs>{payoffs};
+    }
+};
+
+}

tests/CMakeLists.txt

@@ -21,6 +21,7 @@ set(TEST_SOURCES
     test_process.cpp
     test_scheme.cpp
     test_pipeline.cpp
+    test_convergency.cpp
 )
 
 add_executable(tests ${TEST_SOURCES})