vinecopulib::Vinecop class

#include <vinecopulib/include/vinecopulib/vinecop/class.hpp>

static std::vector<std::vector<Bicop>> vinecopulib::Vinecop::make_pair_copula_store(const size_t d, const size_t trunc_lvl = std::numeric_limits<size_t>::max())

Initializes object for storing pair copulas.

vinecopulib::Vinecop::Vinecop(size_t d) explicit

Instantiates a D-vine with all pair-copulas set to independence.

vinecopulib::Vinecop::Vinecop(const RVineStructure& structure, const std::vector<std::vector<Bicop>>& pair_copulas = {}, const std::vector<std::string>& var_types = {}) explicit

Instantiates an arbitrary vine copula model.

vinecopulib::Vinecop::Vinecop(const Eigen::Matrix<size_t, Eigen::Dynamic, Eigen::Dynamic>& matrix, const std::vector<std::vector<Bicop>>& pair_copulas = {}, const std::vector<std::string>& var_types = {}) explicit

Instantiates an arbitrary vine copula model.

vinecopulib::Vinecop::Vinecop(const Eigen::MatrixXd& u, const RVineStructure& structure = RVineStructure(), const std::vector<std::string>& var_types = {}, const FitControlsVinecop& controls = FitControlsVinecop()) explicit

Instantiates from data.

Equivalent to creating a default Vinecop() and then selecting the model using select().

vinecopulib::Vinecop::Vinecop(const Eigen::MatrixXd& u, const Eigen::Matrix<size_t, Eigen::Dynamic, Eigen::Dynamic>& matrix, const std::vector<std::string>& var_types = {}, const FitControlsVinecop& controls = FitControlsVinecop()) explicit

Instantiates from data.

Equivalent to creating a default Vinecop() and then selecting the model using select().

vinecopulib::Vinecop::Vinecop(const std::string& filename, const bool check = true) explicit

Instantiates from a JSON or CBOR file.

Files ending in .cbor are read as CBOR. All other filenames are read as JSON for backwards compatibility. The input contains 2 attributes: "structure" for the vine structure, which itself contains attributes "array" for the structure triangular array and "order" for the order vector, and "pair copulas". "pair copulas" contains a list of attributes for the trees ("tree1", "tree2", etc), each containing a list of attributes for the edges ("pc1", "pc2", etc). See the corresponding method of Bicop objects for the encoding of pair-copulas.

vinecopulib::Vinecop::Vinecop(const nlohmann::json& input, const bool check = true) explicit

Instantiates from a nlohmann::json object.

nlohmann::json vinecopulib::Vinecop::to_json() const

Converts the copula into a nlohmann::json object.

The nlohmann::json object contains two nodes : "structure" for the vine structure, which itself contains nodes "array" for the structure triangular array and "order" for the order vector, and "pair copulas". The former two encode the R-Vine structure and the latter is a list of child nodes for the trees ("tree1", "tree2", etc), each containing a list of child nodes for the edges ("pc1", "pc2", etc). See Bicop::to_json() for the encoding of pair-copulas.

void vinecopulib::Vinecop::to_file(const std::string& filename) const

Writes the copula object into a JSON or CBOR file.

Filenames ending in .cbor are written as CBOR. All other filenames are written as JSON for backwards compatibility. The output contains 2 attributes: "structure" for the vine structure, which itself contains attributes "array" for the structure triangular array and "order" for the order vector, and "pair copulas". "pair copulas" contains a list of attributes for the trees ("tree1", "tree2", etc), each containing a list of attributes for the edges ("pc1", "pc2", etc). See Bicop::to_file() objects for the encoding of pair-copulas.

void vinecopulib::Vinecop::select(const Eigen::MatrixXd& u, const FitControlsVinecop& controls = FitControlsVinecop())

Automatically fits and selects a vine copula model.

