| Title: | Coverage Correlation Coefficient and Testing for Independence |
|---|---|
| Description: | Computes the coverage correlation coefficient introduced in <doi:10.48550/arXiv.2508.06402> , a statistical measure that quantifies dependence between two random vectors by computing the union volume of data-centered hypercubes in a uniform space. |
| Authors: | Tengyao Wang [aut, cre], Mona Azadkia [aut, ctb], Xuzhi Yang [aut, ctb] |
| Maintainer: | Tengyao Wang <[email protected]> |
| License: | GPL-3 |
| Version: | 1.1.0 |
| Built: | 2026-09-27 07:37:37 UTC |
| Source: | https://github.com/cran/covercorr |
The CD8T dataset provides the gene expression data of fetal CD8+ T cells obtained in a single-cell RNA-seq experiment.
data(CD8T)data(CD8T)
A data frame with 9369 rows (cells) and 1000 columns (genes).
Suo et al., Science (2022).
Suo, C., Dann, E., Goh, I., Jardine, L., Kleshchevnikov, V., Park, J.-E., Botting, R. A., et al. "Mapping the developing human immune system across organs." Science 376(6597), eabo0510 (2022).
Computes the coverage correlation coefficient between input x and y, as introduced in the arXiv preprint. This coefficient measures the dependence between two random variables or vectors.
coverage_correlation( x, y, visualise = FALSE, method = c("auto", "exact", "approx"), M = NULL, na.rm = TRUE )coverage_correlation( x, y, visualise = FALSE, method = c("auto", "exact", "approx"), M = NULL, na.rm = TRUE )
x |
Numeric vector or matrix. |
y |
Numeric vector or matrix with the same number of rows as |
visualise |
Logical; if |
method |
Character string specifying the computation method. Options are |
M |
Integer; Number of Monte Carlo integration sample points (used when |
na.rm |
Logical; if |
The procedure is as follows:
Calculate the rank transformations of the inputs x and y.
Construct small cubes (in 2D, squares) of volume centered at each rank-transformed point.
Compute the total area of the union of these cubes, intersected with where .
The coverage correlation coefficient is then calculated based on this union area.
For more details, please refer to the original paper: the arXiv preprint.
The method argument controls how the computation is performed:
"exact": Computes the exact value.
"approx": Uses a Monte Carlo approximation with M sample points.
"auto": Automatically selects a method based on the total number of columns in x and y: if more than 6, "approx" is used (with M = nrow(x)^{1.5} if M is not provided); otherwise, "exact" is used.
A list with four elements:
stat – The numeric value of the coverage correlation coefficient.
pval – The p-value, calculated using the exact variance under the null hypothesis of independence between x and y.
method – A character string indicating the computation method used.
mc_se – A numeric value. If method "approx" was used mc_se is the standard error of the Monte Carlo approximation, otherwise it is 0.
set.seed(1) n <- 100 x <- runif(n) y <- sin(3*x) + runif(n) * 0.01 coverage_correlation(x, y, visualise = TRUE)set.seed(1) n <- 100 x <- runif(n) y <- sin(3*x) + runif(n) * 0.01 coverage_correlation(x, y, visualise = TRUE)
Identical to coverage_correlation, except that the reference
points used for the Monge–Kantorovich rank transformation may be supplied
directly via u and v rather than being generated internally
from runif. This is useful for reproducibility, for using
low-discrepancy (e.g. quasi-Monte Carlo) reference grids, or for comparing
results across calls with a fixed reference set.
coverage_correlation_grid( x, y, u = NULL, v = NULL, visualise = FALSE, method = c("auto", "exact", "approx"), M = NULL, na.rm = TRUE )coverage_correlation_grid( x, y, u = NULL, v = NULL, visualise = FALSE, method = c("auto", "exact", "approx"), M = NULL, na.rm = TRUE )
x |
Numeric vector or matrix. |
y |
Numeric vector or matrix with the same number of rows as |
u |
Numeric vector or matrix of reference points for |
v |
Numeric vector or matrix of reference points for |
visualise |
Logical; if |
method |
Character string specifying the computation method. Options are |
M |
Integer; Number of Monte Carlo integration sample points (used when |
na.rm |
Logical; if |
When both x and y are one-dimensional, u and v
may be omitted; in that case they default to the deterministic uniform grid
, which is the natural 1D reference set and
makes the rank transformation deterministic.
The method argument controls how the computation is performed:
"exact": Computes the exact value.
"approx": Uses a Monte Carlo approximation with M sample points.
"auto": Automatically selects a method based on the total number of columns in x and y: if more than 6, "approx" is used (with M = nrow(x)^{1.5} if M is not provided); otherwise, "exact" is used.
When na.rm = TRUE, rows with NA in x or y are
removed, and the corresponding rows of any user-supplied u and
v are removed as well so that the reference grids stay aligned with
the data. Default grids are constructed after NA removal.
A list with four elements:
stat – The numeric value of the coverage correlation coefficient.
pval – The p-value, calculated using the exact variance under the null hypothesis of independence between x and y.
method – A character string indicating the computation method used.
mc_se – A numeric value. If method "approx" was used mc_se is the standard error of the Monte Carlo approximation, otherwise it is 0.
set.seed(1) n <- 100 x <- runif(n) y <- sin(3*x) + runif(n) * 0.01 # 1D: u and v default to the uniform grid {1/n, ..., 1} coverage_correlation_grid(x, y, visualise = TRUE) # supplying grids explicitly still works u <- runif(n) v <- runif(n) coverage_correlation_grid(x, y, u, v)set.seed(1) n <- 100 x <- runif(n) y <- sin(3*x) + runif(n) * 0.01 # 1D: u and v default to the uniform grid {1/n, ..., 1} coverage_correlation_grid(x, y, visualise = TRUE) # supplying grids explicitly still works u <- runif(n) v <- runif(n) coverage_correlation_grid(x, y, u, v)
Computes the coverage correlation coefficient jointly across input
variables or vectors , following exactly the same logic
as coverage_correlation but generalised from a pair to an
arbitrary number of inputs. The coefficient measures the joint dependence
among the inputs.
coverage_correlation_K( data, method = c("auto", "exact", "approx"), M = NULL, na.rm = TRUE )coverage_correlation_K( data, method = c("auto", "exact", "approx"), M = NULL, na.rm = TRUE )
data |
A list of |
method |
Character string specifying the computation method. Options are |
M |
Integer; Number of Monte Carlo integration sample points (used when |
na.rm |
Logical; if |
The procedure is as follows:
Calculate the rank transformation of each input .
Construct small cubes of volume centered at each
rank-transformed point in , where .
Compute the total volume of the union of these cubes, intersected
with .
The coverage correlation coefficient is then calculated based on this union volume.
For more details, please refer to the original paper: the arXiv preprint.
The method argument controls how the computation is performed:
"exact": Computes the exact value.
"approx": Uses a Monte Carlo approximation with M sample points.
"auto": Automatically selects a method based on the total number of columns across all inputs: if more than 6, "approx" is used (with M = n^{1.5} if M is not provided); otherwise, "exact" is used.
A list with four elements:
stat – The numeric value of the coverage correlation coefficient.
pval – The p-value, calculated using the exact variance under the null hypothesis of mutual independence among the inputs.
method – A character string indicating the computation method used.
mc_se – A numeric value. If method "approx" was used mc_se is the standard error of the Monte Carlo approximation, otherwise it is 0.
set.seed(1) n <- 100 x1 <- runif(n) x2 <- sin(3 * x1) + runif(n) * 0.01 x3 <- x1 * x2 + runif(n) * 0.1 coverage_correlation_K(list(x1, x2, x3))set.seed(1) n <- 100 x1 <- runif(n) x2 <- sin(3 * x1) + runif(n) * 0.01 x3 <- x1 * x2 + runif(n) * 0.1 coverage_correlation_K(list(x1, x2, x3))
Identical to coverage_correlation_K, except that the reference
points used for the Monge–Kantorovich rank transformation may be supplied
directly via grid rather than being generated internally from
runif. This is useful for reproducibility, for using low-discrepancy
(e.g. quasi-Monte Carlo) reference grids, or for comparing results across
calls with a fixed reference set.
coverage_correlation_K_grid( data, grid = NULL, method = c("auto", "exact", "approx"), M = NULL, na.rm = TRUE )coverage_correlation_K_grid( data, grid = NULL, method = c("auto", "exact", "approx"), M = NULL, na.rm = TRUE )
data |
A list of |
grid |
A list of |
method |
Character string specifying the computation method. Options are |
M |
Integer; Number of Monte Carlo integration sample points (used when |
na.rm |
Logical; if |
When every input in data is one-dimensional, grid may be
omitted; in that case each reference grid defaults to the deterministic
uniform grid , which is the natural 1D reference
set and makes the rank transformation deterministic.
The method argument controls how the computation is performed:
"exact": Computes the exact value.
"approx": Uses a Monte Carlo approximation with M sample points.
"auto": Automatically selects a method based on the total number of columns across all inputs: if more than 6, "approx" is used (with M = n^{1.5} if M is not provided); otherwise, "exact" is used.
When na.rm = TRUE, rows with NA in any input are removed, and
the corresponding rows of any supplied grids are removed as well so that the
reference grids stay aligned with the data. Default grids are constructed
after NA removal.
A list with four elements:
stat – The numeric value of the coverage correlation coefficient.
pval – The p-value, calculated using the exact variance under the null hypothesis of mutual independence among the inputs, if K > 2 returns NA.
method – A character string indicating the computation method used.
mc_se – A numeric value. If method "approx" was used mc_se is the standard error of the Monte Carlo approximation, otherwise it is 0.
coverage_correlation_K, coverage_correlation_grid
set.seed(1) n <- 100 x1 <- runif(n) x2 <- sin(3 * x1) + runif(n) * 0.01 x3 <- x1 * x2 + runif(n) * 0.1 # all 1D: grid defaults to the uniform grid {1/n, ..., 1} for each input coverage_correlation_K_grid(list(x1, x2, x3)) # supplying grids explicitly still works g <- list(runif(n), runif(n), runif(n)) coverage_correlation_K_grid(list(x1, x2, x3), grid = g)set.seed(1) n <- 100 x1 <- runif(n) x2 <- sin(3 * x1) + runif(n) * 0.01 x3 <- x1 * x2 + runif(n) * 0.1 # all 1D: grid defaults to the uniform grid {1/n, ..., 1} for each input coverage_correlation_K_grid(list(x1, x2, x3)) # supplying grids explicitly still works g <- list(runif(n), runif(n), runif(n)) coverage_correlation_K_grid(list(x1, x2, x3), grid = g)
A single front-end that dispatches to the appropriate coverage correlation
routine based on its inputs. It bundles together
coverage_correlation, coverage_correlation_grid,
coverage_correlation_K, and
coverage_correlation_K_grid.
covercorr( x, y = NULL, reference = c("random", "deterministic"), grid = NULL, visualise = FALSE, method = c("auto", "exact", "approx"), M = NULL, na.rm = TRUE )covercorr( x, y = NULL, reference = c("random", "deterministic"), grid = NULL, visualise = FALSE, method = c("auto", "exact", "approx"), M = NULL, na.rm = TRUE )
x |
A numeric vector, matrix, data frame, data table, or a list of numeric vectors/matrices. See Details for how each type is dispatched. |
y |
Optional numeric vector or matrix with the same number of rows as
|
reference |
Character string, either |
grid |
Optional list of reference-point sets, one per variable, each
matching the shape of the variable it corresponds to (same number of rows
and columns). In the pairwise case |
visualise |
Logical; if |
method |
Character string specifying the computation method. Options are |
M |
Integer; Number of Monte Carlo integration sample points (used when |
na.rm |
Logical; if |
Dispatch rules, based on the first argument x:
If y is supplied, the pairwise case is used on (x, y).
If x is a list, each element is treated as one variable
(possibly multivariate) and the -input case is used.
If x is a matrix, data frame, or data table (and y is
not supplied), each column is treated as a univariate variable: a
two-column input uses the pairwise case, and an input with more than two
columns uses the -input case with equal to the number of
columns.
The reference argument selects the reference points used for the
Monge–Kantorovich rank transformation:
"random": independent runif reference points are
generated internally (routes to coverage_correlation /
coverage_correlation_K).
"deterministic": the deterministic uniform grid
is used for each (univariate) variable, unless
the user supplies their own reference points via grid. Routes to
coverage_correlation_grid / coverage_correlation_K_grid.
Supplying grid implies reference = "deterministic"
automatically.
A list with elements stat, pval, method, and
mc_se; see coverage_correlation for details.
coverage_correlation,
coverage_correlation_grid,
coverage_correlation_K,
coverage_correlation_K_grid
set.seed(1) n <- 100 x <- runif(n) y <- sin(3 * x) + runif(n) * 0.01 # pairwise, random reference points covercorr(x, y) # pairwise, deterministic grid, with visualisation covercorr(x, y, reference = "deterministic", visualise = TRUE) # pairwise, user-supplied reference points (implies deterministic) covercorr(x, y, grid = list(runif(n), runif(n))) # K variables as a matrix; supply custom grids for each column z <- x * y + runif(n) * 0.1 covercorr(cbind(x, y, z), grid = list(runif(n), runif(n), runif(n)))set.seed(1) n <- 100 x <- runif(n) y <- sin(3 * x) + runif(n) * 0.01 # pairwise, random reference points covercorr(x, y) # pairwise, deterministic grid, with visualisation covercorr(x, y, reference = "deterministic", visualise = TRUE) # pairwise, user-supplied reference points (implies deterministic) covercorr(x, y, grid = list(runif(n), runif(n))) # K variables as a matrix; supply custom grids for each column z <- x * y + runif(n) * 0.1 covercorr(cbind(x, y, z), grid = list(runif(n), runif(n), runif(n)))
Total volume of union of rectangles
covered_volume(zmin, zmax)covered_volume(zmin, zmax)
zmin |
n x d matrix of bottomleft coordinates, one row per rectangle |
zmax |
n x d matrix of topright coordinates, one row per rectangle |
This is a wrapper of the C_covered_volume_partitioned function in C
a numeric value of the volume of the union
Total volume of union of rectangles using Monte Carlo integration
covered_volume_mc(zmin_s, zmax_s, M)covered_volume_mc(zmin_s, zmax_s, M)
zmin_s |
n x d matrix of bottomleft coordinates, one row per rectangle |
zmax_s |
n x d matrix of topright coordinates, one row per rectangle |
M |
number of Monte Carlo integration sample points |
This is a wrapper of the C_covered_volume_mc function in C
a list of the estimated volume of the union and its standard error
Total volume of union of rectangles using volume hashing
covered_volume_partitioned(zmin, zmax)covered_volume_partitioned(zmin, zmax)
zmin |
n x d matrix of bottomleft coordinates, one row per rectangle |
zmax |
n x d matrix of topright coordinates, one row per rectangle |
This is a wrapper of the C_covered_volume_partitioned function in C
a numeric value of the volume of the union
Computes the optimal matching that maps each observation in X to a
reference point in U using uniform weights and squared Euclidean cost.
Internally uses transport::transport(method = "networkflow", p = 2).
In 1D, this reduces to a rank-based matching
sort(U)[rank(X, ties.method = "random")].
MK_rank(X, U)MK_rank(X, U)
X |
Numeric vector of length |
U |
Numeric vector of length |
Rows must match: nrow(X) == nrow(U) (otherwise an error is thrown).
Columns must match: ncol(X) == ncol(U) (otherwise an error is thrown).
Weights are uniform () and the cost matrix is the sum of squared
coordinate differences across columns.
In 1D, ties in X are broken at random via
ties.method = "random"; use set.seed() for reproducibility.
If ncol(X) == 1, a numeric vector of length
containing the entries of U reordered to match the ranks of
X. Otherwise, a numeric matrix whose -th row
is the matched row of U corresponding to the -th row of
X.
Requires the transport package.
# 1D example (set seed for reproducible tie-breaking) set.seed(1) x <- rnorm(10) u <- seq(0, 1, length.out = 10) MK_rank(x, u) # 2D example set.seed(42) X <- matrix(rnorm(200), ncol = 2) # 100 x 2 U <- matrix(runif(200), ncol = 2) # 100 x 2 R <- MK_rank(X, U) dim(R) # 100 2# 1D example (set seed for reproducible tie-breaking) set.seed(1) x <- rnorm(10) u <- seq(0, 1, length.out = 10) MK_rank(x, u) # 2D example set.seed(42) X <- matrix(rnorm(200), ncol = 2) # 100 x 2 U <- matrix(runif(200), ncol = 2) # 100 x 2 R <- MK_rank(X, U) dim(R) # 100 2
Draws rectangles specified by their xmin, xmax, ymin,
and ymax, optionally adding them to an existing plot. When
add = FALSE, a fresh plot with a grid and
equal aspect ratio is created.
plot_rectangles(xmin, xmax, ymin, ymax, add = FALSE)plot_rectangles(xmin, xmax, ymin, ymax, add = FALSE)
xmin |
Numeric vector of left x-coordinates. |
xmax |
Numeric vector of right x-coordinates (same length as |
ymin |
Numeric vector of bottom y-coordinates (same length as |
ymax |
Numeric vector of top y-coordinates (same length as |
add |
Logical; if |
Invisibly returns NULL. Use this function for its plotting output, not for a returned value.
Split rectangles by wrapping them around edges of
split_rectangles(zmin, zmax)split_rectangles(zmin, zmax)
zmin |
n x d matrix of bottom-left coordinates, one row per rectangle |
zmax |
n x d matrix of top-right coordinates, one row per rectangle |
This is a wrapper of the C_split_rectangles function implemented in C
a list of zmin and zmax, describing the bottom-left and top-right coordinates of splitted rectangles
Exact formula for times the variance of the excess vacancy.
For independent and , the variance of the coverage correlation
coefficient is obtained by dividing the returned value by .
check the arXiv preprint for more details
variance_formula(n, d)variance_formula(n, d)
n |
sample size |
d |
dimension |
variance formula in paper
Produces an image plot of the log-ratio of an estimated joint density to the
uniform density over , given the (Monge–Kantorovich) rank
transformations of two variables. Regions where the pair of variables is more
concentrated than under independence appear in one colour and regions where
it is sparser appear in another, making departures from independence easy to
read off visually.
visualise_density(x_rank, y_rank)visualise_density(x_rank, y_rank)
x_rank |
Numeric vector of rank values in |
y_rank |
Numeric vector of rank values in |
The density is estimated with a two-dimensional kernel density estimate
(kde2d). To avoid edge effects near the boundary of the
unit square, the points are first tiled toroidally (see the internal
wrap_points helper) before the kernel density estimate is computed on
. The estimate is normalised by its mean over the unit square,
so that a value of zero on the log scale corresponds to the uniform density.
Invisibly returns NULL. Use this function for its plotting
output, not for a returned value.
set.seed(1) n <- 500 x <- runif(n) y <- sin(3 * x) + runif(n) * 0.1 x_rank <- MK_rank(as.matrix(x), runif(n)) y_rank <- MK_rank(as.matrix(y), runif(n)) visualise_density(x_rank, y_rank)set.seed(1) n <- 500 x <- runif(n) y <- sin(3 * x) + runif(n) * 0.1 x_rank <- MK_rank(as.matrix(x), runif(n)) y_rank <- MK_rank(as.matrix(y), runif(n)) visualise_density(x_rank, y_rank)