matrixStats

https://rdrr.io/cran/matrixStats/
Admin
matrixStats is an R package providing high-performing functions for row and column operations on...
Tokens:218,781
Snippets:958
Trust Score:9.9
Update:6 months ago
Show doc for...
Tokens:
Raw
### Initialize Matrix Data

Source: https://rdrr.io/cran/matrixStats/src/tests/rowAvgsPerColSet.R

Setup a sample matrix with row and column names for demonstration.

```R
library("matrixStats")

X <- matrix(rnorm(20 * 6), nrow = 20, ncol = 6)
rownames(X) <- LETTERS[1:nrow(X)]
colnames(X) <- letters[1:ncol(X)]
print(X)
```

--------------------------------

### Initialize 1x1 matrix

Source: https://rdrr.io/cran/matrixStats/src/tests/rowDiffs.R

Setup for a minimal 1x1 matrix test case.

```R
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# A 1x1 matrix
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
x <- matrix(0, nrow = 1L, ncol = 1L)
dimnames <- list("a", "A")
```

--------------------------------

### Access Package Documentation

Source: https://rdrr.io/cran/matrixStats/src/R/zzz.R

Example command to load the package and access help documentation for the unload function.

```R
library(matrixStats) help(.onUnload)
```

--------------------------------

### sum2 examples and validation

Source: https://rdrr.io/cran/matrixStats/man/sum2.html

Examples demonstrating subsetting, integer overflow handling, and comparison with base R sum().

```R
x <- 1:10
n <- length(x)

idxs <- seq(from = 1, to = n, by = 2)
s1 <- sum(x[idxs])                     # 25
s2 <- sum2(x, idxs = idxs)             # 25
stopifnot(identical(s1, s2))

idxs <- seq(from = n, to = 1, by = -2)
s1 <- sum(x[idxs])                     # 25
s2 <- sum2(x, idxs = idxs)             # 25
stopifnot(identical(s1, s2))

s1 <- sum(x)                           # 55
s2 <- sum2(x)                          # 55
stopifnot(identical(s1, s2))


# Total gives integer overflow
x <- c(.Machine$integer.max, 1L, -.Machine$integer.max)
s1 <- sum(x[1:2])                      # NA_integer_ in R (< 3.5.0)
s2 <- sum2(x[1:2])                     # NA_integer_

# Total gives integer overflow (coerce to numeric)
s1 <- sum(as.numeric(x[1:2]))          # 2147483648
s2 <- sum2(as.numeric(x[1:2]))         # 2147483648
s3 <- sum2(x[1:2], mode = "double")    # 2147483648 w/out copy
stopifnot(identical(s1, s2))
stopifnot(identical(s1, s3))

# Cumulative sum would give integer overflow but not the total
s1 <- sum(x)                           # 1L
s2 <- sum2(x)                          # 1L
stopifnot(identical(s1, s2))
```

--------------------------------

### Initialize testing environment

Source: https://rdrr.io/cran/matrixStats/src/tests/rowSds_subset.R

Setup code for testing matrix operations including index validation and matrix creation.

```R
library("matrixStats")

## Always allow testing of the 'center' argument (as long as it's not defunct)
options(matrixStats.center.onUse = "ignore")

## Create isFALSE() if running on an old version of R
if (!exists("isFALSE", mode="function")) {
  isFALSE <- function(x) is.logical(x) && length(x) == 1L && !is.na(x) && !x
}
```

```R
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# Subsetted tests
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
source("utils/validateIndicesFramework.R")
x <- matrix(runif(6 * 6, min = -6, max = 6), nrow = 6, ncol = 6)
storage.mode(x) <- "integer"

# To check names attribute
dimnames <- list(letters[1:6], LETTERS[1:6])
```

--------------------------------

### Example of diff2

Source: https://rdrr.io/cran/matrixStats/man/diff2.html

Basic usage example calculating differences for a sequence of integers.

```R
diff2(1:10)
```

--------------------------------

### Load and Get Help for update_package_options

Source: https://rdrr.io/cran/matrixStats/src/R/options.R

Loads the matrixStats library and displays the help documentation for the update_package_options function.

```R
library(matrixStats) help(update_package_options)
```

--------------------------------

### LogSumExp Example 3: Harmonic Mean Calculation

Source: https://rdrr.io/cran/matrixStats/man/logSumExp.html

This example shows how logSumExp can be used to compute the logarithm of the harmonic mean of a vector. It compares the result with direct calculation.

