[Not ready] Quick rvine trees implementation for Theresa

.Rbuildignore

@@ -19,3 +19,4 @@
 ^\.github$
 ^\.vscode$
 ^CRAN-SUBMISSION$
+air.toml

R/RcppExports.R

@@ -101,3 +101,7 @@ fit_margins_cpp <- function(data, xmin, xmax, type, mult, bw, deg, weights, num_
     .Call(`_rvinecopulib_fit_margins_cpp`, data, xmin, xmax, type, mult, bw, deg, weights, num_threads)
 }
 
+merge_rvine_structures <- function(rvine_structure_list) {
+    .Call(`_rvinecopulib_merge_rvine_structures`, rvine_structure_list)
+}
+

inst/include/vinecopulib-wrappers.hpp

@@ -173,6 +173,20 @@ inline Rcpp::List rvine_structure_wrap(const RVineStructure& rvine_struct)
   return rvs;
 }
 
+inline Rcpp::List rvine_trees_wrap(const RVineTrees &rvine_trees)
+{
+  auto [order, struct_array] = rvine_trees.to_struct_array();
+  auto struct_array_r = struct_array_wrap(struct_array);
+
+  Rcpp::List rvt = Rcpp::List::create(
+      Rcpp::Named("order") = order,
+      Rcpp::Named("struct_array") = struct_array_r,
+      Rcpp::Named("d") = rvine_trees.get_dim(),
+      Rcpp::Named("trunc_lvl") = rvine_trees.get_trunc_lvl());
+
+  rvt.attr("class") = Rcpp::CharacterVector{"rvine_structure", "list"};
+  return rvt;
+}
 
 // vinecop wrappers --------------------------------------------------------
 

inst/include/vinecopulib/bicop/abstract.hpp

@@ -11,7 +11,6 @@
 #include <Eigen/Dense>
 #include <vinecopulib/bicop/family.hpp>
 
