sparsediscrim

https://topepo.github.io/sparsediscrim/
Admin
The R package sparsediscrim provides a collection of sparse and regularized discriminant analysis...
Tokens:35,603
Snippets:293
Trust Score:9.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### Install Development Dependencies

Source: https://topepo.github.io/sparsediscrim/CONTRIBUTING.html

Installs all necessary development dependencies for the package. This should be run before checking the package.

```R
devtools::install_dev_deps()
```

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

### SDQDA Classifier Training and Prediction Example

Source: https://topepo.github.io/sparsediscrim/reference/qda_shrink_cov.html

This example demonstrates how to train an SDQDA classifier using both formula and direct data input, and then make predictions. It also verifies the consistency between the two training methods.

```R
library(modeldata)
data(penguins)
pred_rows <- seq(1, 344, by = 20)
penguins <- penguins[, c("species", "body_mass_g", "flipper_length_mm")]#' set.seed(42)
sdqda_out <- qda_shrink_cov(species ~ ., data = penguins[-pred_rows, ])
predicted <- predict(sdqda_out, penguins[pred_rows, -1], type = "class")

sdqda_out2 <- qda_shrink_cov(x = penguins[-pred_rows, -1], y = penguins$species[-pred_rows])
predicted2 <- predict(sdqda_out2, penguins[pred_rows, -1], type = "class")
all.equal(predicted, predicted2)
```

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

### Example of cv_partition with 10 folds

Source: https://topepo.github.io/sparsediscrim/reference/cv_partition.html

This example demonstrates partitioning the iris dataset into 10 folds using cv_partition. The output shows the indices for the training and test sets for each fold. Ensure the 'iris' dataset is loaded and the 'cv_partition' function is available.

```R
cv_partition(iris$Species, num_folds = 10, seed = 42)
```

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

### Install Latest Version of sparsediscrim

Source: https://topepo.github.io/sparsediscrim/index.html

Installs the latest development version of the sparsediscrim package from GitHub using the devtools library.

```r
library(devtools)
install_github('ramhiser/sparsediscrim')
```

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

### LDA Pseudo Example with Formula Interface

Source: https://topepo.github.io/sparsediscrim/reference/lda_pseudo.html

Demonstrates building an LDA classifier using the formula interface and predicting class labels. Requires the 'modeldata' package and 'penguins' dataset.

```R
library(modeldata)
data(penguins)
pred_rows <- seq(1, 344, by = 20)
penguins <- penguins[, c("species", "body_mass_g", "flipper_length_mm")]
lda_pseudo_out <- lda_pseudo(species ~ ., data = penguins[-pred_rows, ])
predicted <- predict(lda_pseudo_out, penguins[pred_rows, -1], type = "class")
```

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

### SmDQDA Classifier Training and Prediction Example

Source: https://topepo.github.io/sparsediscrim/reference/qda_shrink_mean.html

Demonstrates how to train an SmDQDA classifier using a formula interface and then predict class labels for new data. It also shows an equivalent training using the default interface and verifies the consistency of predictions.

```R
library(modeldata)
data(penguins)
pred_rows <- seq(1, 344, by = 20)
penguins <- penguins[, c("species", "body_mass_g", "flipper_length_mm")]
smdqda_out <- qda_shrink_mean(species ~ ., data = penguins[-pred_rows, ])
predicted <- predict(smdqda_out, penguins[pred_rows, -1], type = "class")

smdqda_out2 <- qda_shrink_mean(x = penguins[-pred_rows, -1], y = penguins$species[-pred_rows])
predicted2 <- predict(smdqda_out2, penguins[pred_rows, -1], type = "class")
all.equal(predicted, predicted2)
```

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

### LDA Pseudo Example with Matrix Interface and Comparison

Source: https://topepo.github.io/sparsediscrim/reference/lda_pseudo.html

Shows building an LDA classifier using the matrix interface and compares its predictions to the formula interface. Requires the 'modeldata' package and 'penguins' dataset.

```R
lda_pseudo_out2 <- lda_pseudo(x = penguins[-pred_rows, -1], y = penguins$species[-pred_rows])
predicted2 <- predict(lda_pseudo_out2, penguins[pred_rows, -1], type = "class")
all.equal(predicted, predicted2)
```

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