```R
set.seed(1)
x <- runif(50)

## The logarithm of the harmonic mean
y0 <- log(1 / mean(1 / x))
print(y0)  ## -1.600885

lx <- log(x)
y1 <- log(length(x)) - logSumExp(-lx)
print(y1)  ## [1] -1.600885

# Sanity check
stopifnot(all.equal(y1, y0))
```

--------------------------------

### Index Validation Framework Setup

Source: https://rdrr.io/cran/matrixStats/src/tests/rowWeightedMedians_subset.R

Sets up the testing environment for index validation, including sourcing a validation script and defining test cases for rows and columns.

```R
source("utils/validateIndicesFramework.R")
# To check names attribute
dimnames <- list(letters[1:6], LETTERS[1:6])
```

--------------------------------

### Matrix Initialization and Dimension Setup

Source: https://rdrr.io/cran/matrixStats/src/tests/rowRanks_subset.R

Initializes a matrix with random values and sets up dimnames for testing purposes. Storage mode is set to integer.

```R
# To check dimnames attribute
dimnames <- list(letters[1:6], LETTERS[1:6])
```

--------------------------------

### Example Usage of anyMissing

Source: https://rdrr.io/cran/matrixStats/src/R/anyMissing.R

Demonstrates how to use anyMissing and verifies its output against base::any(is.na(x)).

```R
x <- rnorm(n = 1000)
x[seq(300, length(x), by = 100)] <- NA
stopifnot(anyMissing(x) == any(is.na(x)))
```

--------------------------------

### R: Example of adding 'y' to each column of 'x'

Source: https://rdrr.io/cran/matrixStats/man/x_OP_y.html

Demonstrates how to use x_OP_y to add a vector 'y' to each column of a matrix 'x'. Compares the result with the base R operation.

```R
x <- matrix(c(1, 2, 3, NA, 5, 6), nrow = 3, ncol = 2)

# Add 'y' to each column
y <- 1:2
z0 <- x + y
z1 <- x_OP_y(x, y, OP = "+")
print(z1)
stopifnot(all.equal(z1, z0))
```

--------------------------------

### Load matrixStats and access help

Source: https://rdrr.io/cran/matrixStats/src/R/000.DEPRECATION.R

Loads the matrixStats package and displays the help documentation for the centerOnUse function. Ensure the package is installed before running.

```r
library(matrixStats) 
help(centerOnUse)
```

--------------------------------

### Compute Weighted Median in R

Source: https://rdrr.io/cran/matrixStats/man/weightedMedian.html

Examples demonstrating basic usage, tie-breaking strategies, and weight manipulation for the weightedMedian function.

```R
weightedMedian(x, w = NULL, idxs = NULL, na.rm = FALSE,
  interpolate = is.null(ties), ties = NULL, ...)
```

```R
x <- 1:10
n <- length(x)

m1 <- median(x)                             # 5.5
m2 <- weightedMedian(x)                     # 5.5
stopifnot(identical(m1, m2))

w <- rep(1, times = n)
m1 <- weightedMedian(x, w)                  # 5.5 (default)
m2 <- weightedMedian(x, ties = "weighted")  # 5.5 (default)
m3 <- weightedMedian(x, ties = "min")       # 5
m4 <- weightedMedian(x, ties = "max")       # 6
stopifnot(identical(m1, m2))

# Pull the median towards zero
w[1] <- 5
m1 <- weightedMedian(x, w)                  # 3.5
y <- c(rep(0, times = w[1]), x[-1])         # Only possible for integer weights
m2 <- median(y)                             # 3.5
stopifnot(identical(m1, m2))

# Put even more weight on the zero
w[1] <- 8.5
weightedMedian(x, w)                # 2

# All weight on the first value
w[1] <- Inf
weightedMedian(x, w)                # 1

# All weight on the last value
w[1] <- 1
w[n] <- Inf
weightedMedian(x, w)                # 10

# All weights set to zero
w <- rep(0, times = n)
weightedMedian(x, w)                # NA
```

--------------------------------

### MatrixStats Package Setup and Testing Framework

Source: https://rdrr.io/cran/matrixStats/src/tests/rowLogSumExps_subset.R

Loads the matrixStats package and sets up a testing framework to validate matrix operations. It includes creating a sample matrix and defining test cases for indices.

