Package 'CausalMixGPD'

Description

Scalar Amoroso utilities used as flexible positive-support base kernels and mixture components. The package parameterization uses loc, scale, shape1, and shape2, allowing the family to represent a broad range of skewed bulk shapes.

Usage

dAmoroso(x, loc, scale, shape1, shape2, log = 0)

pAmoroso(q, loc, scale, shape1, shape2, lower.tail = 1, log.p = 0)

qAmoroso(p, loc, scale, shape1, shape2, lower.tail = TRUE, log.p = FALSE)

rAmoroso(n, loc, scale, shape1, shape2)

Arguments

Details

Writing loc = a, scale = theta, shape1 = alpha, and shape2 = beta, the transformed quantity $((X - a) / \theta)^\beta$ follows a gamma law with shape $\alpha$.

These uppercase NIMBLE-compatible functions are scalar (x/q and n = 1). For vectorized R usage, use base_lowercase().

The Amoroso family used in the package is defined by the density

$f(x) = \left|\frac{\beta}{\theta}\right| \frac{z^{\alpha \beta - 1}\exp(-z^\beta)}{\Gamma(\alpha)}, \qquad z = \frac{x-a}{\theta},$

on the side of the location parameter determined by the sign of $\theta$. Equivalently, $Z = ((X-a)/\theta)^\beta$ follows a Gamma distribution with shape $\alpha$ and unit scale. That representation explains why the quantile function is computed from a gamma quantile and then mapped back through the inverse transformation.

The mean exists whenever $\alpha + 1/\beta$ lies in the domain of the gamma function used by the moment formula. In the package this family serves as a flexible positive-support bulk kernel capable of reproducing gamma-like, Weibull-like, and other skewed shapes with a single parameterization.

Value

Density/CDF/RNG functions return numeric scalars. The quantile function returns a numeric scalar or vector matching the length of p.

Functions

• dAmoroso(): Density Function of Amoroso Distribution

• pAmoroso(): Distribution Function of Amoroso Distribution

• qAmoroso(): Quantile Function of Amoroso Distribution

• rAmoroso(): Sample generating Function of Amoroso Distribution

See Also

amoroso_mix(), amoroso_gpd(), base_lowercase(), kernel_support_table().

Other base bulk distributions: InvGauss, cauchy

Examples

loc <- 0
scale <- 1.5
shape1 <- 2
shape2 <- 1.2

dAmoroso(1.0, loc, scale, shape1, shape2, log = 0)
pAmoroso(1.0, loc, scale, shape1, shape2, lower.tail = 1, log.p = 0)
qAmoroso(0.50, loc, scale, shape1, shape2)
qAmoroso(0.95, loc, scale, shape1, shape2)
replicate(10, rAmoroso(1, loc, scale, shape1, shape2))

Description

Spliced family obtained by attaching a generalized Pareto tail above threshold to a single Amoroso bulk.

Usage

dAmorosoGpd(
  x,
  loc,
  scale,
  shape1,
  shape2,
  threshold,
  tail_scale,
  tail_shape,
  log = 0
)

pAmorosoGpd(
  q,
  loc,
  scale,
  shape1,
  shape2,
  threshold,
  tail_scale,
  tail_shape,
  lower.tail = 1,
  log.p = 0
)

rAmorosoGpd(n, loc, scale, shape1, shape2, threshold, tail_scale, tail_shape)

qAmorosoGpd(
  p,
  loc,
  scale,
  shape1,
  shape2,
  threshold,
  tail_scale,
  tail_shape,
  lower.tail = TRUE,
  log.p = FALSE,
  tol = 1e-10,
  maxiter = 200
)

Arguments

Details

This is the single-component Amoroso splice. The Amoroso law controls the distribution below the threshold and the GPD controls exceedances above it, scaled so that the resulting CDF is continuous at the threshold. The ordinary mean of the spliced law exists only when the tail satisfies $\xi < 1$; otherwise users should rely on restricted means or quantile summaries.

Value

Spliced density/CDF/RNG functions return numeric scalars. qAmorosoGpd() returns a numeric vector with the same length as p.

Functions

• dAmorosoGpd(): Density Function of Amoroso Distribution with GPD Tail

• pAmorosoGpd(): Cumulative Distribution Function of Amoroso Distribution with GPD Tail

• rAmorosoGpd(): Random Generation for Amoroso Distribution with GPD Tail

• qAmorosoGpd(): Quantile Function of Amoroso Distribution with GPD Tail

See Also

amoroso_mix(), amoroso_mixgpd(), gpd(), amoroso_lowercase().

Other amoroso kernel families: amoroso_mix, amoroso_mixgpd

Examples

loc <- 0
scale <- 1.5
shape1 <- 2
shape2 <- 1.2
threshold <- 3
tail_scale <- 1.0
tail_shape <- 0.2

dAmorosoGpd(4.0, loc, scale, shape1, shape2,
           threshold, tail_scale, tail_shape, log = 0)
pAmorosoGpd(4.0, loc, scale, shape1, shape2,
           threshold, tail_scale, tail_shape, lower.tail = 1, log.p = 0)
qAmorosoGpd(0.50, loc, scale, shape1, shape2,
           threshold, tail_scale, tail_shape)
qAmorosoGpd(0.95, loc, scale, shape1, shape2,
           threshold, tail_scale, tail_shape)
replicate(10, rAmorosoGpd(1, loc, scale, shape1, shape2,
                         threshold, tail_scale, tail_shape))

Description

Vectorized R wrappers for the scalar Amoroso-kernel topics in this file.

Usage

damorosomix(x, w, loc, scale, shape1, shape2, log = FALSE)

pamorosomix(q, w, loc, scale, shape1, shape2, lower.tail = TRUE, log.p = FALSE)

qamorosomix(
  p,
  w,
  loc,
  scale,
  shape1,
  shape2,
  lower.tail = TRUE,
  log.p = FALSE,
  tol = 1e-10,
  maxiter = 200
)

ramorosomix(n, w, loc, scale, shape1, shape2)

damorosomixgpd(
  x,
  w,
  loc,
  scale,
  shape1,
  shape2,
  threshold,
  tail_scale,
  tail_shape,
  log = FALSE
)

pamorosomixgpd(
  q,
  w,
  loc,
  scale,
  shape1,
  shape2,
  threshold,
  tail_scale,
  tail_shape,
  lower.tail = TRUE,
  log.p = FALSE
)

qamorosomixgpd(
  p,
  w,
  loc,
  scale,
  shape1,
  shape2,
  threshold,
  tail_scale,
  tail_shape,
  lower.tail = TRUE,
  log.p = FALSE,
  tol = 1e-10,
  maxiter = 200
)

ramorosomixgpd(
  n,
  w,
  loc,
  scale,
  shape1,
  shape2,
  threshold,
  tail_scale,
  tail_shape
)

damorosogpd(
  x,
  loc,
  scale,
  shape1,
  shape2,
  threshold,
  tail_scale,
  tail_shape,
  log = FALSE
)