### Install Stable Version of sparsediscrim

Source: https://topepo.github.io/sparsediscrim/index.html

Installs the stable version of the sparsediscrim package from CRAN. Ensure dependencies are included.

```r
install.packages('sparsediscrim', dependencies = TRUE)
```

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

### LDA Thomaz Example with Matrix Interface and Comparison

Source: https://topepo.github.io/sparsediscrim/reference/lda_thomaz.html

Shows how to use lda_thomaz with direct matrix and vector inputs for training data and class labels. It compares the predictions from this method against the formula interface method.

```R
lda_thomaz_out2 <- lda_thomaz(x = penguins[-pred_rows, -1], y = penguins$species[-pred_rows])
predicted2 <- predict(lda_thomaz_out2, penguins[pred_rows, -1], type = "class")
all.equal(predicted, predicted2)
```

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

### Example Usage of MDMEB Classifier

Source: https://topepo.github.io/sparsediscrim/reference/lda_emp_bayes_eigen.html

Demonstrates how to train an MDMEB classifier using both formula and default methods and compares their predictions. Ensure the 'modeldata' package is loaded and the 'penguins' dataset is available.

```R
library(modeldata)
data(penguins)
pred_rows <- seq(1, 344, by = 20)
penguins <- penguins[, c("species", "body_mass_g", "flipper_length_mm")]
mdmeb_out <- lda_emp_bayes_eigen(species ~ ., data = penguins[-pred_rows, ])
predicted <- predict(mdmeb_out, penguins[pred_rows, -1], type = "class")

mdmeb_out2 <- lda_emp_bayes_eigen(x = penguins[-pred_rows, -1], y = penguins$species[-pred_rows])
predicted2 <- predict(mdmeb_out2, penguins[pred_rows, -1], type = "class")
all.equal(predicted, predicted2)
```

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

### LDA Schafer Example with Formula Interface

Source: https://topepo.github.io/sparsediscrim/reference/lda_schafer.html

Demonstrates using the lda_schafer function with a formula interface and the penguins dataset. It trains a model and then predicts class labels for a subset of the data.

```R
library(modeldata)
data(penguins)
pred_rows <- seq(1, 344, by = 20)
penguins <- penguins[, c("species", "body_mass_g", "flipper_length_mm")]
lda_schafer_out <- lda_schafer(species ~ ., data = penguins[-pred_rows, ])
predicted <- predict(lda_schafer_out, penguins[pred_rows, -1], type = "class")
```

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

### LDA Thomaz Example with Formula Interface

Source: https://topepo.github.io/sparsediscrim/reference/lda_thomaz.html

Demonstrates using the lda_thomaz function with a formula interface and the penguins dataset. It trains a model and then predicts class labels for a subset of the data.

```R
library(modeldata)
data(penguins)
pred_rows <- seq(1, 344, by = 20)
penguins <- penguins[, c("species", "body_mass_g", "flipper_length_mm")]
lda_thomaz_out <- lda_thomaz(species ~ ., data = penguins[-pred_rows, ])
predicted <- predict(lda_thomaz_out, penguins[pred_rows, -1], type = "class")
```

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

### LDA Schafer Example with Matrix Interface

Source: https://topepo.github.io/sparsediscrim/reference/lda_schafer.html

Demonstrates using the lda_schafer function with a matrix interface for input data and class labels. It trains a model and predicts class labels, comparing the output to the formula interface.

```R
lda_schafer_out2 <- lda_schafer(x = penguins[-pred_rows, -1], y = penguins$species[-pred_rows])
predicted2 <- predict(lda_schafer_out2, penguins[pred_rows, -1], type = "class")
all.equal(predicted, predicted2)
```

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

### Compute Eigenvalues for Pooled Covariance Matrix

Source: https://topepo.github.io/sparsediscrim/reference/cov_eigen.html

This example demonstrates computing eigenvalues using a pooled covariance matrix, which assumes equal covariance across all classes. This can be more stable when class sample sizes are small.

```R
cov_eigen(x = x, y = y, pool = TRUE, fast = TRUE)
```

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

### two_class_sim_data

Source: https://topepo.github.io/sparsediscrim/reference/index.html

Example bivariate classification data from caret.