```R
library("matrixStats")

## Create isFALSE() if running on an old version of R
if (!exists("isFALSE", mode="function")) {
  isFALSE <- function(x) is.logical(x) && length(x) == 1L && !is.na(x) && !x
}

rowLogSumExps_R <- function(x, ..., useNames = TRUE) {
  res <- apply(x, MARGIN = 1L, FUN = function(rx, ...) {
    log(sum(exp(rx), ...))
  }, ...) 
  if (isFALSE(useNames)) names(res) <- NULL
  res
}


# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
# Subsetted tests
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
source("utils/validateIndicesFramework.R")
x <- matrix(runif(6 * 6, min = -6, max = 6), nrow = 6, ncol = 6)

# To check names attribute
dimnames <- list(letters[1:6], LETTERS[1:6])

# Test with and without dimnames on x
for (setDimnames in c(TRUE, FALSE)) {
  if (setDimnames) dimnames(x) <- dimnames
  else dimnames(x) <- NULL
  for (rows in index_cases) {
    for (cols in index_cases) {
      for (na.rm in c(TRUE, FALSE)) {
        for (useNames in c(TRUE, FALSE)) {
          validateIndicesTestMatrix(x, rows, cols,
                                    ftest = rowLogSumExps,
                                    fsure = rowLogSumExps_R,
                                    na.rm = na.rm, useNames = useNames)
          validateIndicesTestMatrix(x, rows, cols,
                                    fcoltest = colLogSumExps,
                                    fsure = rowLogSumExps_R,
                                    na.rm = na.rm, useNames = useNames)
        }
      }
    }
  }
}
```

--------------------------------

### Examples of weighted mean calculations

Source: https://rdrr.io/cran/matrixStats/man/rowWeightedMeans.html

Demonstrates usage of rowWeightedMeans and colWeightedMeans with various weighting strategies and column subsetting.

```R
x <- matrix(rnorm(20), nrow = 5, ncol = 4)
print(x)

# Non-weighted row averages
mu_0 <- rowMeans(x)
mu <- rowWeightedMeans(x)
stopifnot(all.equal(mu, mu_0))

# Weighted row averages (uniform weights)
w <- rep(2.5, times = ncol(x))
mu <- rowWeightedMeans(x, w = w)
stopifnot(all.equal(mu, mu_0))

# Weighted row averages (excluding some columns)
w <- c(1, 1, 0, 1)
mu_0 <- rowMeans(x[, (w == 1), drop = FALSE])
mu <- rowWeightedMeans(x, w = w)
stopifnot(all.equal(mu, mu_0))

# Weighted row averages (excluding some columns)
w <- c(0, 1, 0, 0)
mu_0 <- rowMeans(x[, (w == 1), drop = FALSE])
mu <- rowWeightedMeans(x, w = w)
stopifnot(all.equal(mu, mu_0))

# Weighted averages by rows and columns
w <- 1:4
mu_1 <- rowWeightedMeans(x, w = w)
mu_2 <- colWeightedMeans(t(x), w = w)
stopifnot(all.equal(mu_2, mu_1))
```

--------------------------------

### Calculate and Plot Binned Means

Source: https://rdrr.io/cran/matrixStats/man/binMeans.html

Example demonstrating how to generate data, calculate bin means, and visualize the results using lines.

```R
x <- 1:200
mu <- double(length(x))
mu[1:50] <- 5
mu[101:150] <- -5
y <- mu + rnorm(length(x))

# Binning
bx <- c(0, 50, 100, 150, 200) + 0.5
y_s <- binMeans(y, x = x, bx = bx)

plot(x, y)
for (kk in seq_along(y_s)) {
  lines(bx[c(kk, kk + 1)], y_s[c(kk, kk)], col = "blue", lwd = 2)
}
```

--------------------------------

### Matrix Statistics Examples

Source: https://rdrr.io/cran/matrixStats/man/rowVars.html

Demonstrates calculating various row and column statistics including means, medians, variances, standard deviations, and ranges.

```R
set.seed(1)

x <- matrix(rnorm(20), nrow = 5, ncol = 4)
print(x)

# Row averages
print(rowMeans(x))
print(rowMedians(x))

# Column averages
print(colMeans(x))
print(colMedians(x))


# Row variabilities
print(rowVars(x))
print(rowSds(x))
print(rowMads(x))
print(rowIQRs(x))

# Column variabilities
print(rowVars(x))
print(colSds(x))
print(colMads(x))
print(colIQRs(x))

# Row ranges
print(rowRanges(x))
print(cbind(rowMins(x), rowMaxs(x)))
print(cbind(rowOrderStats(x, which = 1), rowOrderStats(x, which = ncol(x))))

# Column ranges
print(colRanges(x))
print(cbind(colMins(x), colMaxs(x)))
print(cbind(colOrderStats(x, which = 1), colOrderStats(x, which = nrow(x))))


x <- matrix(rnorm(2000), nrow = 50, ncol = 40)

# Row standard deviations
d <- rowDiffs(x)
s1 <- rowSds(d) / sqrt(2)
s2 <- rowSds(x)
print(summary(s1 - s2))

# Column standard deviations
d <- colDiffs(x)
s1 <- colSds(d) / sqrt(2)
s2 <- colSds(x)
print(summary(s1 - s2))
```

