style: apply clang-format

Author: github-actions[bot]

src/payoffs/asian_payoffs.cpp

@@ -3,74 +3,66 @@
 #include "lfmc/payoff.hpp"
 #include "lfmc/types.hpp"
 
+#include <algorithm>
 #include <expected>
 #include <numeric>
-#include <algorithm>
-#include <vector>
 #include <string>
+#include <vector>
 
 namespace lfmc {
 
-
-
-
 class AsianCall : public Payoff {
-private:
+  private:
     double strike_;
 
-public:
+  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());
+            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:
+  private:
     double strike_;
 
-public:
+  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());
+            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};
     }
 };
 
-}
+} // namespace lfmc

src/payoffs/barrier_payoffs.cpp

@@ -3,40 +3,34 @@
 #include "lfmc/payoff.hpp"
 #include "lfmc/types.hpp"
 
+#include <algorithm>
 #include <expected>
 #include <numeric>
-#include <algorithm>
-#include <vector>
 #include <string>
+#include <vector>
 
 namespace lfmc {
 
 class UpAndOutCall : public Payoff {
-private:
+  private:
     double strike_;
     double barrier_;
 
-public:
-    UpAndOutCall(double strike, double barrier)
-        : strike_(strike), barrier_(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_; });
-
-
-
+            bool knocked_out =
+                std::any_of(path.begin(), path.end(), [this](double s) { return s >= barrier_; });
 
             if (knocked_out) {
                 payoffs.push_back(0.0);
@@ -49,35 +43,30 @@ class UpAndOutCall : public Payoff {
     }
 };
 
-
-
 class DownAndInPut : public Payoff {
-private:
+  private:
     double strike_;
     double barrier_;
 
-public:
-    DownAndInPut(double strike, double barrier)
-        : strike_(strike), barrier_(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_; });
+            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);
             }
@@ -86,4 +75,4 @@ class DownAndInPut : public Payoff {
         return std::vector<Payoffs>{payoffs};
     }
 };
-}
+} // namespace lfmc

src/payoffs/lookback_payoffs.cpp

@@ -3,21 +3,18 @@
 #include "lfmc/payoff.hpp"
 #include "lfmc/types.hpp"
 
+#include <algorithm>
 #include <expected>
 #include <numeric>
-#include <algorithm>
-#include <vector>
 #include <string>
+#include <vector>
 
 namespace lfmc {
 
-
-    class LookbackCall : public Payoff {
-public:
+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());
@@ -26,8 +23,6 @@ namespace lfmc {
             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);
         }
@@ -36,11 +31,8 @@ namespace lfmc {
     }
 };
 
-
-
 class LookbackPut : public Payoff {
-public:
-
+  public:
     std::expected<std::vector<Payoffs>, std::string>
     generate_payoffs(const std::vector<Path>& paths) const override {
         Payoffs payoffs;
@@ -51,14 +43,12 @@ class LookbackPut : public Payoff {
                 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};
     }
 };
 
-}
+} // namespace lfmc