pamorosogpd(
  q,
  loc,
  scale,
  shape1,
  shape2,
  threshold,
  tail_scale,
  tail_shape,
  lower.tail = TRUE,
  log.p = FALSE
)

qamorosogpd(
  p,
  loc,
  scale,
  shape1,
  shape2,
  threshold,
  tail_scale,
  tail_shape,
  lower.tail = TRUE,
  log.p = FALSE,
  tol = 1e-10,
  maxiter = 200
)

ramorosogpd(n, loc, scale, shape1, shape2, threshold, tail_scale, tail_shape)

Arguments

Details

These are vectorized wrappers around the scalar Amoroso routines used internally by the package. They preserve the same location-scale-shape parameterization and the same piecewise splice logic for GPD tails. Quantile wrappers therefore continue to rely on the scalar numerical inversion or scalar GPD inverse exactly as documented for the uppercase functions.

Value

Numeric vector of densities, probabilities, quantiles, or random variates.

Functions

• damorosomix(): Amoroso mixture density (vectorized)

• pamorosomix(): Amoroso mixture distribution function (vectorized)

• qamorosomix(): Amoroso mixture quantile function (vectorized)

• ramorosomix(): Amoroso mixture random generation (vectorized)

• damorosomixgpd(): Amoroso mixture + GPD density (vectorized)

• pamorosomixgpd(): Amoroso mixture + GPD distribution function (vectorized)

• qamorosomixgpd(): Amoroso mixture + GPD quantile function (vectorized)

• ramorosomixgpd(): Amoroso mixture + GPD random generation (vectorized)

• damorosogpd(): Amoroso + GPD density (vectorized)

• pamorosogpd(): Amoroso + GPD distribution function (vectorized)

• qamorosogpd(): Amoroso + GPD quantile function (vectorized)

• ramorosogpd(): Amoroso + GPD random generation (vectorized)

See Also

amoroso_mix(), amoroso_mixgpd(), amoroso_gpd(), bundle(), get_kernel_registry().

Other vectorized kernel helpers: base_lowercase, cauchy_mix_lowercase, gamma_lowercase, invgauss_lowercase, laplace_lowercase, lognormal_lowercase, normal_lowercase

Examples

w <- c(0.6, 0.3, 0.1)
locs <- c(0.5, 0.5, 0.5)
scls <- c(1, 1.3, 1.6)
s1 <- c(2.5, 3, 4)
s2 <- c(1.2, 1.2, 1.2)

# Amoroso mixture
damorosomix(c(1, 2, 3), w = w, loc = locs, scale = scls, shape1 = s1, shape2 = s2)
ramorosomix(5, w = w, loc = locs, scale = scls, shape1 = s1, shape2 = s2)

Description

Finite mixture of Amoroso components for flexible positive-support bulk modeling.

Usage

dAmorosoMix(x, w, loc, scale, shape1, shape2, log = 0)

pAmorosoMix(q, w, loc, scale, shape1, shape2, lower.tail = 1, log.p = 0)

rAmorosoMix(n, w, loc, scale, shape1, shape2)

qAmorosoMix(
  p,
  w,
  loc,
  scale,
  shape1,
  shape2,
  lower.tail = TRUE,
  log.p = FALSE,
  tol = 1e-10,
  maxiter = 200
)

Arguments

Details

The mixture density is

$f(x) = \sum_{k = 1}^K \tilde{w}_k f_{Amoroso}(x \mid a_k, \theta_k, \alpha_k, \beta_k),$

with normalized weights $\tilde{w}_k$. These scalar functions are NIMBLE-compatible; for vectorized R usage, use amoroso_lowercase().

The Amoroso family is especially useful for positive-support data because it can reproduce a wide range of skewed and heavy-right-tail shapes while remaining analytically tractable through its gamma transformation. The mixture CDF is

$F(x) = \sum_{k=1}^K \tilde{w}_k F_{Amoroso}(x \mid a_k,\theta_k,\alpha_k,\beta_k),$

and random generation proceeds by selecting a component and sampling from that component.

Closed-form mixture quantiles are not available, so qAmorosoMix() inverts the mixture CDF numerically. The analytical mixture mean is the weighted average of the component means, $a_k + \theta_k \Gamma(\alpha_k + 1/\beta_k) / \Gamma(\alpha_k)$, whenever those component moments exist.

Value

Mixture density/CDF/RNG functions return numeric scalars. qAmorosoMix() returns a numeric vector with the same length as p.

Functions

• dAmorosoMix(): Density Function of Amoroso Mixture Distribution

• pAmorosoMix(): Cumulative Distribution Function of Amoroso Mixture Distribution

• rAmorosoMix(): Random Generation for Amoroso Mixture Distribution

• qAmorosoMix(): Quantile Function of Amoroso Mixture Distribution

See Also

amoroso_mixgpd(), amoroso_gpd(), amoroso_lowercase(), build_nimble_bundle(), kernel_support_table().

Other amoroso kernel families: amoroso_gpd, amoroso_mixgpd

Examples

w <- c(0.60, 0.25, 0.15)
loc <- c(0, 1, 2)
scale <- c(1.0, 1.2, 1.6)
shape1 <- c(2, 4, 6)
shape2 <- c(1.0, 1.2, 1.5)

dAmorosoMix(2.0, w, loc, scale, shape1, shape2, log = 0)
pAmorosoMix(2.0, w, loc, scale, shape1, shape2, lower.tail = 1, log.p = 0)
qAmorosoMix(0.50, w, loc, scale, shape1, shape2)
qAmorosoMix(0.95, w, loc, scale, shape1, shape2)
replicate(10, rAmorosoMix(1, w, loc, scale, shape1, shape2))

Description

Spliced bulk-tail family formed by attaching a generalized Pareto tail to an Amoroso mixture bulk. Let $F_{mix}$ denote the Amoroso mixture CDF. The spliced CDF is $F(x)=F_{mix}(x)$ for $x<threshold$ and $F(x)=F_{mix}(threshold) + \left\{1-F_{mix}(threshold)\right\}G(x)$ for $x\ge threshold$, where $G$ is the GPD CDF for exceedances above threshold.

Usage

dAmorosoMixGpd(
  x,
  w,
  loc,
  scale,
  shape1,
  shape2,
  threshold,
  tail_scale,
  tail_shape,
  log = 0
)

pAmorosoMixGpd(
  q,
  w,
  loc,
  scale,
  shape1,
  shape2,
  threshold,
  tail_scale,
  tail_shape,
  lower.tail = 1,
  log.p = 0
)

rAmorosoMixGpd(
  n,
  w,
  loc,
  scale,
  shape1,
  shape2,
  threshold,
  tail_scale,
  tail_shape
)

qAmorosoMixGpd(
  p,
  w,
  loc,
  scale,
  shape1,
  shape2,
  threshold,
  tail_scale,
  tail_shape,
  lower.tail = TRUE,
  log.p = FALSE,
  tol = 1e-10,
  maxiter = 200
)

Arguments

Details