```APIDOC
## two_class_sim_data

### Description
Example bivariate classification data from caret.

### Method
Not applicable (function)

### Endpoint
Not applicable (function)

### Parameters
Not specified in source.

### Request Example
Not specified in source.

### Response
Not specified in source.
```

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

### Train and Predict with DQDA using Formula

Source: https://topepo.github.io/sparsediscrim/reference/qda_diag.html

Demonstrates training a DQDA model using a formula interface and then predicting class labels for new data. It also shows an alternative training method and verifies the consistency of predictions.

```R
library(modeldata)
data(penguins)
pred_rows <- seq(1, 344, by = 20)
penguins <- penguins[, c("species", "body_mass_g", "flipper_length_mm")]
dqda_out <- qda_diag(species ~ ., data = penguins[-pred_rows, ])
predicted <- predict(dqda_out, penguins[pred_rows, -1], type = "class")

dqda_out2 <- qda_diag(x = penguins[-pred_rows, -1], y = penguins$species[-pred_rows])
predicted2 <- predict(dqda_out2, penguins[pred_rows, -1], type = "class")
all.equal(predicted, predicted2)
```

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

### Train and Predict MDEB Classifier using Default Interface

Source: https://topepo.github.io/sparsediscrim/reference/lda_emp_bayes.html

Demonstrates training an MDEB classifier using the default interface (matrix and vector inputs) and then predicting class labels for new data. Compares the results with the formula interface.

```R
mdeb_out2 <- lda_emp_bayes(x = penguins[-pred_rows, -1], y = penguins$species[-pred_rows])
predicted2 <- predict(mdeb_out2, penguins[pred_rows, -1], type = "class")
all.equal(predicted, predicted2)
```

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

### Train and Predict MDEB Classifier using Formula

Source: https://topepo.github.io/sparsediscrim/reference/lda_emp_bayes.html

Demonstrates training an MDEB classifier using a formula interface and then predicting class labels for new data. Ensures the output is consistent when using the default interface.

```R
library(modeldata)
data(penguins)
pred_rows <- seq(1, 344, by = 20)
penguins <- penguins[, c("species", "body_mass_g", "flipper_length_mm")]
mdeb_out <- lda_emp_bayes(species ~ ., data = penguins[-pred_rows, ])
predicted <- predict(mdeb_out, penguins[pred_rows, -1], type = "class")
```

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

### Training and Predicting with MDMP Classifier

Source: https://topepo.github.io/sparsediscrim/reference/lda_eigen.html

Demonstrates how to train an MDMP classifier using both formula and matrix interfaces and then use the predict method to classify new data. It also verifies the consistency between the two training methods.

```R
library(modeldata)
data(penguins)
pred_rows <- seq(1, 344, by = 20)
penguins <- penguins[, c("species", "body_mass_g", "flipper_length_mm")]
mdmp_out <- lda_eigen(species ~ ., data = penguins[-pred_rows, ])
predicted <- predict(mdmp_out, penguins[pred_rows, -1], type = "class")

mdmp_out2 <- lda_eigen(x = penguins[-pred_rows, -1], y = penguins$species[-pred_rows])
predicted2 <- predict(mdmp_out2, penguins[pred_rows, -1], type = "class")
all.equal(predicted, predicted2)
```

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

### Sample Data Output (K=3 Classes)

Source: https://topepo.github.io/sparsediscrim/reference/generate_blockdiag.html

This snippet displays a portion of the generated data matrix, where each row represents an observation and columns correspond to features for K=3 classes. The data is presented in a format typical for R matrix output.

```r
data$y

#>  [1] 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3
#> [39] 3 3 3 3 3 3 3
#> Levels: 1 2 3
```

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

### Check Package with R CMD check

Source: https://topepo.github.io/sparsediscrim/CONTRIBUTING.html

Runs R CMD check to ensure the package passes all checks. It's recommended to resolve any issues before proceeding.

```R
devtools::check()
```

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

### Fit DLDA Model and Predict Classes

Source: https://topepo.github.io/sparsediscrim/reference/lda_diag.html

Demonstrates fitting a DLDA model using a formula interface and predicting class labels for new data. It also shows an alternative fitting method using matrix and vector inputs and verifies the consistency of predictions between the two methods.

