support for pipe | notation in formula (unstable implementation), code update

Author: AlePalu

fdaPDE/src/formula.h

@@ -20,12 +20,42 @@
 namespace fdapde {
 
 class Formula {
+    // available tokens
+    struct efx_token {
+       private:
+        std::string cov_;
+        std::string efx_;
+       public:
+        efx_token(const std::string& cov, const std::string& efx) : cov_(cov), efx_(efx) { }
+        // observers
+        const std::string& cov() const { return cov_; }
+        const std::string& efx() const { return efx_; }
+        friend std::ostream& operator<<(std::ostream& os, const efx_token& m) {
+            os << "(" << m.cov_ << ", " << m.efx_ << ")";
+            return os;
+        }
+    };
+
     std::string lhs_;
-    std::vector<std::string> rhs_;
+    std::vector<std::string> covs_;
+    std::vector<efx_token> efxs_;
 
     void throw_parse_error_(const std::string& msg) {
         throw std::runtime_error(std::string("Formula parse error: ") + msg);
     }
+    void analyze_token_(std::string token) {
+        size_t pos = token.find('|');
+        if (pos != std::string::npos) {
+            std::string cov_token, efx_token;
+            cov_token = token.substr(0, pos);
+            token.erase(0, pos + 1);
+            efx_token = token;
+            efxs_.emplace_back(cov_token, efx_token);
+        } else {
+            covs_.push_back(token);
+        }
+        return;
+    }
    public:
     Formula() noexcept = default;
     Formula(const std::string& formula) {
@@ -37,20 +67,21 @@ class Formula {
         // rhs parsing logic
         std::string rhs = formula.substr(tilde + 1, formula.size() - tilde - 1);
         std::erase(rhs, ' ');
-	if (rhs.empty())  { throw_parse_error_("no rhs found."); }
+        if (rhs.empty()) { throw_parse_error_("no rhs found."); }
         size_t pos = rhs.find('+');
         std::string token;
         while (pos != std::string::npos) {
             token = rhs.substr(0, pos);
-            rhs_.push_back(token);
+            analyze_token_(token);
             rhs.erase(0, pos + 1);
-	    pos = rhs.find('+');
+            pos = rhs.find('+');
         }
-        rhs_.push_back(rhs);
+        analyze_token_(rhs);
     }
     // observers
     const std::string& lhs() const { return lhs_; }
-    const std::vector<std::string>& rhs() const { return rhs_; }
+    const std::vector<std::string>& covs() const { return covs_; }
+    const std::vector<efx_token>& efxs() const { return efxs_; }
 };
 
 }   // namespace fdapde

fdaPDE/src/models/gsr.h

@@ -63,7 +63,7 @@ class GSRPDE {
         Formula formula_(formula);
         n_obs_ = gf[0].rows();
         n_covs_ = 0;
-        for (const std::string& token : formula_.rhs()) {
+        for (const std::string& token : formula_.covs()) {
             if (gf.contains(token)) { n_covs_++; }
         }
         solver_.analyze_data(formula, gf, W);

fdaPDE/src/models/qsr.h

@@ -48,7 +48,7 @@ template <typename VariationalSolver> class QSRPDE {
         Formula formula_(formula);
         n_obs_ = gf[0].rows();
         n_covs_ = 0;
-        for (const std::string& token : formula_.rhs()) {
+        for (const std::string& token : formula_.covs()) {
             if (gf.contains(token)) { n_covs_++; }
         }
         solver_.analyze_data(formula, gf, W);

fdaPDE/src/models/sr.h

@@ -46,7 +46,7 @@ class SRPDE {
         Formula formula_(formula);
 	n_obs_  = gf[0].rows();
 	n_covs_ = 0;
-        for (const std::string& token : formula_.rhs()) {
+        for (const std::string& token : formula_.covs()) {
             if (gf.contains(token)) { n_covs_++; }
         }
         solver_.analyze_data(formula, gf, W);

fdaPDE/src/solvers/fe_ls_elliptic.h

@@ -201,7 +201,7 @@ struct fe_ls_elliptic {
         // parse formula, extract response vector and design matrix
         Formula formula_(formula);
         std::vector<std::string> covs;
-        for (const std::string& token : formula_.rhs()) {
+        for (const std::string& token : formula_.covs()) {
             if (gf.contains(token)) { covs.push_back(token); }
         }
 	bool require_woodbury_realloc = std::cmp_not_equal(n_covs_, covs.size());

fdaPDE/src/solvers/fe_ls_parabolic.h

@@ -278,7 +278,7 @@ class fe_ls_parabolic_mono {
         // parse formula, extract response vector and design matrix
         Formula formula_(formula);
         std::vector<std::string> covs;
-        for (const std::string& token : formula_.rhs()) {
+        for (const std::string& token : formula_.covs()) {
             if (gf.contains(token)) { covs.push_back(token); }
         }
 	bool require_woodbury_realloc = std::cmp_not_equal(n_covs_, covs.size());

fdaPDE/src/solvers/fe_ls_separable.h

@@ -278,7 +278,7 @@ class fe_ls_separable_mono {
         // parse formula, extract response vector and design matrix
         Formula formula_(formula);
         std::vector<std::string> covs;
-        for (const std::string& token : formula_.rhs()) {
+        for (const std::string& token : formula_.covs()) {
             if (gf.contains(token)) { covs.push_back(token); }
         }
         bool require_woodbury_realloc = std::cmp_not_equal(n_covs_, covs.size());