--------------------------------

### R: Example of adding 'y' to each row of 'x'

Source: https://rdrr.io/cran/matrixStats/man/x_OP_y.html

Demonstrates how to use t_tx_OP_y to add a vector 'y' to each row of a matrix 'x'. Compares the result with the base R operation.

```R
y <- 1:3
z0 <- t(t(x) + y)
z1 <- t_tx_OP_y(x, y, OP = "+")
print(z1)
stopifnot(all.equal(z1, z0))
```

--------------------------------

### Load and Initialize matrixStats

Source: https://rdrr.io/cran/matrixStats/src/tests/rowVarDiffs_mad%2Ciqr_subset.R

Loads the matrixStats package and defines a list of functions for testing. This is a common setup for package testing.

```R
library("matrixStats")

fcns <- list(
  madDiff = c(rowMadDiffs, colMadDiffs),
  iqrDiff = c(rowIQRDiffs, colIQRDiffs)
)
```

--------------------------------

### Initialize matrixStats and Define Functions

Source: https://rdrr.io/cran/matrixStats/src/tests/rowWeightedVars_subset.R

Loads the matrixStats library and defines a list of weighted statistics functions for row and column operations. This is a setup step for subsequent tests.

```r
library("matrixStats")

fcns <- list(
  weightedVar = c(rowWeightedVars, colWeightedVars),
  weightedSd = c(rowWeightedSds, colWeightedSds),
  weightedMad = c(rowWeightedMads, colWeightedMads)
)
```

--------------------------------

### Setup for Subsetted Tests

Source: https://rdrr.io/cran/matrixStats/src/tests/rowVars_subset.R

Initializes a matrix 'x' with random integer values and defines dimension names for testing subsetting functionalities within the matrixStats package.

```R
source("utils/validateIndicesFramework.R")
x <- matrix(runif(6 * 6, min = -6, max = 6), nrow = 6, ncol = 6)
storage.mode(x) <- "integer"

# To check names attribute
dimnames <- list(letters[1:6], LETTERS[1:6])
```

--------------------------------

### Check Suggested Packages and Benchmark

Source: https://rdrr.io/cran/matrixStats/src/tests/benchmark.R

This R code block checks if all suggested packages for matrixStats are installed and loadable. If they are, it runs a benchmark for the 'binCounts' function and prints the HTML output. It avoids running under Valgrind to prevent potential issues.

```R
if (Sys.getenv("_R_CHECK_USE_VALGRIND_") == "") {

## 3. Make sure all suggested packages are installed / can be loaded
pkgs <- c("base64enc", "ggplot2", "knitr", "markdown", "microbenchmark",
          "R.devices", "R.rsp")
if (all(unlist(lapply(pkgs, FUN = requireNamespace)))) {
  html <- matrixStats:::benchmark("binCounts")
  print(html)
}

rm(list = "pkgs")

}
```

--------------------------------

### Example Usage of rowAnys and colCounts

Source: https://rdrr.io/cran/matrixStats/man/rowAlls.html

Demonstrates creating a logical matrix and applying row/column analysis functions to identify rows or columns containing specific values.

```R
x <- matrix(FALSE, nrow = 10, ncol = 5)
x[3:7, c(2, 4)] <- TRUE
x[2:4, ] <- TRUE
x[, 1] <- TRUE
x[5, ] <- FALSE
x[, 5] <- FALSE
print(x)

print(rowCounts(x))       # 1 4 4 4 0 3 3 1 1 1
print(colCounts(x))       # 9 5 3 5 0

print(rowAnys(x))
print(which(rowAnys(x)))  # 1  2  3  4  6  7  8  9 10
print(colAnys(x))
print(which(colAnys(x)))  # 1 2 3 4
```

--------------------------------

### MatrixStats Subsetted Tests Setup (R)

Source: https://rdrr.io/cran/matrixStats/src/tests/rowMads_subset.R