```R
library(modeldata)
data(penguins)
pred_rows <- seq(1, 344, by = 20)
penguins <- penguins[, c("species", "body_mass_g", "flipper_length_mm")]
dlda_out <- lda_diag(species ~ ., data = penguins[-pred_rows, ])
predicted <- predict(dlda_out, penguins[pred_rows, -1], type = "class")

dlda_out2 <- lda_diag(x = penguins[-pred_rows, -1], y = penguins$species[-pred_rows])
predicted2 <- predict(dlda_out2, penguins[pred_rows, -1], type = "class")
all.equal(predicted, predicted2)
```

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

### Create Fork from GitHub

Source: https://topepo.github.io/sparsediscrim/CONTRIBUTING.html

This function helps in forking a GitHub repository and cloning it to your local machine, recommended for new contributors.

```R
usethis::create_from_github("", fork = TRUE)
```

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

### Generate Cross-Validation Partitions

Source: https://topepo.github.io/sparsediscrim/reference/cv_partition.html

This snippet demonstrates how to use `cv_partition` to create partitions for cross-validation. It specifies the data to partition (`iris$Species`), the size of the hold-out set, and a seed for reproducibility.

```R
cv_partition(iris$Species, hold_out = 15, seed = 42)
```

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

### Initialize a Pull Request Branch

Source: https://topepo.github.io/sparsediscrim/CONTRIBUTING.html

Use this function to create a new Git branch for a pull request, providing a brief description of the intended changes.

```R
usethis::pr_init("brief-description-of-change")
```

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

### quadform_inv

Source: https://topepo.github.io/sparsediscrim/reference/quadform_inv.html

Computes the quadratic form of a vector and the inverse of a matrix in an efficient manner. This function calculates q = x'A^{-1}x, where x is a real vector and A is a nonsingular matrix.

```APIDOC
## quadform_inv

### Description
Computes the quadratic form of a vector and the inverse of a matrix efficiently. Calculates q = x'A^{-1}x.

### Arguments
* **A** (matrix) - A p x p nonsingular matrix.
* **x** (vector) - A vector of length p.

### Value
* **scalar** - The computed quadratic form value.

### Details
Provides an efficient method for calculating x'A^{-1}x, which is more performant than the naive approach (t(x) %*% solve(A) %*% x) for large dimensions.
```

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

### SmDLDA Classifier Training and Prediction

Source: https://topepo.github.io/sparsediscrim/reference/lda_shrink_mean.html

Demonstrates how to train an SmDLDA classifier using a formula interface and predict class labels for new data. It also shows an alternative training method using matrix and vector inputs and verifies the consistency of predictions between the two methods.

```r
library(modeldata)
data(penguins)
pred_rows <- seq(1, 344, by = 20)
penguins <- penguins[, c("species", "body_mass_g", "flipper_length_mm")]
smdlda_out <- lda_shrink_mean(species ~ ., data = penguins[-pred_rows, ])
predicted <- predict(smdlda_out, penguins[pred_rows, -1], type = "class")

smdlda_out2 <- lda_shrink_mean(x = penguins[-pred_rows, -1], y = penguins$species[-pred_rows])
predicted2 <- predict(smdlda_out2, penguins[pred_rows, -1], type = "class")
all.equal(predicted, predicted2)
```

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

### Load Two Class Simulation Data

Source: https://topepo.github.io/sparsediscrim/reference/two_class_sim_data.html

Loads the `two_class_sim_data` dataset into the R environment. This dataset is suitable for practicing bivariate classification tasks.

```r
data(two_class_sim_data)
```

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

### Fit SDLDA using formula interface

Source: https://topepo.github.io/sparsediscrim/reference/lda_shrink_cov.html

Fit an SDLDA model using a formula interface. Requires training data and class labels. Assumes features are uncorrelated within each class.

```R
library(modeldata)
data(penguins)
pred_rows <- seq(1, 344, by = 20)
penguins <- penguins[, c("species", "body_mass_g", "flipper_length_mm")]
sdlda_out <- lda_shrink_cov(species ~ ., data = penguins[-pred_rows, ])
predicted <- predict(sdlda_out, penguins[pred_rows, -1], type = "class")
```

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

### quadform