-
 namespace vinecopulib {
 //! @brief An abstract class for bivariate copula families.
 //!

inst/include/vinecopulib/bicop/class.hpp

@@ -17,11 +17,11 @@ using BicopPtr = std::shared_ptr<AbstractBicop>;
 
 //! @brief A class for bivariate copula models.
 //!
-//! @details The model is fully characterized by the family, 
-//! rotation (one of `0`, `90`, `180`, `270`), a matrix of parameters, and 
-//! variable types (two strings, one for each variable, either `"c"` 
+//! @details The model is fully characterized by the family,
+//! rotation (one of `0`, `90`, `180`, `270`), a matrix of parameters, and
+//! variable types (two strings, one for each variable, either `"c"`
 //! for continuous or `"d"` for discrete).
-//! 
+//!
 //! Implemented families (see `BicopFamily`):
 //!
 //! ```

inst/include/vinecopulib/bicop/extreme_value.hpp

@@ -23,7 +23,7 @@ class ExtremeValueBicop : public ParBicop
   // pdf, cdf, hfunctions and inverses
   Eigen::VectorXd cdf(const Eigen::MatrixXd& u);
 
-  Eigen::VectorXd pdf_raw(const Eigen::MatrixXd &u);
+  Eigen::VectorXd pdf_raw(const Eigen::MatrixXd& u);
 
   Eigen::VectorXd hfunc1_raw(const Eigen::MatrixXd& u);
 

inst/include/vinecopulib/bicop/family.hpp

@@ -43,7 +43,7 @@ const std::vector<BicopFamily> all = {
   BicopFamily::indep,   BicopFamily::gaussian, BicopFamily::student,
   BicopFamily::clayton, BicopFamily::gumbel,   BicopFamily::frank,
   BicopFamily::joe,     BicopFamily::bb1,      BicopFamily::bb6,
-  BicopFamily::bb7,     BicopFamily::bb8,      BicopFamily::tawn, 
+  BicopFamily::bb7,     BicopFamily::bb8,      BicopFamily::tawn,
   BicopFamily::tll
 };
 
@@ -73,9 +73,7 @@ const std::vector<BicopFamily> two_par = { BicopFamily::student,
                                            BicopFamily::bb8 };
 
 //! All three-parameter families
-const std::vector<BicopFamily> three_par = {
-  BicopFamily::tawn
-};
+const std::vector<BicopFamily> three_par = { BicopFamily::tawn };
 
 //! All elliptical copulas
 const std::vector<BicopFamily> elliptical = { BicopFamily::gaussian,
@@ -89,9 +87,8 @@ const std::vector<BicopFamily> archimedean = {
 };
 
 //! All Extreme-value copulas
-const std::vector<BicopFamily> extreme_value = {
-  BicopFamily::tawn, BicopFamily::gumbel
-};
+const std::vector<BicopFamily> extreme_value = { BicopFamily::tawn,
+                                                 BicopFamily::gumbel };
 
 //! All BB copulas
 const std::vector<BicopFamily> bb = { BicopFamily::bb1,
@@ -127,7 +124,6 @@ const std::vector<BicopFamily> itau = {
   BicopFamily::joe
 };
 
-
 } // end of namespace BicopFamilies
 } // end of namespace vinecopulib
 

inst/include/vinecopulib/bicop/implementation/abstract.ipp

@@ -250,7 +250,7 @@ AbstractBicop::hfunc2(const Eigen::MatrixXd& u)
     // the quotient can be instable, use analytical derivative if denominator
     // too small
     for (Eigen::Index i = 0; i < u.rows(); i++) {
-       if (u2diff(i) > 5e-3) {
+      if (u2diff(i) > 5e-3) {
         h(i) = cdf(uu.row(i).leftCols(2))(0) - cdf(uu.row(i).rightCols(2))(0);
         h(i) /= u2diff(i);
       } else {

inst/include/vinecopulib/bicop/implementation/class.ipp

@@ -753,7 +753,7 @@ Bicop::flip()
   } else if (rotation_ == 270) {
     rotation_ = 90;
   }
-  // The following implements any changes to the shape beyond the change in 
+  // The following implements any changes to the shape beyond the change in
   // rotation. Formost of our families, it does nothing.
   bicop_->flip();
 }

inst/include/vinecopulib/bicop/implementation/extreme_value.ipp

@@ -8,68 +8,64 @@
 #include <vinecopulib/misc/tools_integration.hpp>
 
 namespace vinecopulib {
-inline Eigen::VectorXd ExtremeValueBicop::cdf(
-    const Eigen::MatrixXd &u
-)
+inline Eigen::VectorXd
+ExtremeValueBicop::cdf(const Eigen::MatrixXd& u)
 {
-    auto f = [this](const double &u1, const double &u2) {
-        double t = std::log(u2) / std::log(u1 * u2);
-        t = pickands(t);
-        t = (std::log(u1) + std::log(u2)) * t;
-        return std::exp(t);
-    };
-    return tools_eigen::binaryExpr_or_nan(u, f);
+  auto f = [this](const double& u1, const double& u2) {
+    double t = std::log(u2) / std::log(u1 * u2);
+    t = pickands(t);
+    t = (std::log(u1) + std::log(u2)) * t;
+    return std::exp(t);
+  };
+  return tools_eigen::binaryExpr_or_nan(u, f);
 }
 
-inline Eigen::VectorXd ExtremeValueBicop::pdf_raw(
-    const Eigen::MatrixXd &u
-)
+inline Eigen::VectorXd
+ExtremeValueBicop::pdf_raw(const Eigen::MatrixXd& u)
 {
-    auto f = [this](const double &u1, const double &u2) {
-        double t = std::log(u2) / std::log(u1 * u2);
-        double t2 = pickands(t);
-        double t3 = pickands_derivative(t);
-        double t4 = pickands_derivative2(t);
+  auto f = [this](const double& u1, const double& u2) {
+    double t = std::log(u2) / std::log(u1 * u2);
+    double t2 = pickands(t);
+    double t3 = pickands_derivative(t);
+    double t4 = pickands_derivative2(t);
 
-        t3 = std::pow(t2, 2) + (1 - 2 * t) * t3 * t2 - 
-                (1 - t) * t * (std::pow(t3, 2) + t4 / std::log(u1 * u2));
-        t2 = (std::log(u1) + std::log(u2)) * t2;
+    t3 = std::pow(t2, 2) + (1 - 2 * t) * t3 * t2 -
+         (1 - t) * t * (std::pow(t3, 2) + t4 / std::log(u1 * u2));
+    t2 = (std::log(u1) + std::log(u2)) * t2;
 
-        return std::exp(t2) * t3 / (u1 * u2);
-    };
-    return tools_eigen::binaryExpr_or_nan(u, f);
+    return std::exp(t2) * t3 / (u1 * u2);
+  };
+  return tools_eigen::binaryExpr_or_nan(u, f);
 }
 
-inline Eigen::VectorXd ExtremeValueBicop::hfunc1_raw(
-    const Eigen::MatrixXd &u
-)
+inline Eigen::VectorXd
+ExtremeValueBicop::hfunc1_raw(const Eigen::MatrixXd& u)
 {
-    auto f = [this](const double &u1, const double &u2) {
-        double t = std::log(u2) / std::log(u1 * u2);
-        double t2 = pickands(t);
-        double t3 = pickands_derivative(t);
-        t3 = t2 - t * t3;
-        t2 = (std::log(u1) + std::log(u2)) * t2;
+  auto f = [this](const double& u1, const double& u2) {
+    double t = std::log(u2) / std::log(u1 * u2);
+    double t2 = pickands(t);
+    double t3 = pickands_derivative(t);
+    t3 = t2 - t * t3;
+    t2 = (std::log(u1) + std::log(u2)) * t2;
 
-        return std::exp(t2) * t3 / u1;
-    };
-    return tools_eigen::binaryExpr_or_nan(u, f);
+    return std::exp(t2) * t3 / u1;
+  };
+  return tools_eigen::binaryExpr_or_nan(u, f);
 }
 
-inline Eigen::VectorXd ExtremeValueBicop::hfunc2_raw(
-    const Eigen::MatrixXd &u
-)
+inline Eigen::VectorXd
+ExtremeValueBicop::hfunc2_raw(const Eigen::MatrixXd& u)
 {
-    auto f = [this](const double &u1, const double &u2) {
-        double t = std::log(u2) / std::log(u1 * u2);
-        double t2 = pickands(t);
-        double t3 = pickands_derivative(t);
-        t3 = t2 + (1 - t) * t3;
-        t2 = (std::log(u1) + std::log(u2)) * t2;
+  auto f = [this](const double& u1, const double& u2) {
+    double t = std::log(u2) / std::log(u1 * u2);
+    double t2 = pickands(t);
+    double t3 = pickands_derivative(t);
+    t3 = t2 + (1 - t) * t3;
+    t2 = (std::log(u1) + std::log(u2)) * t2;
 
-        return std::exp(t2) * t3 / u2;
-    };
-    return tools_eigen::binaryExpr_or_nan(u, f);
+    return std::exp(t2) * t3 / u2;
+  };
+  return tools_eigen::binaryExpr_or_nan(u, f);
 }
 
 inline Eigen::VectorXd

inst/include/vinecopulib/bicop/implementation/family.ipp

@@ -12,19 +12,16 @@ namespace vinecopulib {
 typedef boost::bimap<BicopFamily, std::string> family_bimap;
 const family_bimap family_names =
   boost::assign::list_of<family_bimap::relation>(
-    BicopFamily::indep, "Independence")
-    (BicopFamily::gaussian, "Gaussian")
-    (BicopFamily::student, "Student")
-    (BicopFamily::clayton, "Clayton")
-    (BicopFamily::gumbel, "Gumbel")
-    (BicopFamily::frank, "Frank")(
-    BicopFamily::joe, "Joe")
-    (BicopFamily::bb1, "BB1")
-    (BicopFamily::bb6, "BB6")
-    (BicopFamily::bb7,"BB7")
-    (BicopFamily::bb8, "BB8")
-    (BicopFamily::tawn, "Tawn")
-    (BicopFamily::tll, "TLL");
+    BicopFamily::indep,
+    "Independence")(BicopFamily::gaussian, "Gaussian")(
+    BicopFamily::student,
+    "Student")(BicopFamily::clayton, "Clayton")(BicopFamily::gumbel, "Gumbel")(
+    BicopFamily::frank,
+    "Frank")(BicopFamily::joe, "Joe")(BicopFamily::bb1, "BB1")(BicopFamily::bb6,
+                                                               "BB6")(
+    BicopFamily::bb7,
+    "BB7")(BicopFamily::bb8, "BB8")(BicopFamily::tawn, "Tawn")(BicopFamily::tll,
+                                                               "TLL");
 
 //! @brief Converts a BicopFamily into a string with its name.
 //! @param family The family.

inst/include/vinecopulib/bicop/implementation/fit_controls.ipp

@@ -24,7 +24,7 @@ namespace vinecopulib {
 //! @param selection_criterion The selection criterion (`"loglik"`, `"aic"`
 //!     or `"bic"`) for the pair copula families.
 //! @param weights A vector of weights for the observations.
-//! @param psi0 Only for `selection_criterion = "mbic"`, the prior probability 
+//! @param psi0 Only for `selection_criterion = "mbic"`, the prior probability
 //!     of non-independence.
 //! @param preselect_families Whether to exclude families before fitting
 //!     based on symmetry properties of the data.
@@ -82,38 +82,38 @@ inline FitControlsBicop::FitControlsBicop(std::string nonparametric_method,
 //! @brief Instantiates the controls from a configuration object.
 //! @param config The configuration object.
 inline FitControlsBicop::FitControlsBicop(const FitControlsConfig& config)
-    : FitControlsBicop() // Call default constructor
+  : FitControlsBicop() // Call default constructor
 {
-    if (optional::has_value(config.family_set)) {
-        set_family_set(optional::value(config.family_set));
-    }
-    if (optional::has_value(config.parametric_method)) {
-        set_parametric_method(optional::value(config.parametric_method));
-    }
-    if (optional::has_value(config.nonparametric_method)) {
-        set_nonparametric_method(optional::value(config.nonparametric_method));
-    }
-    if (optional::has_value(config.nonparametric_mult)) {
-        set_nonparametric_mult(optional::value(config.nonparametric_mult));
-    }
-    if (optional::has_value(config.selection_criterion)) {
-        set_selection_criterion(optional::value(config.selection_criterion));
-    }
-    if (optional::has_value(config.weights)) {
-        set_weights(optional::value(config.weights));
-    }
-    if (optional::has_value(config.psi0)) {
-        set_psi0(optional::value(config.psi0));
-    }
-    if (optional::has_value(config.preselect_families)) {
-        set_preselect_families(optional::value(config.preselect_families));
-    }
-    if (optional::has_value(config.num_threads)) {
-        set_num_threads(optional::value(config.num_threads));
-    }
-    if (optional::has_value(config.allow_rotations)) {
-        set_allow_rotations(optional::value(config.allow_rotations));
-    }
+  if (optional::has_value(config.family_set)) {
+    set_family_set(optional::value(config.family_set));
+  }
+  if (optional::has_value(config.parametric_method)) {
+    set_parametric_method(optional::value(config.parametric_method));
+  }
+  if (optional::has_value(config.nonparametric_method)) {
+    set_nonparametric_method(optional::value(config.nonparametric_method));
+  }
+  if (optional::has_value(config.nonparametric_mult)) {
+    set_nonparametric_mult(optional::value(config.nonparametric_mult));
+  }
+  if (optional::has_value(config.selection_criterion)) {
+    set_selection_criterion(optional::value(config.selection_criterion));
+  }
+  if (optional::has_value(config.weights)) {
+    set_weights(optional::value(config.weights));
+  }
+  if (optional::has_value(config.psi0)) {
+    set_psi0(optional::value(config.psi0));
+  }
+  if (optional::has_value(config.preselect_families)) {
+    set_preselect_families(optional::value(config.preselect_families));
+  }
+  if (optional::has_value(config.num_threads)) {
+    set_num_threads(optional::value(config.num_threads));
+  }
+  if (optional::has_value(config.allow_rotations)) {
+    set_allow_rotations(optional::value(config.allow_rotations));
+  }
 }
 
 //! @name Sanity checks