Sets up a matrix 'x' and dimension names for testing the subsetting capabilities of matrixStats functions. It iterates through various index cases and NA removal/naming options.

```R
source("utils/validateIndicesFramework.R")
x <- matrix(runif(6 * 6, min = -6, max = 6), nrow = 6, ncol = 6)
storage.mode(x) <- "integer"

# To check names attribute
dimnames <- list(letters[1:6], LETTERS[1:6])

# Test with and without dimnames on x
for (setDimnames in c(TRUE, FALSE)) {
  if (setDimnames) dimnames(x) <- dimnames
  else dimnames(x) <- NULL

  count <- 0L
  for (rows in index_cases) {
    for (cols in index_cases) {
      count <- count + 1L
      na.rm <- c(TRUE, FALSE)[count %% 2 + 1]
      useNames <- c(TRUE, FALSE)
      useNames <- useNames[count %% length(useNames) + 1]
      
      validateIndicesTestMatrix(x, rows, cols,
                                ftest = rowMads, fsure = rowMads_R,
                                na.rm = na.rm, useNames = useNames)
      validateIndicesTestMatrix(x, rows, cols,
                                ftest = rowMads_center, fsure = rowMads_R,
                                na.rm = na.rm, useNames = useNames)

      validateIndicesTestMatrix(x, rows, cols,
                                fcoltest = colMads, fsure = rowMads_R,
                                na.rm = na.rm, useNames = useNames)
      validateIndicesTestMatrix(x, rows, cols,
                                fcoltest = colMads_center, fsure = rowMads_R,
                                na.rm = na.rm, useNames = useNames)
    }
  }
}
```

--------------------------------

### Run matrixStats help(colVars)

Source: https://rdrr.io/cran/matrixStats/src/R/rowVars.R

This command opens the help page for the colVars function in the matrixStats package. It's useful for understanding the function's parameters, return values, and examples.

```R
library(matrixStats) help(colVars)
```

--------------------------------

### LogSumExp Example 1: Large Positive Values

Source: https://rdrr.io/cran/matrixStats/man/logSumExp.html

Demonstrates the logSumExp function with large positive log values. Direct computation results in Inf, while logSumExp provides an accurate finite result.

```R
lx <- c(1000.01, 1000.02)
y0 <- log(sum(exp(lx)))
print(y0) ## Inf

y1 <- logSumExp(lx)
print(y1) ## 1000.708
```

--------------------------------

### Build and Run matrixStats Tests

Source: https://rdrr.io/cran/matrixStats/src/tests/mean2_subset.R

This R script demonstrates how to load the matrixStats library and run subsetted tests for index validation. It includes setup for a test vector and iterates through various index cases.

```r
library("matrixStats")

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
# Subsetted tests
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
source("utils/validateIndicesFramework.R")
x <- runif(6, min = -6, max = 6)
storage.mode(x) <- "integer"
for (idxs in index_cases) {
  validateIndicesTestVector(x, idxs,
                            ftest = mean2, fsure = mean,
                            na.rm = FALSE)
  validateIndicesTestVector(x, idxs,
                            ftest = mean2, fsure = mean,
                            na.rm = TRUE)
}
```

--------------------------------

### LogSumExp Example 2: Large Negative Values

Source: https://rdrr.io/cran/matrixStats/man/logSumExp.html

Illustrates the logSumExp function with large negative log values. Direct computation results in -Inf, while logSumExp provides an accurate finite result.

```R
lx <- c(-1000.01, -1000.02)
y0 <- log(sum(exp(lx)))
print(y0) ## -Inf

y1 <- logSumExp(lx)
print(y1) ## -999.3218
```

--------------------------------

### Get Column Order Statistic - R

Source: https://rdrr.io/cran/matrixStats/man/rowOrderStats.html

Computes a specific order statistic for each column of a matrix. Use when you need to find, for example, the minimum, maximum, or median value across rows for each column.

```R
colOrderStats(x, rows = NULL, cols = NULL, which, dim. = dim(x), ...,
  useNames = TRUE)
```

--------------------------------

### Get Row Order Statistic - R

Source: https://rdrr.io/cran/matrixStats/man/rowOrderStats.html

Computes a specific order statistic for each row of a matrix. Use when you need to find, for example, the minimum, maximum, or median value across columns for each row.

```R
rowOrderStats(x, rows = NULL, cols = NULL, which, dim. = dim(x), ...,
  useNames = TRUE)
```

--------------------------------

### Install matrixStats package

Source: https://rdrr.io/cran/matrixStats