Source: https://topepo.github.io/sparsediscrim/reference/index.html

Quadratic form of a matrix and a vector.

```APIDOC
## quadform

### Description
Quadratic form of a matrix and a vector.

### Method
Not applicable (function)

### Endpoint
Not applicable (function)

### Parameters
Not specified in source.

### Request Example
Not specified in source.

### Response
Not specified in source.
```

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

### Tong Mean Shrinkage Function Signature

Source: https://topepo.github.io/sparsediscrim/reference/tong_mean_shrinkage.html

This is the function signature for `tong_mean_shrinkage`. It takes a data matrix `x` and an optional shrinkage coefficient `r_opt` as input.

```R
tong_mean_shrinkage(x, r_opt = NULL)
```

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

### Generate Cross-Validation Partitions

Source: https://topepo.github.io/sparsediscrim/reference/cv_partition.html

This snippet demonstrates how to use the `cv_partition` function with a factor variable to create cross-validation folds. Setting the random seed ensures reproducible results.

```R
set.seed(42)
cv_partition(iris$Species)
```

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

### Quadratic Form Calculation

Source: https://topepo.github.io/sparsediscrim/reference/quadform.html

This function computes the quadratic form q=x'Ax. It is an efficient alternative to the naive t(x) %*% A %*% x method, especially for large dimensions.

```R
quadform(A, x)
```

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

### Fit SDLDA using matrix interface

Source: https://topepo.github.io/sparsediscrim/reference/lda_shrink_cov.html

Fit an SDLDA model using a matrix interface for training data and class labels. This method is an alternative to the formula interface and yields identical results.

```R
sdlda_out2 <- lda_shrink_cov(x = penguins[-pred_rows, -1], y = penguins$species[-pred_rows])
predicted2 <- predict(sdlda_out2, penguins[pred_rows, -1], type = "class")
all.equal(predicted, predicted2)
```

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

### SmDQDA Function Signatures

Source: https://topepo.github.io/sparsediscrim/reference/qda_shrink_mean.html

Provides the S3 method signatures for the qda_shrink_mean function, including default, formula, and predict methods.

```R
qda_shrink_mean(x, ...)

# S3 method for default
qda_shrink_mean(x, y, prior = NULL, ...)

# S3 method for formula
qda_shrink_mean(formula, data, prior = NULL, ...)

# S3 method for qda_shrink_mean
predict(object, newdata, type = c("class", "prob", "score"), ...)
```

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

### Push Pull Request

Source: https://topepo.github.io/sparsediscrim/CONTRIBUTING.html

After making changes and committing them to Git, use this function to push your branch and initiate the pull request process on GitHub.

```R
usethis::pr_push()
```

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

### Call solve_chol function

Source: https://topepo.github.io/sparsediscrim/reference/solve_chol.html

This snippet shows the basic usage of the `solve_chol` function. It takes a single argument, `x`, which must be a symmetric, positive-definite matrix. The function returns the inverse of the input matrix.

```r
solve_chol(x)
```

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

### var_shrinkage Function Signature

Source: https://topepo.github.io/sparsediscrim/reference/var_shrinkage.html

This is the function signature for `var_shrinkage`. It takes sample size, number of classes, feature variances, and optional parameters for alpha values and the shrinkage exponent.

```R
var_shrinkage(N, K, var_feature, num_alphas = 101, t = -1)
```

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

### var_shrinkage

Source: https://topepo.github.io/sparsediscrim/reference/index.html

Shrinkage-based estimator of variances for each feature from Pang et al. (2009).

```APIDOC
## var_shrinkage

### Description
Shrinkage-based estimator of variances for each feature from Pang et al. (2009).

### Method
Not applicable (function)

### Endpoint
Not applicable (function)

### Parameters
Not specified in source.

### Request Example
Not specified in source.

### Response
Not specified in source.
```

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

### solve_chol

Source: https://topepo.github.io/sparsediscrim/reference/index.html

Computes the inverse of a symmetric, positive-definite matrix using the Cholesky decomposition.

```APIDOC
## solve_chol

### Description
Computes the inverse of a symmetric, positive-definite matrix using the Cholesky decomposition.

### Method
Not applicable (function)

### Endpoint
Not applicable (function)

### Parameters
Not specified in source.

### Request Example
Not specified in source.

### Response
Not specified in source.
```

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

