, 1990), we can\n use the alpha quantile of the chi-square distribution with k degrees of freedom (k being the\n number of columns). By default, the alpha threshold is set to 0.025 (corresponding to the 2.5\\\n Cabana, 2019). This criterion is a natural extension of the median plus or minus a coefficient\n times the MAD method (Leys et al., 2013).\n • Robust Mahalanobis Distance: A robust version of Mahalanobis distance using an Orthog-\n onalized Gnanadesikan-Kettenring pairwise estimator (Gnanadesikan and Kettenring, 1972).\n Requires the bigutilsr package. See the bigutilsr::dist_ogk() function.\n • Minimum Covariance Determinant (MCD): Another robust version of Mahalanobis. Leys\n et al. (2018) argue that Mahalanobis Distance is not a robust way to determine outliers, as it\n uses the means and covariances of all the data - including the outliers - to determine individual\n difference scores. Minimum Covariance Determinant calculates the mean and covariance\n matrix based on the most central subset of the data (by default, 66\\ is deemed to be a more\n robust method of identifying and removing outliers than regular Mahalanobis distance.\n • Invariant Coordinate Selection (ICS): The outlier are detected using ICS, which by default\n uses an alpha threshold of 0.025 (corresponding to the 2.5\\ value for outliers classification.\n Refer to the help-file of ICSOutlier::ics.outlier() to get more details about this proce-\n dure. Note that method = \"ics\" requires both ICS and ICSOutlier to be installed, and that it\n takes some time to compute the results.\n • OPTICS: The Ordering Points To Identify the Clustering Structure (OPTICS) algorithm (Ankerst\n et al., 1999) is using similar concepts to DBSCAN (an unsupervised clustering technique that\n can be used for outliers detection). The threshold argument is passed as minPts, which cor-\n responds to the minimum size of a cluster. By default, this size is set at 2 times the number\n of columns (Sander et al., 1998). Compared to the other techniques, that will always detect\n several outliers (as these are usually defined as a percentage of extreme values), this algo-\n rithm functions in a different manner and won’t always detect outliers. Note that method =\n \"optics\" requires the dbscan package to be installed, and that it takes some time to compute\n the results.\n • Local Outlier Factor: Based on a K nearest neighbors algorithm, LOF compares the local\n density of a point to the local densities of its neighbors instead of computing a distance from\n the center (Breunig et al., 2000). Points that have a substantially lower density than their\n neighbors are considered outliers. A LOF score of approximately 1 indicates that density\n around the point is comparable to its neighbors. Scores significantly larger than 1 indicate\n outliers. The default threshold of 0.025 will classify as outliers the observations located at\n qnorm(1-0.025) * SD) of the log-transformed LOF distance. Requires the dbscan package.\nThreshold specification\n Default thresholds are currently specified as follows:\n list(\n zscore = stats::qnorm(p = 1 - 0.001 / 2),\n zscore_robust = stats::qnorm(p = 1 - 0.001 / 2),\n iqr = 1.7,\n ci = 1 - 0.001,\n eti = 1 - 0.001,\n hdi = 1 - 0.001,\n bci = 1 - 0.001,\n cook = stats::qf(0.5, ncol(x), nrow(x) - ncol(x)),\n pareto = 0.7,\n mahalanobis = stats::qchisq(p = 1 - 0.001, df = ncol(x)),\n mahalanobis_robust = stats::qchisq(p = 1 - 0.001, df = ncol(x)),\n mcd = stats::qchisq(p = 1 - 0.001, df = ncol(x)),\n ics = 0.001,\n optics = 2 * ncol(x),\n lof = 0.001\n )\nMeta-analysis models\n For meta-analysis models (e.g. objects of class rma from the metafor package or metagen from\n package meta), studies are defined as outliers when their confidence interval lies outside the confi-\n dence interval of the pooled effect.\nNote\n There is also a plot()-method implemented in the see-package. Please note that the range of the\n distance-values along the y-axis is re-scaled to range from 0 to 1.\nReferences\n • ., ., and . (2018). ICS for multivariate outlier\n detection with application to quality control. Computational Statistics and Data Analysis,\n 128, 184-199. doi:10.1016/j.csda.2018.06.011\n • ., and . (1972). Robust estimates, residuals, and outlier de-\n tection with multiresponse data. Biometrics, 81-124.\n • ., and . (1985). Regression diagnostics: An expository treatment\n of outliers and influential cases. Sociological Methods and Research, 13(4), 510-542.\n • ., ., and . (2019). Multivariate outlier detection based on a\n robust Mahalanobis distance with shrinkage estimators. arXiv preprint arXiv:1904.02596.\n • . (1977). Detection of influential observation in linear regression. Technometrics,\n 19(1), 15-18.\n • ., and . (1993). How to detect and handle outliers (Vol. 16). Asq\n Press.\n • ., ., ., and . (2018). Detecting multivariate outliers: Use\n a robust variant of Mahalanobis distance. Journal of Experimental Social Psychology, 74,\n 150-156.\n • ., ., and . (2008, December). Isolation forest. In 2008 Eighth\n IEEE International Conference on Data Mining (pp. 413-422). IEEE.\n • ., ., ., ., and . (2021). perfor-\n mance: An R package for assessment, comparison and testing of statistical models. Journal of\n Open Source Software, 6(60), 3139. doi:10.21105/joss.03139\n • ., and . (1990). Unmasking multivariate outliers and lever-\n age points. Journal of the American Statistical association, 85(411), 633-639.\nSee Also\n Other functions to check model assumptions and and assess model quality: check_autocorrelation(),\n check_collinearity(), check_convergence(), check_heteroscedasticity(), check_homogeneity(),\n check_model(), check_overdispersion(), check_predictions(), check_singularity(), check_zeroinflation()\nExamples\n data <- mtcars # Size nrow(data) = 32\n # For single variables ------------------------------------------------------\n outliers_list <- check_outliers(data$mpg) # Find outliers\n outliers_list # Show the row index of the outliers\n as.numeric(outliers_list) # The object is a binary vector...\n filtered_data <- data[!outliers_list, ] # And can be used to filter a dataframe\n nrow(filtered_data) # New size, 28 (4 outliers removed)\n # Find all observations beyond +/- 2 SD\n check_outliers(data$mpg, method = \"zscore\", threshold = 2)\n # For dataframes ------------------------------------------------------\n check_outliers(data) # It works the same way on dataframes\n # You can also use multiple methods at once\n outliers_list <- check_outliers(data, method = c(\n \"mahalanobis\",\n \"iqr\",\n \"zscore\"\n ))\n outliers_list\n # Using `as.data.frame()`, we can access more details!\n outliers_info <- as.data.frame(outliers_list)\n head(outliers_info)\n outliers_info$Outlier # Including the probability of being an outlier\n # And we can be more stringent in our outliers removal process\n filtered_data <- data[outliers_info$Outlier < 0.1, ]\n # We can run the function stratified by groups using `{datawizard}` package:\n group_iris <- datawizard::data_group(iris, \"Species\")\n check_outliers(group_iris)\n ## Not run:\n # You can also run all the methods\n check_outliers(data, method = \"all\")\n # For statistical models ---------------------------------------------\n # select only mpg and disp (continuous)\n mt1 <- mtcars[, c(1, 3, 4)]\n # create some fake outliers and attach outliers to main df\n mt2 <- rbind(mt1, data.frame(\n mpg = c(37, 40), disp = c(300, 400),\n hp = c(110, 120)\n ))\n # fit model with outliers\n model <- lm(disp ~ mpg + hp, data = mt2)\n outliers_list <- check_outliers(model)\n if (require(\"see\")) {\n plot(outliers_list)\n }\n insight::get_data(model)[outliers_list, ] # Show outliers data\n ## End(Not run)\n check_overdispersion Check overdispersion of GL(M)M’s\nDescription\n check_overdispersion() checks generalized linear (mixed) models for overdispersion.\nUsage\n check_overdispersion(x, ...)\nArguments\n x Fitted model of class merMod, glmmTMB, glm, or glm.nb (package MASS).\n ... Currently not used.\nDetails\n Overdispersion occurs when the observed variance is higher than the variance of a theoretical model.\n For Poisson models, variance increases with the mean and, therefore, variance usually (roughly)\n equals the mean value. If the variance is much higher, the data are \"overdispersed\".\nValue\n A list with results from the overdispersion test, like chi-squared statistics, p-value or dispersion\n ratio.\nInterpretation of the Dispersion Ratio\n If the dispersion ratio is close to one, a Poisson model fits well to the data. Dispersion ratios larger\n than one indicate overdispersion, thus a negative binomial model or similar might fit better to the\n data. A p-value < .05 indicates overdispersion.\nOverdispersion in Poisson Models\n For Poisson models, the overdispersion test is based on the code from Hill (2007), page\n 115.\nOverdispersion in Mixed Models\n For merMod- and glmmTMB-objects, check_overdispersion() is based on the code in the GLMM\n FAQ, section How can I deal with overdispersion in GLMMs?. Note that this function only returns\n an approximate estimate of an overdispersion parameter, and is probably inaccurate for zero-inflated\n mixed models (fitted with glmmTMB).\nHow to fix Overdispersion\n Overdispersion can be fixed by either modeling the dispersion parameter, or by choosing a different\n distributional family (like Quasi-Poisson, or negative binomial, see Gel (2007), pages\n 115-116).\nReferences\n • et al. (2017): GLMM FAQ.\n • ., and . (2007). Data analysis using regression and multilevel/hierarchical\n models. Cambridge; New York: Cambridge University Press.\nSee Also\n Other functions to check model assumptions and and assess model quality: check_autocorrelation(),\n check_collinearity(), check_convergence(), check_heteroscedasticity(), check_homogeneity(),\n check_model(), check_outliers(), check_predictions(), check_singularity(), check_zeroinflation()\nExamples\n library(glmmTMB)\n data(Salamanders)\n m <- glm(count ~ spp + mined, family = poisson, data = Salamanders)\n check_overdispersion(m)\n m <- glmmTMB(\n count ~ mined + spp + (1 | site),\n family = poisson,\n data = Salamanders\n )\n check_overdispersion(m)\n check_predictions Posterior predictive checks\nDescription\n Posterior predictive checks mean \"simulating replicated data under the fitted model and then com-\n paring these to the observed data\" (, 2007, p. 158). Posterior predictive checks\n can be used to \"look for systematic discrepancies between real and simulated data\" (Gelman et al.\n 2014, p. 169).\n performance provides posterior predictive check methods for a variety of frequentist models (e.g.,\n lm, merMod, glmmTMB, ...). For Bayesian models, the model is passed to bayesplot::pp_check().\nUsage\n check_predictions(object, ...)\n ## Default S3 method:\n check_predictions(\n object,\n iterations = 50,\n check_range = FALSE,\n re_formula = NULL,\n bandwidth = \"nrd\",\n type = \"density\",\n verbose = TRUE,\n ...\n )\n posterior_predictive_check(object, ...)\n check_posterior_predictions(object, ...)\nArguments\n object A statistical model.\n ... Passed down to simulate().\n iterations The number of draws to simulate/bootstrap.\n check_range Logical, if TRUE, includes a plot with the minimum value of the original response\n against the minimum values of the replicated responses, and the same for the\n maximum value. This plot helps judging whether the variation in the original\n data is captured by the model or not (Gelman et al. 2020, pp.163). The minimum\n and maximum values of y should be inside the range of the related minimum and\n maximum values of yrep.\n re_formula Formula containing group-level effects (random effects) to be considered in the\n simulated data. If NULL (default), condition on all random effects. If NA or ~0,\n condition on no random effects. See simulate() in lme4.\n bandwidth A character string indicating the smoothing bandwidth to be used. Unlike stats::density(),\n which used \"nrd0\" as default, the default used here is \"nrd\" (which seems to\n give more plausible results for non-Gaussian models). When problems with\n plotting occur, try to change to a different value.\n type Plot type for the posterior predictive checks plot. Can be \"density\", \"discrete_dots\",\n \"discrete_interval\" or \"discrete_both\" (the discrete_* options are ap-\n propriate for models with discrete - binary, integer or ordinal etc. - outcomes).\n verbose Toggle warnings.\nDetails\n An example how posterior predictive checks can also be used for model comparison is Figure 6\n from Gabry et al. 2019, Figure 6.\n The model shown in the right panel (b) can simulate new data that are more similar to the observed\n outcome than the model in the left panel (a). Thus, model (b) is likely to be preferred over model\n (a).\nValue\n A data frame of simulated responses and the original response vector.\nNote\n Every model object that has a simulate()-method should work with check_predictions(). On\n R 3.6.0 and higher, if bayesplot (or a package that imports bayesplot such as rstanarm or brms)\n is loaded, pp_check() is also available as an alias for check_predictions().\nReferences\n • ., ., ., ., and . (2019). Visualization in\n Bayesian workflow. Journal of the Royal Statistical Society: Series A (Statistics in Society),\n 182(2), 389–402. https://doi.org/10.1111/rssa.12378\n • ., and . (2007). Data analysis using regression and multilevel/hierarchical\n models. Cambridge; New York: Cambridge University Press.\n • ., ., ., ., ., and . (2014).\n Bayesian data analysis. (Third edition). CRC Press.\n • ., ., and . (2020). Regression and Other Stories. Cambridge Uni-\n versity Press.\nSee Also\n Other functions to check model assumptions and and assess model quality: check_autocorrelation(),\n check_collinearity(), check_convergence(), check_heteroscedasticity(), check_homogeneity(),\n check_model(), check_outliers(), check_overdispersion(), check_singularity(), check_zeroinflation()\nExamples\n library(performance)\n # linear model\n if (require(\"see\")) {\n model <- lm(mpg ~ disp, data = mtcars)\n check_predictions(model)\n }\n # discrete/integer outcome\n if (require(\"see\")) {\n set.seed(99)\n d <- iris\n d$skewed <- rpois(150, 1)\n model <- glm(\n skewed ~ Species + Petal.Length + Petal.Width,\n family = poisson(),\n data = d\n )\n check_predictions(model, type = \"discrete_both\")\n }\n check_singularity Check mixed models for boundary fits\nDescription\n Check mixed models for boundary fits.\nUsage\n check_singularity(x, tolerance = 1e-05, ...)\nArguments\n x A mixed model.\n tolerance Indicates up to which value the convergence result is accepted. The larger\n tolerance is, the stricter the test will be.\n ... Currently not used.\nDetails\n If a model is \"singular\", this means that some dimensions of the variance-covariance matrix have\n been estimated as exactly zero. This often occurs for mixed models with complex random effects\n structures.\n \"While singular models are statistically well defined (it is theoretically sensible for the true max-\n imum likelihood estimate to correspond to a singular fit), there are real concerns that (1) singular\n fits correspond to overfitted models that may have poor power; (2) chances of numerical problems\n and mis-convergence are higher for singular models (e.g. it may be computationally difficult to\n compute profile confidence intervals for such models); (3) standard inferential procedures such as\n Wald statistics and likelihood ratio tests may be inappropriate.\" (lme4 Reference Manual)\n There is no gold-standard about how to deal with singularity and which random-effects specification\n to choose. Beside using fully Bayesian methods (with informative priors), proposals in a frequentist\n framework are:\n • avoid fitting overly complex models, such that the variance-covariance matrices can be esti-\n mated precisely enough (Matuschek et al. 2017)\n • use some form of model selection to choose a model that balances predictive accuracy and\n overfitting/type I error (Bates et al. 2015, Matuschek et al. 2017)\n • \"keep it maximal\", i.e. fit the most complex model consistent with the experimental design,\n removing only terms required to allow a non-singular fit (Barr et al. 2013)\n Note the different meaning between singularity and convergence: singularity indicates an issue with\n the \"true\" best estimate, i.e. whether the maximum likelihood estimation for the variance-covariance\n matrix of the random effects is positive definite or only semi-definite. Convergence is a question of\n whether we can assume that the numerical optimization has worked correctly or not.\nValue\n TRUE if the model fit is singular.\nReferences\n • , , , . Parsimonious Mixed Models. arXiv:1506.04967,\n June 2015.\n • , , , . Random effects structure for confirmatory hypothesis\n testing: Keep it maximal. Journal of Memory and Language, 68(3):255-278, April 2013.\n • , , , , . Balancing type I error and power in\n linear mixed models. Journal of Memory and Language, 94:305-315, 2017.\n • lme4 Reference Manual, https://cran.r-project.org/package=lme4\nSee Also\n Other functions to check model assumptions and and assess model quality: check_autocorrelation(),\n check_collinearity(), check_convergence(), check_heteroscedasticity(), check_homogeneity(),\n check_model(), check_outliers(), check_overdispersion(), check_predictions(), check_zeroinflation()\nExamples\n library(lme4)\n data(sleepstudy)\n set.seed(123)\n sleepstudy$mygrp <- sample(1:5, size = 180, replace = TRUE)\n sleepstudy$mysubgrp <- NA\n for (i in 1:5) {\n filter_group <- sleepstudy$mygrp == i\n sleepstudy$mysubgrp[filter_group] <-\n sample(1:30, size = sum(filter_group), replace = TRUE)\n }\n model <- lmer(\n Reaction ~ Days + (1 | mygrp / mysubgrp) + (1 | Subject),\n data = sleepstudy\n )\n check_singularity(model)\n check_sphericity Check model for violation of sphericity\nDescription\n Check model for violation of sphericity. For Bartlett’s Test of Sphericity (used for correlation\n matrices and factor analyses), see check_sphericity_bartlett.\nUsage\n check_sphericity(x, ...)\nArguments\n x A model object.\n ... Arguments passed to car::Anova.\nValue\n Invisibly returns the p-values of the test statistics. A p-value < 0.05 indicates a violation of spheric-\n ity.\nExamples\n if (require(\"car\")) {\n soils.mod <- lm(\n cbind(pH, N, Dens, P, Ca, Mg, K, Na, Conduc) ~ Block + Contour * Depth,\n data = Soils\n )\n check_sphericity(Manova(soils.mod))\n }\n check_symmetry Check distribution symmetry\nDescription\n Uses Hotelling and Solomons test of symmetry by testing if the standardized nonparametric skew\n ( (M ean−M\n SD\n edian)\n ) is different than 0.\n This is an underlying assumption of Wilcoxon signed-rank test.\nUsage\n check_symmetry(x, ...)\nArguments\n x Model or numeric vector\n ... Not used.\nExamples\n V <- wilcox.test(mtcars$mpg)\n check_symmetry(V)\n check_zeroinflation Check for zero-inflation in count models\nDescription\n check_zeroinflation() checks whether count models are over- or underfitting zeros in the out-\n come.\nUsage\n check_zeroinflation(x, tolerance = 0.05)\nArguments\n x Fitted model of class merMod, glmmTMB, glm, or glm.nb (package MASS).\n tolerance The tolerance for the ratio of observed and predicted zeros to considered as over-\n or underfitting zeros. A ratio between 1 +/- tolerance is considered as OK,\n while a ratio beyond or below this threshold would indicate over- or underfitting.\nDetails\n If the amount of observed zeros is larger than the amount of predicted zeros, the model is under-\n fitting zeros, which indicates a zero-inflation in the data. In such cases, it is recommended to use\n negative binomial or zero-inflated models.\nValue\n A list with information about the amount of predicted and observed zeros in the outcome, as well\n as the ratio between these two values.\nSee Also\n Other functions to check model assumptions and and assess model quality: check_autocorrelation(),\n check_collinearity(), check_convergence(), check_heteroscedasticity(), check_homogeneity(),\n check_model(), check_outliers(), check_overdispersion(), check_predictions(), check_singularity()\nExamples\n if (require(\"glmmTMB\")) {\n data(Salamanders)\n m <- glm(count ~ spp + mined, family = poisson, data = Salamanders)\n check_zeroinflation(m)\n }\n classify_distribution Classify the distribution of a model-family using machine learning\nDescription\n Classify the distribution of a model-family using machine learning\nDetails\n The trained model to classify distributions, which is used by the check_distribution() function.\n compare_performance Compare performance of different models\nDescription\n compare_performance() computes indices of model performance for different models at once and\n hence allows comparison of indices across models.\nUsage\n compare_performance(\n ...,\n metrics = \"all\",\n rank = FALSE,\n estimator = \"ML\",\n verbose = TRUE\n )\nArguments\n ... Multiple model objects (also of different classes).\n metrics Can be \"all\", \"common\" or a character vector of metrics to be computed. See\n related documentation() of object’s class for details.\n rank Logical, if TRUE, models are ranked according to ’best’ overall model perfor-\n mance. See ’Details’.\n estimator Only for linear models. Corresponds to the different estimators for the standard\n deviation of the errors. If estimator = \"ML\" (default), the scaling is done by n\n (the biased ML estimator), which is then equivalent to using AIC(logLik()).\n Setting it to \"REML\" will give the same results as AIC(logLik(..., REML =\n TRUE)).\n verbose Toggle warnings.\nDetails\n Model Weights: When information criteria (IC) are requested in metrics (i.e., any of \"all\",\n \"common\", \"AIC\", \"AICc\", \"BIC\", \"WAIC\", or \"LOOIC\"), model weights based on these criteria are\n also computed. For all IC except LOOIC, weights are computed as w = exp(-0.5 * delta_ic)\n / sum(exp(-0.5 * delta_ic)), where delta_ic is the difference between the model’s IC value\n and the smallest IC value in the model set (Burnham and Anderson, 2002). For LOOIC, weights\n are computed as \"stacking weights\" using loo::stacking_weights().\n Ranking Models: When rank = TRUE, a new column Performance_Score is returned. This\n score ranges from 0\\ performance. Note that all score value do not necessarily sum up to 100\\\n Rather, calculation is based on normalizing all indices (i.e. rescaling them to a range from 0 to\n 1), and taking the mean value of all indices for each model. This is a rather quick heuristic, but\n might be helpful as exploratory index.\n In particular when models are of different types (e.g. mixed models, classical linear models,\n logistic regression, ...), not all indices will be computed for each model. In case where an index\n can’t be calculated for a specific model type, this model gets an NA value. All indices that have\n any NAs are excluded from calculating the performance score.\n There is a plot()-method for compare_performance(), which creates a \"spiderweb\" plot, where\n the different indices are normalized and larger values indicate better model performance. Hence,\n points closer to the center indicate worse fit indices (see online-documentation for more details).\n REML versus ML estimator: By default, estimator = \"ML\", which means that values from\n information criteria (AIC, AICc, BIC) for specific model classes (like models from lme4) are\n based on the ML-estimator, while the default behaviour of AIC() for such classes is setting REML\n = TRUE. This default is intentional, because comparing information criteria based on REML fits is\n usually not valid (it might be useful, though, if all models share the same fixed effects - however,\n this is usually not the case for nested models, which is a prerequisite for the LRT). Set estimator\n = \"REML\" explicitly return the same (AIC/...) values as from the defaults in AIC.merMod().\nValue\n A data frame with one row per model and one column per \"index\" (see metrics).\nNote\n There is also a plot()-method implemented in the see-package.\nReferences\n ., and . (2002). Model selection and multimodel inference: A practical\n information-theoretic approach (2nd ed.). Springer-Verlag. doi:10.1007/b97636\nExamples\n data(iris)\n lm1 <- lm(Sepal.Length ~ Species, data = iris)\n lm2 <- lm(Sepal.Length ~ Species + Petal.Length, data = iris)\n lm3 <- lm(Sepal.Length ~ Species * Petal.Length, data = iris)\n compare_performance(lm1, lm2, lm3)\n compare_performance(lm1, lm2, lm3, rank = TRUE)\n if (require(\"lme4\")) {\n m1 <- lm(mpg ~ wt + cyl, data = mtcars)\n m2 <- glm(vs ~ wt + mpg, data = mtcars, family = \"binomial\")\n m3 <- lmer(Petal.Length ~ Sepal.Length + (1 | Species), data = iris)\n compare_performance(m1, m2, m3)\n }\n cronbachs_alpha Cronbach’s Alpha for Items or Scales\nDescription\n Compute various measures of internal consistencies for tests or item-scales of questionnaires.\nUsage\n cronbachs_alpha(x, ...)\nArguments\n x A matrix or a data frame.\n ... Currently not used.\nDetails\n The Cronbach’s Alpha value for x. A value closer to 1 indicates greater internal consistency, where\n usually following rule of thumb is applied to interpret the results: α < 0.5 is unacceptable, 0.5 < α\n < 0.6 is poor, 0.6 < α < 0.7 is questionable, 0.7 < α < 0.8 is acceptable, and everything > 0.8 is good\n or excellent.\nValue\n The Cronbach’s Alpha value for x.\nReferences\n ., and . Statistics notes: Cronbach’s alpha. BMJ 1997;314:572. 10.1136/bmj.314.7080.572\nExamples\n data(mtcars)\n x <- mtcars[, c(\"cyl\", \"gear\", \"carb\", \"hp\")]\n cronbachs_alpha(x)\n display.performance_model\n Print tables in different output formats\nDescription\n Prints tables (i.e. data frame) in different output formats. print_md() is a alias for display(format\n = \"markdown\").\nUsage\n ## S3 method for class 'performance_model'\n display(object, format = \"markdown\", digits = 2, caption = NULL, ...)\n ## S3 method for class 'performance_model'\n print_md(\n x,\n digits = 2,\n caption = \"Indices of model performance\",\n layout = \"horizontal\",\n ...\n )\n ## S3 method for class 'compare_performance'\n print_md(\n x,\n digits = 2,\n caption = \"Comparison of Model Performance Indices\",\n layout = \"horizontal\",\n ...\n )\nArguments\n object, x An object returned by model_performance() or or compare_performance().\n or its summary.\n format String, indicating the output format. Currently, only \"markdown\" is supported.\n digits Number of decimal places.\n caption Table caption as string. If NULL, no table caption is printed.\n ... Currently not used.\n layout Table layout (can be either \"horizontal\" or \"vertical\").\nDetails\n display() is useful when the table-output from functions, which is usually printed as formatted\n text-table to console, should be formatted for pretty table-rendering in markdown documents, or if\n knitted from rmarkdown to PDF or Word files. See vignette for examples.\nValue\n A character vector. If format = \"markdown\", the return value will be a character vector in markdown-\n table format.\nExamples\n model <- lm(mpg ~ wt + cyl, data = mtcars)\n mp <- model_performance(model)\n display(mp)\n icc Intraclass Correlation Coefficient (ICC)\nDescription\n This function calculates the intraclass-correlation coefficient (ICC) - sometimes also called variance\n partition coefficient (VPC) or repeatability - for mixed effects models. The ICC can be calculated\n for all models supported by insight::get_variance(). For models fitted with the brms-package,\n icc() might fail due to the large variety of models and families supported by the brms-package.\n In such cases, an alternative to the ICC is the variance_decomposition(), which is based on the\n posterior predictive distribution (see ’Details’).\nUsage\n icc(\n model,\n by_group = FALSE,\n tolerance = 1e-05,\n ci = NULL,\n iterations = 100,\n ci_method = NULL,\n verbose = TRUE,\n ...\n )\n variance_decomposition(model, re_formula = NULL, robust = TRUE, ci = 0.95, ...)\nArguments\n model A (Bayesian) mixed effects model.\n by_group Logical, if TRUE, icc() returns the variance components for each random-effects\n level (if there are multiple levels). See ’Details’.\n tolerance Tolerance for singularity check of random effects, to decide whether to compute\n random effect variances or not. Indicates up to which value the convergence\n result is accepted. The larger tolerance is, the stricter the test will be. See\n performance::check_singularity().\n ci Confidence resp. credible interval level. For icc() and r2(), confidence in-\n tervals are based on bootstrapped samples from the ICC resp. R2 value. See\n iterations.\n iterations Number of bootstrap-replicates when computing confidence intervals for the\n ICC or R2.\n ci_method Character string, indicating the bootstrap-method. Should be NULL (default),\n in which case lme4::bootMer() is used for bootstrapped confidence intervals.\n However, if bootstrapped intervals cannot be calculated this was, try ci_method\n = \"boot\", which falls back to boot::boot(). This may successfully return\n bootstrapped confidence intervals, but bootstrapped samples may not be ap-\n propriate for the multilevel structure of the model. There is also an option\n ci_method = \"analytical\", which tries to calculate analytical confidence as-\n suming a chi-squared distribution. However, these intervals are rather inaccurate\n and often too narrow. It is recommended to calculate bootstrapped confidence\n intervals for mixed models.\n verbose Toggle warnings and messages.\n ... Arguments passed down to brms::posterior_predict().\n re_formula Formula containing group-level effects to be considered in the prediction. If\n NULL (default), include all group-level effects. Else, for instance for nested mod-\n els, name a specific group-level effect to calculate the variance decomposition\n for this group-level. See ’Details’ and ?brms::posterior_predict.\n robust Logical, if TRUE, the median instead of mean is used to calculate the central\n tendency of the variances.\nDetails\n Interpretation:\n The ICC can be interpreted as \"the proportion of the variance explained by the grouping structure\n in the population\". The grouping structure entails that measurements are organized into groups\n (e.g., test scores in a school can be grouped by classroom if there are multiple classrooms and each\n classroom was administered the same test) and ICC indexes how strongly measurements in the\n same group resemble each other. This index goes from 0, if the grouping conveys no information,\n to 1, if all observations in a group are identical (, 2007, p. 258). In other word,\n the ICC - sometimes conceptualized as the measurement repeatability - \"can also be interpreted\n as the expected correlation between two randomly drawn units that are in the same group\" (Hox\n 2010: 15), although this definition might not apply to mixed models with more complex random\n effects structures. The ICC can help determine whether a mixed model is even necessary: an ICC\n of zero (or very close to zero) means the observations within clusters are no more similar than\n observations from different clusters, and setting it as a random factor might not be necessary.\n Difference with R2:\n The coefficient of determination R2 (that can be computed with r2()) quantifies the proportion\n of variance explained by a statistical model, but its definition in mixed model is complex (hence,\n different methods to compute a proxy exist). ICC is related to R2 because they are both ratios of\n variance components. More precisely, R2 is the proportion of the explained variance (of the full\n model), while the ICC is the proportion of explained variance that can be attributed to the random\n effects. In simple cases, the ICC corresponds to the difference between the conditional R2 and\n the marginal R2 (see r2_nakagawa()).\n Calculation:\n The ICC is calculated by dividing the random effect variance, σi2 , by the total variance, i.e. the\n sum of the random effect variance and the residual variance, σ\u000f2 .\n Adjusted and unadjusted ICC:\n icc() calculates an adjusted and an unadjusted ICC, which both take all sources of uncertainty\n (i.e. of all random effects) into account. While the adjusted ICC only relates to the random effects,\n the unadjusted ICC also takes the fixed effects variances into account, more precisely, the fixed\n effects variance is added to the denominator of the formula to calculate the ICC (see Nakagawa\n et al. 2017). Typically, the adjusted ICC is of interest when the analysis of random effects is of\n interest. icc() returns a meaningful ICC also for more complex random effects structures, like\n models with random slopes or nested design (more than two levels) and is applicable for models\n with other distributions than Gaussian. For more details on the computation of the variances, see\n ?insight::get_variance.\n ICC for unconditional and conditional models:\n Usually, the ICC is calculated for the null model (\"unconditional model\"). However, according to\n Raudenbush and Bryk (2002) or Rabe-Hesketh and Skrondal (2012) it is also feasible to compute\n the ICC for full models with covariates (\"conditional models\") and compare how much, e.g., a\n level-2 variable explains the portion of variation in the grouping structure (random intercept).\n ICC for specific group-levels:\n The proportion of variance for specific levels related to the overall model can be computed by\n setting by_group = TRUE. The reported ICC is the variance for each (random effect) group com-\n pared to the total variance of the model. For mixed models with a simple random intercept, this is\n identical to the classical (adjusted) ICC.\n Variance decomposition for brms-models:\n If model is of class brmsfit, icc() might fail due to the large variety of models and families\n supported by the brms package. In such cases, variance_decomposition() is an alternative\n ICC measure. The function calculates a variance decomposition based on the posterior predictive\n distribution. In this case, first, the draws from the posterior predictive distribution not conditioned\n on group-level terms (posterior_predict(..., re_formula = NA)) are calculated as well as\n draws from this distribution conditioned on all random effects (by default, unless specified else in\n re_formula) are taken. Then, second, the variances for each of these draws are calculated. The\n \"ICC\" is then the ratio between these two variances. This is the recommended way to analyse\n random-effect-variances for non-Gaussian models. It is then possible to compare variances across\n models, also by specifying different group-level terms via the re_formula-argument.\n Sometimes, when the variance of the posterior predictive distribution is very large, the variance\n ratio in the output makes no sense, e.g. because it is negative. In such cases, it might help to use\n robust = TRUE.\nValue\n A list with two values, the adjusted ICC and the unadjusted ICC. For variance_decomposition(),\n a list with two values, the decomposed ICC as well as the credible intervals for this ICC.\nReferences\n • . (2010). Multilevel analysis: techniques and applications (2nd ed). New York:\n Routledge.\n • ., ., and . (2017). The coefficient of determina-\n tion R2 and intra-class correlation coefficient from generalized linear mixed-effects models\n revisited and expanded. Journal of The Royal Society Interface, 14(134), 20170213.\n • ., and . (2012). Multilevel and longitudinal modeling using Stata\n (3rd ed). College Station, Tex: Stata Press Publication.\n • ., and . (2002). Hierarchical linear models: applications and data\n analysis methods (2nd ed). Thousand Oaks: Sage Publications.\nExamples\n if (require(\"lme4\")) {\n model <- lmer(Sepal.Length ~ Petal.Length + (1 | Species), data = iris)\n icc(model)\n }\n # ICC for specific group-levels\n if (require(\"lme4\")) {\n data(sleepstudy)\n set.seed(12345)\n sleepstudy$grp <- sample(1:5, size = 180, replace = TRUE)\n sleepstudy$subgrp <- NA\n for (i in 1:5) {\n filter_group <- sleepstudy$grp == i\n sleepstudy$subgrp[filter_group] <-\n sample(1:30, size = sum(filter_group), replace = TRUE)\n }\n model <- lmer(\n Reaction ~ Days + (1 | grp / subgrp) + (1 | Subject),\n data = sleepstudy\n )\n icc(model, by_group = TRUE)\n }\n item_difficulty Difficulty of Questionnaire Items\nDescription\n Compute various measures of internal consistencies for tests or item-scales of questionnaires.\nUsage\n item_difficulty(x, maximum_value = NULL)\nArguments\n x Depending on the function, x may be a matrix as returned by the cor()-function,\n or a data frame with items (e.g. from a test or questionnaire).\n maximum_value Numeric value, indicating the maximum value of an item. If NULL (default),\n the maximum is taken from the maximum value of all columns in x (assuming\n that the maximum value at least appears once in the data). If NA, each item’s\n maximum value is taken as maximum. If the required maximum value is not\n present in the data, specify the theoreritcal maximum using maximum_value.\nDetails\n Item difficutly of an item is defined as the quotient of the sum actually achieved for this item of all\n and the maximum achievable score. This function calculates the item difficulty, which should range\n between 0.2 and 0.8. Lower values are a signal for more difficult items, while higher values close\n to one are a sign for easier items. The ideal value for item difficulty is p + (1 - p) / 2, where p = 1\n / max(x). In most cases, the ideal item difficulty lies between 0.5 and 0.8.\nValue\n A data frame with three columns: The name(s) of the item(s), the item difficulties for each item,\n and the ideal item difficulty.\nReferences\n • ., and . (2006). Quantitative Methoden der Datenerhebung. In and\n N. Döring, Forschungsmethoden und Evaluation. Springer: Berlin, Heidelberg: 137–293\n • , (2020). Deskriptivstatistische Itemanalyse und Testwertbestim-\n mung. In: , , editors. Testtheorie und Fragebogenkonstruktion.\n Berlin, Heidelberg: Springer, 143–158\nExamples\n data(mtcars)\n x <- mtcars[, c(\"cyl\", \"gear\", \"carb\", \"hp\")]\n item_difficulty(x)\n item_discrimination Discrimination of Questionnaire Items\nDescription\n Compute various measures of internal consistencies for tests or item-scales of questionnaires.\nUsage\n item_discrimination(x, standardize = FALSE)\nArguments\n x A matrix or a data frame.\n standardize Logical, if TRUE, the data frame’s vectors will be standardized. Recommended\n when the variables have different measures / scales.\nDetails\n This function calculates the item discriminations (corrected item-total correlations for each item of\n x with the remaining items) for each item of a scale. The absolute value of the item discrimination\n indices should be above 0.2. An index between 0.2 and 0.4 is considered as \"fair\", while a satis-\n factory index ranges from 0.4 to 0.7. Items with low discrimination indices are often ambiguously\n worded and should be examined. Items with negative indices should be examined to determine\n why a negative value was obtained (e.g. reversed answer categories regarding positive and negative\n poles).\nValue\n A data frame with the item discrimination (corrected item-total correlations) for each item of the\n scale.\nReferences\n • , (2020). Deskriptivstatistische Itemanalyse und Testwertbestim-\n mung. In: , , editors. Testtheorie und Fragebogenkonstruktion.\n Berlin, Heidelberg: Springer, 143–158\nExamples\n data(mtcars)\n x <- mtcars[, c(\"cyl\", \"gear\", \"carb\", \"hp\")]\n item_discrimination(x)\n item_intercor Mean Inter-Item-Correlation\nDescription\n Compute various measures of internal consistencies for tests or item-scales of questionnaires.\nUsage\n item_intercor(x, method = c(\"pearson\", \"spearman\", \"kendall\"))\nArguments\n x A matrix as returned by the cor()-function, or a data frame with items (e.g.\n from a test or questionnaire).\n method Correlation computation method. May be one of \"pearson\" (default), \"spearman\"\n or \"kendall\". You may use initial letter only.\nDetails\n This function calculates a mean inter-item-correlation, i.e. a correlation matrix of x will be com-\n puted (unless x is already a matrix as returned by the cor() function) and the mean of the sum of\n all items’ correlation values is returned. Requires either a data frame or a computed cor() object.\n \"Ideally, the average inter-item correlation for a set of items should be between 0.20 and 0.40,\n suggesting that while the items are reasonably homogeneous, they do contain sufficiently unique\n variance so as to not be isomorphic with each other. When values are lower than 0.20, then the\n items may not be representative of the same content domain. If values are higher than 0.40, the\n items may be only capturing a small bandwidth of the construct.\" (Piedmont 2014)\nValue\n The mean inter-item-correlation value for x.\nReferences\n Piedmont RL. 2014. Inter-item Correlations. In: Michalos AC (eds) Encyclopedia of Quality of Life\n and Well-Being Research. Dordrecht: Springer, 3303-3304. doi:10.1007/9789400707535_1493\nExamples\n data(mtcars)\n x <- mtcars[, c(\"cyl\", \"gear\", \"carb\", \"hp\")]\n item_intercor(x)\n item_reliability Reliability Test for Items or Scales\nDescription\n Compute various measures of internal consistencies for tests or item-scales of questionnaires.\nUsage\n item_reliability(x, standardize = FALSE, digits = 3)\nArguments\n x A matrix or a data frame.\n standardize Logical, if TRUE, the data frame’s vectors will be standardized. Recommended\n when the variables have different measures / scales.\n digits Amount of digits for returned values.\nDetails\n This function calculates the item discriminations (corrected item-total correlations for each item of\n x with the remaining items) and the Cronbach’s alpha for each item, if it was deleted from the scale.\n The absolute value of the item discrimination indices should be above 0.2. An index between 0.2\n and 0.4 is considered as \"fair\", while an index above 0.4 (or below -0.4) is \"good\". The range of\n satisfactory values is from 0.4 to 0.7. Items with low discrimination indices are often ambiguously\n worded and should be examined. Items with negative indices should be examined to determine\n why a negative value was obtained (e.g. reversed answer categories regarding positive and negative\n poles).\nValue\n A data frame with the corrected item-total correlations (item discrimination, column item_discrimination)\n and Cronbach’s Alpha (if item deleted, column alpha_if_deleted) for each item of the scale, or\n NULL if data frame had too less columns.\nExamples\n data(mtcars)\n x <- mtcars[, c(\"cyl\", \"gear\", \"carb\", \"hp\")]\n item_reliability(x)\n item_split_half Split-Half Reliability\nDescription\n Compute various measures of internal consistencies for tests or item-scales of questionnaires.\nUsage\n item_split_half(x, digits = 3)\nArguments\n x A matrix or a data frame.\n digits Amount of digits for returned values.\nDetails\n This function calculates the split-half reliability for items in x, including the Spearman-Brown ad-\n justment. Splitting is done by selecting odd versus even columns in x. A value closer to 1 indicates\n greater internal consistency.\nValue\n A list with two elements: the split-half reliability splithalf and the Spearman-Brown corrected\n split-half reliability spearmanbrown.\nReferences\n • . 1910. Correlation calculated from faulty data. British Journal of Psychology (3):\n 271-295. doi:10.1111/j.20448295.1910.tb00206.x\n • . 1910. Some experimental results in the correlation of mental abilities. British\n Journal of Psychology (3): 296-322. doi:10.1111/j.20448295.1910.tb00207.x\nExamples\n data(mtcars)\n x <- mtcars[, c(\"cyl\", \"gear\", \"carb\", \"hp\")]\n item_split_half(x)\n looic LOO-related Indices for Bayesian regressions.\nDescription\n Compute LOOIC (leave-one-out cross-validation (LOO) information criterion) and ELPD (ex-\n pected log predictive density) for Bayesian regressions. For LOOIC and ELPD, smaller and larger\n values are respectively indicative of a better fit.\nUsage\n looic(model, verbose = TRUE)\nArguments\n model A Bayesian regression model.\n verbose Toggle off warnings.\nValue\n A list with four elements, the ELPD, LOOIC and their standard errors.\nExamples\n if (require(\"rstanarm\")) {\n model <- stan_glm(mpg ~ wt + cyl, data = mtcars, chains = 1, iter = 500, refresh = 0)\n looic(model)\n }\n model_performance Model Performance\nDescription\n See the documentation for your object’s class:\n • Frequentist Regressions\n • Instrumental Variables Regressions\n • Mixed models\n • Bayesian models\n • CFA / SEM lavaan models\n • Meta-analysis models\nUsage\n model_performance(model, ...)\n performance(model, ...)\nArguments\n model Statistical model.\n ... Arguments passed to or from other methods, resp. for compare_performance(),\n one or multiple model objects (also of different classes).\nDetails\n model_performance() correctly detects transformed response and returns the \"corrected\" AIC and\n BIC value on the original scale. To get back to the original scale, the likelihood of the model is\n multiplied by the Jacobian/derivative of the transformation.\nValue\n A data frame (with one row) and one column per \"index\" (see metrics).\nSee Also\n compare_performance() to compare performance of many different models.\nExamples\n model <- lm(mpg ~ wt + cyl, data = mtcars)\n model_performance(model)\n model <- glm(vs ~ wt + mpg, data = mtcars, family = \"binomial\")\n model_performance(model)\n model_performance.ivreg\n Performance of instrumental variable regression models\nDescription\n Performance of instrumental variable regression models\nUsage\n ## S3 method for class 'ivreg'\n model_performance(model, metrics = \"all\", verbose = TRUE, ...)\nArguments\n model A model.\n metrics Can be \"all\", \"common\" or a character vector of metrics to be computed (some\n of c(\"AIC\", \"AICc\", \"BIC\", \"R2\", \"RMSE\", \"SIGMA\", \"Sargan\", \"Wu_Hausman\",\n \"weak_instruments\")). \"common\" will compute AIC, BIC, R2 and RMSE.\n verbose Toggle off warnings.\n ... Arguments passed to or from other methods.\nDetails\n model_performance() correctly detects transformed response and returns the \"corrected\" AIC and\n BIC value on the original scale. To get back to the original scale, the likelihood of the model is\n multiplied by the Jacobian/derivative of the transformation.\n model_performance.kmeans\n Model summary for k-means clustering\nDescription\n Model summary for k-means clustering\nUsage\n ## S3 method for class 'kmeans'\n model_performance(model, verbose = TRUE, ...)\nArguments\n model Object of type kmeans.\n verbose Toggle off warnings.\n ... Arguments passed to or from other methods.\nExamples\n # a 2-dimensional example\n x <- rbind(\n matrix(rnorm(100, sd = 0.3), ncol = 2),\n matrix(rnorm(100, mean = 1, sd = 0.3), ncol = 2)\n )\n colnames(x) <- c(\"x\", \"y\")\n model <- kmeans(x, 2)\n model_performance(model)\n model_performance.lavaan\n Performance of lavaan SEM / CFA Models\nDescription\n Compute indices of model performance for SEM or CFA models from the lavaan package.\nUsage\n ## S3 method for class 'lavaan'\n model_performance(model, metrics = \"all\", verbose = TRUE, ...)\nArguments\n model A lavaan model.\n metrics Can be \"all\" or a character vector of metrics to be computed (some of c(\"Chi2\",\n \"Chi2_df\", \"p_Chi2\", \"Baseline\", \"Baseline_df\", \"p_Baseline\", \"GFI\",\n \"AGFI\", \"NFI\", \"NNFI\", \"CFI\", \"RMSEA\", \"RMSEA_CI_low\", \"RMSEA_CI_high\",\n \"p_RMSEA\", \"RMR\", \"SRMR\", \"RFI\", \"PNFI\", \"IFI\", \"RNI\", \"Loglikelihood\",\n \"AIC\", \"BIC\", \"BIC_adjusted\")).\n verbose Toggle off warnings.\n ... Arguments passed to or from other methods.\nDetails\n Indices of fit:\n • Chisq: The model Chi-squared assesses overall fit and the discrepancy between the sample\n and fitted covariance matrices. Its p-value should be > .05 (i.e., the hypothesis of a perfect fit\n cannot be rejected). However, it is quite sensitive to sample size.\n • GFI/AGFI: The (Adjusted) Goodness of Fit is the proportion of variance accounted for by\n the estimated population covariance. Analogous to R2. The GFI and the AGFI should be >\n .95 and > .90, respectively.\n • NFI/NNFI/TLI: The (Non) Normed Fit Index. An NFI of 0.95, indicates the model of inter-\n est improves the fit by 95\\ null model. The NNFI (also called the Tucker Lewis index; TLI)\n is preferable for smaller samples. They should be > .90 (Byrne, 1994) or > .95 (Schumacker\n and Lomax, 2004).\n • CFI: The Comparative Fit Index is a revised form of NFI. Not very sensitive to sample\n size (Fan, Thompson, and Wang, 1999). Compares the fit of a target model to the fit of an\n independent, or null, model. It should be > .90.\n • RMSEA: The Root Mean Square Error of Approximation is a parsimony-adjusted index.\n Values closer to 0 represent a good fit. It should be < .08 or < .05. The p-value printed with\n it tests the hypothesis that RMSEA is less than or equal to .05 (a cutoff sometimes used for\n good fit), and thus should be not significant.\n • RMR/SRMR: the (Standardized) Root Mean Square Residual represents the square-root of\n the difference between the residuals of the sample covariance matrix and the hypothesized\n model. As the RMR can be sometimes hard to interpret, better to use SRMR. Should be <\n .08.\n • RFI: the Relative Fit Index, also known as RHO1, is not guaranteed to vary from 0 to 1.\n However, RFI close to 1 indicates a good fit.\n • IFI: the Incremental Fit Index (IFI) adjusts the Normed Fit Index (NFI) for sample size and\n degrees of freedom (Bollen’s, 1989). Over 0.90 is a good fit, but the index can exceed 1.\n • PNFI: the Parsimony-Adjusted Measures Index. There is no commonly agreed-upon cutoff\n value for an acceptable model for this index. Should be > 0.50.\n See the documentation for ?lavaan::fitmeasures.\n What to report: Kline (2015) suggests that at a minimum the following indices should be\n reported: The model chi-square, the RMSEA, the CFI and the SRMR.\nValue\n A data frame (with one row) and one column per \"index\" (see metrics).\nReferences\n • . (1994). Structural equation modeling with EQS and EQS/Windows. Thousand\n Oaks, CA: Sage Publications.\n • ., and . (1973). The reliability coefficient for maximum likelihood factor\n analysis. Psychometrika, 38, 1-10.\n • ., and . (2004). A beginner’s guide to structural equation mod-\n eling, Second edition. Mahwah, NJ: Lawrence Erlbaum Associates.\n • ., , and (1999). Effects of sample size, estimation method, and\n model specification on structural equation modeling fit indexes. Structural Equation Model-\n ing, 6, 56-83.\n • . (2015). Principles and practice of structural equation modeling. Guilford publi-\n cations.\nExamples\n # Confirmatory Factor Analysis (CFA) ---------\n if (require(\"lavaan\")) {\n structure <- \" visual =~ x1 + x2 + x3\n textual =~ x4 + x5 + x6\n speed =~ x7 + x8 + x9 \"\n model <- lavaan::cfa(structure, data = HolzingerSwineford1939)\n model_performance(model)\n }\n model_performance.lm Performance of Regression Models\nDescription\n Compute indices of model performance for regression models.\nUsage\n ## S3 method for class 'lm'\n model_performance(model, metrics = \"all\", verbose = TRUE, ...)\nArguments\n model A model.\n metrics Can be \"all\", \"common\" or a character vector of metrics to be computed (one or\n more of \"AIC\", \"AICc\", \"BIC\", \"R2\", \"R2_adj\", \"RMSE\", \"SIGMA\", \"LOGLOSS\",\n \"PCP\", \"SCORE\"). \"common\" will compute AIC, BIC, R2 and RMSE.\n verbose Toggle off warnings.\n ... Arguments passed to or from other methods.\nDetails\n Depending on model, following indices are computed:\n • AIC: Akaike’s Information Criterion, see ?stats::AIC\n • AICc: Second-order (or small sample) AIC with a correction for small sample sizes\n • BIC: Bayesian Information Criterion, see ?stats::BIC\n • R2: r-squared value, see r2()\n • R2_adj: adjusted r-squared, see r2()\n • RMSE: root mean squared error, see performance_rmse()\n • SIGMA: residual standard deviation, see insight::get_sigma()\n • LOGLOSS: Log-loss, see performance_logloss()\n • SCORE_LOG: score of logarithmic proper scoring rule, see performance_score()\n • SCORE_SPHERICAL: score of spherical proper scoring rule, see performance_score()\n • PCP: percentage of correct predictions, see performance_pcp()\n model_performance() correctly detects transformed response and returns the \"corrected\" AIC and\n BIC value on the original scale. To get back to the original scale, the likelihood of the model is\n multiplied by the Jacobian/derivative of the transformation.\nValue\n A data frame (with one row) and one column per \"index\" (see metrics).\nExamples\n model <- lm(mpg ~ wt + cyl, data = mtcars)\n model_performance(model)\n model <- glm(vs ~ wt + mpg, data = mtcars, family = \"binomial\")\n model_performance(model)\n model_performance.merMod\n Performance of Mixed Models\nDescription\n Compute indices of model performance for mixed models.\nUsage\n ## S3 method for class 'merMod'\n model_performance(\n model,\n metrics = \"all\",\n estimator = \"REML\",\n verbose = TRUE,\n ...\n )\nArguments\n model A mixed effects model.\n metrics Can be \"all\", \"common\" or a character vector of metrics to be computed (some\n of c(\"AIC\", \"AICc\", \"BIC\", \"R2\", \"ICC\", \"RMSE\", \"SIGMA\", \"LOGLOSS\", \"SCORE\")).\n \"common\" will compute AIC, BIC, R2, ICC and RMSE.\n estimator Only for linear models. Corresponds to the different estimators for the standard\n deviation of the errors. If estimator = \"ML\" (default), the scaling is done by n\n (the biased ML estimator), which is then equivalent to using AIC(logLik()).\n Setting it to \"REML\" will give the same results as AIC(logLik(..., REML =\n TRUE)).\n verbose Toggle warnings and messages.\n ... Arguments passed to or from other methods.\nDetails\n Intraclass Correlation Coefficient (ICC): This method returns the adjusted ICC only, as this is\n typically of interest when judging the variance attributed to the random effects part of the model\n (see also icc()).\n REML versus ML estimator: The default behaviour of model_performance() when com-\n puting AIC or BIC of linear mixed model from package lme4 is the same as for AIC() or BIC()\n (i.e. estimator = \"REML\"). However, for model comparison using compare_performance() sets\n estimator = \"ML\" by default, because comparing information criteria based on REML fits is usu-\n ally not valid (unless all models have the same fixed effects). Thus, make sure to set the correct\n estimator-value when looking at fit-indices or comparing model fits.\n Other performance indices: Furthermore, see ’Details’ in model_performance.lm() for more\n details on returned indices.\nValue\n A data frame (with one row) and one column per \"index\" (see metrics).\nExamples\n if (require(\"lme4\")) {\n model <- lmer(Petal.Length ~ Sepal.Length + (1 | Species), data = iris)\n model_performance(model)\n }\n model_performance.rma Performance of Meta-Analysis Models\nDescription\n Compute indices of model performance for meta-analysis model from the metafor package.\nUsage\n ## S3 method for class 'rma'\n model_performance(\n model,\n metrics = \"all\",\n estimator = \"ML\",\n verbose = TRUE,\n ...\n )\nArguments\n model A rma object as returned by metafor::rma().\n metrics Can be \"all\" or a character vector of metrics to be computed (some of c(\"AIC\",\n \"BIC\", \"I2\", \"H2\", \"TAU2\", \"R2\", \"CochransQ\", \"QE\", \"Omnibus\", \"QM\")).\n estimator Only for linear models. Corresponds to the different estimators for the standard\n deviation of the errors. If estimator = \"ML\" (default), the scaling is done by n\n (the biased ML estimator), which is then equivalent to using AIC(logLik()).\n Setting it to \"REML\" will give the same results as AIC(logLik(..., REML =\n TRUE)).\n verbose Toggle off warnings.\n ... Arguments passed to or from other methods.\nDetails\n Indices of fit:\n • AIC Akaike’s Information Criterion, see ?stats::AIC\n • BIC Bayesian Information Criterion, see ?stats::BIC\n • I2: For a random effects model, I2 estimates (in percent) how much of the total variability\n in the effect size estimates can be attributed to heterogeneity among the true effects. For a\n mixed-effects model, I2 estimates how much of the unaccounted variability can be attributed\n to residual heterogeneity.\n • H2: For a random-effects model, H2 estimates the ratio of the total amount of variability in\n the effect size estimates to the amount of sampling variability. For a mixed-effects model, H2\n estimates the ratio of the unaccounted variability in the effect size estimates to the amount of\n sampling variability.\n • TAU2: The amount of (residual) heterogeneity in the random or mixed effects model.\n • CochransQ (QE): Test for (residual) Heterogeneity. Without moderators in the model, this\n is simply Cochran’s Q-test.\n • Omnibus (QM): Omnibus test of parameters.\n • R2: Pseudo-R2-statistic, which indicates the amount of heterogeneity accounted for by the\n moderators included in a fixed-effects model.\n See the documentation for ?metafor::fitstats.\nValue\n A data frame (with one row) and one column per \"index\" (see metrics).\nExamples\n if (require(\"metafor\")) {\n data(dat.bcg)\n dat <- escalc(measure = \"RR\", ai = tpos, bi = tneg, ci = cpos, di = cneg, data = dat.bcg)\n model <- rma(yi, vi, data = dat, method = \"REML\")\n model_performance(model)\n }\n model_performance.stanreg\n Performance of Bayesian Models\nDescription\n Compute indices of model performance for (general) linear models.\nUsage\n ## S3 method for class 'stanreg'\n model_performance(model, metrics = \"all\", verbose = TRUE, ...)\n ## S3 method for class 'BFBayesFactor'\n model_performance(\n model,\n metrics = \"all\",\n verbose = TRUE,\n average = FALSE,\n prior_odds = NULL,\n ...\n )\nArguments\n model Object of class stanreg or brmsfit.\n metrics Can be \"all\", \"common\" or a character vector of metrics to be computed (some\n of c(\"LOOIC\", \"WAIC\", \"R2\", \"R2_adj\", \"RMSE\", \"SIGMA\", \"LOGLOSS\", \"SCORE\")).\n \"common\" will compute LOOIC, WAIC, R2 and RMSE.\n verbose Toggle off warnings.\n ... Arguments passed to or from other methods.\n average Compute model-averaged index? See bayestestR::weighted_posteriors().\n prior_odds Optional vector of prior odds for the models compared to the first model (or the\n denominator, for BFBayesFactor objects). For data.frames, this will be used\n as the basis of weighting.\nDetails\n Depending on model, the following indices are computed:\n • ELPD: expected log predictive density. Larger ELPD values mean better fit. See looic().\n • LOOIC: leave-one-out cross-validation (LOO) information criterion. Lower LOOIC values\n mean better fit. See looic().\n • WAIC: widely applicable information criterion. Lower WAIC values mean better fit. See\n ?loo::waic.\n • R2: r-squared value, see r2_bayes().\n • R2_adjusted: LOO-adjusted r-squared, see r2_loo().\n • RMSE: root mean squared error, see performance_rmse().\n • SIGMA: residual standard deviation, see insight::get_sigma().\n • LOGLOSS: Log-loss, see performance_logloss().\n • SCORE_LOG: score of logarithmic proper scoring rule, see performance_score().\n • SCORE_SPHERICAL: score of spherical proper scoring rule, see performance_score().\n • PCP: percentage of correct predictions, see performance_pcp().\nValue\n A data frame (with one row) and one column per \"index\" (see metrics).\nReferences\n ., ., ., and . (2018). R-squared for Bayesian regression\n models. The American Statistician, The American Statistician, 1-6.\nSee Also\n r2_bayes\nExamples\n ## Not run:\n if (require(\"rstanarm\") && require(\"rstantools\")) {\n model <- stan_glm(mpg ~ wt + cyl, data = mtcars, chains = 1, iter = 500, refresh = 0)\n model_performance(model)\n model <- stan_glmer(\n mpg ~ wt + cyl + (1 | gear),\n data = mtcars,\n chains = 1,\n iter = 500,\n refresh = 0\n )\n model_performance(model)\n }\n if (require(\"BayesFactor\") && require(\"rstantools\")) {\n model <- generalTestBF(carb ~ am + mpg, mtcars)\n model_performance(model)\n model_performance(model[3])\n model_performance(model, average = TRUE)\n }\n ## End(Not run)\n performance_accuracy Accuracy of predictions from model fit\nDescription\n This function calculates the predictive accuracy of linear or logistic regression models.\nUsage\n performance_accuracy(\n model,\n method = c(\"cv\", \"boot\"),\n k = 5,\n n = 1000,\n ci = 0.95,\n verbose = TRUE\n )\nArguments\n model A linear or logistic regression model. A mixed-effects model is also accepted.\n method Character string, indicating whether cross-validation (method = \"cv\") or boot-\n strapping (method = \"boot\") is used to compute the accuracy values.\n k The number of folds for the k-fold cross-validation.\n n Number of bootstrap-samples.\n ci The level of the confidence interval.\n verbose Toggle warnings.\nDetails\n For linear models, the accuracy is the correlation coefficient between the actual and the predicted\n value of the outcome. For logistic regression models, the accuracy corresponds to the AUC-value,\n calculated with the bayestestR::auc()-function.\n The accuracy is the mean value of multiple correlation resp. AUC-values, which are either com-\n puted with cross-validation or non-parametric bootstrapping (see argument method). The standard\n error is the standard deviation of the computed correlation resp. AUC-values.\nValue\n A list with three values: The Accuracy of the model predictions, i.e. the proportion of accurately\n predicted values from the model, its standard error, SE, and the Method used to compute the accu-\n racy.\nExamples\n model <- lm(mpg ~ wt + cyl, data = mtcars)\n performance_accuracy(model)\n model <- glm(vs ~ wt + mpg, data = mtcars, family = \"binomial\")\n performance_accuracy(model)\n performance_aicc Compute the AIC or second-order AIC\nDescription\n Compute the AIC or the second-order Akaike’s information criterion (AICc). performance_aic()\n is a small wrapper that returns the AIC, however, for models with a transformed response variable,\n performance_aic() returns the corrected AIC value (see ’Examples’). It is a generic function that\n also works for some models that don’t have a AIC method (like Tweedie models). performance_aicc()\n returns the second-order (or \"small sample\") AIC that incorporates a correction for small sample\n sizes.\nUsage\n performance_aicc(x, ...)\n performance_aic(x, ...)\n ## Default S3 method:\n performance_aic(x, estimator = \"ML\", verbose = TRUE, ...)\nArguments\n x A model object.\n ... Currently not used.\n estimator Only for linear models. Corresponds to the different estimators for the standard\n deviation of the errors. If estimator = \"ML\" (default), the scaling is done by n\n (the biased ML estimator), which is then equivalent to using AIC(logLik()).\n Setting it to \"REML\" will give the same results as AIC(logLik(..., REML =\n TRUE)).\n verbose Toggle warnings.\nDetails\n performance_aic() correctly detects transformed response and, unlike stats::AIC(), returns the\n \"corrected\" AIC value on the original scale. To get back to the original scale, the likelihood of the\n model is multiplied by the Jacobian/derivative of the transformation.\nValue\n Numeric, the AIC or AICc value.\nReferences\n • . (1973) Information theory as an extension of the maximum likelihood principle.\n In: Second International Symposium on Information Theory, pp. 267-281. .,\n ., .\n • ., . (1991) Bias of the corrected AIC criterion for underfitted regres-\n sion and time series models. Biometrika 78, 499–509.\nExamples\n m <- lm(mpg ~ wt + cyl + gear + disp, data = mtcars)\n AIC(m)\n performance_aicc(m)\n # correct AIC for models with transformed response variable\n data(\"mtcars\")\n mtcars$mpg <- floor(mtcars$mpg)\n model <- lm(log(mpg) ~ factor(cyl), mtcars)\n # wrong AIC, not corrected for log-transformation\n AIC(model)\n # performance_aic() correctly detects transformed response and\n # returns corrected AIC\n performance_aic(model)\n performance_cv Cross-validated model performance\nDescription\n This function cross-validates regression models in a user-supplied new sample or by using holdout\n (train-test), k-fold, or leave-one-out cross-validation.\nUsage\n performance_cv(\n model,\n data = NULL,\n method = c(\"holdout\", \"k_fold\", \"loo\"),\n metrics = \"all\",\n prop = 0.3,\n k = 5,\n stack = TRUE,\n verbose = TRUE,\n ...\n )\nArguments\n model A regression model.\n data Optional. A data frame containing the same variables as model that will be used\n as the cross-validation sample.\n method Character string, indicating the cross-validation method to use: whether holdout\n (\"holdout\", aka train-test), k-fold (\"k_fold\"), or leave-one-out (\"loo\"). If\n data is supplied, this argument is ignored.\n metrics Can be \"all\", \"common\" or a character vector of metrics to be computed (some\n of c(\"ELPD\", \"Deviance\", \"MSE\", \"RMSE\", \"R2\")). \"common\" will compute\n R2 and RMSE.\n prop If method = \"holdout\", what proportion of the sample to hold out as the test\n sample?\n k If method = \"k_fold\", the number of folds to use.\n stack Logical. If method = \"k_fold\", should performance be computed by stacking\n residuals from each holdout fold and calculating each metric on the stacked\n data (TRUE, default) or should performance be computed by calculating metrics\n within each holdout fold and averaging performance across each fold (FALSE)?\n verbose Toggle warnings.\n ... Not used.\nValue\n A data frame with columns for each metric requested, as well as k if method = \"holdout\" and\n the Method used for cross-validation. If method = \"holdout\" and stack = TRUE, the standard error\n (standard deviation across holdout folds) for each metric is also included.\nExamples\n model <- lm(mpg ~ wt + cyl, data = mtcars)\n performance_cv(model)\n performance_hosmer Hosmer-Lemeshow goodness-of-fit test\nDescription\n Check model quality of logistic regression models.\nUsage\n performance_hosmer(model, n_bins = 10)\nArguments\n model A glm-object with binomial-family.\n n_bins Numeric, the number of bins to divide the data.\nDetails\n A well-fitting model shows no significant difference between the model and the observed data, i.e.\n the reported p-value should be greater than 0.05.\nValue\n An object of class hoslem_test with following values: chisq, the Hosmer-Lemeshow chi-squared\n statistic; df, degrees of freedom and p.value the p-value for the goodness-of-fit test.\nReferences\n ., and . (2000). Applied Logistic Regression. Hoboken, NJ, USA: John\n Wiley and Sons, Inc. doi:10.1002/0471722146\nExamples\n model <- glm(vs ~ wt + mpg, data = mtcars, family = \"binomial\")\n performance_hosmer(model)\n performance_logloss Log Loss\nDescription\n Compute the log loss for models with binary outcome.\nUsage\n performance_logloss(model, verbose = TRUE, ...)\nArguments\n model Model with binary outcome.\n verbose Toggle off warnings.\n ... Currently not used.\nDetails\n Logistic regression models predict the probability of an outcome of being a \"success\" or \"failure\"\n (or 1 and 0 etc.). performance_logloss() evaluates how good or bad the predicted probabilities\n are. High values indicate bad predictions, while low values indicate good predictions. The lower\n the log-loss, the better the model predicts the outcome.\nValue\n Numeric, the log loss of model.\nSee Also\n performance_score()\nExamples\n data(mtcars)\n m <- glm(formula = vs ~ hp + wt, family = binomial, data = mtcars)\n performance_logloss(m)\n performance_mae Mean Absolute Error of Models\nDescription\n Compute mean absolute error of models.\nUsage\n performance_mae(model, ...)\n mae(model, ...)\nArguments\n model A model.\n ... Arguments passed to or from other methods.\nValue\n Numeric, the mean absolute error of model.\nExamples\n data(mtcars)\n m <- lm(mpg ~ hp + gear, data = mtcars)\n performance_mae(m)\n performance_mse Mean Square Error of Linear Models\nDescription\n Compute mean square error of linear models.\nUsage\n performance_mse(model, ...)\n mse(model, ...)\nArguments\n model A model.\n ... Arguments passed to or from other methods.\nDetails\n The mean square error is the mean of the sum of squared residuals, i.e. it measures the average of\n the squares of the errors. Less technically speaking, the mean square error can be considered as the\n variance of the residuals, i.e. the variation in the outcome the model doesn’t explain. Lower values\n (closer to zero) indicate better fit.\nValue\n Numeric, the mean square error of model.\nExamples\n data(mtcars)\n m <- lm(mpg ~ hp + gear, data = mtcars)\n performance_mse(m)\n performance_pcp Percentage of Correct Predictions\nDescription\n Percentage of correct predictions (PCP) for models with binary outcome.\nUsage\n performance_pcp(model, ci = 0.95, method = \"Herron\", verbose = TRUE)\nArguments\n model Model with binary outcome.\n ci The level of the confidence interval.\n method Name of the method to calculate the PCP (see ’Details’). Default is \"Herron\".\n May be abbreviated.\n verbose Toggle off warnings.\nDetails\n method = \"Gelman-Hill\" (or \"gelman_hill\") computes the PCP based on the proposal from Gel-\n man and Hill 2017, 99, which is defined as the proportion of cases for which the deterministic\n prediction is wrong, i.e. the proportion where the predicted probability is above 0.5, although y=0\n (and vice versa) (see also Herron 1999, 90).\n method = \"Herron\" (or \"herron\") computes a modified version of the PCP (Herron 1999, 90-92),\n which is the sum of predicted probabilities, where y=1, plus the sum of 1 - predicted probabilities,\n where y=0, divided by the number of observations. This approach is said to be more accurate.\n The PCP ranges from 0 to 1, where values closer to 1 mean that the model predicts the outcome\n better than models with an PCP closer to 0. In general, the PCP should be above 0.5 (i.e. 50\\\n Furthermore, the PCP of the full model should be considerably above the null model’s PCP.\n The likelihood-ratio test indicates whether the model has a significantly better fit than the null-model\n (in such cases, p < 0.05).\nValue\n A list with several elements: the percentage of correct predictions of the full and the null model,\n their confidence intervals, as well as the chi-squared and p-value from the Likelihood-Ratio-Test\n between the full and null model.\nReferences\n • . (1999). Postestimation Uncertainty in Limited Dependent Variable Models. Polit-\n ical Analysis, 8, 83–98.\n • ., and . (2007). Data analysis using regression and multilevel/hierarchical\n models. Cambridge; New York: Cambridge University Press, 99.\nExamples\n data(mtcars)\n m <- glm(formula = vs ~ hp + wt, family = binomial, data = mtcars)\n performance_pcp(m)\n performance_pcp(m, method = \"Gelman-Hill\")\n performance_rmse Root Mean Squared Error\nDescription\n Compute root mean squared error for (mixed effects) models, including Bayesian regression mod-\n els.\nUsage\n performance_rmse(model, normalized = FALSE, verbose = TRUE)\n rmse(model, normalized = FALSE, verbose = TRUE)\nArguments\n model A model.\n normalized Logical, use TRUE if normalized rmse should be returned.\n verbose Toggle off warnings.\nDetails\n The RMSE is the square root of the variance of the residuals and indicates the absolute fit of the\n model to the data (difference between observed data to model’s predicted values). It can be inter-\n preted as the standard deviation of the unexplained variance, and is in the same units as the response\n variable. Lower values indicate better model fit.\n The normalized RMSE is the proportion of the RMSE related to the range of the response variable.\n Hence, lower values indicate less residual variance.\nValue\n Numeric, the root mean squared error.\nExamples\n if (require(\"nlme\")) {\n m <- lme(distance ~ age, data = Orthodont)\n # RMSE\n performance_rmse(m, normalized = FALSE)\n # normalized RMSE\n performance_rmse(m, normalized = TRUE)\n }\n performance_roc Simple ROC curve\nDescription\n This function calculates a simple ROC curves of x/y coordinates based on response and predictions\n of a binomial model.\nUsage\n performance_roc(x, ..., predictions, new_data)\nArguments\n x A numeric vector, representing the outcome (0/1), or a model with binomial\n outcome.\n ... One or more models with binomial outcome. In this case, new_data is ignored.\n predictions If x is numeric, a numeric vector of same length as x, representing the actual\n predicted values.\n new_data If x is a model, a data frame that is passed to predict() as newdata-argument.\n If NULL, the ROC for the full model is calculated.\nValue\n A data frame with three columns, the x/y-coordinate pairs for the ROC curve (Sensitivity and\n Specificity), and a column with the model name.\nNote\n There is also a plot()-method implemented in the see-package.\nExamples\n library(bayestestR)\n data(iris)\n set.seed(123)\n iris$y <- rbinom(nrow(iris), size = 1, .3)\n folds <- sample(nrow(iris), size = nrow(iris) / 8, replace = FALSE)\n test_data <- iris[folds, ]\n train_data <- iris[-folds, ]\n model <- glm(y ~ Sepal.Length + Sepal.Width, data = train_data, family = \"binomial\")\n as.data.frame(performance_roc(model, new_data = test_data))\n roc <- performance_roc(model, new_data = test_data)\n area_under_curve(roc$Specificity, roc$Sensitivity)\n if (interactive()) {\n m1 <- glm(y ~ Sepal.Length + Sepal.Width, data = iris, family = \"binomial\")\n m2 <- glm(y ~ Sepal.Length + Petal.Width, data = iris, family = \"binomial\")\n m3 <- glm(y ~ Sepal.Length + Species, data = iris, family = \"binomial\")\n performance_roc(m1, m2, m3)\n # if you have `see` package installed, you can also plot comparison of\n # ROC curves for different models\n if (require(\"see\")) plot(performance_roc(m1, m2, m3))\n }\n performance_rse Residual Standard Error for Linear Models\nDescription\n Compute residual standard error of linear models.\nUsage\n performance_rse(model)\nArguments\n model A model.\nDetails\n The residual standard error is the square root of the residual sum of squares divided by the residual\n degrees of freedom.\nValue\n Numeric, the residual standard error of model.\nExamples\n data(mtcars)\n m <- lm(mpg ~ hp + gear, data = mtcars)\n performance_rse(m)\n performance_score Proper Scoring Rules\nDescription\n Calculates the logarithmic, quadratic/Brier and spherical score from a model with binary or count\n outcome.\nUsage\n performance_score(model, verbose = TRUE, ...)\nArguments\n model Model with binary or count outcome.\n verbose Toggle off warnings.\n ... Arguments from other functions, usually only used internally.\nDetails\n Proper scoring rules can be used to evaluate the quality of model predictions and model fit. performance_score()\n calculates the logarithmic, quadratic/Brier and spherical scoring rules. The spherical rule takes val-\n ues in the interval [0, 1], with values closer to 1 indicating a more accurate model, and the loga-\n rithmic rule in the interval [-Inf, 0], with values closer to 0 indicating a more accurate model.\n For stan_lmer() and stan_glmer() models, the predicted values are based on posterior_predict(),\n instead of predict(). Thus, results may differ more than expected from their non-Bayesian coun-\n terparts in lme4.\nValue\n A list with three elements, the logarithmic, quadratic/Brier and spherical score.\nNote\n Code is partially based on GLMMadaptive::scoring_rules().\nReferences\n . (2016). An overview of applications of proper scoring rules. Decision Analysis 13,\n 223–242. doi:10.1287/deca.2016.0337\nSee Also\n performance_logloss()\nExamples\n ## Dobson (1990) Page 93: Randomized Controlled Trial :\n counts <- c(18, 17, 15, 20, 10, 20, 25, 13, 12)\n outcome <- gl(3, 1, 9)\n treatment <- gl(3, 3)\n model <- glm(counts ~ outcome + treatment, family = poisson())\n performance_score(model)\n ## Not run:\n if (require(\"glmmTMB\")) {\n data(Salamanders)\n model <- glmmTMB(\n count ~ spp + mined + (1 | site),\n zi = ~ spp + mined,\n family = nbinom2(),\n data = Salamanders\n )\n performance_score(model)\n }\n ## End(Not run)\n r2 Compute the model’s R2\nDescription\n Calculate the R2, also known as the coefficient of determination, value for different model objects.\n Depending on the model, R2, pseudo-R2, or marginal / adjusted R2 values are returned.\nUsage\n r2(model, ...)\n ## Default S3 method:\n r2(model, ci = NULL, verbose = TRUE, ...)\n ## S3 method for class 'merMod'\n r2(model, ci = NULL, tolerance = 1e-05, ...)\nArguments\n model A statistical model.\n ... Arguments passed down to the related r2-methods.\n ci Confidence interval level, as scalar. If NULL (default), no confidence intervals\n for R2 are calculated.\n verbose Logical. Should details about R2 and CI methods be given (TRUE) or not (FALSE)?\n tolerance Tolerance for singularity check of random effects, to decide whether to com-\n pute random effect variances for the conditional r-squared or not. Indicates up\n to which value the convergence result is accepted. When r2_nakagawa() re-\n turns a warning, stating that random effect variances can’t be computed (and\n thus, the conditional r-squared is NA), decrease the tolerance-level. See also\n check_singularity().\nValue\n Returns a list containing values related to the most appropriate R2 for the given model (or NULL if\n no R2 could be extracted). See the list below:\n • Logistic models: Tjur’s R2\n • General linear models: Nagelkerke’s R2\n • Multinomial Logit: McFadden’s R2\n • Models with zero-inflation: R2 for zero-inflated models\n • Mixed models: Nakagawa’s R2\n • Bayesian models: R2 bayes\nNote\n If there is no r2()-method defined for the given model class, r2() tries to return a \"generic\" r-\n quared value, calculated as following: 1-sum((y-y_hat)^2)/sum((y-y_bar)^2))\nSee Also\n r2_bayes(), r2_coxsnell(), r2_kullback(), r2_loo(), r2_mcfadden(), r2_nagelkerke(),\n r2_nakagawa(), r2_tjur(), r2_xu() and r2_zeroinflated().\nExamples\n # Pseudo r-quared for GLM\n model <- glm(vs ~ wt + mpg, data = mtcars, family = \"binomial\")\n r2(model)\n # r-squared including confidence intervals\n model <- lm(mpg ~ wt + hp, data = mtcars)\n r2(model, ci = 0.95)\n if (require(\"lme4\")) {\n model <- lmer(Sepal.Length ~ Petal.Length + (1 | Species), data = iris)\n r2(model)\n }\n r2_bayes Bayesian R2\nDescription\n Compute R2 for Bayesian models. For mixed models (including a random part), it additionally\n computes the R2 related to the fixed effects only (marginal R2). While r2_bayes() returns a single\n R2 value, r2_posterior() returns a posterior sample of Bayesian R2 values.\nUsage\n r2_bayes(model, robust = TRUE, ci = 0.95, verbose = TRUE, ...)\n r2_posterior(model, ...)\n ## S3 method for class 'brmsfit'\n r2_posterior(model, verbose = TRUE, ...)\n ## S3 method for class 'stanreg'\n r2_posterior(model, verbose = TRUE, ...)\n ## S3 method for class 'BFBayesFactor'\n r2_posterior(model, average = FALSE, prior_odds = NULL, verbose = TRUE, ...)\nArguments\n model A Bayesian regression model (from brms, rstanarm, BayesFactor, etc).\n robust Logical, if TRUE, the median instead of mean is used to calculate the central\n tendency of the variances.\n ci Value or vector of probability of the CI (between 0 and 1) to be estimated.\n verbose Toggle off warnings.\n ... Arguments passed to r2_posterior().\n average Compute model-averaged index? See bayestestR::weighted_posteriors().\n prior_odds Optional vector of prior odds for the models compared to the first model (or the\n denominator, for BFBayesFactor objects). For data.frames, this will be used\n as the basis of weighting.\nDetails\n r2_bayes() returns an \"unadjusted\" R2 value. See r2_loo() to calculate a LOO-adjusted R2,\n which comes conceptually closer to an adjusted R2 measure.\n For mixed models, the conditional and marginal R2 are returned. The marginal R2 considers only\n the variance of the fixed effects, while the conditional R2 takes both the fixed and random effects\n into account.\n r2_posterior() is the actual workhorse for r2_bayes() and returns a posterior sample of Bayesian\n R2 values.\nValue\n A list with the Bayesian R2 value. For mixed models, a list with the Bayesian R2 value and the\n marginal Bayesian R2 value. The standard errors and credible intervals for the R2 values are saved\n as attributes.\nReferences\n ., ., ., and . (2018). R-squared for Bayesian regression\n models. The American Statistician, 1–6. doi:10.1080/00031305.2018.1549100\nExamples\n library(performance)\n if (require(\"rstanarm\") && require(\"rstantools\")) {\n model <- stan_glm(mpg ~ wt + cyl, data = mtcars, chains = 1, iter = 500, refresh = 0)\n r2_bayes(model)\n model <- stan_lmer(\n Petal.Length ~ Petal.Width + (1 | Species),\n data = iris,\n chains = 1,\n iter = 500,\n refresh = 0\n )\n r2_bayes(model)\n }\n if (require(\"BayesFactor\")) {\n BFM <- generalTestBF(mpg ~ qsec + gear, data = mtcars, progress = FALSE)\n FM <- lmBF(mpg ~ qsec + gear, data = mtcars)\n r2_bayes(FM)\n r2_bayes(BFM[3])\n r2_bayes(BFM, average = TRUE) # across all models\n # with random effects:\n mtcars$gear <- factor(mtcars$gear)\n model <- lmBF(\n mpg ~ hp + cyl + gear + gear:wt,\n mtcars,\n progress = FALSE,\n whichRandom = c(\"gear\", \"gear:wt\")\n )\n r2_bayes(model)\n }\n ## Not run:\n if (require(\"brms\")) {\n model <- brms::brm(mpg ~ wt + cyl, data = mtcars)\n r2_bayes(model)\n model <- brms::brm(Petal.Length ~ Petal.Width + (1 | Species), data = iris)\n r2_bayes(model)\n }\n ## End(Not run)\n r2_coxsnell Cox & Snell’s R2\nDescription\n Calculates the pseudo-R2 value based on the proposal from Cox & Snell (1989).\nUsage\n r2_coxsnell(model, ...)\nArguments\n model Model with binary outcome.\n ... Currently not used.\nDetails\n This index was proposed by Cox and Snell (1989, pp. 208-9) and, apparently independently, by\n Magee (1990); but had been suggested earlier for binary response models by Maddala (1983).\n However, this index achieves a maximum of less than 1 for discrete models (i.e. models whose\n likelihood is a product of probabilities) which have a maximum of 1, instead of densities, which\n can become infinite (Nagelkerke, 1991).\nValue\n A named vector with the R2 value.\nReferences\n • ., . (1989). Analysis of binary data (Vol. 32). Monographs on Statistics\n and Applied Probability.\n • . (1990). R 2 measures based on Wald and likelihood ratio joint significance tests.\n The American Statistician, 44(3), 250-253.\n • . (1986). Limited-dependent and qualitative variables in econometrics (No. 3).\n Cambridge university press.\n • . (1991). A note on a general definition of the coefficient of determination.\n Biometrika, 78(3), 691-692.\nExamples\n model <- glm(vs ~ wt + mpg, data = mtcars, family = \"binomial\")\n r2_coxsnell(model)\n r2_efron Efron’s R2\nDescription\n Calculates Efron’s pseudo R2.\nUsage\n r2_efron(model)\nArguments\n model Generalized linear model.\nDetails\n Efron’s R2 is calculated by taking the sum of the squared model residuals, divided by the total\n variability in the dependent variable. This R2 equals the squared correlation between the predicted\n values and actual values, however, note that model residuals from generalized linear models are not\n generally comparable to those of OLS.\nValue\n The R2 value.\nReferences\n Efron, B. (1978). Regression and ANOVA with zero-one data: Measures of residual variation.\n Journal of the American Statistical Association, 73, 113-121.\nExamples\n ## Dobson (1990) Page 93: Randomized Controlled Trial:\n counts <- c(18, 17, 15, 20, 10, 20, 25, 13, 12) #\n outcome <- gl(3, 1, 9)\n treatment <- gl(3, 3)\n model <- glm(counts ~ outcome + treatment, family = poisson())\n r2_efron(model)\n r2_kullback Kullback-Leibler R2\nDescription\n Calculates the Kullback-Leibler-divergence-based R2 for generalized linear models.\nUsage\n r2_kullback(model, adjust = TRUE)\nArguments\n model A generalized linear model.\n adjust Logical, if TRUE (the default), the adjusted R2 value is returned.\nValue\n A named vector with the R2 value.\nReferences\n . and . (1997) An R-squared measure of goodness of fit for some\n common nonlinear regression models. Journal of Econometrics, 77: 329-342.\nExamples\n model <- glm(vs ~ wt + mpg, data = mtcars, family = \"binomial\")\n r2_kullback(model)\n r2_loo LOO-adjusted R2\nDescription\n Compute LOO-adjusted R2.\nUsage\n r2_loo(model, robust = TRUE, ci = 0.95, verbose = TRUE, ...)\n r2_loo_posterior(model, ...)\n ## S3 method for class 'brmsfit'\n r2_loo_posterior(model, verbose = TRUE, ...)\n ## S3 method for class 'stanreg'\n r2_loo_posterior(model, verbose = TRUE, ...)\nArguments\n model A Bayesian regression model (from brms, rstanarm, BayesFactor, etc).\n robust Logical, if TRUE, the median instead of mean is used to calculate the central\n tendency of the variances.\n ci Value or vector of probability of the CI (between 0 and 1) to be estimated.\n verbose Toggle off warnings.\n ... Arguments passed to r2_posterior().\nDetails\n r2_loo() returns an \"adjusted\" R2 value computed using a leave-one-out-adjusted posterior dis-\n tribution. This is conceptually similar to an adjusted/unbiased R2 estimate in classical regression\n modeling. See r2_bayes() for an \"unadjusted\" R2.\n Mixed models are not currently fully supported.\n r2_loo_posterior() is the actual workhorse for r2_loo() and returns a posterior sample of LOO-\n adjusted Bayesian R2 values.\nValue\n A list with the Bayesian R2 value. For mixed models, a list with the Bayesian R2 value and the\n marginal Bayesian R2 value. The standard errors and credible intervals for the R2 values are saved\n as attributes.\n A list with the LOO-adjusted R2 value. The standard errors and credible intervals for the R2 values\n are saved as attributes.\nExamples\n if (require(\"rstanarm\")) {\n model <- stan_glm(mpg ~ wt + cyl, data = mtcars, chains = 1, iter = 500, refresh = 0)\n r2_loo(model)\n }\n r2_mcfadden McFadden’s R2\nDescription\n Calculates McFadden’s pseudo R2.\nUsage\n r2_mcfadden(model, ...)\nArguments\n model Generalized linear or multinomial logit (mlogit) model.\n ... Currently not used.\nValue\n For most models, a list with McFadden’s R2 and adjusted McFadden’s R2 value. For some models,\n only McFadden’s R2 is available.\nReferences\n • . (1987). Regression-based specification tests for the multinomial logit model.\n Journal of econometrics, 34(1-2), 63-82.\n • . (1973). Conditional logit analysis of qualitative choice behavior.\nExamples\n if (require(\"mlogit\")) {\n data(\"Fishing\", package = \"mlogit\")\n Fish <- mlogit.data(Fishing, varying = c(2:9), shape = \"wide\", choice = \"mode\")\n model <- mlogit(mode ~ price + catch, data = Fish)\n r2_mcfadden(model)\n }\n r2_mckelvey McKelvey & Zavoinas R2\nDescription\n Calculates McKelvey and Zavoinas pseudo R2.\nUsage\n r2_mckelvey(model)\nArguments\n model Generalized linear model.\nDetails\n McKelvey and Zavoinas R2 is based on the explained variance, where the variance of the predicted\n response is divided by the sum of the variance of the predicted response and residual variance.\n For binomial models, the residual variance is either pi^2/3 for logit-link and 1 for probit-link.\n For poisson-models, the residual variance is based on log-normal approximation, similar to the\n distribution-specific variance as described in ?insight::get_variance.\nValue\n The R2 value.\nReferences\n ., . (1975), \"A Statistical Model for the Analysis of Ordinal Level Depen-\n dent Variables\", Journal of Mathematical Sociology 4, S. 103–120.\nExamples\n ## Dobson (1990) Page 93: Randomized Controlled Trial:\n counts <- c(18, 17, 15, 20, 10, 20, 25, 13, 12) #\n outcome <- gl(3, 1, 9)\n treatment <- gl(3, 3)\n model <- glm(counts ~ outcome + treatment, family = poisson())\n r2_mckelvey(model)\n r2_nagelkerke Nagelkerke’s R2\nDescription\n Calculate Nagelkerke’s pseudo-R2.\nUsage\n r2_nagelkerke(model, ...)\nArguments\n model A generalized linear model, including cumulative links resp. multinomial mod-\n els.\n ... Currently not used.\nValue\n A named vector with the R2 value.\nReferences\n Nagelkerke, . (1991). A note on a general definition of the coefficient of determination.\n Biometrika, 78(3), 691-692.\nExamples\n model <- glm(vs ~ wt + mpg, data = mtcars, family = \"binomial\")\n r2_nagelkerke(model)\n r2_nakagawa Nakagawa’s R2 for mixed models\nDescription\n Compute the marginal and conditional r-squared value for mixed effects models with complex\n random effects structures.\nUsage\n r2_nakagawa(\n model,\n by_group = FALSE,\n tolerance = 1e-05,\n ci = NULL,\n iterations = 100,\n ci_method = NULL,\n verbose = TRUE,\n ...\n )\nArguments\n model A mixed effects model.\n by_group Logical, if TRUE, returns the explained variance at different levels (if there are\n multiple levels). This is essentially similar to the variance reduction approach\n by Hox (2010), pp. 69-78.\n tolerance Tolerance for singularity check of random effects, to decide whether to com-\n pute random effect variances for the conditional r-squared or not. Indicates up\n to which value the convergence result is accepted. When r2_nakagawa() re-\n turns a warning, stating that random effect variances can’t be computed (and\n thus, the conditional r-squared is NA), decrease the tolerance-level. See also\n check_singularity().\n ci Confidence resp. credible interval level. For icc() and r2(), confidence in-\n tervals are based on bootstrapped samples from the ICC resp. R2 value. See\n iterations.\n iterations Number of bootstrap-replicates when computing confidence intervals for the\n ICC or R2.\n ci_method Character string, indicating the bootstrap-method. Should be NULL (default),\n in which case lme4::bootMer() is used for bootstrapped confidence intervals.\n However, if bootstrapped intervals cannot be calculated this was, try ci_method\n = \"boot\", which falls back to boot::boot(). This may successfully return\n bootstrapped confidence intervals, but bootstrapped samples may not be ap-\n propriate for the multilevel structure of the model. There is also an option\n ci_method = \"analytical\", which tries to calculate analytical confidence as-\n suming a chi-squared distribution. However, these intervals are rather inaccurate\n and often too narrow. It is recommended to calculate bootstrapped confidence\n intervals for mixed models.\n verbose Toggle warnings and messages.\n ... Arguments passed down to brms::posterior_predict().\nDetails\n Marginal and conditional r-squared values for mixed models are calculated based on Nakagawa et\n al. (2017). For more details on the computation of the variances, see ?insight::get_variance.\n The random effect variances are actually the mean random effect variances, thus the r-squared value\n is also appropriate for mixed models with random slopes or nested random effects (see Johnson,\n 2014).\n • Conditional R2: takes both the fixed and random effects into account.\n • Marginal R2: considers only the variance of the fixed effects.\n The contribution of random effects can be deduced by subtracting the marginal R2 from the condi-\n tional R2 or by computing the icc().\nValue\n A list with the conditional and marginal R2 values.\nReferences\n • . (2010). Multilevel analysis: techniques and applications (2nd ed). New York:\n Routledge.\n • . (2014). Extension of Nakagawa and Schielzeth’s R2 GLMM to random\n slopes models. Methods in Ecology and Evolution, 5(9), 944–946. doi:10.1111/2041210X.12225\n • ., and . (2013). A general and simple method for obtaining R2 from\n generalized linear mixed-effects models. Methods in Ecology and Evolution, 4(2), 133–142.\n doi:10.1111/j.2041210x.2012.00261.x\n • ., ., and . (2017). The coefficient of determina-\n tion R2 and intra-class correlation coefficient from generalized linear mixed-effects models\n revisited and expanded. Journal of The Royal Society Interface, 14(134), 20170213.\nExamples\n if (require(\"lme4\")) {\n model <- lmer(Sepal.Length ~ Petal.Length + (1 | Species), data = iris)\n r2_nakagawa(model)\n r2_nakagawa(model, by_group = TRUE)\n }\n r2_somers Somers’ Dxy rank correlation for binary outcomes\nDescription\n Calculates the Somers’ Dxy rank correlation for logistic regression models.\nUsage\n r2_somers(model)\nArguments\n model A logistic regression model.\nValue\n A named vector with the R2 value.\nReferences\n . (1962). A new asymmetric measure of association for ordinal variables. American\n Sociological Review. 27 (6).\nExamples\n ## Not run:\n if (require(\"correlation\") && require(\"Hmisc\")) {\n model <- glm(vs ~ wt + mpg, data = mtcars, family = \"binomial\")\n r2_somers(model)\n }\n ## End(Not run)\n r2_tjur Tjur’s R2 - coefficient of determination (D)\nDescription\n This method calculates the Coefficient of Discrimination D (also known as Tjur’s R2; Tjur, 2009 )\n for generalized linear (mixed) models for binary outcomes. It is an alternative to other pseudo-R2\n values like Nagelkerke’s R2 or Cox-Snell R2. The Coefficient of Discrimination D can be read like\n any other (pseudo-)R2 value.\nUsage\n r2_tjur(model, ...)\nArguments\n model Binomial Model.\n ... Arguments from other functions, usually only used internally.\nValue\n A named vector with the R2 value.\nReferences\n . (2009). Coefficients of determination in logistic regression models - A new proposal: The\n coefficient of discrimination. The American Statistician, 63(4), 366-372.\nExamples\n model <- glm(vs ~ wt + mpg, data = mtcars, family = \"binomial\")\n r2_tjur(model)\n r2_xu Xu’ R2 (Omega-squared)\nDescription\n Calculates Xu’ Omega-squared value, a simple R2 equivalent for linear mixed models.\nUsage\n r2_xu(model)\nArguments\n model A linear (mixed) model.\nDetails\n r2_xu() is a crude measure for the explained variance from linear (mixed) effects models, which is\n originally denoted as Ω2 .\nValue\n The R2 value.\nReferences\n . (2003). Measuring explained variation in linear mixed effects models. Statistics in Medicine,\n 22(22), 3527–3541. doi:10.1002/sim.1572\nExamples\n model <- lm(Sepal.Length ~ Petal.Length + Species, data = iris)\n r2_xu(model)\n r2_zeroinflated R2 for models with zero-inflation\nDescription\n Calculates R2 for models with zero-inflation component, including mixed effects models.\nUsage\n r2_zeroinflated(model, method = c(\"default\", \"correlation\"))\nArguments\n model A model.\n method Indicates the method to calculate R2. See ’Details’. May be abbreviated.\nDetails\n The default-method calculates an R2 value based on the residual variance divided by the total vari-\n ance. For method = \"correlation\", R2 is a correlation-based measure, which is rather crude. It\n simply computes the squared correlation between the model’s actual and predicted response.\nValue\n For the default-method, a list with the R2 and adjusted R2 values. For method = \"correlation\", a\n named numeric vector with the correlation-based R2 value.\nExamples\n if (require(\"pscl\")) {\n data(bioChemists)\n model <- zeroinfl(\n art ~ fem + mar + kid5 + ment | kid5 + phd,\n data = bioChemists\n )\n r2_zeroinflated(model)\n }\n test_bf Test if models are different\nDescription\n Testing whether models are \"different\" in terms of accuracy or explanatory power is a delicate and\n often complex procedure, with many limitations and prerequisites. Moreover, many tests exist, each\n coming with its own interpretation, and set of strengths and weaknesses.\n The test_performance() function runs the most relevant and appropriate tests based on the type\n of input (for instance, whether the models are nested or not). However, it still requires the user to\n understand what the tests are and what they do in order to prevent their misinterpretation. See the\n Details section for more information regarding the different tests and their interpretation.\nUsage\n test_bf(...)\n ## Default S3 method:\n test_bf(..., reference = 1, text_length = NULL)\n test_likelihoodratio(..., estimator = \"ML\", verbose = TRUE)\n test_lrt(..., estimator = \"ML\", verbose = TRUE)\n test_performance(..., reference = 1, verbose = TRUE)\n test_vuong(..., verbose = TRUE)\n test_wald(..., verbose = TRUE)\nArguments\n ... Multiple model objects.\n reference This only applies when models are non-nested, and determines which model\n should be taken as a reference, against which all the other models are tested.\n text_length Numeric, length (number of chars) of output lines. test_bf() describes models\n by their formulas, which can lead to overly long lines in the output. text_length\n fixes the length of lines to a specified limit.\n estimator Applied when comparing regression models using test_likelihoodratio().\n Corresponds to the different estimators for the standard deviation of the errors.\n Defaults to \"OLS\" for linear models, \"ML\" for all other models (including mixed\n models), or \"REML\" for linear mixed models when these have the same fixed\n effects. See ’Details’.\n verbose Toggle warning and messages.\nDetails\n Nested vs. Non-nested Models:\n Model’s \"nesting\" is an important concept of models comparison. Indeed, many tests only make\n sense when the models are \"nested\", i.e., when their predictors are nested. This means that all\n the fixed effects predictors of a model are contained within the fixed effects predictors of a larger\n model (sometimes referred to as the encompassing model). For instance, model1 (y ~ x1 + x2)\n is \"nested\" within model2 (y ~ x1 + x2 + x3). Usually, people have a list of nested models, for\n instance m1 (y ~ 1), m2 (y ~ x1), m3 (y ~ x1 + x2), m4 (y ~ x1 + x2 + x3), and it is conventional\n that they are \"ordered\" from the smallest to largest, but it is up to the user to reverse the order from\n largest to smallest. The test then shows whether a more parsimonious model, or whether adding\n a predictor, results in a significant difference in the model’s performance. In this case, models are\n usually compared sequentially: m2 is tested against m1, m3 against m2, m4 against m3, etc.\n Two models are considered as \"non-nested\" if their predictors are different. For instance, model1\n (y ~ x1 + x2) and model2 (y ~ x3 + x4). In the case of non-nested models, all models are usually\n compared against the same reference model (by default, the first of the list).\n Nesting is detected via the insight::is_nested_models() function. Note that, apart from the\n nesting, in order for the tests to be valid, other requirements have often to be the fulfilled. For in-\n stance, outcome variables (the response) must be the same. You cannot meaningfully test whether\n apples are significantly different from oranges!\n Estimator of the standard deviation:\n The estimator is relevant when comparing regression models using test_likelihoodratio().\n If estimator = \"OLS\", then it uses the same method as anova(..., test = \"LRT\") implemented\n in base R, i.e., scaling by n-k (the unbiased OLS estimator) and using this estimator under the\n alternative hypothesis. If estimator = \"ML\", which is for instance used by lrtest(...) in pack-\n age lmtest, the scaling is done by n (the biased ML estimator) and the estimator under the null\n hypothesis. In moderately large samples, the differences should be negligible, but it is possible\n that OLS would perform slightly better in small samples with Gaussian errors. For estimator =\n \"REML\", the LRT is based on the REML-fit log-likelihoods of the models. Note that not all types\n of estimators are available for all model classes.\n REML versus ML estimator:\n When estimator = \"ML\", which is the default for linear mixed models (unless they share the\n same fixed effects), values from information criteria (AIC, AICc) are based on the ML-estimator,\n while the default behaviour of AIC() may be different (in particular for linear mixed models from\n lme4, which sets REML = TRUE). This default in test_likelihoodratio() intentional, because\n comparing information criteria based on REML fits requires the same fixed effects for all models,\n which is often not the case. Thus, while anova.merMod() automatically refits all models to REML\n when performing a LRT, test_likelihoodratio() checks if a comparison based on REML fits\n is indeed valid, and if so, uses REML as default (else, ML is the default). Set the estimator\n argument explicitely to override the default behaviour.\n Tests Description:\n • Bayes factor for Model Comparison - test_bf(): If all models were fit from the same\n data, the returned BF shows the Bayes Factor (see bayestestR::bayesfactor_models())\n for each model against the reference model (which depends on whether the models are nested\n or not). Check out this vignette for more details.\n • Wald’s F-Test - test_wald(): The Wald test is a rough approximation of the Likelihood\n Ratio Test. However, it is more applicable than the LRT: you can often run a Wald test in\n situations where no other test can be run. Importantly, this test only makes statistical sense if\n the models are nested.\n Note: this test is also available in base R through the anova() function. It returns an F-value\n column as a statistic and its associated p-value.\n • Likelihood Ratio Test (LRT) - test_likelihoodratio(): The LRT tests which model\n is a better (more likely) explanation of the data. Likelihood-Ratio-Test (LRT) gives usually\n somewhat close results (if not equivalent) to the Wald test and, similarly, only makes sense for\n nested models. However, maximum likelihood tests make stronger assumptions than method\n of moments tests like the F-test, and in turn are more efficient. Agresti (1990) suggests that\n you should use the LRT instead of the Wald test for small sample sizes (under or about 30)\n or if the parameters are large.\n Note: for regression models, this is similar to anova(..., test=\"LRT\") (on models) or\n lmtest::lrtest(...), depending on the estimator argument. For lavaan models (SEM,\n CFA), the function calls lavaan::lavTestLRT().\n For models with transformed response variables (like log(x) or sqrt(x)), logLik() returns\n a wrong log-likelihood. However, test_likelihoodratio() calls insight::get_loglikelihood()\n with check_response=TRUE, which returns a corrected log-likelihood value for models with\n transformed response variables. Furthermore, since the LRT only accepts nested models (i.e.\n models that differ in their fixed effects), the computed log-likelihood is always based on the\n ML estimator, not on the REML fits.\n • Vuong’s Test - test_vuong(): Vuong’s (1989) test can be used both for nested and non-\n nested models, and actually consists of two tests.\n – The Test of Distinguishability (the Omega2 column and its associated p-value) indicates\n whether or not the models can possibly be distinguished on the basis of the observed\n data. If its p-value is significant, it means the models are distinguishable.\n – The Robust Likelihood Test (the LR column and its associated p-value) indicates whether\n each model fits better than the reference model. If the models are nested, then the test\n works as a robust LRT. The code for this function is adapted from the nonnest2 package,\n and all credit go to their authors.\nValue\n A data frame containing the relevant indices.\nReferences\n • . (1989). Likelihood ratio tests for model selection and non-nested hypotheses.\n Econometrica, 57, 307-333.\n • ., ., & . (2016). Testing non-nested structural equation models.\n Psychological Methods, 21, 151-163.\nSee Also\n compare_performance() to compare the performance indices of many different models.\nExamples\n # Nested Models\n # -------------\n m1 <- lm(Sepal.Length ~ Petal.Width, data = iris)\n m2 <- lm(Sepal.Length ~ Petal.Width + Species, data = iris)\n m3 <- lm(Sepal.Length ~ Petal.Width * Species, data = iris)\n test_performance(m1, m2, m3)\n test_bf(m1, m2, m3)\n test_wald(m1, m2, m3) # Equivalent to anova(m1, m2, m3)\n # Equivalent to lmtest::lrtest(m1, m2, m3)\n test_likelihoodratio(m1, m2, m3, estimator = \"ML\")\n # Equivalent to anova(m1, m2, m3, test='LRT')\n test_likelihoodratio(m1, m2, m3, estimator = \"OLS\")\n if (require(\"CompQuadForm\")) {\n test_vuong(m1, m2, m3) # nonnest2::vuongtest(m1, m2, nested=TRUE)\n # Non-nested Models\n # -----------------\n m1 <- lm(Sepal.Length ~ Petal.Width, data = iris)\n m2 <- lm(Sepal.Length ~ Petal.Length, data = iris)\n m3 <- lm(Sepal.Length ~ Species, data = iris)\n test_performance(m1, m2, m3)\n test_bf(m1, m2, m3)\n test_vuong(m1, m2, m3) # nonnest2::vuongtest(m1, m2)\n }\n # Tweak the output\n # ----------------\n test_performance(m1, m2, m3, include_formula = TRUE)\n # SEM / CFA (lavaan objects)\n # --------------------------\n # Lavaan Models\n if (require(\"lavaan\")) {\n structure <- \" visual =~ x1 + x2 + x3\n textual =~ x4 + x5 + x6\n speed =~ x7 + x8 + x9\n visual ~~ textual + speed \"\n m1 <- lavaan::cfa(structure, data = HolzingerSwineford1939)\n structure <- \" visual =~ x1 + x2 + x3\n textual =~ x4 + x5 + x6\n speed =~ x7 + x8 + x9\n visual ~~ 0 * textual + speed \"\n m2 <- lavaan::cfa(structure, data = HolzingerSwineford1939)\n structure <- \" visual =~ x1 + x2 + x3\n textual =~ x4 + x5 + x6\n speed =~ x7 + x8 + x9\n visual ~~ 0 * textual + 0 * speed \"\n m3 <- lavaan::cfa(structure, data = HolzingerSwineford1939)\n test_likelihoodratio(m1, m2, m3)\n # Different Model Types\n # ---------------------\n if (require(\"lme4\") && require(\"mgcv\")) {\n m1 <- lm(Sepal.Length ~ Petal.Length + Species, data = iris)\n m2 <- lmer(Sepal.Length ~ Petal.Length + (1 | Species), data = iris)\n m3 <- gam(Sepal.Length ~ s(Petal.Length, by = Species) + Species, data = iris)\n test_performance(m1, m2, m3)\n }\n }"}}},{"rowIdx":586,"cells":{"project":{"kind":"string","value":"sharded-slab"},"source":{"kind":"string","value":"rust"},"language":{"kind":"string","value":"Rust"},"content":{"kind":"string","value":"Crate sharded_slab\n===\n\nA lock-free concurrent slab.\n\nSlabs provide pre-allocated storage for many instances of a single data type. When a large number of values of a single type are required,\nthis can be more efficient than allocating each item individually. Since the allocated items are the same size, memory fragmentation is reduced, and creating and removing new items can be very cheap.\n\nThis crate implements a lock-free concurrent slab, indexed by `usize`s.\n\n### Usage\n\nFirst, add this to your `Cargo.toml`:\n```\nsharded-slab = \"0.1.1\"\n```\nThis crate provides two types, `Slab` and `Pool`, which provide slightly different APIs for using a sharded slab.\n\n`Slab` implements a slab for *storing* small types, sharing them between threads, and accessing them by index. New entries are allocated by inserting data, moving it in by value. Similarly, entries may be deallocated by taking from the slab, moving the value out. This API is similar to a `Vec>`, but allowing lock-free concurrent insertion and removal.\n\nIn contrast, the `Pool` type provides an object pool style API for\n*reusing storage*. Rather than constructing values and moving them into the pool, as with `Slab`, allocating an entry from the pool takes a closure that’s provided with a mutable reference to initialize the entry in place. When entries are deallocated, they are cleared in place. Types which own a heap allocation can be cleared by dropping any *data* they store, but retaining any previously-allocated capacity. This means that a\n`Pool` may be used to reuse a set of existing heap allocations, reducing allocator load.\n\nExamples\n---\n\nInserting an item into the slab, returning an index:\n```\nlet slab = Slab::new();\n\nlet key = slab.insert(\"hello world\").unwrap();\nassert_eq!(slab.get(key).unwrap(), \"hello world\");\n```\nTo share a slab across threads, it may be wrapped in an `Arc`:\n```\nuse std::sync::Arc;\nlet slab = Arc::new(Slab::new());\n\nlet slab2 = slab.clone();\nlet thread2 = std::thread::spawn(move || {\n let key = slab2.insert(\"hello from thread two\").unwrap();\n assert_eq!(slab2.get(key).unwrap(), \"hello from thread two\");\n key\n});\n\nlet key1 = slab.insert(\"hello from thread one\").unwrap();\nassert_eq!(slab.get(key1).unwrap(), \"hello from thread one\");\n\n// Wait for thread 2 to complete.\nlet key2 = thread2.join().unwrap();\n\n// The item inserted by thread 2 remains in the slab.\nassert_eq!(slab.get(key2).unwrap(), \"hello from thread two\");\n```\nIf items in the slab must be mutated, a `Mutex` or `RwLock` may be used for each item, providing granular locking of items rather than of the slab:\n```\nuse std::sync::{Arc, Mutex};\nlet slab = Arc::new(Slab::new());\n\nlet key = slab.insert(Mutex::new(String::from(\"hello world\"))).unwrap();\n\nlet slab2 = slab.clone();\nlet thread2 = std::thread::spawn(move || {\n let hello = slab2.get(key).expect(\"item missing\");\n let mut hello = hello.lock().expect(\"mutex poisoned\");\n *hello = String::from(\"hello everyone!\");\n});\n\nthread2.join().unwrap();\n\nlet hello = slab.get(key).expect(\"item missing\");\nlet mut hello = hello.lock().expect(\"mutex poisoned\");\nassert_eq!(hello.as_str(), \"hello everyone!\");\n```\nConfiguration\n---\n\nFor performance reasons, several values used by the slab are calculated as constants. In order to allow users to tune the slab’s parameters, we provide a `Config` trait which defines these parameters as associated `consts`.\nThe `Slab` type is generic over a `C: Config` parameter.\n\nComparison with Similar Crates\n---\n\n* `slab`: ’s `slab` crate provides a slab implementation with a similar API, implemented by storing all data in a single vector.\n\nUnlike `sharded_slab`, inserting and removing elements from the slab requires mutable access. This means that if the slab is accessed concurrently by multiple threads, it is necessary for it to be protected by a `Mutex` or `RwLock`. Items may not be inserted or removed (or accessed, if a `Mutex` is used) concurrently, even when they are unrelated. In many cases, the lock can become a significant bottleneck. On the other hand, this crate allows separate indices in the slab to be accessed, inserted, and removed concurrently without requiring a global lock. Therefore, when the slab is shared across multiple threads, this crate offers significantly better performance than `slab`.\n\nHowever, the lock free slab introduces some additional constant-factor overhead. This means that in use-cases where a slab is *not* shared by multiple threads and locking is not required, this crate will likely offer slightly worse performance.\n\nIn summary: `sharded-slab` offers significantly improved performance in concurrent use-cases, while `slab` should be preferred in single-threaded use-cases.\n\nSafety and Correctness\n---\n\nMost implementations of lock-free data structures in Rust require some amount of unsafe code, and this crate is not an exception. In order to catch potential bugs in this unsafe code, we make use of `loom`, a permutation-testing tool for concurrent Rust programs. All `unsafe` blocks this crate occur in accesses to `loom` `UnsafeCell`s. This means that when those accesses occur in this crate’s tests, `loom` will assert that they are valid under the C11 memory model across multiple permutations of concurrent executions of those tests.\n\nIn order to guard against the ABA problem, this crate makes use of\n*generational indices*. Each slot in the slab tracks a generation counter which is incremented every time a value is inserted into that slot, and the indices returned by `Slab::insert` include the generation of the slot when the value was inserted, packed into the high-order bits of the index. This ensures that if a value is inserted, removed, and a new value is inserted into the same slot in the slab, the key returned by the first call to\n`insert` will not map to the new value.\n\nSince a fixed number of bits are set aside to use for storing the generation counter, the counter will wrap around after being incremented a number of times. To avoid situations where a returned index lives long enough to see the generation counter wrap around to the same value, it is good to be fairly generous when configuring the allocation of index bits.\n\nPerformance\n---\n\nThese graphs were produced by benchmarks of the sharded slab implementation,\nusing the `criterion` crate.\n\nThe first shows the results of a benchmark where an increasing number of items are inserted and then removed into a slab concurrently by five threads. It compares the performance of the sharded slab implementation with a `RwLock`:\n\n\nThe second graph shows the results of a benchmark where an increasing number of items are inserted and then removed by a *single* thread. It compares the performance of the sharded slab implementation with an\n`RwLock` and a `mut slab::Slab`.\n\n\nThese benchmarks demonstrate that, while the sharded approach introduces a small constant-factor overhead, it offers significantly better performance across concurrent accesses.\n\nImplementation Notes\n---\n\nSee this page for details on this crate’s design and implementation.\n\nModules\n---\n\n* implementationNotes on `sharded-slab`’s implementation and design.\n* poolA lock-free concurrent object pool.\n\nStructs\n---\n\n* DefaultConfigDefault slab configuration values.\n* EntryA handle that allows access to an occupied entry in a `Slab`.\n* OwnedEntryAn owned reference to an occupied entry in a `Slab`.\n* PoolA lock-free concurrent object pool.\n* SlabA sharded slab.\n* UniqueIterAn exclusive fused iterator over the items in a `Slab`.\n* VacantEntryA handle to a vacant entry in a `Slab`.\n\nTraits\n---\n\n* ClearTrait implemented by types which can be cleared in place, retaining any allocated memory.\n* ConfigConfiguration parameters which can be overridden to tune the behavior of a slab.\n\nCrate sharded_slab\n===\n\nA lock-free concurrent slab.\n\nSlabs provide pre-allocated storage for many instances of a single data type. When a large number of values of a single type are required,\nthis can be more efficient than allocating each item individually. Since the allocated items are the same size, memory fragmentation is reduced, and creating and removing new items can be very cheap.\n\nThis crate implements a lock-free concurrent slab, indexed by `usize`s.\n\n### Usage\n\nFirst, add this to your `Cargo.toml`:\n```\nsharded-slab = \"0.1.1\"\n```\nThis crate provides two types, `Slab` and `Pool`, which provide slightly different APIs for using a sharded slab.\n\n`Slab` implements a slab for *storing* small types, sharing them between threads, and accessing them by index. New entries are allocated by inserting data, moving it in by value. Similarly, entries may be deallocated by taking from the slab, moving the value out. This API is similar to a `Vec>`, but allowing lock-free concurrent insertion and removal.\n\nIn contrast, the `Pool` type provides an object pool style API for\n*reusing storage*. Rather than constructing values and moving them into the pool, as with `Slab`, allocating an entry from the pool takes a closure that’s provided with a mutable reference to initialize the entry in place. When entries are deallocated, they are cleared in place. Types which own a heap allocation can be cleared by dropping any *data* they store, but retaining any previously-allocated capacity. This means that a\n`Pool` may be used to reuse a set of existing heap allocations, reducing allocator load.\n\nExamples\n---\n\nInserting an item into the slab, returning an index:\n```\nlet slab = Slab::new();\n\nlet key = slab.insert(\"hello world\").unwrap();\nassert_eq!(slab.get(key).unwrap(), \"hello world\");\n```\nTo share a slab across threads, it may be wrapped in an `Arc`:\n```\nuse std::sync::Arc;\nlet slab = Arc::new(Slab::new());\n\nlet slab2 = slab.clone();\nlet thread2 = std::thread::spawn(move || {\n let key = slab2.insert(\"hello from thread two\").unwrap();\n assert_eq!(slab2.get(key).unwrap(), \"hello from thread two\");\n key\n});\n\nlet key1 = slab.insert(\"hello from thread one\").unwrap();\nassert_eq!(slab.get(key1).unwrap(), \"hello from thread one\");\n\n// Wait for thread 2 to complete.\nlet key2 = thread2.join().unwrap();\n\n// The item inserted by thread 2 remains in the slab.\nassert_eq!(slab.get(key2).unwrap(), \"hello from thread two\");\n```\nIf items in the slab must be mutated, a `Mutex` or `RwLock` may be used for each item, providing granular locking of items rather than of the slab:\n```\nuse std::sync::{Arc, Mutex};\nlet slab = Arc::new(Slab::new());\n\nlet key = slab.insert(Mutex::new(String::from(\"hello world\"))).unwrap();\n\nlet slab2 = slab.clone();\nlet thread2 = std::thread::spawn(move || {\n let hello = slab2.get(key).expect(\"item missing\");\n let mut hello = hello.lock().expect(\"mutex poisoned\");\n *hello = String::from(\"hello everyone!\");\n});\n\nthread2.join().unwrap();\n\nlet hello = slab.get(key).expect(\"item missing\");\nlet mut hello = hello.lock().expect(\"mutex poisoned\");\nassert_eq!(hello.as_str(), \"hello everyone!\");\n```\nConfiguration\n---\n\nFor performance reasons, several values used by the slab are calculated as constants. In order to allow users to tune the slab’s parameters, we provide a `Config` trait which defines these parameters as associated `consts`.\nThe `Slab` type is generic over a `C: Config` parameter.\n\nComparison with Similar Crates\n---\n\n* `slab`: ’s `slab` crate provides a slab implementation with a similar API, implemented by storing all data in a single vector.\n\nUnlike `sharded_slab`, inserting and removing elements from the slab requires mutable access. This means that if the slab is accessed concurrently by multiple threads, it is necessary for it to be protected by a `Mutex` or `RwLock`. Items may not be inserted or removed (or accessed, if a `Mutex` is used) concurrently, even when they are unrelated. In many cases, the lock can become a significant bottleneck. On the other hand, this crate allows separate indices in the slab to be accessed, inserted, and removed concurrently without requiring a global lock. Therefore, when the slab is shared across multiple threads, this crate offers significantly better performance than `slab`.\n\nHowever, the lock free slab introduces some additional constant-factor overhead. This means that in use-cases where a slab is *not* shared by multiple threads and locking is not required, this crate will likely offer slightly worse performance.\n\nIn summary: `sharded-slab` offers significantly improved performance in concurrent use-cases, while `slab` should be preferred in single-threaded use-cases.\n\nSafety and Correctness\n---\n\nMost implementations of lock-free data structures in Rust require some amount of unsafe code, and this crate is not an exception. In order to catch potential bugs in this unsafe code, we make use of `loom`, a permutation-testing tool for concurrent Rust programs. All `unsafe` blocks this crate occur in accesses to `loom` `UnsafeCell`s. This means that when those accesses occur in this crate’s tests, `loom` will assert that they are valid under the C11 memory model across multiple permutations of concurrent executions of those tests.\n\nIn order to guard against the ABA problem, this crate makes use of\n*generational indices*. Each slot in the slab tracks a generation counter which is incremented every time a value is inserted into that slot, and the indices returned by `Slab::insert` include the generation of the slot when the value was inserted, packed into the high-order bits of the index. This ensures that if a value is inserted, removed, and a new value is inserted into the same slot in the slab, the key returned by the first call to\n`insert` will not map to the new value.\n\nSince a fixed number of bits are set aside to use for storing the generation counter, the counter will wrap around after being incremented a number of times. To avoid situations where a returned index lives long enough to see the generation counter wrap around to the same value, it is good to be fairly generous when configuring the allocation of index bits.\n\nPerformance\n---\n\nThese graphs were produced by benchmarks of the sharded slab implementation,\nusing the `criterion` crate.\n\nThe first shows the results of a benchmark where an increasing number of items are inserted and then removed into a slab concurrently by five threads. It compares the performance of the sharded slab implementation with a `RwLock`:\n\n\nThe second graph shows the results of a benchmark where an increasing number of items are inserted and then removed by a *single* thread. It compares the performance of the sharded slab implementation with an\n`RwLock` and a `mut slab::Slab`.\n\n\nThese benchmarks demonstrate that, while the sharded approach introduces a small constant-factor overhead, it offers significantly better performance across concurrent accesses.\n\nImplementation Notes\n---\n\nSee this page for details on this crate’s design and implementation.\n\nModules\n---\n\n* implementationNotes on `sharded-slab`’s implementation and design.\n* poolA lock-free concurrent object pool.\n\nStructs\n---\n\n* DefaultConfigDefault slab configuration values.\n* EntryA handle that allows access to an occupied entry in a `Slab`.\n* OwnedEntryAn owned reference to an occupied entry in a `Slab`.\n* PoolA lock-free concurrent object pool.\n* SlabA sharded slab.\n* UniqueIterAn exclusive fused iterator over the items in a `Slab`.\n* VacantEntryA handle to a vacant entry in a `Slab`.\n\nTraits\n---\n\n* ClearTrait implemented by types which can be cleared in place, retaining any allocated memory.\n* ConfigConfiguration parameters which can be overridden to tune the behavior of a slab.\n\nStruct sharded_slab::Pool\n===\n\n\n```\npub struct Poolwhere\n T: Clear + Default,\n C: Config,{ /* private fields */ }\n```\nA lock-free concurrent object pool.\n\nSlabs provide pre-allocated storage for many instances of a single type. But, when working with heap allocated objects, the advantages of a slab are lost, as the memory allocated for the object is freed when the object is removed from the slab. With a pool, we can instead reuse this memory for objects being added to the pool in the future, therefore reducing memory fragmentation and avoiding additional allocations.\n\nThis type implements a lock-free concurrent pool, indexed by `usize`s. The items stored in this type need to implement `Clear` and `Default`.\n\nThe `Pool` type shares similar semantics to `Slab` when it comes to sharing across threads and storing mutable shared data. The biggest difference is there are no `Slab::insert` and\n`Slab::take` analouges for the `Pool` type. Instead new items are added to the pool by using the `Pool::create` method, and marked for clearing by the `Pool::clear` method.\n\nExamples\n---\n\nAdd an entry to the pool, returning an index:\n```\nlet pool: Pool = Pool::new();\n\nlet key = pool.create_with(|item| item.push_str(\"hello world\")).unwrap();\nassert_eq!(pool.get(key).unwrap(), String::from(\"hello world\"));\n```\nCreate a new pooled item, returning a guard that allows mutable access:\n```\nlet pool: Pool = Pool::new();\n\nlet mut guard = pool.create().unwrap();\nlet key = guard.key();\nguard.push_str(\"hello world\");\n\ndrop(guard); // release the guard, allowing immutable access.\nassert_eq!(pool.get(key).unwrap(), String::from(\"hello world\"));\n```\nPool entries can be cleared by calling `Pool::clear`. This marks the entry to be cleared when the guards referencing to it are dropped.\n```\nlet pool: Pool = Pool::new();\n\nlet key = pool.create_with(|item| item.push_str(\"hello world\")).unwrap();\n\n// Mark this entry to be cleared.\npool.clear(key);\n\n// The cleared entry is no longer available in the pool assert!(pool.get(key).is_none());\n```\nConfiguration\n---\n\nBoth `Pool` and `Slab` share the same configuration mechanism. See crate level documentation for more details.\n\nImplementations\n---\n\n### impl Poolwhere\n T: Clear + Default,\n\n#### pub fn new() -> Self\n\nReturns a new `Pool` with the default configuration parameters.\n\n#### pub fn new_with_config() -> Pool Poolwhere\n T: Clear + Default,\n C: Config,\n\n#### pub const USED_BITS: usize = C::USED_BITS\n\nThe number of bits in each index which are used by the pool.\n\nIf other data is packed into the `usize` indices returned by\n`Pool::create`, user code is free to use any bits higher than the\n`USED_BITS`-th bit freely.\n\nThis is determined by the `Config` type that configures the pool’s parameters. By default, all bits are used; this can be changed by overriding the `Config::RESERVED_BITS` constant.\n\n#### pub fn create(&self) -> OptionCreates a new object in the pool, returning an `RefMut` guard that may be used to mutate the new object.\n\nIf this function returns `None`, then the shard for the current thread is full and no items can be added until some are removed, or the maximum number of shards has been reached.\n\n##### Examples\n```\nlet pool: Pool = Pool::new();\n\n// Create a new pooled item, returning a guard that allows mutable\n// access to the new item.\nlet mut item = pool.create().unwrap();\n// Return a key that allows indexing the created item once the guard\n// has been dropped.\nlet key = item.key();\n\n// Mutate the item.\nitem.push_str(\"Hello\");\n// Drop the guard, releasing mutable access to the new item.\ndrop(item);\n\n/// Other threads may now (immutably) access the item using the returned key.\nthread::spawn(move || {\n assert_eq!(pool.get(key).unwrap(), String::from(\"Hello\"));\n}).join().unwrap();\n```\n#### pub fn create_owned(self: Arc) -> OptionCreates a new object in the pool, returning an `OwnedRefMut` guard that may be used to mutate the new object.\n\nIf this function returns `None`, then the shard for the current thread is full and no items can be added until some are removed, or the maximum number of shards has been reached.\n\nUnlike `create`, which borrows the pool, this method *clones* the `Arc`\naround the pool if a value exists for the given key. This means that the returned `OwnedRefMut` can be held for an arbitrary lifetime. However,\nthis method requires that the pool itself be wrapped in an `Arc`.\n\nAn `OwnedRefMut` functions more or less identically to an owned\n`Box`: it can be passed to functions, stored in structure fields, and borrowed mutably or immutably, and can be owned for arbitrary lifetimes.\nThe difference is that, unlike a `Box`, the memory allocation for the\n`T` lives in the `Pool`; when an `OwnedRefMut` is created, it may reuse memory that was allocated for a previous pooled object that has been cleared. Additionally, the `OwnedRefMut` may be downgraded to an\n`OwnedRef` which may be shared freely, essentially turning the `Box`\ninto an `Arc`.\n\n##### Examples\n```\nuse std::sync::Arc;\n\nlet pool: Arc> = Arc::new(Pool::new());\n\n// Create a new pooled item, returning an owned guard that allows mutable\n// access to the new item.\nlet mut item = pool.clone().create_owned().unwrap();\n// Return a key that allows indexing the created item once the guard\n// has been dropped.\nlet key = item.key();\n\n// Mutate the item.\nitem.push_str(\"Hello\");\n// Drop the guard, releasing mutable access to the new item.\ndrop(item);\n\n/// Other threads may now (immutably) access the item using the returned key.\nthread::spawn(move || {\n assert_eq!(pool.get(key).unwrap(), String::from(\"Hello\"));\n}).join().unwrap();\n```\n```\nuse std::sync::Arc;\n\nlet pool: Arc> = Arc::new(Pool::new());\n\n// Create a new item, returning an owned, mutable guard.\nlet mut value = pool.clone().create_owned().unwrap();\n\n// Now, the original `Arc` clone of the pool may be dropped, but the\n// returned `OwnedRefMut` can still access the value.\ndrop(pool);\n\nvalue.push_str(\"hello world\");\nassert_eq!(value, String::from(\"hello world\"));\n```\nUnlike `RefMut`, an `OwnedRefMut` may be stored in a struct which must live for the `'static` lifetime:\n```\nuse sharded_slab::pool::OwnedRefMut;\nuse std::sync::Arc;\n\npub struct MyStruct {\n pool_ref: OwnedRefMut,\n // ... other fields ...\n}\n\n// Suppose this is some arbitrary function which requires a value that\n// lives for the 'static lifetime...\nfn function_requiring_static(t: &T) {\n // ... do something extremely important and interesting ...\n}\n\nlet pool: Arc> = Arc::new(Pool::new());\n\n// Create a new item, returning a mutable owned reference.\nlet pool_ref = pool.clone().create_owned().unwrap();\n\nlet my_struct = MyStruct {\n pool_ref,\n // ...\n};\n\n// We can use `my_struct` anywhere where it is required to have the\n// `'static` lifetime:\nfunction_requiring_static(&my_struct);\n```\n`OwnedRefMut`s may be sent between threads:\n```\nuse std::{thread, sync::Arc};\n\nlet pool: Arc> = Arc::new(Pool::new());\n\nlet mut value = pool.clone().create_owned().unwrap();\nlet key = value.key();\n\nthread::spawn(move || {\n value.push_str(\"hello world\");\n // ...\n}).join().unwrap();\n\n// Once the `OwnedRefMut` has been dropped by the other thread, we may\n// now access the value immutably on this thread.\n\nassert_eq!(pool.get(key).unwrap(), String::from(\"hello world\"));\n```\nDowngrading from a mutable to an immutable reference:\n```\nuse std::{thread, sync::Arc};\n\nlet pool: Arc> = Arc::new(Pool::new());\n\nlet mut value = pool.clone().create_owned().unwrap();\nlet key = value.key();\nvalue.push_str(\"hello world\");\n\n// Downgrade the mutable owned ref to an immutable owned ref.\nlet value = value.downgrade();\n\n// Once the `OwnedRefMut` has been downgraded, other threads may\n// immutably access the pooled value:\nthread::spawn(move || {\n assert_eq!(pool.get(key).unwrap(), String::from(\"hello world\"));\n}).join().unwrap();\n\n// This thread can still access the pooled value through the\n// immutable owned ref:\nassert_eq!(value, String::from(\"hello world\"));\n```\n#### pub fn create_with(&self, init: impl FnOnce(&mut T)) -> Option = Pool::new();\n\n// Create a new pooled item, returning its integer key.\nlet key = pool.create_with(|s| s.push_str(\"Hello\")).unwrap();\n\n/// Other threads may now (immutably) access the item using the key.\nthread::spawn(move || {\n assert_eq!(pool.get(key).unwrap(), String::from(\"Hello\"));\n}).join().unwrap();\n```\n#### pub fn get(&self, key: usize) -> OptionReturn a borrowed reference to the value associated with the given key.\n\nIf the pool does not contain a value for the given key, `None` is returned instead.\n\n##### Examples\n```\nlet pool: Pool = Pool::new();\nlet key = pool.create_with(|item| item.push_str(\"hello world\")).unwrap();\n\nassert_eq!(pool.get(key).unwrap(), String::from(\"hello world\"));\nassert!(pool.get(12345).is_none());\n```\n#### pub fn get_owned(self: Arc, key: usize) -> OptionReturn an owned reference to the value associated with the given key.\n\nIf the pool does not contain a value for the given key, `None` is returned instead.\n\nUnlike `get`, which borrows the pool, this method *clones* the `Arc`\naround the pool if a value exists for the given key. This means that the returned `OwnedRef` can be held for an arbitrary lifetime. However,\nthis method requires that the pool itself be wrapped in an `Arc`.\n\n##### Examples\n```\nuse std::sync::Arc;\n\nlet pool: Arc> = Arc::new(Pool::new());\nlet key = pool.create_with(|item| item.push_str(\"hello world\")).unwrap();\n\n// Look up the created `Key`, returning an `OwnedRef`.\nlet value = pool.clone().get_owned(key).unwrap();\n\n// Now, the original `Arc` clone of the pool may be dropped, but the\n// returned `OwnedRef` can still access the value.\nassert_eq!(value, String::from(\"hello world\"));\n```\nUnlike `Ref`, an `OwnedRef` may be stored in a struct which must live for the `'static` lifetime:\n```\nuse sharded_slab::pool::OwnedRef;\nuse std::sync::Arc;\n\npub struct MyStruct {\n pool_ref: OwnedRef,\n // ... other fields ...\n}\n\n// Suppose this is some arbitrary function which requires a value that\n// lives for the 'static lifetime...\nfn function_requiring_static(t: &T) {\n // ... do something extremely important and interesting ...\n}\n\nlet pool: Arc> = Arc::new(Pool::new());\nlet key = pool.create_with(|item| item.push_str(\"hello world\")).unwrap();\n\n// Look up the created `Key`, returning an `OwnedRef`.\nlet pool_ref = pool.clone().get_owned(key).unwrap();\nlet my_struct = MyStruct {\n pool_ref,\n // ...\n};\n\n// We can use `my_struct` anywhere where it is required to have the\n// `'static` lifetime:\nfunction_requiring_static(&my_struct);\n```\n`OwnedRef`s may be sent between threads:\n```\nuse std::{thread, sync::Arc};\n\nlet pool: Arc> = Arc::new(Pool::new());\nlet key = pool.create_with(|item| item.push_str(\"hello world\")).unwrap();\n\n// Look up the created `Key`, returning an `OwnedRef`.\nlet value = pool.clone().get_owned(key).unwrap();\n\nthread::spawn(move || {\n assert_eq!(value, String::from(\"hello world\"));\n // ...\n}).join().unwrap();\n```\n#### pub fn clear(&self, key: usize) -> bool\n\nRemove the value using the storage associated with the given key from the pool, returning\n`true` if the value was removed.\n\nThis method does *not* block the current thread until the value can be cleared. Instead, if another thread is currently accessing that value, this marks it to be cleared by that thread when it is done accessing that value.\n\n##### Examples\n```\nlet pool: Pool = Pool::new();\n\n// Check out an item from the pool.\nlet mut item = pool.create().unwrap();\nlet key = item.key();\nitem.push_str(\"hello world\");\ndrop(item);\n\nassert_eq!(pool.get(key).unwrap(), String::from(\"hello world\"));\n\npool.clear(key);\nassert!(pool.get(key).is_none());\n```\n```\nlet pool: Pool = Pool::new();\n\nlet key = pool.create_with(|item| item.push_str(\"Hello world!\")).unwrap();\n\n// Clearing a key that doesn't exist in the `Pool` will return `false`\nassert_eq!(pool.clear(key + 69420), false);\n\n// Clearing a key that does exist returns `true`\nassert!(pool.clear(key));\n\n// Clearing a key that has previously been cleared will return `false`\nassert_eq!(pool.clear(key), false);\n```\nTrait Implementations\n---\n\n### impl Debug for Poolwhere\n T: Debug + Clear + Default,\n C: Config,\n\n#### fn fmt(&self, f: &mut Formatter<'_>) -> Result\n\nFormats the value using the given formatter. \n T: Clear + Default,\n\n#### fn default() -> Self\n\nReturns the “default value” for a type. \n T: Send + Clear + Default,\n C: Config,\n\n### impl Sync for Poolwhere\n T: Sync + Clear + Default,\n C: Config,\n\nAuto Trait Implementations\n---\n\n### impl RefUnwindSafe for Poolwhere\n C: RefUnwindSafe,\n\n### impl Unpin for Poolwhere\n C: Unpin,\n\n### impl !UnwindSafe for Pool Any for Twhere\n T: 'static + ?Sized,\n\n#### fn type_id(&self) -> TypeId\n\nGets the `TypeId` of `self`. \n T: ?Sized,\n\n#### fn borrow(&self) -> &T\n\nImmutably borrows from an owned value. \n T: ?Sized,\n\n#### fn borrow_mut(&mut self) -> &mut T\n\nMutably borrows from an owned value. \n\n#### fn from(t: T) -> T\n\nReturns the argument unchanged.\n\n### impl Into for Twhere\n U: From,\n\n#### fn into(self) -> U\n\nCalls `U::from(self)`.\n\nThat is, this conversion is whatever the implementation of\n`From for U` chooses to do.\n\n### impl TryFrom for Twhere\n U: Into,\n\n#### type Error = Infallible\n\nThe type returned in the event of a conversion error.#### fn try_from(value: U) -> Result>::ErrorPerforms the conversion.### impl TryInto for Twhere\n U: TryFrom,\n\n#### type Error = >::Error\n\nThe type returned in the event of a conversion error.#### fn try_into(self) -> Result>::ErrorPerforms the conversion.\n\nStruct sharded_slab::Slab\n===\n\n\n```\npub struct Slab { /* private fields */ }\n```\nA sharded slab.\n\nSee the crate-level documentation for details on using this type.\n\nImplementations\n---\n\n### impl Slab Self\n\nReturns a new slab with the default configuration parameters.\n\n#### pub fn new_with_config() -> Slab Slab Option OptionReturn a handle to a vacant entry allowing for further manipulation.\n\nThis function is useful when creating values that must contain their slab index. The returned `VacantEntry` reserves a slot in the slab and is able to return the index of the entry.\n\n##### Examples\n```\nlet mut slab = Slab::new();\n\nlet hello = {\n let entry = slab.vacant_entry().unwrap();\n let key = entry.key();\n\n entry.insert((key, \"hello\"));\n key\n};\n\nassert_eq!(hello, slab.get(hello).unwrap().0);\nassert_eq!(\"hello\", slab.get(hello).unwrap().1);\n```\n#### pub fn remove(&self, idx: usize) -> bool\n\nRemove the value at the given index in the slab, returning `true` if a value was removed.\n\nUnlike `take`, this method does *not* block the current thread until the value can be removed. Instead, if another thread is currently accessing that value, this marks it to be removed by that thread when it finishes accessing the value.\n\n##### Examples\n```\nlet slab = sharded_slab::Slab::new();\nlet key = slab.insert(\"hello world\").unwrap();\n\n// Remove the item from the slab.\nassert!(slab.remove(key));\n\n// Now, the slot is empty.\nassert!(!slab.contains(key));\n```\n```\nuse std::sync::Arc;\n\nlet slab = Arc::new(sharded_slab::Slab::new());\nlet key = slab.insert(\"hello world\").unwrap();\n\nlet slab2 = slab.clone();\nlet thread2 = std::thread::spawn(move || {\n // Depending on when this thread begins executing, the item may\n // or may not have already been removed...\n if let Some(item) = slab2.get(key) {\n assert_eq!(item, \"hello world\");\n }\n});\n\n// The item will be removed by thread2 when it finishes accessing it.\nassert!(slab.remove(key));\n\nthread2.join().unwrap();\nassert!(!slab.contains(key));\n```\n#### pub fn take(&self, idx: usize) -> Option OptionReturn a reference to the value associated with the given key.\n\nIf the slab does not contain a value for the given key, or if the maximum number of concurrent references to the slot has been reached,\n`None` is returned instead.\n\n##### Examples\n```\nlet slab = sharded_slab::Slab::new();\nlet key = slab.insert(\"hello world\").unwrap();\n\nassert_eq!(slab.get(key).unwrap(), \"hello world\");\nassert!(slab.get(12345).is_none());\n```\n#### pub fn get_owned(self: Arc, key: usize) -> OptionReturn an owned reference to the value at the given index.\n\nIf the slab does not contain a value for the given key, `None` is returned instead.\n\nUnlike `get`, which borrows the slab, this method *clones* the `Arc`\naround the slab. This means that the returned `OwnedEntry` can be held for an arbitrary lifetime. However, this method requires that the slab itself be wrapped in an `Arc`.\n\n##### Examples\n```\nuse std::sync::Arc;\n\nlet slab: Arc> = Arc::new(Slab::new());\nlet key = slab.insert(\"hello world\").unwrap();\n\n// Look up the created key, returning an `OwnedEntry`.\nlet value = slab.clone().get_owned(key).unwrap();\n\n// Now, the original `Arc` clone of the slab may be dropped, but the\n// returned `OwnedEntry` can still access the value.\nassert_eq!(value, \"hello world\");\n```\nUnlike `Entry`, an `OwnedEntry` may be stored in a struct which must live for the `'static` lifetime:\n```\nuse sharded_slab::OwnedEntry;\nuse std::sync::Arc;\n\npub struct MyStruct {\n entry: OwnedEntry<&'static str>,\n // ... other fields ...\n}\n\n// Suppose this is some arbitrary function which requires a value that\n// lives for the 'static lifetime...\nfn function_requiring_static(t: &T) {\n // ... do something extremely important and interesting ...\n}\n\nlet slab: Arc> = Arc::new(Slab::new());\nlet key = slab.insert(\"hello world\").unwrap();\n\n// Look up the created key, returning an `OwnedEntry`.\nlet entry = slab.clone().get_owned(key).unwrap();\nlet my_struct = MyStruct {\n entry,\n // ...\n};\n\n// We can use `my_struct` anywhere where it is required to have the\n// `'static` lifetime:\nfunction_requiring_static(&my_struct);\n```\n`OwnedEntry`s may be sent between threads:\n```\nuse std::{thread, sync::Arc};\n\nlet slab: Arc> = Arc::new(Slab::new());\nlet key = slab.insert(\"hello world\").unwrap();\n\n// Look up the created key, returning an `OwnedEntry`.\nlet value = slab.clone().get_owned(key).unwrap();\n\nthread::spawn(move || {\n assert_eq!(value, \"hello world\");\n // ...\n}).join().unwrap();\n```\n#### pub fn contains(&self, key: usize) -> bool\n\nReturns `true` if the slab contains a value for the given key.\n\n##### Examples\n```\nlet slab = sharded_slab::Slab::new();\n\nlet key = slab.insert(\"hello world\").unwrap();\nassert!(slab.contains(key));\n\nslab.take(key).unwrap();\nassert!(!slab.contains(key));\n```\n#### pub fn unique_iter(&mut self) -> UniqueIter<'_, T, CReturns an iterator over all the items in the slab.\n\nBecause this iterator exclusively borrows the slab (i.e. it holds an\n`&mut Slab`), elements will not be added or removed while the iteration is in progress.\n\nTrait Implementations\n---\n\n### impl Debug for Slab) -> Result\n\nFormats the value using the given formatter. \n\nReturns the “default value” for a type. \n---\n\n### impl RefUnwindSafe for Slabwhere\n C: RefUnwindSafe,\n\n### impl Unpin for Slabwhere\n C: Unpin,\n\n### impl !UnwindSafe for Slab Any for Twhere\n T: 'static + ?Sized,\n\n#### fn type_id(&self) -> TypeId\n\nGets the `TypeId` of `self`. \n T: ?Sized,\n\n#### fn borrow(&self) -> &T\n\nImmutably borrows from an owned value. \n T: ?Sized,\n\n#### fn borrow_mut(&mut self) -> &mut T\n\nMutably borrows from an owned value. \n\n#### fn from(t: T) -> T\n\nReturns the argument unchanged.\n\n### impl Into for Twhere\n U: From,\n\n#### fn into(self) -> U\n\nCalls `U::from(self)`.\n\nThat is, this conversion is whatever the implementation of\n`From for U` chooses to do.\n\n### impl TryFrom for Twhere\n U: Into,\n\n#### type Error = Infallible\n\nThe type returned in the event of a conversion error.#### fn try_from(value: U) -> Result>::ErrorPerforms the conversion.### impl TryInto for Twhere\n U: TryFrom,\n\n#### type Error = >::Error\n\nThe type returned in the event of a conversion error.#### fn try_into(self) -> Result>::ErrorPerforms the conversion.{\"UniqueIter<'_, T, C>\":\"Notable traits for
Notable traits for UniqueIter<'a, T, C>
impl<'a, T, C: Config> Iterator for UniqueIter<'a, T, C> type Item = &'a T;\"}\n\nTrait sharded_slab::Clear\n===\n\n\n```\npub trait Clear {\n // Required method\n fn clear(&mut self);\n}\n```\nTrait implemented by types which can be cleared in place, retaining any allocated memory.\n\nThis is essentially a generalization of methods on standard library collection types, including as `Vec::clear`, `String::clear`, and\n`HashMap::clear`. These methods drop all data stored in the collection,\nbut retain the collection’s heap allocation for future use. Types such as\n`BTreeMap`, whose `clear` methods drops allocations, should not implement this trait.\n\nWhen implemented for types which do not own a heap allocation, `Clear`\nshould reset the type in place if possible. If the type has an empty state or stores `Option`s, those values should be reset to the empty state. For\n“plain old data” types, which hold no pointers to other data and do not have an empty or initial state, it’s okay for a `Clear` implementation to be a no-op. In that case, it essentially serves as a marker indicating that the type may be reused to store new data.\n\nRequired Methods\n---\n\n#### fn clear(&mut self)\n\nClear all data in `self`, retaining the allocated capacithy.\n\nImplementations on Foreign Types\n---\n\n### impl Clear for Mutex Clear for Vec