Use this command to install the latest version of the matrixStats package from CRAN.

```R
install.packages("matrixStats")
```

--------------------------------

### Load matrixStats library

Source: https://rdrr.io/cran/matrixStats/src/inst/benchmarking/R/random-matrices.R

Initializes the matrixStats package and opens the help documentation.

```R
library(matrixStats) help(matrixStats)
```

--------------------------------

### Load matrixStats and access help

Source: https://rdrr.io/cran/matrixStats/src/R/benchmark.R

Loads the matrixStats library and opens the help documentation for the benchmark function.

```R
library(matrixStats) help(benchmark)
```

--------------------------------

### Test weightedVar with frequency weights (Wikipedia example)

Source: https://rdrr.io/cran/matrixStats/src/tests/weightedVar.R

Calculates weighted variance using frequency weights based on a Wikipedia example. Compares results with base R variance.

```R
message("- Frequency weights")

## From https://en.wikipedia.org/wiki/Weighted_arithmetic_mean
y <-  c(2, 2, 4, 5, 5, 5)
x <- unique(y)
w <- table(y)
stopifnot(names(w) == x)

m0 <- weightedVar(x, w = w)
m1 <- var(y)
stopifnot(all.equal(m1, m0))
m2 <- weightedVar(x, w = w)
str(list(m0 = m0, m1 = m1, m2 = m2))
stopifnot(all.equal(m2, m0))
```

--------------------------------

### Get Ranks of Matrix Elements (colRanks)

Source: https://rdrr.io/cran/matrixStats/man/rowRanks.html

Use colRanks to get the rank of elements in each column of a matrix. The preserveShape argument controls the output matrix dimensions. Default ties.method is 'max'.

```R
colRanks(x, rows = NULL, cols = NULL, ties.method = c("max", "average",
"first", "last", "random", "max", "min", "dense"), dim. = dim(x),
preserveShape = FALSE, ..., useNames = TRUE)
```

--------------------------------

### Accessing binMeans Help

Source: https://rdrr.io/cran/matrixStats/src/R/binMeans.R

Commands to load the matrixStats library and open the documentation for the binMeans function.

```R
library(matrixStats) help(binMeans)
```

--------------------------------

### Get Ranks of Matrix Elements (rowRanks)

Source: https://rdrr.io/cran/matrixStats/man/rowRanks.html