### Call rda_weights Function

Source: https://topepo.github.io/sparsediscrim/reference/rda_weights.html

This is the basic function signature for rda_weights. It takes the data matrix x, class labels y, and the RDA pooling parameter lambda.

```r
rda_weights(x, y, lambda = 1)
```

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

### DQDA Classifier Functions

Source: https://topepo.github.io/sparsediscrim/reference/qda_diag.html

Provides the function signatures for creating and predicting with the DQDA classifier in R.

```R
qda_diag(x, ...)

# S3 method for default
qda_diag(x, y, prior = NULL, ...)

# S3 method for formula
qda_diag(formula, data, prior = NULL, ...)

# S3 method for qda_diag
predict(object, newdata, type = c("class", "prob", "score"), ...)
```

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

### risk_stein

Source: https://topepo.github.io/sparsediscrim/reference/index.html

Stein Risk function from Pang et al. (2009).

```APIDOC
## risk_stein

### Description
Stein Risk function from Pang et al. (2009).

### Method
Not applicable (function)

### Endpoint
Not applicable (function)

### Parameters
Not specified in source.

### Request Example
Not specified in source.

### Response
Not specified in source.
```

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

### Call diag_estimates function

Source: https://topepo.github.io/sparsediscrim/reference/diag_estimates.html

This is the function signature for `diag_estimates`. It takes training data `x`, class labels `y`, and optional arguments for prior probabilities, pooling variances, and mean estimation method.

```R
diag_estimates(x, y, prior = NULL, pool = FALSE, est_mean = c("mle", "tong"))
```

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

### lda_pseudo

Source: https://topepo.github.io/sparsediscrim/reference/index.html

Linear Discriminant Analysis (LDA) with the Moore-Penrose Pseudo-Inverse.

```APIDOC
## lda_pseudo

### Description
Linear Discriminant Analysis (LDA) with the Moore-Penrose Pseudo-Inverse.

### Method
Not applicable (function)

### Endpoint
Not applicable (function)

### Parameters
Not specified in source.

### Request Example
Not specified in source.

### Response
Not specified in source.
```

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

### Log Determinant Function Signature

Source: https://topepo.github.io/sparsediscrim/reference/log_determinant.html

This snippet shows the basic signature of the log_determinant function. It takes a single argument, 'x', which is expected to be a matrix.

```r
log_determinant(x)
```

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

### SDQDA Function Signatures

Source: https://topepo.github.io/sparsediscrim/reference/qda_shrink_cov.html

These are the S3 method signatures for the qda_shrink_cov function, including the default, formula, and predict methods.

```R
qda_shrink_cov(x, ...)

# S3 method for default
qda_shrink_cov(x, y, prior = NULL, num_alphas = 101, ...)

# S3 method for formula
qda_shrink_cov(formula, data, prior = NULL, num_alphas = 101, ...)

# S3 method for qda_shrink_cov
predict(object, newdata, type = c("class", "prob", "score"), ...)
```

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

### R Function Signature for center_data

Source: https://topepo.github.io/sparsediscrim/reference/center_data.html

This is the function signature for `center_data`. It takes a data matrix `x` and a class label vector `y` as input.

```R
center_data(x, y)
```

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

### Generate Data for Sparse Discriminant Analysis

Source: https://topepo.github.io/sparsediscrim/reference/generate_blockdiag.html

Generates synthetic data for K=4 classes with specified variances. This is useful for testing discriminant analysis algorithms.

```R
data <- gendata(K = 4, p = 10, n = 65, var = 1.0, seed = 123)
data$y
```

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

### Compute Pooled Eigenvalue Decomposition using Fast SVD

Source: https://topepo.github.io/sparsediscrim/reference/cov_eigen.html

Calculates the pooled eigenvalue decomposition using the Fast SVD method for improved performance, especially with large datasets. This is an efficient alternative when speed is critical.

```R
cov_eigen(x = iris[, -5], y = iris[, 5], pool = TRUE, fast = TRUE)
```

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

### generate_blockdiag

Source: https://topepo.github.io/sparsediscrim/reference/index.html

Generates data from K multivariate normal data populations, where each population (class) has a covariance matrix consisting of block-diagonal autocorrelation matrices.

