docs only one option

DESCRIPTION

@@ -1,7 +1,7 @@
 Type: Package
 Package: performance
 Title: Assessment of Regression Models Performance
-Version: 0.13.0.2
+Version: 0.13.0.3
 Authors@R:
     c(person(given = "Daniel",
              family = "Lüdecke",

R/binned_residuals.R

@@ -80,13 +80,19 @@ binned_residuals <- function(model,
                              n_bins = NULL,
                              show_dots = NULL,
                              ci = 0.95,
-                             ci_type = c("exact", "gaussian", "boot"),
-                             residuals = c("deviance", "pearson", "response"),
+                             ci_type = "exact",
+                             residuals = "deviance",
                              iterations = 1000,
                              verbose = TRUE,
                              ...) {
-  ci_type <- match.arg(ci_type)
-  residuals <- match.arg(residuals)
+  ci_type <- insight::validate_argument(
+    ci_type,
+    c("exact", "gaussian", "boot")
+  )
+  residuals <- insight::validate_argument(
+    residuals,
+    c("deviance", "pearson", "response")
+  )
 
   # for non-bernoulli models, `"exact"` doesn't work
   if (isFALSE(insight::model_info(model)$is_bernoulli)) {

R/check_collinearity.R

@@ -305,55 +305,70 @@
 #' @rdname check_collinearity
 #' @export
 check_collinearity.glmmTMB <- function(x,
-                                       component = c("all", "conditional", "count", "zi", "zero_inflated"),
+                                       component = "all",
                                        ci = 0.95,
                                        verbose = TRUE,
                                        ...) {
-  component <- match.arg(component)
+  component <- insight::validate_argument(
+    component,
+    c("all", "conditional", "count", "zi", "zero_inflated")
+  )
   .check_collinearity_zi_model(x, component, ci = ci, verbose = verbose)
 }
 
 
 #' @export
 check_collinearity.MixMod <- function(x,
-                                      component = c("all", "conditional", "count", "zi", "zero_inflated"),
+                                      component = "all",
                                       ci = 0.95,
                                       verbose = TRUE,
                                       ...) {
-  component <- match.arg(component)
+  component <- insight::validate_argument(
+    component,
+    c("all", "conditional", "count", "zi", "zero_inflated")
+  )
   .check_collinearity_zi_model(x, component, ci = ci, verbose = verbose)
 }
 
 
 #' @export
 check_collinearity.hurdle <- function(x,
-                                      component = c("all", "conditional", "count", "zi", "zero_inflated"),
+                                      component = "all",
                                       ci = 0.95,
                                       verbose = verbose,
                                       ...) {
-  component <- match.arg(component)
+  component <- insight::validate_argument(
+    component,
+    c("all", "conditional", "count", "zi", "zero_inflated")
+  )
   .check_collinearity_zi_model(x, component, ci = ci, verbose = verbose)
 }
 
 
 #' @export
 check_collinearity.zeroinfl <- function(x,
-                                        component = c("all", "conditional", "count", "zi", "zero_inflated"),
+                                        component = "all",
                                         ci = 0.95,
                                         verbose = verbose,
                                         ...) {
-  component <- match.arg(component)
+  component <- insight::validate_argument(
+    component,
+    c("all", "conditional", "count", "zi", "zero_inflated")
+  )
   .check_collinearity_zi_model(x, component, ci = ci, verbose = verbose)
 }
 
 
 #' @export
 check_collinearity.zerocount <- function(x,
-                                         component = c("all", "conditional", "count", "zi", "zero_inflated"),
+                                         component = "all",
                                          ci = 0.95,
                                          verbose = verbose,
                                          ...) {
-  component <- match.arg(component)
+  component <- insight::validate_argument(
+    component,
+    c("all", "conditional", "count", "zi", "zero_inflated")
+  )
   .check_collinearity_zi_model(x, component, ci = ci, verbose = verbose)
 }
 
@@ -407,7 +422,7 @@
 }
 
 
 .check_collinearity <- function(x, component, ci = 0.95, verbose = TRUE) {
   v <- .safe(insight::get_varcov(x, component = component, verbose = FALSE))
 
   # sanity check

R/check_dag.R

@@ -215,14 +215,17 @@ check_dag <- function(...,
                       exposure = NULL,
                       adjusted = NULL,
                       latent = NULL,
-                      effect = c("all", "total", "direct"),
+                      effect = "all",
                       coords = NULL) {
   insight::check_if_installed(
     c("ggdag", "dagitty"),
     reason = "to check correct adjustments for identifying causal effects."
   )
 
-  effect <- match.arg(effect)
+  effect <- insight::validate_argument(
+    effect,
+    c("all", "total", "direct")
+  )
 
   # retrieve formulas
   formulas <- list(...)

R/check_homogeneity.R

@@ -30,16 +30,19 @@
 #' result <- check_homogeneity(model)
 #' plot(result)
 #' @export
-check_homogeneity <- function(x, method = c("bartlett", "fligner", "levene", "auto"), ...) {
+check_homogeneity <- function(x, method = "bartlett", ...) {
   UseMethod("check_homogeneity")
 }
 
 
 # default -------------------------
 
 #' @export
-check_homogeneity.default <- function(x, method = c("bartlett", "fligner", "levene", "auto"), ...) {
-  method <- match.arg(method)
+check_homogeneity.default <- function(x, method = "bartlett", ...) {
+  method <- insight::validate_argument(
+    method,
+    c("bartlett", "fligner", "levene", "auto")
+  )
 
   resp <- insight::find_response(x)
   pred <- insight::find_predictors(x, component = "conditional", flatten = TRUE)

R/check_normality.R

@@ -189,9 +189,9 @@ print.check_normality <- function(x, ...) {
 
 #' @rdname check_normality
 #' @export
-check_normality.merMod <- function(x, effects = c("fixed", "random"), ...) {
+check_normality.merMod <- function(x, effects = "fixed", ...) {
   # args
-  effects <- match.arg(effects)
+  effects <- insight::validate_argument(effects, c("fixed", "random"))
   info <- insight::model_info(x)
 
   # valid model?

R/check_outliers.R

@@ -1489,8 +1489,8 @@ check_outliers.metabin <- check_outliers.metagen
 #' @rdname check_outliers
 #' @export
 check_outliers.performance_simres <- function(x, type = "default", iterations = 100, alternative = "two.sided", ...) {
-  type <- match.arg(type, c("default", "binomial", "bootstrap"))
-  alternative <- match.arg(alternative, c("two.sided", "greater", "less"))
+  type <- insight::validate_argument(type, c("default", "binomial", "bootstrap"))
+  alternative <- insight::validate_argument(alternative, c("two.sided", "greater", "less"))
 
   insight::check_if_installed("DHARMa")
   result <- DHARMa::testOutliers(x, type = type, nBoot = iterations, alternative = alternative, plot = FALSE, ...)

R/check_overdispersion.R

@@ -284,8 +284,11 @@ check_overdispersion.glmmTMB <- check_overdispersion.merMod
 
 #' @rdname check_overdispersion
 #' @export
-check_overdispersion.performance_simres <- function(x, alternative = c("two.sided", "less", "greater"), ...) {
-  alternative <- match.arg(alternative)
+check_overdispersion.performance_simres <- function(x, alternative = "two.sided", ...) {
+  alternative <- insight::validate_argument(
+    alternative,
+    c("two.sided", "less", "greater")
+  )
 
   # check for special arguments - we may pass "object_name" from other methods
   dots <- list(...)

R/check_predictions.R

@@ -126,7 +126,10 @@
   }
 
   # args
-  type <- match.arg(type, choices = c("density", "discrete_dots", "discrete_interval", "discrete_both"))
+  type <- insight::validate_argument(
+    type,
+    c("density", "discrete_dots", "discrete_interval", "discrete_both")
+  )
 
   pp_check.lm(
     object,
@@ -161,7 +164,10 @@
   }
 
   # args
-  type <- match.arg(type, choices = c("density", "discrete_dots", "discrete_interval", "discrete_both"))
+  type <- insight::validate_argument(
+    type,
+    c("density", "discrete_dots", "discrete_interval", "discrete_both")
+  )
 
   # convert to type-argument for pp_check
   pp_type <- switch(type,

R/check_residuals.R

@@ -8,7 +8,8 @@
 #' @param x An object returned by [`simulate_residuals()`] or
 #' [`DHARMa::simulateResiduals()`].
 #' @param alternative A character string specifying the alternative hypothesis.
-#' See [`stats::ks.test()`] for details.
+#' Can be one of `"two.sided"`, `"less"`, or `"greater"`. See
+#' [`stats::ks.test()`] for details.
 #' @param ... Passed down to [`stats::ks.test()`].
 #'
 #' @details Uniformity of residuals is checked using a Kolmogorov-Smirnov test.
@@ -38,7 +39,7 @@ check_residuals <- function(x, ...) {
 
 #' @rdname check_residuals
 #' @export
-check_residuals.default <- function(x, alternative = c("two.sided", "less", "greater"), ...) {
+check_residuals.default <- function(x, alternative = "two.sided", ...) {
   if (insight::is_model(x)) {
     check_residuals(simulate_residuals(x, ...), alternative = alternative)
   } else {
@@ -47,8 +48,11 @@ check_residuals.default <- function(x, alternative = c("two.sided", "less", "gre
 }
 
 #' @export
-check_residuals.performance_simres <- function(x, alternative = c("two.sided", "less", "greater"), ...) {
-  alternative <- match.arg(alternative)
+check_residuals.performance_simres <- function(x, alternative = "two.sided", ...) {
+  alternative <- insight::validate_argument(
+    alternative,
+    c("two.sided", "less", "greater")
+  )
   ts_test <- suppressWarnings(
     stats::ks.test(
       stats::residuals(x),

R/check_zeroinflation.R

@@ -11,6 +11,7 @@
 #' between 1 +/- `tolerance` is considered as OK, while a ratio
 #' beyond or below this threshold would indicate over- or underfitting.
 #' @param alternative A character string specifying the alternative hypothesis.
+#' Can be one of `"two.sided"`, `"less"`, or `"greater"`.
 #' @param ... Arguments passed down to [`simulate_residuals()`]. This only applies
 #' for models with zero-inflation component, or for models of class `glmmTMB`
 #' from `nbinom1` or `nbinom2` family.
@@ -118,9 +119,12 @@ check_zeroinflation.default <- function(x, tolerance = 0.05, ...) {
 #' @export
 check_zeroinflation.performance_simres <- function(x,
                                                    tolerance = 0.1,
-                                                   alternative = c("two.sided", "less", "greater"),
+                                                   alternative = "two.sided",
                                                    ...) {
-  alternative <- match.arg(alternative)
+  alternative <- insight::validate_argument(
+    alternative,
+    c("two.sided", "less", "greater")
+  )
 
   # compute test results
   result <- .simres_statistics(x, statistic_fun = function(i) sum(i == 0), alternative = alternative)

R/compare_performance.R

@@ -17,7 +17,7 @@
 #' @return A data frame with one row per model and one column per "index" (see
 #'   `metrics`).
 #'
 #' @note There is also a [`plot()`-method](https://easystats.github.io/see/articles/performance.html) implemented in the \href{https://easystats.github.io/see/}{\pkg{see}-package}.
 #'
 #' @details \subsection{Model Weights}{
 #'   When information criteria (IC) are requested in `metrics` (i.e., any of `"all"`,
@@ -105,11 +105,11 @@
   }
 
   # iterate over all models, i.e. model-performance for each model
   m <- mapply(function(.x, .y) {
     dat <- model_performance(.x, metrics = metrics, estimator = estimator, verbose = FALSE)
     model_name <- gsub("\"", "", insight::safe_deparse(.y), fixed = TRUE)
     perf_df <- data.frame(Name = model_name, Model = class(.x)[1], dat, stringsAsFactors = FALSE)
     attributes(perf_df) <- c(attributes(perf_df), attributes(dat)[!names(attributes(dat)) %in% c("names", "row.names", "class")])
     perf_df
   }, model_objects, object_names, SIMPLIFY = FALSE)
 
@@ -193,7 +193,7 @@
     !isTRUE(attributes(model_objects)$same_fixef)) {
     insight::format_alert(
       "Information criteria (like AIC) are based on REML fits (i.e. `estimator=\"REML\"`).",
       "Please note that information criteria are probably not directly comparable and that it is not recommended comparing models with different fixed effects in such cases."
     )
   }
 
@@ -207,12 +207,12 @@
 
 #' @export
 print.compare_performance <- function(x, digits = 3, layout = "horizontal", ...) {
-  layout <- match.arg(layout, choices = c("horizontal", "vertical"))
+  layout <- insight::validate_argument(layout, c("horizontal", "vertical"))
   table_caption <- c("# Comparison of Model Performance Indices", "blue")
   formatted_table <- format(x = x, digits = digits, format = "text", ...)
 
   if ("Performance_Score" %in% colnames(formatted_table)) {
     footer <- c(sprintf("\nModel `%s` (of class `%s`) performed best with an overall performance score of %s.", formatted_table$Model[1], formatted_table$Type[1], formatted_table$Performance_Score[1]), "yellow")
   } else {
     footer <- NULL
   }
@@ -224,7 +224,7 @@
     colnames(formatted_table)[1] <- "Metric"
   }
 
   cat(insight::export_table(x = formatted_table, digits = digits, format = "text", caption = table_caption, footer = footer, ...))
   invisible(x)
 }
 

R/item_intercor.R

@@ -1,14 +1,13 @@
 #' @title Mean Inter-Item-Correlation
 #' @name item_intercor
 #'
-#' @description Compute various measures of internal consistencies
-#'    for tests or item-scales of questionnaires.
+#' @description Compute various measures of internal consistencies for tests or
+#' item-scales of questionnaires.
 #'
-#' @param x A matrix as returned by the `cor()`-function,
-#'    or a data frame with items (e.g. from a test or questionnaire).
-#' @param method Correlation computation method. May be one of
-#'    `"pearson"` (default), `"spearman"` or `"kendall"`.
-#'    You may use initial letter only.
+#' @param x A matrix as returned by the `cor()`-function, or a data frame with
+#' items (e.g. from a test or questionnaire).
+#' @param method Correlation computation method. May be one of `"pearson"`
+#' (default), `"spearman"` or `"kendall"`. You may use initial letter only.
 #'
 #' @return The mean inter-item-correlation value for `x`.
 #'
@@ -36,9 +35,9 @@
 #' x <- mtcars[, c("cyl", "gear", "carb", "hp")]
 #' item_intercor(x)
 #' @export
-item_intercor <- function(x, method = c("pearson", "spearman", "kendall")) {
+item_intercor <- function(x, method = "pearson") {
   # Check parameter
-  method <- match.arg(method)
+  method <- insight::validate_argument(method, c("pearson", "spearman", "kendall"))
 
   # Mean-interitem-corelation
   if (inherits(x, "matrix")) {

R/model_performance.R

@@ -45,7 +45,10 @@ performance <- model_performance
 
 #' @export
 print.performance_model <- function(x, digits = 3, layout = "horizontal", ...) {
-  layout <- match.arg(layout, choices = c("horizontal", "vertical"))
+  layout <- insight::validate_argument(
+    layout,
+    c("horizontal", "vertical")
+  )
   formatted_table <- format(x = x, digits = digits, format = "text", ...)
 
   # switch to vertical layout

R/performance_accuracy.R

@@ -14,21 +14,19 @@
 #' @param verbose Toggle warnings.
 #' @inheritParams performance_pcp
 #'
-#' @return A list with three values: The `Accuracy` of the model
-#'   predictions, i.e. the proportion of accurately predicted values from the
-#'   model, its standard error, `SE`, and the `Method` used to compute
-#'   the accuracy.
+#' @return A list with three values: The `Accuracy` of the model predictions,
+#' i.e. the proportion of accurately predicted values from the model, its
+#' standard error, `SE`, and the `Method` used to compute the accuracy.
 #'
 #' @details For linear models, the accuracy is the correlation coefficient
-#'    between the actual and the predicted value of the outcome. For
-#'    logistic regression models, the accuracy corresponds to the
-#'    AUC-value, calculated with the `bayestestR::auc()`-function.
-#'    \cr \cr
-#'    The accuracy is the mean value of multiple correlation resp.
-#'    AUC-values, which are either computed with cross-validation
-#'    or non-parametric bootstrapping (see argument `method`).
-#'    The standard error is the standard deviation of the computed
-#'    correlation resp. AUC-values.
+#' between the actual and the predicted value of the outcome. For logistic
+#' regression models, the accuracy corresponds to the AUC-value, calculated with
+#' the [`bayestestR::auc()`]-function.
+#'
+#' The accuracy is the mean value of multiple correlation resp. AUC-values,
+#' which are either computed with cross-validation or non-parametric
+#' bootstrapping (see argument `method`). The standard error is the standard
+#' deviation of the computed correlation resp. AUC-values.
 #'
 #' @examples
 #' model <- lm(mpg ~ wt + cyl, data = mtcars)
@@ -38,15 +36,15 @@
 #' performance_accuracy(model)
 #' @export
 performance_accuracy <- function(model,
-                                 method = c("cv", "boot"),
+                                 method = "cv",
                                  k = 5,
                                  n = 1000,
                                  ci = 0.95,
                                  verbose = TRUE) {
-  method <- match.arg(method)
+  method <- insight::validate_argument(method, c("cv", "boot"))
 
   # get formula from model fit
   formula <- stats::formula(model)
 
   # get name of response
   resp.name <- insight::find_response(model)
@@ -67,7 +65,7 @@
       bootstr <- replicate(n, sample(nrow(model_data), replace = TRUE), simplify = FALSE)
 
       models <- lapply(bootstr, function(.x) {
         text <- utils::capture.output({
           model_upd <- stats::update(model, data = model_data[.x, ])
         })
         # stats::lm(formula, data = model_data[.x, ])
@@ -82,7 +80,7 @@
         as.data.frame(model_data[.x, ])[[resp.name]]
       })
 
       accuracy <- mapply(function(.x, .y) {
         stats::cor(.x, .y, use = "pairwise.complete.obs")
       }, predictions, response)
     } else {

R/performance_cv.R

@@ -37,7 +37,7 @@
 #' @export
 performance_cv <- function(model,
                            data = NULL,
-                           method = c("holdout", "k_fold", "loo"),
+                           method = "holdout",
                            metrics = "all",
                            prop = 0.30,
                            k = 5,
@@ -53,7 +53,7 @@ performance_cv <- function(model,
     metrics[metrics == "DEVIANCE"] <- "Deviance"
   }
   if (is.null(data)) {
-    method <- match.arg(method, choices = c("holdout", "k_fold", "loo"))
+    method <- insight::validate_argument(method, c("holdout", "k_fold", "loo"))
   }
   if (!is.null(data) && inherits(model, "BFBayesFactor")) {
     insight::format_error("Models of class 'BFBayesFactor' not yet supported.")