Use rowRanks to get the rank of elements in each row of a matrix. Specify ties.method for handling equal values; default is 'max' (differs from base R's 'average').

```R
rowRanks(x, rows = NULL, cols = NULL, ties.method = c("max", "average",
"first", "last", "random", "max", "min", "dense"), dim. = dim(x), ...,
useNames = TRUE)
```

--------------------------------

### Calculate matrix differences

Source: https://rdrr.io/cran/matrixStats/man/rowDiffs.html

Example demonstrating rowDiffs and colDiffs usage on a matrix.

```R
x <- matrix(1:27, ncol = 3)

d1 <- rowDiffs(x)
print(d1)

d2 <- t(colDiffs(t(x)))
stopifnot(all.equal(d2, d1))
```

--------------------------------

### Access matrixStats documentation

Source: https://rdrr.io/cran/matrixStats/src/R/psortKM.R

Load the package and open the help file for the specified function.

```R
library(matrixStats) help(.psortKM)
```

--------------------------------

### View matrixStats Package Help

Source: https://rdrr.io/cran/matrixStats/src/tests/rowCumMinMaxs.R

Displays the help documentation for the matrixStats package, providing an overview of its functions and usage.

```R
help(matrixStats)
```

--------------------------------

### Accessing colRanks Help

Source: https://rdrr.io/cran/matrixStats/src/R/rowRanks.R

Standard R command to load the package and view the documentation for colRanks.

```R
library(matrixStats) help(colRanks)
```

--------------------------------

### Examples of rowCollapse usage

Source: https://rdrr.io/cran/matrixStats/man/rowCollapse.html

Demonstrates extracting elements from a matrix using rowCollapse with various index vectors.

```R
x <- matrix(1:27, ncol = 3)

y <- rowCollapse(x, 1)
stopifnot(identical(y, x[, 1]))

y <- rowCollapse(x, 2)
stopifnot(identical(y, x[, 2]))

y <- rowCollapse(x, c(1, 1, 1, 1, 1, 3, 3, 3, 3))
stopifnot(identical(y, c(x[1:5, 1], x[6:9, 3])))

y <- rowCollapse(x, 1:3)
print(y)
y_truth <- c(x[1, 1], x[2, 2], x[3, 3], x[4, 1], x[5, 2],
             x[6, 3], x[7, 1], x[8, 2], x[9, 3])
stopifnot(identical(y, y_truth))
```

--------------------------------

### Access matrixStats help documentation

Source: https://rdrr.io/cran/matrixStats/src/R/rowMedians.R

Command to load the library and view the help documentation for colMedians.

```R
library(matrixStats) help(colMedians)
```

--------------------------------

### Access colTabulates help documentation

Source: https://rdrr.io/cran/matrixStats/src/R/rowTabulates.R

Load the matrixStats library and open the help page for the colTabulates function.

```R
library(matrixStats) help(colTabulates)
```

--------------------------------

### rowVars Function Documentation

Source: https://rdrr.io/cran/matrixStats/src/R/rowVars.R

Detailed documentation for the `rowVars` function, including its parameters, return values, and usage examples.

```APIDOC
## rowVars

### Description
Variance estimates for each row (column) in a matrix.

### Method
`rowVars(x, rows = NULL, cols = NULL, na.rm = FALSE, refine = TRUE, center = NULL, dim. = dim(x), ..., useNames = TRUE)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **x** (matrix) - The input matrix.
- **rows** (vector, optional) - Subset of rows to consider.
- **cols** (vector, optional) - Subset of columns to consider.
- **na.rm** (logical, optional) - If TRUE, NA values are removed before computation. Defaults to FALSE.
- **refine** (logical, optional) - If TRUE and `center` is NULL and `x` is numeric, extra effort is used to calculate the average with greater numerical precision. Defaults to TRUE.
- **center** (vector, optional) - Pre-specified row/column means. If NULL (default), means are estimated internally.
- **dim.** (vector, optional) - Dimensions of the matrix to consider.
- **...** (any) - Additional arguments passed to `rowMeans()` and `rowSums()`.
- **useNames** (logical, optional) - If TRUE, names are preserved. Defaults to TRUE.

### Request Example
```json
{
  "example": "Not applicable for this R function"
}
```

### Response
#### Success Response (200)
- **vector** (numeric) - A numeric vector of variance estimates for each row (column).

#### Response Example
```json
{
  "example": "Not applicable for this R function"
}
```

### Providing center estimates
The sample variance is estimated as:

  `n/(n-1) * mean((x - center)^2)`,

where `center` is estimated as the sample mean, by default. Argument `center` can be used to provide an already existing estimate. It is important that the sample mean estimate is passed. If not, then the variance estimate of the spread will be biased.

For performance reasons, the check for discrepancy between provided `center` and the sample-mean estimate is performed only once every 50 times by default. This frequency can be controlled by R option `matrixStats.vars.formula.freq`.

### See Also
See `rowMeans()` and `rowSums()` in `colSums()`.

### Keywords
array iteration robust univar
```

--------------------------------

### Initialize test matrix and dimnames

Source: https://rdrr.io/cran/matrixStats/src/tests/rowAllAnys.R

Sets up a 3x3 matrix with specific NA and numeric values for testing purposes.

```R
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# NA 0 test
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
x <- matrix(0, nrow = 3L, ncol = 3L)
x[1, ] <- c(NA_real_, NA_real_, 0)
x[3, ] <- c(1, 0, 1)

dimnames <- list(letters[1:3], LETTERS[1:3])
```

--------------------------------

### Load and Help for colWeightedSds

Source: https://rdrr.io/cran/matrixStats/src/R/weightedVar.R

Demonstrates how to load the matrixStats library and access help documentation for the colWeightedSds function.

```R
library(matrixStats)
help(colWeightedSds)
```

--------------------------------

### Matrix Averaging Examples

Source: https://rdrr.io/cran/matrixStats/man/rowAvgsPerColSet.html

Demonstrates applying rowMeans and colMeans to subsets of a matrix, including validation against standard R functions.

```R
X <- matrix(rnorm(20 * 6), nrow = 20, ncol = 6)
rownames(X) <- LETTERS[1:nrow(X)]
colnames(X) <- letters[1:ncol(X)]
print(X)


# - - - - - - - - - - - - - - - - - - - - - - - - - -
# Apply rowMeans() for 3 sets of 2 columns
# - - - - - - - - - - - - - - - - - - - - - - - - - -
nbr_of_sets <- 3
S <- matrix(1:ncol(X), ncol = nbr_of_sets)
colnames(S) <- sprintf("s%d", 1:nbr_of_sets)
print(S)

Z <- rowAvgsPerColSet(X, S = S)
print(Z)

# Validation
Z0 <- cbind(s1 = rowMeans(X[, 1:2]),
            s2 = rowMeans(X[, 3:4]),
            s3 = rowMeans(X[, 5:6]))
stopifnot(identical(drop(Z), Z0))


# - - - - - - - - - - - - - - - - - - - - - - - - - -
# Apply colMeans() for 5 sets of 4 rows
# - - - - - - - - - - - - - - - - - - - - - - - - - -
nbr_of_sets <- 5
S <- matrix(1:nrow(X), ncol = nbr_of_sets)
colnames(S) <- sprintf("s%d", 1:nbr_of_sets)
print(S)

Z <- colAvgsPerRowSet(X, S = S)
print(Z)

# Validation
Z0 <- rbind(s1 = colMeans(X[  1:4, ]),
            s2 = colMeans(X[  5:8, ]),
            s3 = colMeans(X[ 9:12, ]),
            s4 = colMeans(X[13:16, ]),
            s5 = colMeans(X[17:20, ]))
stopifnot(identical(drop(Z), Z0))


# - - - - - - - - - - - - - - - - - - - - - - - - - -
# When there is only one "complete" set
# - - - - - - - - - - - - - - - - - - - - - - - - - -
nbr_of_sets <- 1
S <- matrix(1:ncol(X), ncol = nbr_of_sets)
colnames(S) <- sprintf("s%d", 1:nbr_of_sets)
print(S)

Z <- rowAvgsPerColSet(X, S = S, FUN = rowMeans)
print(Z)

Z0 <- rowMeans(X)
stopifnot(identical(drop(Z), Z0))


nbr_of_sets <- 1
S <- matrix(1:nrow(X), ncol = nbr_of_sets)
colnames(S) <- sprintf("s%d", 1:nbr_of_sets)
print(S)

Z <- colAvgsPerRowSet(X, S = S, FUN = colMeans)
print(Z)

Z0 <- colMeans(X)
stopifnot(identical(drop(Z), Z0))
```

--------------------------------

### Load matrixStats and Help

Source: https://rdrr.io/cran/matrixStats/src/tests/rowWeightedMedians_subset.R

Loads the matrixStats package and displays its help documentation. This is a standard way to explore R package functionality.

```R
library(matrixStats) 
help(matrixStats)
```

--------------------------------

### Counting occurrences in a matrix

Source: https://rdrr.io/cran/matrixStats/man/rowCounts.html

Examples demonstrating how to count specific values in a matrix, including handling of NA values and subsetting.

```R
x <- matrix(0:11, nrow = 4, ncol = 3)
x[2:3, 2:3] <- 2:5
x[3, 3] <- NA_integer_
print(x)

print(rowCounts(x, value = 2))
## [1]  0  1 NA  0
print(colCounts(x, value = 2))
## [1]  1  1 NA
print(colCounts(x, value = NA_integer_))
## [1] 0 0 1

print(rowCounts(x, value = 2, na.rm = TRUE))
## [1] 0 1 1 0
print(colCounts(x, value = 2, na.rm = TRUE))
## [1] 1 1 0

print(rowAnys(x, value = 2))
## [1] FALSE  TRUE  TRUE FALSE
print(rowAnys(x, value = NA_integer_))
## [1] FALSE FALSE  TRUE FALSE

print(colAnys(x, value = 2))
## [1] TRUE TRUE   NA
print(colAnys(x, value = 2, na.rm = TRUE))
## [1]  TRUE  TRUE FALSE

print(colAlls(x, value = 2))
## [1] FALSE FALSE FALSE
```

--------------------------------

### Load and access help for binCounts

Source: https://rdrr.io/cran/matrixStats/src/R/binCounts.R

Commands to load the matrixStats library and access the help documentation for the binCounts function.

```R
library(matrixStats) help(binCounts)
```

--------------------------------

### Initialize matrixStats and create a matrix

Source: https://rdrr.io/cran/matrixStats/src/tests/rowTabulates.R

Loads the matrixStats package and defines a matrix with specified dimensions and values.

```R
library("matrixStats")

nrow <- 6L
ncol <- 5L
data <- matrix(0:4, nrow = nrow, ncol = ncol)
```

--------------------------------

### Load and access matrixStats documentation

Source: https://rdrr.io/cran/matrixStats

Commands to load the package into the R environment and open the help documentation.

```R
library(matrixStats)
help(matrixStats)
```
Tokens:
Raw