```APIDOC
## generate_blockdiag

### Description
Generates data from K multivariate normal data populations, where each population (class) has a covariance matrix consisting of block-diagonal autocorrelation matrices.

### Method
Not applicable (function)

### Endpoint
Not applicable (function)

### Parameters
Not specified in source.

### Request Example
Not specified in source.

### Response
Not specified in source.
```

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

### qda_shrink_mean

Source: https://topepo.github.io/sparsediscrim/reference/qda_shrink_mean.html

Builds the Shrinkage-mean-based Diagonal Quadratic Discriminant Analysis (SmDQDA) classifier. This function can be called with either a matrix/data frame and a response vector, or using a formula interface.

```APIDOC
## qda_shrink_mean

### Description
Builds the Shrinkage-mean-based Diagonal Quadratic Discriminant Analysis (SmDQDA) classifier from training data.

### Arguments
* `x` (Matrix or data frame): Training data where rows are observations and columns are features. Only complete data is retained.
* `y` (Vector): Class labels for each training observation. Only complete data is retained.
* `prior` (Vector, optional): Prior probabilities for each class. If NULL (default), equal probabilities are used. Must be non-negative and sum to one.
* `formula` (Formula): A formula of the form `groups ~ x1 + x2 + ...` specifying the grouping factor and discriminators.
* `data` (data frame, optional): Data frame from which variables in `formula` are taken.
* `...` (any): Additional arguments (not currently used).

### Value
An object of class `qda_shrink_mean` containing the trained SmDQDA classifier.
```

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

### Stein Risk Function Signature

Source: https://topepo.github.io/sparsediscrim/reference/risk_stein.html

This is the function signature for `risk_stein`. It is used to find the optimal shrinkage parameter alpha that minimizes average risk under a Stein loss function.

```r
risk_stein(N, K, var_feature, num_alphas = 101, t = -1)
```

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

### Posterior Probabilities Function Signature

Source: https://topepo.github.io/sparsediscrim/reference/posterior_probs.html

This is the function signature for `posterior_probs`. It takes observations, class means, covariance matrices, and prior probabilities as input to compute posterior probabilities.

```R
posterior_probs(x, means, covs, priors)
```

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

### LDA Pseudo Function Signatures

Source: https://topepo.github.io/sparsediscrim/reference/lda_pseudo.html

These are the function signatures for lda_pseudo and its predict method, showing the different ways the function can be called.

```R
lda_pseudo(x, ...)

# S3 method for default
lda_pseudo(x, y, prior = NULL, tol = 1e-08, ...)

# S3 method for formula
lda_pseudo(formula, data, prior = NULL, tol = 1e-08, ...)

# S3 method for lda_pseudo
predict(object, newdata, type = c("class", "prob", "score"), ...)
```

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

### tong_mean_shrinkage

Source: https://topepo.github.io/sparsediscrim/reference/index.html

Tong et al. (2012)'s Lindley-type Shrunken Mean Estimator.

```APIDOC
## tong_mean_shrinkage

### Description
Tong et al. (2012)'s Lindley-type Shrunken Mean Estimator.

### Method
Not applicable (function)

### Endpoint
Not applicable (function)

### Parameters
Not specified in source.

### Request Example
Not specified in source.

### Response
Not specified in source.
```

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

### Generate Block Diagonal Data

Source: https://topepo.github.io/sparsediscrim/reference/generate_blockdiag.html

Generates a block-diagonal matrix with specified sample sizes, block sizes, number of blocks, and correlation coefficients. The means matrix is also specified to define class means.

```R
means <- matrix(rep(1:4, each=9), ncol=4)
data <- generate_blockdiag(n = c(15, 15, 15, 20), block_size = 3, num_blocks = 3,
rho = seq(.1, .9, length = 4), mu = means)
data$x
```

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

### HDRDA Classifier Method for Default Input

Source: https://topepo.github.io/sparsediscrim/reference/rda_high_dim.html

S3 method for the default rda_high_dim function, specifying parameters for training the classifier.

```R
rda_high_dim(
  x,
  y,
  lambda = 1,
  gamma = 0,
  shrinkage_type = c("ridge", "convex"),
  prior = NULL,
  tol = 1e-06,
  ...
)
```

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