The density, CDF, and RNG are implemented as nimbleFunctions for use in NIMBLE models. The quantile function is an R function that uses numerical inversion in the bulk region and the closed-form GPD quantile in the tail region.

The Amoroso mixture describes the bulk up to the threshold and the generalized Pareto describes exceedances above it. If $F_{mix}(u)=p_u$, then the splice uses

$f(x) = \left\{ \begin{array}{ll} f_{mix}(x), & x < u, \\ (1-p_u) g_{GPD}(x \mid u,\sigma_u,\xi), & x \ge u. \end{array} \right.$

Bulk quantiles are computed numerically from the Amoroso mixture CDF and tail quantiles are obtained from the GPD inverse after rescaling the tail probability.

Value

Spliced density/CDF/RNG functions return numeric scalars. qAmorosoMixGpd() returns a numeric vector with the same length as p.

Functions

• dAmorosoMixGpd(): Density Function of Amoroso Mixture Distribution with GPD Tail

• pAmorosoMixGpd(): Cumulative Distribution Function of Amoroso Mixture Distribution with GPD Tail

• rAmorosoMixGpd(): Random Generation for Amoroso Mixture Distribution with GPD Tail

• qAmorosoMixGpd(): Quantile Function of Amoroso Mixture Distribution with GPD Tail

See Also

amoroso_mix(), amoroso_gpd(), gpd(), amoroso_lowercase(), dpmgpd().

Other amoroso kernel families: amoroso_gpd, amoroso_mix

Examples

w <- c(0.60, 0.25, 0.15)
loc <- c(0, 1, 2)
scale <- c(1.0, 1.2, 1.6)
shape1 <- c(2, 4, 6)
shape2 <- c(1.0, 1.2, 1.5)
threshold <- 3
tail_scale <- 1.0
tail_shape <- 0.2

dAmorosoMixGpd(4.0, w, loc, scale, shape1, shape2,
              threshold, tail_scale, tail_shape, log = 0)
pAmorosoMixGpd(4.0, w, loc, scale, shape1, shape2,
              threshold, tail_scale, tail_shape, lower.tail = 1, log.p = 0)
qAmorosoMixGpd(0.50, w, loc, scale, shape1, shape2,
              threshold, tail_scale, tail_shape)
qAmorosoMixGpd(0.95, w, loc, scale, shape1, shape2,
              threshold, tail_scale, tail_shape)
replicate(10, rAmorosoMixGpd(1, w, loc, scale, shape1, shape2,
                            threshold, tail_scale, tail_shape))

Description

ate_rmean() is a convenience wrapper for restricted-mean treatment effects when the ordinary mean is unstable or undefined.

Usage

ate_rmean(
  fit,
  newdata = NULL,
  cutoff,
  interval = "credible",
  level = 0.95,
  nsim_mean = 200L,
  show_progress = TRUE
)

Arguments

Details

The restricted-mean estimand replaces $Y(a)$ by $\min\{Y(a), c\}$, so the contrast remains finite even when the fitted GPD tail implies $\xi \ge 1$.

Value

A "causalmixgpd_ate" object computed via ate for unconditional fits or cate for conditional fits. The returned object includes a top-level $fit_df data frame for direct extraction.

See Also

ate, cate, predict.mixgpd_fit.

Examples

N <- 25
X <- data.frame(x1 = stats::rnorm(N))
A <- stats::rbinom(N, 1, 0.5)
y <- abs(stats::rnorm(N)) + 0.1
mcmc_small <- list(niter = 100, nburnin = 50, thin = 1, nchains = 1, seed = 1)
cb <- build_causal_bundle(y = y, X = X, A = A, backend = "sb", kernel = "normal",
                         GPD = TRUE, components = 3,
                         mcmc_outcome = mcmc_small, mcmc_ps = mcmc_small)
fit <- run_mcmc_causal(cb)
ate_rm <- ate_rmean(fit, cutoff = 10, interval = "credible")

Description

ate() computes the posterior predictive average treatment effect.

Usage

## S3 method for class 'causalmixgpd_causal_fit'
ate(
  fit,
  newdata = NULL,
  y = NULL,
  type = c("mean", "rmean"),
  cutoff = NULL,
  interval = "credible",
  level = 0.95,
  nsim_mean = 200L,
  show_progress = TRUE
)

Arguments

Details

The default mean-scale estimand is

$\mathrm{ATE} = E\{Y(1)\} - E\{Y(0)\},$

where the expectation is taken with respect to the empirical training covariate distribution for conditional models.

When type = "rmean", the function instead computes a restricted-mean ATE using $E\{\min(Y(a), c)\}$ for each arm. For outcome kernels with a finite analytical mean, the ordinary mean path is analytical within each posterior draw; rmean remains simulation-based.

For unconditional causal models (X = NULL), the computation reduces to a direct contrast of the unconditional treated and control predictive laws.

Value

An object of class "causalmixgpd_ate" containing the marginal ATE summary, optional intervals, and the arm-specific predictive objects used in the aggregation. The returned object includes a top-level $fit_df data frame for direct extraction.

See Also

att, cate, qte, ate_rmean, predict.causalmixgpd_causal_fit.

Examples

N <- 25
X <- data.frame(x1 = stats::rnorm(N))
A <- stats::rbinom(N, 1, 0.5)
y <- abs(stats::rnorm(N)) + 0.1
mcmc_small <- list(niter = 100, nburnin = 50, thin = 1, nchains = 1, seed = 1)
cb <- build_causal_bundle(y = y, X = X, A = A, backend = "sb", kernel = "normal",
                         components = 3, mcmc_outcome = mcmc_small, mcmc_ps = mcmc_small)
fit <- run_mcmc_causal(cb, show_progress = FALSE)
ate(fit, interval = "credible", level = 0.90, nsim_mean = 100)

Description

att() computes the average treatment effect on the treated.

Usage

att(
  fit,
  newdata = NULL,
  y = NULL,
  type = c("mean", "rmean"),
  cutoff = NULL,
  interval = "credible",
  level = 0.95,
  nsim_mean = 200L,
  show_progress = TRUE
)

Arguments

Details

The estimand is

$\mathrm{ATT} = E\{Y(1) - Y(0) \mid A = 1\},$

approximated by marginalizing over the empirical covariate distribution of treated units.

Value

An object of class "causalmixgpd_ate" containing the ATT summary, optional intervals, and the arm-specific predictive objects used in the aggregation. The returned object includes a top-level $fit_df data frame for direct extraction.

See Also

ate, qtt, cate.

Examples

N <- 25
X <- data.frame(x1 = stats::rnorm(N))
A <- stats::rbinom(N, 1, 0.5)
y <- abs(stats::rnorm(N)) + 0.1
mcmc_small <- list(niter = 100, nburnin = 50, thin = 1, nchains = 1, seed = 1)
cb <- build_causal_bundle(y = y, X = X, A = A, backend = "sb", kernel = "normal",
                         components = 3, mcmc_outcome = mcmc_small, mcmc_ps = mcmc_small)
fit <- run_mcmc_causal(cb, show_progress = FALSE)
att(fit, interval = "credible", nsim_mean = 100)

Description

Vectorized R wrappers around the scalar base-kernel functions defined in this file. These helpers are intended for interactive R use, examples, testing, and checking numerical behavior outside compiled NIMBLE code.

Usage

dgpd(x, threshold, scale, shape, log = FALSE)

pgpd(q, threshold, scale, shape, lower.tail = TRUE, log.p = FALSE)

qgpd(p, threshold, scale, shape, lower.tail = TRUE, log.p = FALSE)

rgpd(n, threshold, scale, shape)

dinvgauss(x, mean, shape, log = FALSE)

pinvgauss(q, mean, shape, lower.tail = TRUE, log.p = FALSE)

qinvgauss(
  p,
  mean,
  shape,
  lower.tail = TRUE,
  log.p = FALSE,
  tol = 1e-10,
  maxiter = 200
)

rinvgauss(n, mean, shape)

damoroso(x, loc, scale, shape1, shape2, log = FALSE)

pamoroso(q, loc, scale, shape1, shape2, lower.tail = TRUE, log.p = FALSE)

qamoroso(p, loc, scale, shape1, shape2, lower.tail = TRUE, log.p = FALSE)

ramoroso(n, loc, scale, shape1, shape2)

dcauchy_vec(x, location, scale, log = FALSE)

pcauchy_vec(q, location, scale, lower.tail = TRUE, log.p = FALSE)

qcauchy_vec(p, location, scale, lower.tail = TRUE, log.p = FALSE)

rcauchy_vec(n, location, scale)

Arguments

Details

The wrappers preserve the same parameterizations as the uppercase scalar functions, but accept vector inputs for x, q, or p and allow n > 1 for random generation.

Each lowercase helper is a vectorized R wrapper around the corresponding uppercase scalar routine documented in this file. The wrapper keeps the same parameterization and applies the scalar kernel repeatedly over the supplied evaluation points or simulation index. These helpers are therefore appropriate for interactive analysis, testing, and examples, whereas the uppercase functions are the building blocks used inside NIMBLE model code.

The wrappers do not change the underlying theory. For example, qgpd() still uses the closed-form GPD inverse, qinvgauss() still performs numerical inversion of the inverse Gaussian CDF, and qamoroso() still maps a gamma quantile through the Amoroso transformation. Random-generation wrappers call the corresponding scalar RNG repeatedly when n > 1.

Value

Numeric vector of densities, probabilities, quantiles, or random variates.

Functions

• dgpd(): GPD density (vectorized)

• pgpd(): GPD distribution function (vectorized)

• qgpd(): GPD quantile function (vectorized)

• rgpd(): GPD random generation (vectorized)

• dinvgauss(): Inverse Gaussian density (vectorized)

• pinvgauss(): Inverse Gaussian distribution function (vectorized)

• qinvgauss(): Inverse Gaussian quantile function (vectorized)

• rinvgauss(): Inverse Gaussian random generation (vectorized)

• damoroso(): Amoroso density (vectorized)

• pamoroso(): Amoroso distribution function (vectorized)

• qamoroso(): Amoroso quantile function (vectorized)

• ramoroso(): Amoroso random generation (vectorized)

• dcauchy_vec(): Cauchy density (vectorized)

• pcauchy_vec(): Cauchy distribution function (vectorized)

• qcauchy_vec(): Cauchy quantile function (vectorized)

• rcauchy_vec(): Cauchy random generation (vectorized)

See Also

gpd(), InvGauss(), amoroso(), cauchy(), build_nimble_bundle(), kernel_support_table().

Other vectorized kernel helpers: amoroso_lowercase, cauchy_mix_lowercase, gamma_lowercase, invgauss_lowercase, laplace_lowercase, lognormal_lowercase, normal_lowercase

Examples

# GPD
dgpd(c(1.5, 2.0, 2.5), threshold = 1, scale = 0.8, shape = 0.2)
pgpd(c(1.5, 2.0), threshold = 1, scale = 0.8, shape = 0.2)
qgpd(c(0.5, 0.9), threshold = 1, scale = 0.8, shape = 0.2)
rgpd(5, threshold = 1, scale = 0.8, shape = 0.2)

# Inverse Gaussian
dinvgauss(c(1, 2, 3), mean = 2, shape = 5)
rinvgauss(5, mean = 2, shape = 5)

# Amoroso
damoroso(c(1, 2), loc = 0, scale = 1.5, shape1 = 2, shape2 = 1.2)
ramoroso(5, loc = 0, scale = 1.5, shape1 = 2, shape2 = 1.2)

# Cauchy
dcauchy_vec(c(-1, 0, 1), location = 0, scale = 1)
rcauchy_vec(5, location = 0, scale = 1)

Description

build_causal_bundle() is the detailed constructor behind bundle for causal analyses. It prepares:

• a propensity score (PS) design block for $A \mid X$,

• a control-arm outcome bundle for $Y(0)$,

• a treated-arm outcome bundle for $Y(1)$.

Usage

build_causal_bundle(
  y,
  X,
  A,
  backend = c("sb", "crp", "spliced"),
  kernel,
  GPD = FALSE,
  components = 10L,
  param_specs = NULL,
  mcmc_outcome = list(niter = 2000, nburnin = 500, thin = 1, nchains = 1, seed = 1),
  mcmc_ps = list(niter = 1000, nburnin = 250, thin = 1, nchains = 1, seed = 1),
  epsilon = 0.025,
  alpha_random = TRUE,
  ps_prior = list(mean = 0, sd = 2),
  include_intercept = TRUE,
  PS = "logit",
  ps_scale = c("logit", "prob"),
  ps_summary = c("mean", "median"),
  ps_clamp = 1e-06,
  monitor = c("core", "full"),
  monitor_latent = FALSE,
  monitor_v = FALSE
)

Arguments

Details

The outcome bundles reuse the one-arm DPM plus optional GPD machinery. The PS block provides a shared adjustment object used by run_mcmc_causal and predict.causalmixgpd_causal_fit.

The causal bundle encodes the two arm-specific predictive laws $F_0(y \mid x)$ and $F_1(y \mid x)$. Downstream causal estimands are functionals of these two distributions:

$\mathrm{ATE} = E\{Y(1)\} - E\{Y(0)\}, \qquad \mathrm{QTE}(\tau) = Q_1(\tau) - Q_0(\tau).$

When PS is enabled, the package estimates a propensity score model $e(x) = \Pr(A = 1 \mid X = x)$ and uses a posterior summary of that score as an augmented covariate in the arm-specific outcome models. This mirrors the workflow described in the manuscript vignette.

Value

A list of class "causalmixgpd_causal_bundle" containing the design bundle, two outcome bundles, training data, arm indices, and metadata required for posterior prediction and causal effect summaries.

See Also

bundle, run_mcmc_causal, predict.causalmixgpd_causal_fit, ate, qte, cate, cqte.

Examples

set.seed(1)
N <- 25
X <- cbind(x1 = rnorm(N), x2 = runif(N))
A <- rbinom(N, 1, plogis(0.3 + 0.5 * X[, 1]))
y <- rexp(N) + 0.1

cb <- build_causal_bundle(
  y = y,
  X = X,
  A = A,
  backend = "sb",
  kernel = "gamma",
  GPD = TRUE,
  components = 3,
  PS = "probit"
)

Description

build_nimble_bundle() is the detailed constructor behind bundle for one-arm models. It compiles the modeling plan into a self-contained object holding code-generation inputs, initialization rules, monitor policy, and stored MCMC defaults.

Usage

build_nimble_bundle(
  y,
  X = NULL,
  ps = NULL,
  backend = c("sb", "crp", "spliced"),
  kernel,
  GPD = FALSE,
  components = 10L,
  param_specs = NULL,
  mcmc = list(niter = 2000, nburnin = 500, thin = 1, nchains = 1, seed = 1),
  epsilon = 0.025,
  alpha_random = TRUE,
  monitor = c("core", "full"),
  monitor_latent = FALSE,
  monitor_v = FALSE
)

Arguments

Details

The returned bundle encodes a finite approximation to a Dirichlet process mixture using either a stick-breaking ("sb") or Chinese restaurant process / spliced ("crp" / "spliced") representation.

For the bulk-only model, the target likelihood is the DPM predictive law

$f(y \mid x) = \sum_{k=1}^{K} w_k(x) f_k(y \mid x, \theta_k).$

When GPD = TRUE, the bundle augments the bulk model with a threshold $u(x)$ and generalized Pareto tail above that threshold, producing the spliced predictive distribution described in the manuscript vignette.

This function intentionally stops before model compilation and sampling. Use run_mcmc_bundle_manual or mcmc to execute the stored model definition.

The object contains:

• compiled model spec

• nimbleCode model code

• constants, data, explicit dimensions

• initialization function inits (stored as a function)

• monitor specification

• MCMC settings list (stored but not used for code generation)

Value

A named list of class "causalmixgpd_bundle". Its primary components are spec, code, constants, dimensions, data, inits, monitors, and stored mcmc settings.

See Also

bundle, run_mcmc_bundle_manual, predict.mixgpd_fit, kernel_support_table, get_kernel_registry.

Examples

y <- abs(rnorm(25)) + 0.1
bundle <- build_nimble_bundle(
  y = y,
  backend = "sb",
  kernel = "normal",
  GPD = FALSE,
  components = 3,
  mcmc = list(niter = 100, nburnin = 50, thin = 1, nchains = 1, seed = 1)
)
bundle

Description

bundle() is the main workflow constructor. It converts raw inputs, a formula/data pair, or an already prepared bundle into the canonical object consumed by mcmc, dpmix, dpmgpd, dpmix.causal, and dpmgpd.causal.

Usage

bundle(
  y = NULL,
  X = NULL,
  treat = NULL,
  data = NULL,
  formula = NULL,
  GPD = FALSE,
  ...
)

Arguments

Details

For one-arm models the returned object represents a bulk Dirichlet process mixture, optionally augmented with a spliced generalized Pareto tail. For causal models the returned object contains two arm-specific outcome bundles plus an optional propensity score block.

The workflow is:

1. prepare a bundle with bundle(),

2. run posterior sampling with mcmc or one of the dpmix*/dpmgpd* wrappers,

3. inspect the fitted object with summary.mixgpd_fit, params, predict.mixgpd_fit, or the causal estimand helpers.

Setting GPD = TRUE requests the spliced bulk-tail model with conditional distribution

$F(y \mid x) = F_{\mathrm{bulk}}(y \mid x)\mathbf{1}\{y \le u(x)\} + \left[p_u(x) + \{1 - p_u(x)\}F_{\mathrm{GPD}}(y \mid x)\right]\mathbf{1}\{y > u(x)\},$

where $p_u(x)$ is the bulk probability below the threshold $u(x)$.

See the manuscript vignette for the DPM hierarchy, SB/CRP representations, and the spliced bulk-tail construction used throughout the package.

Value

A "causalmixgpd_bundle" for one-arm models or a "causalmixgpd_causal_bundle" for causal models. The bundle stores code-generation inputs, monitor policy, and default MCMC settings, but it does not run MCMC.

See Also

build_nimble_bundle, build_causal_bundle, mcmc, dpmix, dpmgpd.

Description

cate() evaluates treated-minus-control predictive means, or restricted means, at user-supplied covariate rows.

Usage

## S3 method for class 'causalmixgpd_causal_fit'
cate(
  fit,
  newdata = NULL,
  type = c("mean", "rmean"),
  cutoff = NULL,
  interval = "credible",
  level = 0.95,
  nsim_mean = 200L,
  show_progress = TRUE
)

Arguments

Details

For each prediction row $x$, the conditional average treatment effect is

$\mathrm{CATE}(x) = E\{Y(1) \mid x\} - E\{Y(0) \mid x\}.$

With type = "rmean", the estimand becomes the conditional restricted mean contrast

$E\{\min(Y(1), c) \mid x\} - E\{\min(Y(0), c) \mid x\},$

which remains finite even when the ordinary mean is unstable under a heavy GPD tail. For outcome kernels with a finite analytical mean, the ordinary mean path is analytical within each posterior draw; rmean remains a separate simulation-based estimand.

This estimand is available only for conditional causal models with covariates. For marginal mean contrasts, use ate or att.

Value

An object of class "causalmixgpd_ate" containing the CATE summary, optional intervals, and the treated/control prediction objects used to construct the effect. The returned object includes a top-level $fit_df data frame for direct extraction.

See Also

ate, att, cqte, ate_rmean, predict.causalmixgpd_causal_fit.

Examples

N <- 25
X <- data.frame(x1 = stats::rnorm(N))
A <- stats::rbinom(N, 1, 0.5)
y <- abs(stats::rnorm(N)) + 0.1
mcmc_small <- list(niter = 100, nburnin = 50, thin = 1, nchains = 1, seed = 1)
cb <- build_causal_bundle(y = y, X = X, A = A, backend = "sb", kernel = "normal",
                         components = 3, mcmc_outcome = mcmc_small, mcmc_ps = mcmc_small)
fit <- run_mcmc_causal(cb, show_progress = FALSE)
cate(fit, newdata = X[1:5, , drop = FALSE])
cate(fit, interval = "credible", level = 0.90)  # 90% CI
cate(fit, interval = "hpd")  # HPD intervals
cate(fit, interval = NULL)   # No intervals

Description

Scalar Cauchy utilities implemented for NIMBLE compatibility. These functions support symmetric heavy-tailed kernels on the real line and feed directly into the finite Cauchy mixture family.

Usage

dCauchy(x, location, scale, log = 0)

pCauchy(q, location, scale, lower.tail = 1, log.p = 0)

rCauchy(n, location, scale)

qCauchy(p, location, scale, lower.tail = TRUE, log.p = FALSE)

Arguments

Details

The density is

$f(x) = \frac{1}{\pi s \{1 + ((x - \ell)/s)^2\}},$

where location = ell and scale = s > 0.

These uppercase NIMBLE-compatible functions are scalar (x/q and n = 1). For vectorized R usage, use base_lowercase().

The Cauchy law is a stable heavy-tailed distribution with undefined mean and variance. That is why the package allows the Cauchy kernel only as a bulk distribution and deliberately does not pair it with GPD tails in the kernel registry. For predictive summaries, ordinary means are not available under Cauchy kernels; medians, quantiles, survival curves, and restricted means remain well defined.

The distribution function is

$F(x) = \frac{1}{2} + \frac{1}{\pi}\arctan\left(\frac{x-\ell}{s}\right),$

and the quantile is the corresponding inverse

$Q(p) = \ell + s \tan\{\pi(p-1/2)\}.$

Value

dCauchy() returns a numeric scalar density, pCauchy() returns a numeric scalar CDF, rCauchy() returns one random draw, and qCauchy() returns a numeric quantile.

Functions

• dCauchy(): Cauchy density function

• pCauchy(): Cauchy distribution function

• rCauchy(): Cauchy random generation

• qCauchy(): Cauchy quantile function

See Also

cauchy_mix(), base_lowercase(), kernel_support_table().

Other base bulk distributions: InvGauss, amoroso

Examples

location <- 0
scale <- 1.5

dCauchy(0.5, location, scale, log = 0)
pCauchy(0.5, location, scale, lower.tail = 1, log.p = 0)
qCauchy(0.50, location, scale)
qCauchy(0.95, location, scale)
replicate(10, rCauchy(1, location, scale))

Description

Finite mixture of Cauchy components for symmetric heavy-tailed bulk modeling on the real line.

Usage

dCauchyMix(x, w, location, scale, log = 0)

pCauchyMix(q, w, location, scale, lower.tail = 1, log.p = 0)

rCauchyMix(n, w, location, scale)

qCauchyMix(
  p,
  w,
  location,
  scale,
  lower.tail = TRUE,
  log.p = FALSE,
  tol = 1e-10,
  maxiter = 200
)

Arguments

Details

The mixture density is

$f(x) = \sum_{k = 1}^K \tilde{w}_k f_C(x \mid \ell_k, s_k),$

with normalized weights $\tilde{w}_k$. These scalar functions are NIMBLE-compatible; for vectorized R usage, use cauchy_mix_lowercase().

The mixture CDF is the weighted average of component CDFs,

$F(x) = \sum_{k=1}^K \tilde{w}_k \left\{\frac{1}{2} + \frac{1}{\pi}\arctan\left(\frac{x-\ell_k}{s_k}\right)\right\}.$

Random generation first selects a component according to the normalized weights and then draws from the chosen Cauchy law by inverse-CDF sampling.

Because each Cauchy component has undefined mean and variance, the mixture also lacks an ordinary mean in general. That is why the package exposes Cauchy kernels for densities, CDFs, quantiles, medians, survival functions, and restricted means, but not for ordinary predictive means.

Value

Density/CDF/RNG functions return numeric scalars. qCauchyMix() returns a numeric vector with the same length as p.

Functions

• dCauchyMix(): Cauchy mixture density

• pCauchyMix(): Cauchy mixture distribution function

• rCauchyMix(): Cauchy mixture random generation

• qCauchyMix(): Cauchy mixture quantile function

See Also

cauchy(), cauchy_mix_lowercase(), build_nimble_bundle(), kernel_support_table().

Examples

w <- c(0.50, 0.30, 0.20)
location <- c(-2, 0, 3)
scale <- c(1.0, 0.7, 1.5)

dCauchyMix(0.5, w = w, location = location, scale = scale, log = FALSE)
pCauchyMix(0.5, w = w, location = location, scale = scale,
           lower.tail = TRUE, log.p = FALSE)
qCauchyMix(0.50, w = w, location = location, scale = scale)
qCauchyMix(0.95, w = w, location = location, scale = scale)
replicate(10, rCauchyMix(1, w = w, location = location, scale = scale))

Description

Vectorized R wrappers for the scalar Cauchy mixture functions in this file.

Usage

dcauchymix(x, w, location, scale, log = FALSE)

pcauchymix(q, w, location, scale, lower.tail = TRUE, log.p = FALSE)

qcauchymix(
  p,
  w,
  location,
  scale,
  lower.tail = TRUE,
  log.p = FALSE,
  tol = 1e-10,
  maxiter = 200
)

rcauchymix(n, w, location, scale)

Arguments

Details

These are vectorized R wrappers around the scalar Cauchy-mixture routines. They retain the same location-scale parameterization and the same inverse-CDF logic for simulation and quantiles. The lowercase functions do not alter the heavy-tail theory of the underlying Cauchy components; they apply the scalar routines elementwise to vector inputs in R.

Value

Numeric vector of densities, probabilities, quantiles, or random variates.

Functions

• dcauchymix(): Cauchy mixture density (vectorized)

• pcauchymix(): Cauchy mixture distribution function (vectorized)

• qcauchymix(): Cauchy mixture quantile function (vectorized)

• rcauchymix(): Cauchy mixture random generation (vectorized)

See Also

cauchy_mix(), cauchy(), bundle(), get_kernel_registry().

Other vectorized kernel helpers: amoroso_lowercase, base_lowercase, gamma_lowercase, invgauss_lowercase, laplace_lowercase, lognormal_lowercase, normal_lowercase

Examples

w <- c(0.6, 0.3, 0.1)
loc <- c(-1, 0, 1)
scl <- c(1, 1.2, 2)

dcauchymix(c(-2, 0, 2), w = w, location = loc, scale = scl)
rcauchymix(5, w = w, location = loc, scale = scl)

Description

Causal dataset (N=500, p=3) with different positive-support kernels by arm. Intended for alternating-kernel causal vignettes (GPD=FALSE).

Usage

causal_alt_pos500_p3_k3

Format

A list with:

y

Numeric outcome vector.

A

Binary treatment indicator (0/1).

X

data.frame with x1-x3.

meta

List with N, support, p, K0, K1, tail, exceed_frac.

truth

List with kernel0, kernel1, params0, params1, tail_params.

Examples

head(causal_alt_pos500_p3_k3$X)

Description

Causal dataset (N=500, p=5) with different positive-support kernels by arm and tail-designed exceedances (GPD=TRUE).

Usage

causal_alt_pos500_p5_k4_tail

Format

A list with:

y

Numeric outcome vector.

A

Binary treatment indicator (0/1).

X

data.frame with x1-x5.

meta

List with N, support, p, K0, K1, tail, exceed_frac.

truth

List with kernel0, kernel1, params0, params1, tail_params.

Examples

head(causal_alt_pos500_p5_k4_tail$X)

Description

Causal dataset (N=500, p=4) with different real-line kernels by arm. Intended for alternating-kernel causal vignettes (GPD=FALSE).

Usage

causal_alt_real500_p4_k2

Format

A list with:

y

Numeric outcome vector.

A

Binary treatment indicator (0/1).

X

data.frame with x1-x4.

meta

List with N, support, p, K0, K1, tail, exceed_frac.

truth

List with kernel0, kernel1, params0, params1, tail_params.

Examples

head(causal_alt_real500_p4_k2$X)

Description

Causal dataset (N=500, p=3) with the same positive-support kernel for both arms. Intended for same-kernel causal baselines (GPD=FALSE).

Usage

causal_pos500_p3_k2

Format

A list with:

y

Numeric outcome vector.

A

Binary treatment indicator (0/1).

X

data.frame with x1-x3.

meta

List with N, support, p, K0, K1, tail, exceed_frac.

truth

List with kernel0, kernel1, params0, params1, tail_params.

Examples

head(causal_pos500_p3_k2$X)

Description

This diagnostic checks whether the implied predictive distribution behaves like a valid distribution (monotone CDF in $[0,1]$, nonnegative density, and sensible behavior around the threshold when a GPD tail is enabled).

Usage

check_glue_validity(
  fit,
  x = NULL,
  grid = NULL,
  n_draws = 50L,
  tol = 1e-08,
  check_continuity = TRUE,
  eps = 1e-06
)

Arguments

Details

The check is performed draw-by-draw on a user-specified grid. It is intended for development, debugging, and CI (not for routine large-scale use).

Value

A list with per-check pass/fail flags and summaries of violations.

Description

Access descriptive cluster profiles without reaching into summary internals.

Usage

cluster_profiles(object, ...)

Arguments

Value

A data frame of cluster-level descriptive summaries, or NULL when profiles are unavailable.

See Also

Other cluster workflow: dpmgpd.cluster(), dpmix.cluster(), plot.dpmixgpd_cluster_bundle(), predict.dpmixgpd_cluster_fit(), print.dpmixgpd_cluster_bundle(), print.dpmixgpd_cluster_fit(), print.dpmixgpd_cluster_labels(), print.dpmixgpd_cluster_psm(), summary.dpmixgpd_cluster_bundle(), summary.dpmixgpd_cluster_fit(), summary.dpmixgpd_cluster_labels(), summary.dpmixgpd_cluster_psm()

Description

cqte() evaluates treated-minus-control predictive quantiles at user-supplied covariate rows.

Usage

## S3 method for class 'causalmixgpd_causal_fit'
cqte(
  fit,
  probs = c(0.1, 0.5, 0.9),
  newdata = NULL,
  interval = "credible",
  level = 0.95,
  show_progress = TRUE
)

Arguments

Details

For each prediction row $x$, the conditional quantile treatment effect is

$\mathrm{CQTE}(\tau, x) = Q_1(\tau \mid x) - Q_0(\tau \mid x).$

This estimand is available only for conditional causal models with covariates. For marginal quantile contrasts over the empirical covariate distribution, use qte or qtt.

If the fit includes a PS block, the same PS adjustment is applied to both arm predictions before differencing.

Value

An object of class "causalmixgpd_qte" containing the CQTE summary, the probability grid, and the treated/control prediction objects used to construct the effect. The returned object includes a top-level $fit_df data frame for direct extraction.

See Also

qte, qtt, cate, predict.causalmixgpd_causal_fit.

Examples

N <- 25
X <- data.frame(x1 = stats::rnorm(N))
A <- stats::rbinom(N, 1, 0.5)
y <- abs(stats::rnorm(N)) + 0.1
mcmc_small <- list(niter = 100, nburnin = 50, thin = 1, nchains = 1, seed = 1)
cb <- build_causal_bundle(y = y, X = X, A = A, backend = "sb", kernel = "normal",
                         components = 3, mcmc_outcome = mcmc_small, mcmc_ps = mcmc_small)
fit <- run_mcmc_causal(cb, show_progress = FALSE)
cqte(fit, probs = c(0.5, 0.9), newdata = X[1:5, , drop = FALSE])
cqte(fit, probs = c(0.5, 0.9), interval = "credible", level = 0.90)  # 90% CI
cqte(fit, probs = c(0.5, 0.9), interval = "hpd")  # HPD intervals
cqte(fit, probs = c(0.5, 0.9), interval = NULL)   # No intervals

Description

dpmgpd() is the one-step convenience wrapper for the spliced bulk-tail model. It combines bundle and mcmc for one-arm data.

Usage

dpmgpd(
  y = NULL,
  X = NULL,
  treat = NULL,
  data = NULL,
  mcmc = list(),
  formula = NULL,
  ...
)

Arguments

Details

This wrapper targets the posterior predictive distribution obtained by combining a flexible bulk DPM with a generalized Pareto exceedance model above the threshold $u(x)$. In the tail region the predictive density is proportional to

$\{1 - p_u(x)\} f_{\mathrm{GPD}}(y \mid x), \qquad y > u(x),$

where $p_u(x)$ is the posterior bulk mass below the threshold.

Use this wrapper when upper-tail behavior matters for inference, prediction, or extrapolation of extreme quantiles and survival probabilities.

Value

A fitted object of class "mixgpd_fit".

See Also

build_nimble_bundle, bundle, dpmix, predict.mixgpd_fit, summary.mixgpd_fit.

Description

dpmgpd.causal() is the highest-level causal fitting wrapper. It builds or accepts a causal bundle, runs posterior sampling for the treated and control arms, and returns a single causal fit ready for prediction and effect estimation.

Usage

dpmgpd.causal(
  y = NULL,
  X = NULL,
  treat = NULL,
  data = NULL,
  mcmc = list(),
  formula = NULL,
  ...
)

Arguments

Details

The arm-specific predictive distributions $F_1(y \mid x)$ and $F_0(y \mid x)$ inherit the spliced bulk-tail structure. Downstream causal estimands are computed as functionals of these two predictive laws, for example

$\mathrm{QTE}(\tau) = Q_1(\tau) - Q_0(\tau), \qquad \mathrm{ATE} = E(Y_1) - E(Y_0).$

Value

A fitted object of class "causalmixgpd_causal_fit".

See Also

build_causal_bundle, bundle, dpmix.causal, predict.causalmixgpd_causal_fit, ate, qte, cate, cqte.

Examples

data("causal_pos500_p3_k2", package = "CausalMixGPD")
idx <- seq_len(30)
fit <- dpmgpd.causal(
  y = causal_pos500_p3_k2$y[idx],
  X = causal_pos500_p3_k2$X[idx, , drop = FALSE],
  treat = causal_pos500_p3_k2$A[idx],
  kernel = "gamma",
  backend = "sb",
  components = 3,
  mcmc = list(niter = 60, nburnin = 30, thin = 1, nchains = 1, seed = 1,
              show_progress = FALSE, quiet = TRUE)
)
ate(fit, show_progress = FALSE)

Description

Variant of dpmix.cluster() that augments the cluster kernel with a generalized Pareto tail. This is the clustering analogue of the spliced bulk-tail workflow used by dpmgpd().

Usage

dpmgpd.cluster(
  formula,
  data,
  type = c("weights", "param", "both"),
  default = "weights",
  mcmc = list(),
  ...
)

Arguments

Details

For observations above a component-specific threshold, the component density is spliced as

$f(y) = (1 - F_{bulk}(u)) g_{GPD}(y \mid u, \sigma_u, \xi_u), \qquad y \ge u,$

so cluster assignment can be informed by both central behavior and tail behavior.

This interface is preferable when cluster separation is driven by upper-tail differences rather than bulk-only shape or location differences.

Value

Object of class dpmixgpd_cluster_fit.

See Also

dpmix.cluster(), predict.dpmixgpd_cluster_fit(), dpmgpd(), sim_bulk_tail().

Other cluster workflow: cluster_profiles(), dpmix.cluster(), plot.dpmixgpd_cluster_bundle(), predict.dpmixgpd_cluster_fit(), print.dpmixgpd_cluster_bundle(), print.dpmixgpd_cluster_fit(), print.dpmixgpd_cluster_labels(), print.dpmixgpd_cluster_psm(), summary.dpmixgpd_cluster_bundle(), summary.dpmixgpd_cluster_fit(), summary.dpmixgpd_cluster_labels(), summary.dpmixgpd_cluster_psm()

Examples

data("nc_posX100_p3_k2", package = "CausalMixGPD")
dat <- data.frame(y = nc_posX100_p3_k2$y[1:20],
                  nc_posX100_p3_k2$X[1:20, , drop = FALSE])
fit <- dpmgpd.cluster(
  y ~ x1 + x2 + x3,
  data = dat,
  kernel = "gamma",
  type = "param",
  components = 3,
  mcmc = list(niter = 60, nburnin = 30, thin = 1, nchains = 1, seed = 1)
)
cluster_profiles(fit)

Description

dpmix() is the one-step convenience wrapper for the bulk-only model. It combines bundle and mcmc for one-arm data.

Usage

dpmix(
  y = NULL,
  X = NULL,
  treat = NULL,
  data = NULL,
  mcmc = list(),
  formula = NULL,
  ...
)

Arguments

Details

The fitted model targets the posterior predictive bulk distribution

$f(y \mid x) = \int f(y \mid x, \theta)\,d\Pi(\theta),$

without the spliced tail augmentation used by dpmgpd.

Use this wrapper when the outcome support is adequately modeled by the bulk kernel alone. If you need threshold exceedance modeling or extreme-quantile extrapolation, use dpmgpd instead.

Value

A fitted object of class "mixgpd_fit".

See Also

build_nimble_bundle, bundle, dpmgpd, predict.mixgpd_fit, summary.mixgpd_fit.

Description

dpmix.causal() fits a causal model with separate treated and control outcome mixtures and, when requested, a propensity score block. It is the bulk-only companion to dpmgpd.causal.

Usage

dpmix.causal(
  y = NULL,
  X = NULL,
  treat = NULL,
  data = NULL,
  mcmc = list(),
  formula = NULL,
  ...
)

Arguments

Details

The resulting fit supports conditional outcome prediction $F_a(y \mid x)$ for $a \in \{0,1\}$, followed by causal functionals such as ate, qte, cate, and cqte.

Value

A fitted object of class "causalmixgpd_causal_fit".

See Also

build_causal_bundle, bundle, dpmgpd.causal, predict.causalmixgpd_causal_fit, ate, qte.

Examples

N <- 30
X <- data.frame(x1 = stats::rnorm(N), x2 = stats::runif(N))
A <- stats::rbinom(N, 1, 0.5)
y <- abs(stats::rnorm(N) + A + 0.5 * X$x1) + 0.1
mcmc_small <- list(niter = 100, nburnin = 50, thin = 1, nchains = 1, seed = 1)

fit <- dpmix.causal(
  y = y, X = X, treat = A,
  backend = "sb", kernel = "normal",
  components = 3, mcmc = mcmc_small
)
summary(fit)
ate(fit, show_progress = FALSE)

Description

Build and fit a Dirichlet-process mixture for clustering without causal estimands or posterior prediction for a response surface. This interface focuses on latent partition recovery from a formula specification and returns a cluster-fit object that can be summarized, plotted, or converted into labels and posterior similarity matrices with predict.dpmixgpd_cluster_fit().

Usage

dpmix.cluster(
  formula,
  data,
  type = c("weights", "param", "both"),
  default = "weights",
  mcmc = list(),
  ...
)

Arguments

Details

The fitted model targets a latent partition $z_1, \dots, z_n$ with component-specific kernel parameters. Depending on type, predictors can enter through the gating probabilities

$\Pr(z_i = k \mid x_i) = \pi_k(x_i)$

or through linked kernel parameters for each component. The returned fit stores posterior draws of the latent cluster labels and associated parameters; the representative clustering is extracted later by predict.dpmixgpd_cluster_fit() using Dahl's least-squares rule.

Use type = "weights" or type = "both" only when the formula includes predictors and when an explicit number of components is supplied. Otherwise the builder stops before fitting.

Value

Object of class dpmixgpd_cluster_fit.

See Also

dpmgpd.cluster(), predict.dpmixgpd_cluster_fit(), summary.dpmixgpd_cluster_fit(), plot.dpmixgpd_cluster_fit(), build_nimble_bundle(), dpmix().

Other cluster workflow: cluster_profiles(), dpmgpd.cluster(), plot.dpmixgpd_cluster_bundle(), predict.dpmixgpd_cluster_fit(), print.dpmixgpd_cluster_bundle(), print.dpmixgpd_cluster_fit(), print.dpmixgpd_cluster_labels(), print.dpmixgpd_cluster_psm(), summary.dpmixgpd_cluster_bundle(), summary.dpmixgpd_cluster_fit(), summary.dpmixgpd_cluster_labels(), summary.dpmixgpd_cluster_psm()

Examples

data("nc_realX100_p3_k2", package = "CausalMixGPD")
dat <- data.frame(y = nc_realX100_p3_k2$y[1:20],
                  nc_realX100_p3_k2$X[1:20, , drop = FALSE])
fit <- dpmix.cluster(
  y ~ x1 + x2 + x3,
  data = dat,
  kernel = "normal",
  type = "param",
  components = 3,
  mcmc = list(niter = 60, nburnin = 30, thin = 1, nchains = 1, seed = 1)
)
summary(fit)

Description

ess_summary() reports effective sample size diagnostics for posterior draws, optionally scaled by wall-clock time.

Usage

ess_summary(
  fit,
  params = NULL,
  per_chain = TRUE,
  wall_time = NULL,
  robust = TRUE,
  ...
)

Arguments

Details

This is a convergence and efficiency diagnostic, not a model summary. For causal fits the function evaluates each outcome arm separately and tags the rows accordingly.

Value

Object of class "mixgpd_ess_summary" with elements table, overall, and meta.

See Also

summary.mixgpd_fit, plot.mixgpd_fit, params.

Description

fitted.mixgpd_fit() is a thin training-data wrapper around predict.mixgpd_fit for conditional models.

Usage

## S3 method for class 'mixgpd_fit'
fitted(
  object,
  type = c("mean", "median", "quantile"),
  p = 0.5,
  level = 0.95,
  interval = "credible",
  seed = 1,
  ...
)