This method can be used to select either the pair-copulas only, or the pair-copulas and the structure. The latter is done by specifying a truncation level in the controls. The method then selects the structure and fits the pair-copulas for all trees up to the truncation level. In other words, select() behaves differently depending on its current truncation level and the truncation level specified in the controls, respectively called trunc_lvl and controls.trunc_lvl in what follows. Essentially, controls.trunc_lvl defines the object's truncation level after calling select():

• If controls.trunc_lvl <= trunc_lvl, the families and parameters for all pairs in trees smaller or equal to controls.trunc_lvl are selected, using the current structure.
• If controls.trunc_lvl > trunc_lvl, select() behaves as above for all trees that are smaller or equal to trunc_lvl, and then it selects the structure for higher trees along with the families and parameters. This includes the case where trunc_lvl = 0, namely where the structure is fully unspecified.

Selection of the structure is performed using the algorithm of Dissmann, J. F., E. C. Brechmann, C. Czado, and D. Kurowicka (2013). Selecting and estimating regular vine copulae and application to financial returns. Computational Statistics & Data Analysis, 59 (1), 52-69. The dependence measure used to select trees (default: Kendall's tau) is corrected for ties (see the wdm library). The dependence measure can be changed using controls.tree_criterion, which can be set to "tau", "rho", "hoeffd", "mcor", "cxi", "joe", or "custom". The last one uses the callable supplied through controls.tree_criterion_function, which is always called on the thread that starts the fit, so it need not be thread safe; the pair-copula fits still use controls.num_threads threads. Both Prim's (default: "mst_prim") and Kruskal's ("mst_kruskal") algorithms are available through controls.tree_algorithm for the maximum spanning tree selection. An alternative to the maximum spanning tree selection is to use random spanning trees, which can be selected using controls.tree_algorithm and come in two flavors, both using Wilson's algorithm loop erased random walks:

• "random_weighted" generates a random spanning tree with probability proportional to the product of the weights (i.e., the dependence) of the edges in the tree.
• "random_unweighted" generates a random spanning tree uniformly over all spanning trees satisfying the proximity condition.

If the controls object has been instantiated with select_families = false, then the method simply updates the parameters of the pair-copulas without selecting the families or the structure. In this case, this is equivalent to calling fit() for each pair-copula, albeit potentially in parallel if num_threads > 1.

When at least one variable is discrete, two types of "observations" are required: the first block contains realizations of ; the second block contains realizations of . The minus indicates a left-sided limit of the cdf. For continuous variables the left limit and the cdf itself coincide. For, e.g., an integer-valued variable, it holds . Continuous variables in the second block can be omitted.

If there are missing data (i.e., NaN entries), incomplete observations are discarded before fitting a pair-copula. This is done on a pair-by-pair basis so that the maximal available information is used.

void vinecopulib::Vinecop::fit(const Eigen::MatrixXd& u, const FitControlsBicop& controls = FitControlsBicop(), const size_t num_threads = 1)

Fits the parameters of a pre-specified vine copula model.

This method fits the pair-copulas of a vine copula model. It is assumed that the structure and pair-copula families are already set. The method is equivalent to calling fit() for each pair-copula in the model. The same can be achieved by calling select() with the same data and a FitControlsVinecop object instantiated with select_families = false.

Eigen::VectorXd vinecopulib::Vinecop::pdf(Eigen::MatrixXd u, const size_t num_threads = 1) const

Evaluates the copula density.

The copula density is defined as joint density divided by marginal densities, irrespective of variable types.

When at least one variable is discrete, two types of "observations" are required in u: the first block contains realizations of . The second block contains realizations of . The minus indicates a left-sided limit of the cdf. For, e.g., an integer-valued variable, it holds . For continuous variables the left limit and the cdf itself coincide. Respective columns can be omitted in the second block.

Eigen::VectorXd vinecopulib::Vinecop::logpdf(Eigen::MatrixXd u, const size_t num_threads = 1) const

Evaluates the copula log-density.

The logarithm of pdf(), and the accurate way to obtain it: a vine density is a product of up to pair-copula densities, so for a high-dimensional or strongly dependent model pdf() underflows to 0, and log(pdf()) to , while the log-density is still perfectly representable. loglik() is the sum of these values.

PdfWithHfuncsResult vinecopulib::Vinecop::pdf_full(Eigen::MatrixXd u, const size_t num_threads = 1, const bool keep_all = true) const

Evaluates the per-pair copula density and h-functions.

The copula density is defined as joint density divided by marginal densities, irrespective of variable types.

When at least one variable is discrete, two types of "observations" are required in u: the first block contains realizations of . The second block contains realizations of . The minus indicates a left-sided limit of the cdf. For, e.g., an integer-valued variable, it holds . For continuous variables the left limit and the cdf itself coincide. Respective columns can be omitted in the second block.

Eigen::VectorXd vinecopulib::Vinecop::pdf(Eigen::MatrixXd u, const Eigen::MatrixXd& parameters, const size_t num_threads = 1) const

Evaluates the copula density with per-observation parameters.

Per-observation counterpart of pdf(); see the per-observation pdf_full() overload for the parameters layout and restrictions.

Eigen::VectorXd vinecopulib::Vinecop::logpdf(Eigen::MatrixXd u, const Eigen::MatrixXd& parameters, const size_t num_threads = 1) const

Evaluates the copula log-density with per-observation parameters.

Per-observation counterpart of logpdf(); see the per-observation pdf_full() overload for the parameters layout and restrictions.

PdfWithHfuncsResult vinecopulib::Vinecop::pdf_full(Eigen::MatrixXd u, const Eigen::MatrixXd& parameters, const size_t num_threads = 1, const bool keep_all = true) const

Evaluates the copula density (and per-edge quantities) with per-observation parameters.

Same as pdf_full(), but each observation uses its own full-vine parameter vector, supplied as an matrix parameters whose columns follow the (tree, edge, parameter) order of scores(). Continuous, all-parametric models only (discrete variables and nonparametric pair copulas are rejected).

Eigen::VectorXd vinecopulib::Vinecop::cdf(const Eigen::MatrixXd& u, const size_t N = 10000, const size_t num_threads = 1, const std::vector<int>& seeds = std::vector<int>()) const

Evaluates the copula distribution.

Because no closed-form expression is available, the distribution is estimated numerically using Monte Carlo integration. The function uses quasi-random numbers from the vine model to do so.

When at least one variable is discrete, two types of "observations" are required in u: the first block contains realizations of . The second block contains realizations of . The minus indicates a left-sided limit of the cdf. For, e.g., an integer-valued variable, it holds . For continuous variables the left limit and the cdf itself coincide. Respective columns can be omitted in the second block.

Eigen::MatrixXd vinecopulib::Vinecop::simulate(const size_t n, const bool qrng = false, const size_t num_threads = 1, const std::vector<int>& seeds = std::vector<int>()) const

Simulates from a vine copula model, see inverse_rosenblatt().

Simulated data is always a continuous matrix. Sampling from a vine copula model is done by first generating uniform random numbers and then applying the inverse Rosenblatt transformation.

Eigen::MatrixXd vinecopulib::Vinecop::simulate_conditional(const Eigen::MatrixXd& u_cond, const bool qrng = false, const size_t num_threads = 1, const std::vector<int>& seeds = std::vector<int>()) const

Simulates from the conditional distribution of a subset of variables given fixed values of the remaining variables.

The conditioning variables are the last k variables of the vine order (they are drawn first by the vine and form a self-contained sub-vine). Each row of u_cond is one conditioning point; the corresponding output row is drawn from the remaining variables' distribution conditional on that point.

Discrete conditioning variables are supported. As for the other data-taking methods, a discrete variable requires its left-limit CDF in addition to ; u_cond therefore carries one extra column per discrete conditioning variable (see the u_cond layout below). The conditioned variables are then drawn using the randomized transform of rosenblatt() (see its randomize_discrete note).

Eigen::MatrixXd vinecopulib::Vinecop::simulate_conditional(const Eigen::MatrixXd& u_cond, const std::vector<size_t>& conditioning_set, const bool qrng = false, const size_t num_threads = 1, const std::vector<int>& seeds = std::vector<int>()) const

Simulates conditionally on a specified set of variables.

void vinecopulib::Vinecop::reorient(const std::vector<size_t>& conditioning_set)

Relabels the vine to an equivalent one whose order tail equals conditioning_set.

A value-preserving re-orientation: the fitted model is unchanged (both the density pdf and the log-likelihood loglik are invariant), only its sampling-order representation changes, so that the variables in conditioning_set are drawn first and can be conditioned on with simulate_conditional. It chooses, per tree, which conditioned variable sits on the matrix diagonal, and flips each pair copula whose stored orientation no longer matches its new position. Truncated models are supported: only the trees they store take part, and the truncation level is preserved. Throws if the current structure admits no sampling order ending in conditioning_set (fit with a conditioning set via FitControlsVinecop to guarantee one exists).

Eigen::MatrixXd vinecopulib::Vinecop::rosenblatt(Eigen::MatrixXd u, const size_t num_threads = 1, bool randomize_discrete = true, std::vector<int> seeds = {}) const

Evaluates the Rosenblatt transform for a vine copula model.

The Rosenblatt transform converts data from this model into independent uniform variates.

The Rosenblatt transform (Rosenblatt, 1952) of a random vector is defined as

where is the conditional distribution of given . The vector then contains independent standard uniform variables. The inverse operation

can be used to simulate from a distribution. For any copula , if is a vector of independent random variables, has distribution .

The formulas above assume a vine copula model with order . More generally, Vinecop::rosenblatt() returns the variables

where is the structure matrix. Similarly, Vinecop::inverse_rosenblatt() computes

If some variables have atoms, Brockwell (10.1016/j.spl.2007.02.008) proposed a simple randomization scheme to ensure that output is still independent uniform if the model is correct. The transformation reads

where is the left limit of the conditional cdf and are are independent standard uniform random variables. This is used by default. If you are interested in the conditional probabilities

set randomize_discrete = FALSE.

Eigen::MatrixXd vinecopulib::Vinecop::rosenblatt(Eigen::MatrixXd u, const std::vector<size_t>& conditioning_set, const size_t num_threads = 1, bool randomize_discrete = true, std::vector<int> seeds = {}) const

Evaluates the Rosenblatt transform for a conditioning set.

The vine is evaluated in an admissible sampling order whose tail contains exactly conditioning_set. The model itself is not modified.

Eigen::MatrixXd vinecopulib::Vinecop::inverse_rosenblatt(const Eigen::MatrixXd& u, const size_t num_threads = 1) const

Evaluates the inverse Rosenblatt transform.

The inverse Rosenblatt transform can be used for simulation: the function applied to independent uniform variates resembles simulated data from the vine copula model.

If the problem is too large, it is split recursively into halves (w.r.t. , the number of observations). "Too large" means that the required memory will exceed 1 GB. An exemplary configuration requiring less than 1 GB is , .

The Rosenblatt transform (Rosenblatt, 1952) of a random vector is defined as

where is the conditional distribution of given . The vector then contains independent standard uniform variables. The inverse operation

can be used to simulate from a distribution. For any copula , if is a vector of independent random variables, has distribution .

The formulas above assume a vine copula model with order . More generally, Vinecop::rosenblatt() returns the variables

where is the structure matrix. Similarly, Vinecop::inverse_rosenblatt() computes

Eigen::MatrixXd vinecopulib::Vinecop::inverse_rosenblatt(const Eigen::MatrixXd& u, const std::vector<size_t>& conditioning_set, const size_t num_threads = 1) const

Evaluates the inverse Rosenblatt transform for a conditioning set.

The vine is evaluated in an admissible sampling order whose tail contains exactly conditioning_set. The model itself is not modified.

double vinecopulib::Vinecop::get_npars() const

Returns sum of the number of parameters for all pair copulas (see. Bicop::get_npars()).

double vinecopulib::Vinecop::loglik(const Eigen::MatrixXd& u = Eigen::MatrixXd(), const size_t num_threads = 1) const

Evaluates the log-likelihood.

The log-likelihood is defined as

where is the copula density, see Vinecop::pdf(). Summing the log-densities keeps the result finite wherever it is representable, which a product of pair-copula densities is not; see Vinecop::logpdf(). An observation containing NaN has no likelihood and is left out of the sum, as it is for Bicop::loglik(); an empty u reports the value recorded by the fit.

double vinecopulib::Vinecop::loglik(const Eigen::MatrixXd& u, const Eigen::MatrixXd& parameters, const size_t num_threads = 1) const

Evaluates the log-likelihood with per-observation parameters.

Log-likelihood with per-observation parameters (see the per-observation pdf() overload for the parameters layout and restrictions).

Per-observation counterpart of loglik(): the sum over observations of , where row i of parameters is . See the per-observation pdf_full() overload for the parameters layout and restrictions.

double vinecopulib::Vinecop::aic(const Eigen::MatrixXd& u = Eigen::MatrixXd(), const size_t num_threads = 1) const

Evaluates the Akaike information criterion (AIC).

The AIC is defined as

where is the log-liklihood (see Vinecop::loglik()) and is the (effective) number of parameters of the model. The AIC is a consistent model selection criterion even for nonparametric models.

double vinecopulib::Vinecop::bic(const Eigen::MatrixXd& u = Eigen::MatrixXd(), const size_t num_threads = 1) const

Evaluates the Bayesian information criterion (BIC).

The BIC is defined as

where is the log-liklihood (see Vinecop::loglik()) and is the (effective) number of parameters of the model. The BIC is a consistent model selection criterion for nonparametric models.

double vinecopulib::Vinecop::mbicv(const Eigen::MatrixXd& u = Eigen::MatrixXd(), const double psi0 = 0.9, const size_t num_threads = 1) const

Evaluates the modified Bayesian information criterion for vines (mBICV).

The mBICV is defined as

where is the log-liklihood, is the (effective) number of parameters of the model, is the tree level, is the prior probability of having a non-independence copula in the first tree, and is the number of non-independence copulas in tree ; The vBIC is a consistent model selection criterion for parametric sparse vine copula models when .

void vinecopulib::Vinecop::truncate(size_t trunc_lvl)

Truncates the vine copula model.

While model for a d dimensional random vector contains at most d-1 nested trees, this function extracts a sub-model based on a given truncation level.

If the model is already truncated at a level less than trunc_lvl, the function does nothing.

std::string vinecopulib::Vinecop::str(const std::vector<size_t>& trees = {}) const

Summarizes the model into a string (can be used for printing).

ScoresResult vinecopulib::Vinecop::scores_full(Eigen::MatrixXd u, bool step_wise = true, const size_t num_threads = 1, const bool keep_all = true)

Evaluates the score function together with the per-edge derivative caches.

The score function is defined as the gradient of the log-likelihood with respect to the parameters.

The scores are computed analytically from the pair copulas' derivatives (Bicop::logpdf_deriv() and, for the full gradient, the h-function derivatives propagated through the vine by the chain rule); models with discrete variables use central finite differences instead (in which case the caches below stay empty). Models with nonparametric pair copulas are rejected (differentiating w.r.t. the interpolation grid is meaningless).

Eigen::MatrixXd vinecopulib::Vinecop::scores(Eigen::MatrixXd u, bool step_wise = true, const size_t num_threads = 1)

Evaluates the score function.

The score function is defined as the gradient of the log-likelihood with respect to the parameters. This is a thin wrapper around scores_full(); see there for the computational details.

Eigen::VectorXd vinecopulib::Vinecop::gradient(Eigen::MatrixXd u, bool step_wise = true, const size_t num_threads = 1)

Evaluates the gradient of the average log-likelihood.

Returns the observation-average of scores() as a vector of length npars, mirroring how hessian() averages hessian_full().

Eigen::MatrixXd vinecopulib::Vinecop::hessian(Eigen::MatrixXd u, bool step_wise = true, const size_t num_threads = 1)

Evaluates the averaged Hessian of the log-likelihood.

Hessian is meant loosely as "gradients of each component of the score function". The Hessian is averaged over all samples in u, yielding an matrix (use hessian_full() for the per-observation decomposition).

TriangularArray<std::vector<Eigen::MatrixXd>> vinecopulib::Vinecop::hessian_full(Eigen::MatrixXd u, bool step_wise = true, const size_t num_threads = 1)

Evaluates the hessian per observation.

Hessian is meant loosely as "gradients of each component of the score function", i.e. hess(t, e)[p](i, a) = ∂² log-likelihood_i / (∂θ_{t,e,p} ∂θ_a). For a continuous model it is computed analytically from the pair copulas' first and second derivatives: the joint (non-step-wise) Hessian by a second-order cascade through the vine (the second derivative of the RVineGrad-style gradient cascade in scores()), and the step-wise Hessian by a first-order cascade of the step-wise score's argument derivatives. Models with discrete variables use central finite differences of scores() instead; models with nonparametric pair copulas are rejected.

Eigen::MatrixXd vinecopulib::Vinecop::scores_cov(Eigen::MatrixXd u, bool step_wise = true, const size_t num_threads = 1)

Computes the covariance matrix of scores.

Returns the (mean-centered, divided by n) covariance of the per-observation scores as an matrix. Together with hessian() this forms the sandwich estimator of the asymptotic covariance.

ScoresResult vinecopulib::Vinecop::scores_full(Eigen::MatrixXd u, const Eigen::MatrixXd& parameters, bool step_wise = true, const size_t num_threads = 1, const bool keep_all = true)

Evaluates the score function with per-observation parameters.

Same as scores_full(), but each observation uses its own full-vine parameter vector, supplied as an matrix parameters whose columns follow the (tree, edge, parameter) order of scores(). Continuous, all-parametric models only; discrete variables are rejected (they would require finite differences that mutate shared parameters).

Eigen::MatrixXd vinecopulib::Vinecop::scores(Eigen::MatrixXd u, const Eigen::MatrixXd& parameters, bool step_wise = true, const size_t num_threads = 1)

Evaluates the score function with per-observation parameters.

Per-observation counterpart of scores(); see the per-observation scores_full() overload for the parameters layout and restrictions.

Eigen::VectorXd vinecopulib::Vinecop::gradient(Eigen::MatrixXd u, const Eigen::MatrixXd& parameters, bool step_wise = true, const size_t num_threads = 1)

Evaluates the gradient of the average log-likelihood with per-observation parameters.

Per-observation counterpart of gradient(); the return is the observation-average of the per-observation scores().

Eigen::MatrixXd vinecopulib::Vinecop::hessian(Eigen::MatrixXd u, const Eigen::MatrixXd& parameters, bool step_wise = true, const size_t num_threads = 1)

Evaluates the averaged Hessian with per-observation parameters.

Per-observation counterpart of hessian(); see the per-observation scores_full() overload for the parameters layout and restrictions.

TriangularArray<std::vector<Eigen::MatrixXd>> vinecopulib::Vinecop::hessian_full(Eigen::MatrixXd u, const Eigen::MatrixXd& parameters, bool step_wise = true, const size_t num_threads = 1)

Evaluates the per-observation Hessians with per-observation parameters.

Per-observation counterpart of hessian_full(); see the per-observation scores_full() overload for the parameters layout and restrictions.

Eigen::MatrixXd vinecopulib::Vinecop::scores_cov(Eigen::MatrixXd u, const Eigen::MatrixXd& parameters, bool step_wise = true, const size_t num_threads = 1)

Computes the covariance matrix of scores with per-observation parameters.

Per-observation counterpart of scores_cov(); see the per-observation scores_full() overload for the parameters layout and restrictions.

Bicop vinecopulib::Vinecop::get_pair_copula(size_t tree, size_t edge) const

Gets a pair copula.

BicopFamily vinecopulib::Vinecop::get_family(size_t tree, size_t edge) const

Gets the family of a pair copula.

int vinecopulib::Vinecop::get_rotation(size_t tree, size_t edge) const

Gets the rotation of a pair copula.

Eigen::MatrixXd vinecopulib::Vinecop::get_parameters(size_t tree, size_t edge) const

Gets the parameters of a pair copula.

double vinecopulib::Vinecop::get_tau(size_t tree, size_t edge) const

Gets the Kendall's of a pair copula.

size_t vinecopulib::Vinecop::get_trunc_lvl() const

std::vector<std::vector<Bicop>> vinecopulib::Vinecop::get_all_pair_copulas() const

Gets all pair copulas.

std::vector<std::vector<BicopFamily>> vinecopulib::Vinecop::get_all_families() const

Gets the families of all pair copulas.

std::vector<std::vector<int>> vinecopulib::Vinecop::get_all_rotations() const

Gets the rotations of all pair copulas.

std::vector<std::vector<Eigen::MatrixXd>> vinecopulib::Vinecop::get_all_parameters() const

Gets the parameters of all pair copulas.

std::vector<std::vector<double>> vinecopulib::Vinecop::get_all_taus() const

Gets the Kendall's s of all pair copulas.

size_t vinecopulib::Vinecop::get_dim() const

Gets the dimension of the vine copula model.

std::vector<size_t> vinecopulib::Vinecop::get_order() const

Gets the order vector of the vine copula model.

RVineStructure vinecopulib::Vinecop::get_rvine_structure() const

Gets the structure matrix of the vine copula model.

Eigen::Matrix<size_t, Eigen::Dynamic, Eigen::Dynamic> vinecopulib::Vinecop::get_matrix() const

Gets the structure matrix of the vine copula model.

TriangularArray<size_t> vinecopulib::Vinecop::get_struct_array(bool natural_order = false) const

Gets the above diagonal coefficients of the vine copula model.

RVineTrees vinecopulib::Vinecop::get_trees() const

Gets the vine as a list-of-trees decomposition, each edge carrying its fitted pair-copula (stored with its first argument on the diagonal).

double vinecopulib::Vinecop::get_threshold() const

Gets the threshold.

Usually zero except select_threshold == TRUE in FitControlsVinecop()).

double vinecopulib::Vinecop::get_loglik() const

Gets the log-likelihood (throws an error if model has not been. fitted to data).

size_t vinecopulib::Vinecop::get_nobs() const

Gets the number of observations used for the fit.

The function throws an error if model has not been fitted to data.

double vinecopulib::Vinecop::get_aic() const

Gets the AIC.

The function throws an error if model has not been fitted to data.

double vinecopulib::Vinecop::get_bic() const

Gets the BIC.

The function throws an error if model has not been fitted to data.

double vinecopulib::Vinecop::get_mbicv(const double psi0 = 0.9) const

Gets the log-likelihood.

The function throws an error if model has not been fitted to data.

void vinecopulib::Vinecop::set_all_pair_copulas(const std::vector<std::vector<Bicop>>& pair_copulas)

Sets all pair-copulas.

Sets every pair copula in one shot.

void vinecopulib::Vinecop::set_var_types(const std::vector<std::string>& var_types)

Sets variable types.

Sets the variable types.

std::vector<std::string> vinecopulib::Vinecop::get_var_types() const

Gets the variable types.