### Call cov_shrink_diag function

Source: https://topepo.github.io/sparsediscrim/reference/cov_shrink_diag.html

This is the basic function call for cov_shrink_diag. It takes a data matrix 'x' and an optional shrinkage parameter 'gamma'.

```r
cov_shrink_diag(x, gamma = 1)
```

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

### Quadratic Form Inverse Function

Source: https://topepo.github.io/sparsediscrim/reference/quadform_inv.html

Computes the quadratic form q=x′A−1x. Use this function for an efficient calculation when dealing with large matrices.

```R
quadform_inv(A, x)
```

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

### Generate Intraclass Data with Default Variance

Source: https://topepo.github.io/sparsediscrim/reference/generate_intraclass.html

Generates data from 3 classes with specified sample sizes, number of features, off-diagonal covariance elements (rho), and mean vectors. Uses default variance (sigma2 = 1).

```R
data <- generate_intraclass(n = 3:5, p = 5, rho = seq(.1, .9, length = 3),
                            mu = c(0, 3, -2))
data$x

#>             [,1]        [,2]       [,3]       [,4]        [,5]
#>  [1,] -0.4952236 -0.09231841  0.5820481  0.4069353 -0.08789382
#>  [2,] -0.7586901  1.12339313  0.9231776 -0.6332903  0.70545237
#>  [3,]  0.4882661  1.05286150  0.2032278 -1.0212341  0.82259500
#>  [4,]  2.8157877  3.70386131  4.5143962  2.3278051  4.43550577
#>  [5,]  3.8168171  2.48614267  2.6823111  2.3750202  2.45667692
#>  [6,]  3.2560923  2.21057101  2.7116475  2.7444760  2.77794385
#>  [7,]  3.3997265  4.40037276  2.9522846  2.7093591  3.83165394
#>  [8,] -1.5656832 -1.61143639 -1.4991122 -2.1324906 -1.34975544
#>  [9,] -2.4122656 -2.25497541 -2.7450749 -3.1382796 -2.70904766
#> [10,] -1.6468736 -0.65720421 -1.4908530 -1.4283055 -1.02396009
#> [11,]  0.3898303  0.40650182  1.0265115  0.2461894  0.79612886
#> [12,] -3.3029130 -3.84452904 -4.0874635 -3.1776978 -3.69913633
data$y

#>  [1] 1 1 1 2 2 2 2 3 3 3 3 3
#> Levels: 1 2 3
```

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

### risk_stein

Source: https://topepo.github.io/sparsediscrim/reference/risk_stein.html

Calculates the value for alpha that empirically minimizes the average risk under a Stein loss function.

```APIDOC
## risk_stein

### Description
This function finds the value for \(\(alpha\)\)\(\in\)\([0,1]\)\(\alpha\)\(\in\)\([0,1]\) that empirically minimizes the average risk under a Stein loss function.

### Arguments
- **N** (numeric) - The sample size.
- **K** (numeric) - The number of classes.
- **var_feature** (vector) - A vector of the sample variances for each dimension.
- **num_alphas** (numeric) - The number of values used to find the optimal amount of shrinkage. Defaults to 101.
- **t** (numeric) - A constant specified by the user that indicates the exponent to use with the variance estimator. By default, t = -1 as in Pang et al. See the paper for more details.

### Value
A list containing:
- **alpha**: The alpha that minimizes the average risk under a Stein loss function. If the minimum is not unique, a random alpha from the minimizers is selected.
- **risk**: The minimum average risk attained.
```

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

### MDMEB Classifier Function Signatures

Source: https://topepo.github.io/sparsediscrim/reference/lda_emp_bayes_eigen.html

Displays the function signatures for the lda_emp_bayes_eigen function and its S3 methods for default, formula, and predict.

```R
lda_emp_bayes_eigen(x, ...)

# S3 method for default
lda_emp_bayes_eigen(x, y, prior = NULL, eigen_pct = 0.95, ...)

# S3 method for formula
lda_emp_bayes_eigen(formula, data, prior = NULL, ...)

# S3 method for lda_emp_bayes_eigen
predict(object, newdata, type = c("class", "prob", "score"), ...)
```
Tokens:
Raw